Refactor control socket and support win32 and linux.

Author: zobo

CHANGELOG.md

@@ -4,6 +4,10 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/) and this project adheres to [Semantic Versioning](http://semver.org/).
 
+
+## [Unreleased]
+
+- Xdebug control socket support for pause on Linux and Windows.
 ## [1.35.0]
 
 - Support for DBGp stream command

package-lock.json

@@ -46,7 +46,6 @@
     "@vscode/debugadapter": "^1.57.0",
     "@vscode/debugprotocol": "^1.55.1",
     "@xmldom/xmldom": "^0.8.4",
-    "abstract-socket": "^2.1.1",
     "buffer-crc32": "^0.2.13",
     "dotenv": "^16.0.3",
     "file-url": "^3.0.0",
@@ -60,6 +59,9 @@
     "urlencode": "^1.1.0",
     "which": "^2.0.2"
   },
+  "optionalDependencies": {
+    "abstract-socket": "^2.1.1"
+  },
   "devDependencies": {
     "@commitlint/cli": "^17.3.0",
     "@commitlint/config-conventional": "^17.3.0",

package.json

@@ -1,13 +1,13 @@
 /// <reference types="node" />
-declare module "abstract-socket" {
-    export function createServer(listener: any): AbstractSocketServer;
-    export function connect(name: any, connectListener: any): net.Socket;
-    export function createConnection(name: any, connectListener: any): net.Socket;
+declare module 'abstract-socket' {
+    export function createServer(listener: any): AbstractSocketServer
+    export function connect(name: any, connectListener: any): net.Socket
+    export function createConnection(name: any, connectListener: any): net.Socket
     class AbstractSocketServer extends net.Server {
         // constructor(listener: any);
         // listen(path: string, listener: () => void): net.Socket;
         // listen(path: string, listeningListener?: () => void): this;
     }
-    import net = require("net");
-    export {};
+    import net = require('net')
+    export {}
 }

src/abstract-socket.d.ts

@@ -0,0 +1,109 @@
+import * as xdebug from './xdebugConnection'
+import * as semver from 'semver'
+import * as net from 'net'
+
+export class ControlSocket {
+    /**
+     * @returns Returns true if the current platoform is supported for Xdebug control socket (win and linux)
+     */
+    supportedPlatform(): boolean {
+        return process.platform === 'linux' || process.platform === 'win32'
+    }
+
+    /**
+     *
+     * @param initPacket
+     * @returns Returns true if the current platform and xdebug version are supporting Xdebug control socket.
+     */
+    supportedInitPacket(initPacket: xdebug.InitPacket): boolean {
+        return (
+            this.supportedPlatform() &&
+            initPacket.engineName === 'Xdebug' &&
+            semver.valid(initPacket.engineVersion, { loose: true }) !== null &&
+            (semver.gte(initPacket.engineVersion, '3.4.0', { loose: true }) || initPacket.engineVersion === '3.4.0-dev')
+        )
+    }
+
+    /**
+     *
+     * @param pid appId returned in the init packet
+     * @returns
+     */
+    async requestPause(pid: string): Promise<void> {
+        let retval
+        if (process.platform === 'linux') {
+            retval = await this.executeLinux(pid, 'pause')
+        } else if (process.platform === 'win32') {
+            retval = await this.executeWindows(pid, 'pause')
+        } else {
+            throw new Error('Invalid platform for Xdebug control socket')
+        }
+        retval
+        return
+    }
+
+    private async executeLinux(pid: string, cmd: string): Promise<string> {
+        const abs = await import('abstract-socket')
+        return new Promise<string>((resolve, reject) => {
+            const cs = `\0xdebug-ctrl.${pid}y`.padEnd(108, 'x')
+            try {
+                const s = abs.connect(cs, () => {
+                    s.write(`${cmd}\0`)
+                })
+                s.setTimeout(3000)
+                s.on('timeout', () => {
+                    reject(new Error('Timed out while reading from Xdebug control socket'))
+                    s.end()
+                })
+                s.on('data', data => {
+                    resolve(data.toString())
+                })
+                s.on('error', error => {
+                    reject(
+                        new Error(
+                            `Cannot connect to Xdebug control socket: ${String(
+                                error instanceof Error ? error.message : error
+                            )}`
+                        )
+                    )
+                })
+                return
+            } catch (error) {
+                reject(
+                    new Error(
+                        `Cannot connect to Xdebug control socket: ${String(
+                            error instanceof Error ? error.message : error
+                        )}`
+                    )
+                )
+                return
+            }
+        })
+    }
+
+    private async executeWindows(pid: string, cmd: string): Promise<string> {
+        return new Promise<string>((resolve, reject) => {
+            const s = net.createConnection(`\\\\.\\pipe\\xdebug-ctrl.${pid}`, () => {
+                s.end(`${cmd}\0`)
+            })
+            s.setTimeout(3000)
+            s.on('timeout', () => {
+                reject(new Error('Timed out while reading from Xdebug control socket'))
+                s.end()
+            })
+            s.on('data', data => {
+                resolve(data.toString())
+            })
+            s.on('error', error => {
+                // sadly this happens all the time - even on normal server-side-close, but luckily the promise is already resolved
+                reject(
+                    new Error(
+                        `Cannot connect to Xdebug control socket: ${String(
+                            error instanceof Error ? error.message : error
+                        )}`
+                    )
+                )
+            })
+        })
+    }
+}

src/controlSocket.ts

@@ -19,7 +19,7 @@ import { randomUUID } from 'crypto'
 import { getConfiguredEnvironment } from './envfile'
 import { XdebugCloudConnection } from './cloud'
 import { shouldIgnoreException } from './ignore'
-import * as abs from 'abstract-socket'
+import { ControlSocket } from './controlSocket'
 
 if (process.env['VSCODE_NLS_CONFIG']) {
     try {
@@ -1387,43 +1387,26 @@ class PhpDebugSession extends vscode.DebugSession {
         response: VSCodeDebugProtocol.PauseResponse,
         args: VSCodeDebugProtocol.PauseArguments
     ): Promise<void> {
-        // test
-        let connection: xdebug.Connection | undefined
-        connection = this._connections.get(args.threadId)
+        const connection = this._connections.get(args.threadId)
         if (!connection) {
             return this.sendErrorResponse(response, new Error(`Unknown thread ID ${args.threadId}`))
         }
 
-        let initPacket = await connection.waitForInitPacket()
-        const supportedControl =
-            process.platform === 'linux' &&
-            initPacket.engineName === 'Xdebug' &&
-            semver.valid(initPacket.engineVersion, { loose: true }) &&
-            (semver.gte(initPacket.engineVersion, '3.4.0', { loose: true }) || initPacket.engineVersion === '3.4.0-dev')
-
-        if (supportedControl) {
-            let cs = `\0xdebug-ctrl.${initPacket.appId}y`.padEnd(108, 'x')
+        const initPacket = await connection.waitForInitPacket()
+        const controlSocket = new ControlSocket()
+        if (controlSocket.supportedInitPacket(initPacket)) {
+            if (this._skippingFiles.has(args.threadId)) {
+                this._skippingFiles.set(args.threadId, false)
+            }
             try {
-                const sock = abs.connect(cs, () => {
-                    sock.write("pause\0")
-                    if (this._skippingFiles.has(args.threadId)) {
-                        this._skippingFiles.set(args.threadId, false)
-                    }
-                    this.sendResponse(response)
-                })
-                sock.on('data', (data) => {
-                    // todo
-                })
-                sock.on('error', (error) => {
-                    this.sendErrorResponse(response, new Error('Cannot connect to Xdebug control socket'))    
-                })
+                await controlSocket.requestPause(initPacket.appId)
+                this.sendResponse(response)
                 return
             } catch (error) {
-                this.sendErrorResponse(response, new Error('Cannot connect to Xdebug control socket'))
-                return
+                this.sendErrorResponse(response, error as Error)
             }
         }
-        // test
+
         if (this._skippingFiles.has(args.threadId)) {
             this._skippingFiles.set(args.threadId, false)
             this.sendResponse(response)