Merge branch 'multisockets'

10 files changed, 479 insertions, 302 deletions

diff --git a/libpcsxcore/CMakeLists.txt b/libpcsxcore/CMakeLists.txt
index b8caef4c..0be1e4ac 100644
--- a/libpcsxcore/CMakeLists.txt
+++ b/libpcsxcore/CMakeLists.txt
@@ -6,6 +6,8 @@ set_property(CACHE DYNAREC PROPERTY STRINGS auto x86_64 x86 ppc no)
 option(ENABLE_CCDDA "Enables compressed CDDA support." OFF)
 option(USE_LIBARCHIVE "Enables compressed data-tracks support." OFF)
 
+include_directories(../dynstr/dynstr/include)
+
 if (ENABLE_CCDDA)
   find_package(FFMPEG REQUIRED)
   include_directories(${FFMPEG_INCLUDE_DIRS})
@@ -114,4 +116,4 @@ endif()
 set(SRCS ${SRCS} ${DYNAREC_SRC})
 
 add_library(pcsxcore STATIC ${SRCS})
-target_link_libraries(pcsxcore ${FFMPEG_LIBRARIES} ${LibArchive_LIBRARIES} ${LIBS})
+target_link_libraries(pcsxcore dynstr gdbstub ${FFMPEG_LIBRARIES} ${LibArchive_LIBRARIES} ${LIBS})
diff --git a/libpcsxcore/debug.c b/libpcsxcore/debug.c
index a4e9ab35..ecc9edc7 100644
--- a/libpcsxcore/debug.c
+++ b/libpcsxcore/debug.c
@@ -19,6 +19,8 @@
 #include "r3000a.h"
 #include "debug.h"
 #include "socket.h"
+#include <dynstr.h>
+#include <stddef.h>
 
 /*
 PCSXR Debug console protocol description, version 1.0
@@ -134,7 +136,7 @@ Execution flow control commands (3xx):
     Soft (quick) resets.
 399
     Resets.
-    
+
 
 Server outputs:
 ~~~~~~~~~~~~~~
@@ -236,6 +238,9 @@ static int step_over = 0;
 static u32 step_over_addr = 0;
 static int mapping_e = 0, mapping_r8 = 0, mapping_r16 = 0, mapping_r32 = 0, mapping_w8 = 0, mapping_w16 = 0, mapping_w32 = 0;
 static int breakmp_e = 0, breakmp_r8 = 0, breakmp_r16 = 0, breakmp_r32 = 0, breakmp_w8 = 0, breakmp_w16 = 0, breakmp_w32 = 0;
+static int server_socket, client_socket;
+static char tbuf[513];
+static size_t ptr;
 
 static void ProcessCommands();
 
@@ -317,6 +322,11 @@ breakpoint_t *find_breakpoint(int number) {
 }
 
 void StartDebugger() {
+    enum
+    {
+        PORT_NUMBER = 12345
+    };
+
     if (debugger_active)
         return;
 
@@ -326,7 +336,9 @@ void StartDebugger() {
         return;
     }
 
-    if (StartServer() == -1) {
+    server_socket = StartServer(PORT_NUMBER);
+
+    if (server_socket == -1) {
         SysPrintf("%s", _("Unable to start debug server.\n"));
         return;
     }
@@ -337,7 +349,7 @@ void StartDebugger() {
 
 void StopDebugger() {
     if (debugger_active) {
-        StopServer();
+        StopServer(server_socket);
         SysPrintf("%s", _("Debugger stopped.\n"));
     }
 
@@ -361,6 +373,14 @@ void ResumeDebugger() {
     paused = 0;
 }
 
+static void DebugHello(void)
+{
+    static const char hello[] = "000 PCSXR Version " PACKAGE_VERSION " - Debug console\r\n";
+
+    WriteSocket(client_socket, hello, sizeof hello);
+    ptr = 0;
+}
+
 void DebugVSync() {
     if (!debugger_active || resetting)
         return;
@@ -375,7 +395,16 @@ void DebugVSync() {
         return;
     }
 
-    GetClient();
+    if (client_socket < 1)
+    {
+        client_socket = GetClient(server_socket, 0);
+
+        if (client_socket > 0)
+        {
+            DebugHello();
+        }
+    }
+
     ProcessCommands();
 }
 
@@ -398,33 +427,42 @@ void ProcessDebug() {
     }
     if (!paused) {
 		if(trace && printpc) {
-			char reply[256];
-			sprintf(reply, "219 %s\r\n", disR3000AF(psxMemRead32(psxRegs.pc), psxRegs.pc));
-			WriteSocket(reply, strlen(reply));
+            struct dynstr reply;
+
+            dynstr_init(&reply);
+			dynstr_append(&reply, "219 %s\r\n", disR3000AF(psxMemRead32(psxRegs.pc), psxRegs.pc));
+			WriteSocket(client_socket, reply.str, reply.len);
+            dynstr_free(&reply);
 		}
-		
+
         if(step_over) {
             if(psxRegs.pc == step_over_addr) {
-                char reply[256];
+                struct dynstr reply;
+
+                dynstr_init(&reply);
                 step_over = 0;
                 step_over_addr = 0;
-                sprintf(reply, "050 @%08X\r\n", psxRegs.pc);
-                WriteSocket(reply, strlen(reply));
+                dynstr_append(&reply, "050 @%08X\r\n", psxRegs.pc);
+                WriteSocket(client_socket, reply.str, reply.len);
+                dynstr_free(&reply);
                 paused = 1;
             }
         }
-        
+
         if(run_to) {
             if(psxRegs.pc == run_to_addr) {
-                char reply[256];
+                struct dynstr reply;
+
                 run_to = 0;
                 run_to_addr = 0;
-                sprintf(reply, "040 @%08X\r\n", psxRegs.pc);
-                WriteSocket(reply, strlen(reply));
+                dynstr_init(&reply);
+                dynstr_append(&reply, "040 @%08X\r\n", psxRegs.pc);
+                WriteSocket(client_socket, reply.str, reply.len);
+                dynstr_free(&reply);
                 paused = 1;
             }
         }
-		
+
         DebugCheckBP(psxRegs.pc, BE);
     }
     if (mapping_e) {
@@ -437,7 +475,17 @@ void ProcessDebug() {
         }
     }
     while (paused) {
-        GetClient();
+
+        if (client_socket < 1)
+        {
+            client_socket = GetClient(server_socket, 0);
+
+            if (client_socket > 0)
+            {
+                DebugHello();
+            }
+        }
+
         ProcessCommands();
         GPU_updateLace();
         SysUpdate();
@@ -446,14 +494,31 @@ void ProcessDebug() {
 
 static void ProcessCommands() {
     int code, i, dumping;
-    FILE *sfile;
-    char cmd[257], *arguments, *p, reply[10240], *save, *dump = NULL;
+    char cmd[348], *arguments, *p, *save, *dump = NULL;
     u32 reg, value, size = 0, address;
     breakpoint_t *bp;
+    size_t len = sizeof cmd;
+    struct dynstr reply;
+
+    if (HasClient(client_socket))
+    {
+        const enum read_socket_err err = ReadSocket(client_socket, cmd, &len);
+
+        switch (err)
+        {
+            case READ_SOCKET_OK:
+                break;
+
+            case READ_SOCKET_ERR_INVALID_ARG:
+                /* Fall through. */
+            case READ_SOCKET_ERR_RECV:
+                /* Fall through. */
+            case READ_SOCKET_SHUTDOWN:
+                /* Fall through. */
+            default:
+                return;
+        }
 
-    if (!HasClient())
-        return;
-    if (ReadSocket(cmd, 256) > 0) {
         arguments = NULL;
         if (strlen(cmd) <= 2) {
             code = 0;
@@ -475,129 +540,126 @@ static void ProcessCommands() {
 
         dumping = 0;
         save = NULL;
+        dynstr_init(&reply);
 
         switch (code) {
         case 0x100:
-            sprintf(reply, "200 %s\r\n", arguments == NULL ? "OK" : arguments);
+            dynstr_append(&reply, "200 %s\r\n", arguments == NULL ? "OK" : arguments);
             break;
         case 0x101:
-            sprintf(reply, "201 %s\r\n", PACKAGE_VERSION);
+            dynstr_append(&reply, "201 %s\r\n", PACKAGE_VERSION);
             break;
         case 0x102:
-            sprintf(reply, "202 1.0\r\n");
+            dynstr_append(&reply, "202 1.0\r\n");
             break;
         case 0x103:
-            sprintf(reply, "203 %i\r\n", paused ? 1 : trace ? 2 : 0);
+            dynstr_append(&reply, "203 %i\r\n", paused ? 1 : trace ? 2 : 0);
             break;
         case 0x110:
-            sprintf(reply, "210 PC=%08X\r\n", psxRegs.pc);
+            dynstr_append(&reply, "210 PC=%08X\r\n", psxRegs.pc);
             break;
         case 0x111:
             if (arguments) {
                 if (sscanf(arguments, "%02X", &code) != 1) {
-                    sprintf(reply, "511 Malformed 111 command '%s'\r\n", cmd);
+                    dynstr_append(&reply, "511 Malformed 111 command '%s'\r\n", cmd);
                     break;
                 }
             }
             if (!arguments) {
-                reply[0] = 0;
                 for (i = 0; i < 32; i++) {
-                    sprintf(reply, "%s211 %02X(%2.2s)=%08X\r\n", reply, i, disRNameGPR[i], psxRegs.GPR.r[i]);
+                    dynstr_append(&reply, "211 %02X(%2.2s)=%08X\r\n", reply, i, disRNameGPR[i], psxRegs.GPR.r[i]);
                 }
             } else {
                 if ((code >= 0) && (code < 32)) {
-                    sprintf(reply, "211 %02X(%2.2s)=%08X\r\n", code, disRNameGPR[code], psxRegs.GPR.r[code]);
+                    dynstr_append(&reply, "211 %02X(%2.2s)=%08X\r\n", code, disRNameGPR[code], psxRegs.GPR.r[code]);
                 } else {
-                    sprintf(reply, "511 Invalid GPR register: %X\r\n", code);
+                    dynstr_append(&reply, "511 Invalid GPR register: %X\r\n", code);
                 }
             }
             break;
         case 0x112:
-            sprintf(reply, "212 LO=%08X HI=%08X\r\n", psxRegs.GPR.n.lo, psxRegs.GPR.n.hi);
+            dynstr_append(&reply, "212 LO=%08X HI=%08X\r\n", psxRegs.GPR.n.lo, psxRegs.GPR.n.hi);
             break;
         case 0x113:
             if (arguments) {
                 if (sscanf(arguments, "%02X", &code) != 1) {
-                    sprintf(reply, "511 Malformed 113 command '%s'\r\n", cmd);
+                    dynstr_append(&reply, "511 Malformed 113 command '%s'\r\n", cmd);
                     break;
                 }
             }
             if (!arguments) {
-                reply[0] = 0;
                 for (i = 0; i < 32; i++) {
-                    sprintf(reply, "%s213 %02X(%8.8s)=%08X\r\n", reply, i, disRNameCP0[i], psxRegs.CP0.r[i]);
+                    dynstr_append(&reply, "213 %02X(%8.8s)=%08X\r\n", i, disRNameCP0[i], psxRegs.CP0.r[i]);
                 }
             } else {
                 if ((code >= 0) && (code < 32)) {
-                    sprintf(reply, "213 %02X(%8.8s)=%08X\r\n", code, disRNameCP0[code], psxRegs.CP0.r[code]);
+                    dynstr_append(&reply, "213 %02X(%8.8s)=%08X\r\n", code, disRNameCP0[code], psxRegs.CP0.r[code]);
                 } else {
-                    sprintf(reply, "511 Invalid COP0 register: %X\r\n", code);
+                    dynstr_append(&reply, "511 Invalid COP0 register: %X\r\n", code);
                 }
             }
             break;
         case 0x114:
             if (arguments) {
                 if (sscanf(arguments, "%02X", &code) != 1) {
-                    sprintf(reply, "511 Malformed 114 command '%s'\r\n", cmd);
+                    dynstr_append(&reply, "511 Malformed 114 command '%s'\r\n", cmd);
                     break;
                 }
             }
             if (!arguments) {
-                reply[0] = 0;
                 for (i = 0; i < 32; i++) {
-                    sprintf(reply, "%s214 %02X(%6.6s)=%08X\r\n", reply, i, disRNameCP2C[i], psxRegs.CP2C.r[i]);
+                    dynstr_append(&reply, "214 %02X(%6.6s)=%08X\r\n", i, disRNameCP2C[i], psxRegs.CP2C.r[i]);
                 }
             } else {
                 if ((code >= 0) && (code < 32)) {
-                    sprintf(reply, "214 %02X(%6.6s)=%08X\r\n", code, disRNameCP2C[code], psxRegs.CP2C.r[code]);
+                    dynstr_append(&reply, "214 %02X(%6.6s)=%08X\r\n", code, disRNameCP2C[code], psxRegs.CP2C.r[code]);
                 } else {
-                    sprintf(reply, "511 Invalid COP2C register: %X\r\n", code);
+                    dynstr_append(&reply, "511 Invalid COP2C register: %X\r\n", code);
                 }
             }
             break;
         case 0x115:
             if (arguments) {
                 if (sscanf(arguments, "%02X", &code) != 1) {
-                    sprintf(reply, "511 Malformed 111 command '%s'\r\n", cmd);
+                    dynstr_append(&reply, "511 Malformed 111 command '%s'\r\n", cmd);
                     break;
                 }
             }
             if (!arguments) {
-                reply[0] = 0;
                 for (i = 0; i < 32; i++) {
-                    sprintf(reply, "%s215 %02X(%4.4s)=%08X\r\n", reply, i, disRNameCP2D[i], psxRegs.CP2D.r[i]);
+                    dynstr_append(&reply, "215 %02X(%4.4s)=%08X\r\n", i, disRNameCP2D[i], psxRegs.CP2D.r[i]);
                 }
             } else {
                 if ((code >= 0) && (code < 32)) {
-                    sprintf(reply, "215 %02X(%4.4s)=%08X\r\n", code, disRNameCP2D[code], psxRegs.CP2D.r[code]);
+                    dynstr_append(&reply, "215 %02X(%4.4s)=%08X\r\n", code, disRNameCP2D[code], psxRegs.CP2D.r[code]);
                 } else {
-                    sprintf(reply, "511 Invalid COP2D register: %X\r\n", code);
+                    dynstr_append(&reply, "511 Invalid COP2D register: %X\r\n", code);
                 }
             }
             break;
         case 0x119:
             if (arguments) {
                 if (sscanf(arguments, "%08X", &code) != 1) {
-                    sprintf(reply, "511 Malformed 119 command '%s'\r\n", cmd);
+                    dynstr_append(&reply, "511 Malformed 119 command '%s'\r\n", cmd);
                     break;
                 }
             }
             if (!arguments)
                 code = psxRegs.pc;
 
-            sprintf(reply, "219 %s\r\n", disR3000AF(psxMemRead32(code), code));
+            dynstr_append(&reply, "219 %s\r\n", disR3000AF(psxMemRead32(code), code));
             break;
         case 0x121:
             if (!arguments || sscanf(arguments, "%02X=%08X", &reg, &value) != 2) {
-                sprintf(reply, "500 Malformed 121 command '%s'\r\n", arguments);
+                dynstr_append(&reply, "500 Malformed 121 command '%s'\r\n", arguments);
                 break;
             }
 
             if (reg < 32) {
                 psxRegs.GPR.r[reg] = value;
-                sprintf(reply, "221 %02X=%08X\r\n", reg, value);
+                dynstr_append(&reply, "221 %02X=%08X\r\n", reg, value);
             } else {
-                sprintf(reply, "512 Invalid GPR register: %02X\r\n", reg);
+                dynstr_append(&reply, "512 Invalid GPR register: %02X\r\n", reg);
             }
             break;
         case 0x122:
@@ -607,88 +669,88 @@ static void ProcessCommands() {
                 reg = 32;
             } else {
                 arguments[2] = 0;
-                sprintf(reply, "512 Invalid LO/HI register: '%s'\r\n", arguments);
+                dynstr_append(&reply, "512 Invalid LO/HI register: '%s'\r\n", arguments);
                 break;
             }
 
             if (sscanf(arguments + 3, "%08X", &value) != 1) {
-                sprintf(reply, "500 Malformed 122 command '%s'\r\n", arguments);
+                dynstr_append(&reply, "500 Malformed 122 command '%s'\r\n", arguments);
             } else {
                 psxRegs.GPR.r[reg] = value;
-                sprintf(reply, "222 LO=%08X HI=%08X\r\n", psxRegs.GPR.n.lo, psxRegs.GPR.n.hi);
+                dynstr_append(&reply, "222 LO=%08X HI=%08X\r\n", psxRegs.GPR.n.lo, psxRegs.GPR.n.hi);
             }
             break;
         case 0x123:
             if (!arguments || sscanf(arguments, "%02X=%08X", &reg, &value) != 2) {
-                sprintf(reply, "500 Malformed 123 command '%s'\r\n", arguments);
+                dynstr_append(&reply, "500 Malformed 123 command '%s'\r\n", arguments);
                 break;
             }
 
             if (reg < 32) {
                 psxRegs.CP0.r[reg] = value;
-                sprintf(reply, "223 %02X=%08X\r\n", reg, value);
+                dynstr_append(&reply, "223 %02X=%08X\r\n", reg, value);
             } else {
-                sprintf(reply, "512 Invalid COP0 register: %02X\r\n", reg);
+                dynstr_append(&reply, "512 Invalid COP0 register: %02X\r\n", reg);
             }
             break;
         case 0x124:
             if (!arguments || sscanf(arguments, "%02X=%08X", &reg, &value) != 2) {
-                sprintf(reply, "500 Malformed 124 command '%s'\r\n", arguments);
+                dynstr_append(&reply, "500 Malformed 124 command '%s'\r\n", arguments);
                 break;
             }
 
             if (reg < 32) {
                 psxRegs.CP2C.r[reg] = value;
-                sprintf(reply, "224 %02X=%08X\r\n", reg, value);
+                dynstr_append(&reply, "224 %02X=%08X\r\n", reg, value);
             } else {
-                sprintf(reply, "512 Invalid COP2C register: %02X\r\n", reg);
+                dynstr_append(&reply, "512 Invalid COP2C register: %02X\r\n", reg);
             }
             break;
         case 0x125:
             if (!arguments || sscanf(arguments, "%02X=%08X", &reg, &value) != 2) {
-                sprintf(reply, "500 Malformed 121 command '%s'\r\n", arguments);
+                dynstr_append(&reply, "500 Malformed 121 command '%s'\r\n", arguments);
                 break;
             }
 
             if (reg < 32) {
                 psxRegs.CP2D.r[reg] = value;
-                sprintf(reply, "225 %02X=%08X\r\n", reg, value);
+                dynstr_append(&reply, "225 %02X=%08X\r\n", reg, value);
             } else {
-                sprintf(reply, "512 Invalid COP2D register: %02X\r\n", reg);
+                dynstr_append(&reply, "512 Invalid COP2D register: %02X\r\n", reg);
             }
             break;
         case 0x130:
             if (!arguments || sscanf(arguments, "%08X@%08X", &size, &address) != 2) {
-                sprintf(reply, "500 Malformed 130 command '%s'\r\n", arguments);
+                dynstr_append(&reply, "500 Malformed 130 command '%s'\r\n", arguments);
                 break;
             }
 
             if ((address >= 0x80000000) && ((address + size) <= 0x80200000)) {
-                sprintf(reply, "230 %08X@%08X\r\n", size, address);
+                dynstr_append(&reply, "230 %08X@%08X\r\n", size, address);
                 dump = (char *) PSXM(address);
                 dumping = 1;
             } else {
-                sprintf(reply, "513 Invalid address or range: '%s'\r\n", arguments);
+                dynstr_append(&reply, "513 Invalid address or range: '%s'\r\n", arguments);
             }
             break;
         case 0x140:
             if (!arguments || sscanf(arguments, "%08X@%08X", &size, &address) != 2) {
-                sprintf(reply, "500 Malformed 140 command '%s'\r\n", arguments);
+                dynstr_append(&reply, "500 Malformed 140 command '%s'\r\n", arguments);
                 break;
             }
 
             if ((address >= 0x80000000) && ((address + size) <= 0x80200000)) {
-                sprintf(reply, "240 %08X@%08X\r\n", size, address);
-                RawReadSocket((char *)PSXM(address), size);
+                dynstr_append(&reply, "240 %08X@%08X\r\n", size, address);
+                RawReadSocket(client_socket, (char *)PSXM(address), size);
             } else {
-                sprintf(reply, "514 Invalid address or range: '%s'\r\n", arguments);
+                dynstr_append(&reply, "514 Invalid address or range: '%s'\r\n", arguments);
             }
             break;
         case 0x150:
             code = 1;
             if (arguments) {
                 if (sscanf(arguments, "%02X", &code) != 1) {
-                    sprintf(reply, "500 Malformed 150 command '%s'\r\n", cmd);
+                    dynstr_append(&reply, "500 Malformed 150 command '%s'\r\n", cmd);
                     break;
                 }
             }
@@ -701,13 +763,13 @@ static void ProcessCommands() {
             } else {
                 mapping_e = 0;
             }
-            sprintf(reply, "250 Mapping of exec flow %s\r\n", code ? "started" : "stopped");
+            dynstr_append(&reply, "250 Mapping of exec flow %s\r\n", code ? "started" : "stopped");
             break;
         case 0x151:
             code = 1;
             if (arguments) {
                 if (sscanf(arguments, "%02X", &code) != 1) {
-                    sprintf(reply, "500 Malformed 151 command '%s'\r\n", cmd);
+                    dynstr_append(&reply, "500 Malformed 151 command '%s'\r\n", cmd);
                     break;
                 }
             }
@@ -719,13 +781,13 @@ static void ProcessCommands() {
             } else {
                 mapping_r8 = 0;
             }
-            sprintf(reply, "251 Mapping of read8 flow %s\r\n", code ? "started" : "stopped");
+            dynstr_append(&reply, "251 Mapping of read8 flow %s\r\n", code ? "started" : "stopped");
             break;
         case 0x152:
             code = 1;
             if (arguments) {
                 if (sscanf(arguments, "%02X", &code) != 1) {
-                    sprintf(reply, "500 Malformed 152 command '%s'\r\n", cmd);
+                    dynstr_append(&reply, "500 Malformed 152 command '%s'\r\n", cmd);
                     break;
                 }
             }
@@ -737,13 +799,13 @@ static void ProcessCommands() {
             } else {
                 mapping_r16 = 0;
             }
-            sprintf(reply, "252 Mapping of read16 flow %s\r\n", code ? "started" : "stopped");
+            dynstr_append(&reply, "252 Mapping of read16 flow %s\r\n", code ? "started" : "stopped");
             break;
         case 0x153:
             code = 1;
             if (arguments) {
                 if (sscanf(arguments, "%02X", &code) != 1) {
-                    sprintf(reply, "500 Malformed 153 command '%s'\r\n", cmd);
+                    dynstr_append(&reply, "500 Malformed 153 command '%s'\r\n", cmd);
                     break;
                 }
             }
@@ -755,13 +817,13 @@ static void ProcessCommands() {
             } else {
                 mapping_r32 = 0;
             }
-            sprintf(reply, "253 Mapping of read32 flow %s\r\n", code ? "started" : "stopped");
+            dynstr_append(&reply, "253 Mapping of read32 flow %s\r\n", code ? "started" : "stopped");
             break;
         case 0x154:
             code = 1;
             if (arguments) {
                 if (sscanf(arguments, "%02X", &code) != 1) {
-                    sprintf(reply, "500 Malformed 154 command '%s'\r\n", cmd);
+                    dynstr_append(&reply, "500 Malformed 154 command '%s'\r\n", cmd);
                     break;
                 }
             }
@@ -773,13 +835,13 @@ static void ProcessCommands() {
             } else {
                 mapping_w8 = 0;
             }
-            sprintf(reply, "254 Mapping of write8 flow %s\r\n", code ? "started" : "stopped");
+            dynstr_append(&reply, "254 Mapping of write8 flow %s\r\n", code ? "started" : "stopped");
             break;
         case 0x155:
             code = 1;
             if (arguments) {
                 if (sscanf(arguments, "%02X", &code) != 1) {
-                    sprintf(reply, "500 Malformed 155 command '%s'\r\n", cmd);
+                    dynstr_append(&reply, "500 Malformed 155 command '%s'\r\n", cmd);
                     break;
                 }
             }
@@ -791,13 +853,13 @@ static void ProcessCommands() {
             } else {
                 mapping_w16 = 0;
             }
-            sprintf(reply, "255 Mapping of write16 flow %s\r\n", code ? "started" : "stopped");
+            dynstr_append(&reply, "255 Mapping of write16 flow %s\r\n", code ? "started" : "stopped");
             break;
         case 0x156:
             code = 1;
             if (arguments) {
                 if (sscanf(arguments, "%02X", &code) != 1) {
-                    sprintf(reply, "500 Malformed 156 command '%s'\r\n", cmd);
+                    dynstr_append(&reply, "500 Malformed 156 command '%s'\r\n", cmd);
                     break;
                 }
             }
@@ -809,13 +871,13 @@ static void ProcessCommands() {
             } else {
                 mapping_w32 = 0;
             }
-            sprintf(reply, "256 Mapping of write32 flow %s\r\n", code ? "started" : "stopped");
+            dynstr_append(&reply, "256 Mapping of write32 flow %s\r\n", code ? "started" : "stopped");
             break;
         case 0x160:
             code = 1;
             if (arguments) {
                 if (sscanf(arguments, "%02X", &code) != 1) {
-                    sprintf(reply, "500 Malformed 160 command '%s'\r\n", cmd);
+                    dynstr_append(&reply, "500 Malformed 160 command '%s'\r\n", cmd);
                     break;
                 }
             }
@@ -824,13 +886,13 @@ static void ProcessCommands() {
             } else {
                 breakmp_e = 0;
             }
-            sprintf(reply, "260 Break on map of exec flow %s\r\n", code ? "started" : "stopped");
+            dynstr_append(&reply, "260 Break on map of exec flow %s\r\n", code ? "started" : "stopped");
             break;
         case 0x161:
             code = 1;
             if (arguments) {
                 if (sscanf(arguments, "%02X", &code) != 1) {
-                    sprintf(reply, "500 Malformed 161 command '%s'\r\n", cmd);
+                    dynstr_append(&reply, "500 Malformed 161 command '%s'\r\n", cmd);
                     break;
                 }
             }
@@ -839,13 +901,13 @@ static void ProcessCommands() {
             } else {
                 breakmp_r8 = 0;
             }
-            sprintf(reply, "261 Break on map of read8 flow %s\r\n", code ? "started" : "stopped");
+            dynstr_append(&reply, "261 Break on map of read8 flow %s\r\n", code ? "started" : "stopped");
             break;
         case 0x162:
             code = 1;
             if (arguments) {
                 if (sscanf(arguments, "%02X", &code) != 1) {
-                    sprintf(reply, "500 Malformed 162 command '%s'\r\n", cmd);
+                    dynstr_append(&reply, "500 Malformed 162 command '%s'\r\n", cmd);
                     break;
                 }
             }
@@ -854,13 +916,13 @@ static void ProcessCommands() {
             } else {
                 breakmp_r16 = 0;
             }
-            sprintf(reply, "262 Break on map of read16 flow %s\r\n", code ? "started" : "stopped");
+            dynstr_append(&reply, "262 Break on map of read16 flow %s\r\n", code ? "started" : "stopped");
             break;
         case 0x163:
             code = 1;
             if (arguments) {
                 if (sscanf(arguments, "%02X", &code) != 1) {
-                    sprintf(reply, "500 Malformed 163 command '%s'\r\n", cmd);
+                    dynstr_append(&reply, "500 Malformed 163 command '%s'\r\n", cmd);
                     break;
                 }
             }
@@ -869,13 +931,13 @@ static void ProcessCommands() {
             } else {
                 breakmp_r32 = 0;
             }
-            sprintf(reply, "263 Break on map of read32 flow %s\r\n", code ? "started" : "stopped");
+            dynstr_append(&reply, "263 Break on map of read32 flow %s\r\n", code ? "started" : "stopped");
             break;
         case 0x164:
             code = 1;
             if (arguments) {
                 if (sscanf(arguments, "%02X", &code) != 1) {
-                    sprintf(reply, "500 Malformed 164 command '%s'\r\n", cmd);
+                    dynstr_append(&reply, "500 Malformed 164 command '%s'\r\n", cmd);
                     break;
                 }
             }
@@ -884,13 +946,13 @@ static void ProcessCommands() {
             } else {
                 breakmp_w8 = 0;
             }
-            sprintf(reply, "264 Break on map of write8 flow %s\r\n", code ? "started" : "stopped");
+            dynstr_append(&reply, "264 Break on map of write8 flow %s\r\n", code ? "started" : "stopped");
             break;
         case 0x165:
             code = 1;
             if (arguments) {
                 if (sscanf(arguments, "%02X", &code) != 1) {
-                    sprintf(reply, "500 Malformed 165 command '%s'\r\n", cmd);
+                    dynstr_append(&reply, "500 Malformed 165 command '%s'\r\n", cmd);
                     break;
                 }
             }
@@ -899,13 +961,13 @@ static void ProcessCommands() {
             } else {
                 breakmp_w16 = 0;
             }
-            sprintf(reply, "265 Break on map of write16 flow %s\r\n", code ? "started" : "stopped");
+            dynstr_append(&reply, "265 Break on map of write16 flow %s\r\n", code ? "started" : "stopped");
             break;
         case 0x166:
             code = 1;
             if (arguments) {
                 if (sscanf(arguments, "%02X", &code) != 1) {
-                    sprintf(reply, "500 Malformed 166 command '%s'\r\n", cmd);
+                    dynstr_append(&reply, "500 Malformed 166 command '%s'\r\n", cmd);
                     break;
                 }
             }
@@ -914,30 +976,37 @@ static void ProcessCommands() {
             } else {
                 breakmp_w32 = 0;
             }
-            sprintf(reply, "266 Break on map of write32 flow %s\r\n", code ? "started" : "stopped");
+            dynstr_append(&reply, "266 Break on map of write32 flow %s\r\n", code ? "started" : "stopped");
             break;
         case 0x170:
-            sfile = fopen("flow.idc", "wb");
-            fprintf(sfile, "#include <idc.idc>\r\n\r\n");
-            fprintf(sfile, "static main(void) {\r\n");
-            for (i = 0; i < 0x00200000; i++) {
-                if (IsMapMarked(i, MAP_EXEC_JAL)) {
-                    fprintf(sfile, "\tMakeFunction(0X8%07X,BADADDR);\r\n", i);
+        {
+            {
+                FILE *const sfile = fopen("flow.idc", "wb");
+                fprintf(sfile, "#include <idc.idc>\r\n\r\n");
+                fprintf(sfile, "static main(void) {\r\n");
+                for (i = 0; i < 0x00200000; i++) {
+                    if (IsMapMarked(i, MAP_EXEC_JAL)) {
+                        fprintf(sfile, "\tMakeFunction(0X8%07X,BADADDR);\r\n", i);
+                    }
                 }
+                fprintf(sfile, "}\r\n");
+                fclose(sfile);
             }
-            fprintf(sfile, "}\r\n");
-            fclose(sfile);
-            sfile = fopen("markcode.idc", "wb");
-            fprintf(sfile, "#include <idc.idc>\r\n\r\n");
-            fprintf(sfile, "static main(void) {\r\n");
-            for (i = 0; i < 0x00200000; i++) {
-                if (IsMapMarked(i, MAP_EXEC)) {
-                    fprintf(sfile, "\tMakeCode(0X8%07X);\r\n", i);
+
+            {
+                FILE *const sfile = fopen("markcode.idc", "wb");
+                fprintf(sfile, "#include <idc.idc>\r\n\r\n");
+                fprintf(sfile, "static main(void) {\r\n");
+                for (i = 0; i < 0x00200000; i++) {
+                    if (IsMapMarked(i, MAP_EXEC)) {
+                        fprintf(sfile, "\tMakeCode(0X8%07X);\r\n", i);
+                    }
                 }
+                fprintf(sfile, "}\r\n");
+                fclose(sfile);
+                dynstr_append(&reply, "270 flow.idc and markcode.idc dumped\r\n");
             }
-            fprintf(sfile, "}\r\n");
-            fclose(sfile);
-            sprintf(reply, "270 flow.idc and markcode.idc dumped\r\n");
+        }
             break;
         case 0x300:
             p = arguments;
@@ -946,18 +1015,17 @@ static void ProcessCommands() {
             }
             if (p == arguments) {
                 if (first) {
-                    reply[0] = 0;
                     for (bp = first; bp; bp = next_breakpoint(bp)) {
-                        sprintf(reply, "%s400 %X@%08X-%s\r\n", reply, bp->number, bp->address, breakpoint_type_names[bp->type]);
+                        dynstr_append(&reply, "%s400 %X@%08X-%s\r\n", bp->number, bp->address, breakpoint_type_names[bp->type]);
                     }
                 } else {
-                    sprintf(reply, "530 No breakpoint\r\n");
+                    dynstr_append(&reply, "530 No breakpoint\r\n");
                 }
             } else {
                 if ((bp = find_breakpoint(code))) {
-                    sprintf(reply, "400 %X@%08X-%s\r\n", bp->number, bp->address, breakpoint_type_names[bp->type]);
+                    dynstr_append(&reply, "400 %X@%08X-%s\r\n", bp->number, bp->address, breakpoint_type_names[bp->type]);
                 } else {
-                    sprintf(reply, "530 Invalid breakpoint number: %X\r\n", code);
+                    dynstr_append(&reply, "530 Invalid breakpoint number: %X\r\n", code);
                 }
             }
             break;
@@ -968,107 +1036,107 @@ static void ProcessCommands() {
             }
             if (p == arguments) {
                 while (first != NULL) delete_breakpoint(first);
-                sprintf(reply, "401 All breakpoints deleted.\r\n");
+                dynstr_append(&reply, "401 All breakpoints deleted.\r\n");
             } else {
                 if ((bp = find_breakpoint(code))) {
                     delete_breakpoint(bp);
-                    sprintf(reply, "401 Breakpoint %X deleted.\r\n", code);
+                    dynstr_append(&reply, "401 Breakpoint %X deleted.\r\n", code);
                 } else {
-                    sprintf(reply, "530 Invalid breakpoint number: %X\r\n", code);
+                    dynstr_append(&reply, "530 Invalid breakpoint number: %X\r\n", code);
                 }
             }
             break;
         case 0x310:
             if (!arguments || sscanf(arguments, "%08X", &address) != 1) {
-                sprintf(reply, "500 Malformed 310 command '%s'\r\n", arguments);
+                dynstr_append(&reply, "500 Malformed 310 command '%s'\r\n", arguments);
                 break;
             }
-//            if ((address & 3) || (address < 0x80000000) || (address >= 0x80200000)) {
-//                sprintf(reply, "531 Invalid address %08X\r\n", address);
-//                break;
-//            }
+    //            if ((address & 3) || (address < 0x80000000) || (address >= 0x80200000)) {
+    //                dynstr_append(&reply, "531 Invalid address %08X\r\n", address);
+    //                break;
+    //            }
             code = add_breakpoint(BE, address);
-            sprintf(reply, "410 %X\r\n", code);
+            dynstr_append(&reply, "410 %X\r\n", code);
             break;
         case 0x320:
             if (!arguments || sscanf(arguments, "%08X", &address) != 1) {
-                sprintf(reply, "500 Malformed 320 command '%s'\r\n", arguments);
+                dynstr_append(&reply, "500 Malformed 320 command '%s'\r\n", arguments);
                 break;
             }
             if ((address < 0x80000000) || (address >= 0x80200000)) {
-                sprintf(reply, "532 Invalid address %08X\r\n", address);
+                dynstr_append(&reply, "532 Invalid address %08X\r\n", address);
                 break;
             }
             code = add_breakpoint(BR1, address);
-            sprintf(reply, "420 %X\r\n", code);
+            dynstr_append(&reply, "420 %X\r\n", code);
             break;
         case 0x321:
             if (!arguments || sscanf(arguments, "%08X", &address) != 1) {
-                sprintf(reply, "500 Malformed 321 command '%s'\r\n", arguments);
+                dynstr_append(&reply, "500 Malformed 321 command '%s'\r\n", arguments);
                 break;
             }
             if ((address & 1) || (address < 0x80000000) || (address >= 0x80200000)) {
-                sprintf(reply, "532 Invalid address %08X\r\n", address);
+                dynstr_append(&reply, "532 Invalid address %08X\r\n", address);
                 break;
             }
             code = add_breakpoint(BR2, address);
-            sprintf(reply, "421 %X\r\n", code);
+            dynstr_append(&reply, "421 %X\r\n", code);
             break;
         case 0x322:
             if (!arguments || sscanf(arguments, "%08X", &address) != 1) {
-                sprintf(reply, "500 Malformed 322 command '%s'\r\n", arguments);
+                dynstr_append(&reply, "500 Malformed 322 command '%s'\r\n", arguments);
                 break;
             }
             if ((address & 3) || (address < 0x80000000) || (address >= 0x80200000)) {
-                sprintf(reply, "532 Invalid address %08X\r\n", address);
+                dynstr_append(&reply, "532 Invalid address %08X\r\n", address);
                 break;
             }
             code = add_breakpoint(BR4, address);
-            sprintf(reply, "422 %X\r\n", code);
+            dynstr_append(&reply, "422 %X\r\n", code);
             break;
         case 0x330:
             if (!arguments || sscanf(arguments, "%08X", &address) != 1) {
-                sprintf(reply, "500 Malformed 330 command '%s'\r\n", arguments);
+                dynstr_append(&reply, "500 Malformed 330 command '%s'\r\n", arguments);
                 break;
             }
             if ((address < 0x80000000) || (address >= 0x80200000)) {
-                sprintf(reply, "533 Invalid address %08X\r\n", address);
+                dynstr_append(&reply, "533 Invalid address %08X\r\n", address);
                 break;
             }
             code = add_breakpoint(BW1, address);
-            sprintf(reply, "430 %X\r\n", code);
+            dynstr_append(&reply, "430 %X\r\n", code);
             break;
         case 0x331:
             if (!arguments || sscanf(arguments, "%08X", &address) != 1) {
-                sprintf(reply, "500 Malformed 331 command '%s'\r\n", arguments);
+                dynstr_append(&reply, "500 Malformed 331 command '%s'\r\n", arguments);
                 break;
             }
             if ((address & 1) || (address < 0x80000000) || (address >= 0x80200000)) {
-                sprintf(reply, "533 Invalid address %08X\r\n", address);
+                dynstr_append(&reply, "533 Invalid address %08X\r\n", address);
                 break;
             }
             code = add_breakpoint(BW2, address);
-            sprintf(reply, "431 %X\r\n", code);
+            dynstr_append(&reply, "431 %X\r\n", code);
             break;
         case 0x332:
             if (!arguments || sscanf(arguments, "%08X", &address) != 1) {
-                sprintf(reply, "500 Malformed 332 command '%s'\r\n", arguments);
+                dynstr_append(&reply, "500 Malformed 332 command '%s'\r\n", arguments);
                 break;
             }
             if ((address & 3) || (address < 0x80000000) || (address >= 0x80200000)) {
-                sprintf(reply, "533 Invalid address %08X\r\n", address);
+                dynstr_append(&reply, "533 Invalid address %08X\r\n", address);
                 break;
             }
             code = add_breakpoint(BW4, address);
-            sprintf(reply, "432 %X\r\n", code);
+            dynstr_append(&reply, "432 %X\r\n", code);
             break;
         case 0x390:
             paused = 1;
-            sprintf(reply, "490 Paused\r\n");
+            dynstr_append(&reply, "490 Paused\r\n");
             break;
         case 0x391:
             paused = 0;
-            sprintf(reply, "491 Resumed\r\n");
+            dynstr_append(&reply, "491 Resumed\r\n");
             break;
         case 0x395:
             p = arguments;
@@ -1079,7 +1147,7 @@ static void ProcessCommands() {
                 trace = 1;
             }
             paused = 0;
-            sprintf(reply, "495 Tracing\r\n");
+            dynstr_append(&reply, "495 Tracing\r\n");
             break;
         case 0x396:
             p = arguments;
@@ -1089,19 +1157,19 @@ static void ProcessCommands() {
             if (p == arguments) {
                 printpc = !printpc;
             }
-            sprintf(reply, "496 Printing %s\r\n", printpc ? "enabled" : "disabled");
+            dynstr_append(&reply, "496 Printing %s\r\n", printpc ? "enabled" : "disabled");
             break;
         case 0x398:
             paused = 0;
             trace = 0;
             reset = 2;
-            sprintf(reply, "498 Soft resetting\r\n");
+            dynstr_append(&reply, "498 Soft resetting\r\n");
             break;
         case 0x399:
             paused = 0;
             trace = 0;
             reset = 1;
-            sprintf(reply, "499 Resetting\r\n");
+            dynstr_append(&reply, "499 Resetting\r\n");
             break;
         case 0x3A0:
             // run to
@@ -1112,10 +1180,10 @@ static void ProcessCommands() {
                 paused = 0;
             }
             if (p == arguments) {
-                sprintf(reply, "500 Malformed 3A0 command '%s'\r\n", arguments);
+                dynstr_append(&reply, "500 Malformed 3A0 command '%s'\r\n", arguments);
                 break;
             }
-            sprintf(reply, "4A0 run to addr %08X\r\n", run_to_addr);
+            dynstr_append(&reply, "4A0 run to addr %08X\r\n", run_to_addr);
             break;
         case 0x3A1:
             // step over (jal)
@@ -1125,8 +1193,8 @@ static void ProcessCommands() {
                     step_over = 1;
                     step_over_addr = psxRegs.pc + 8;
                     paused = 0;
-                    
-                    sprintf(reply, "4A1 step over addr %08X\r\n", psxRegs.pc);
+
+                    dynstr_append(&reply, "4A1 step over addr %08X\r\n", psxRegs.pc);
                 }
                 else {
                     trace = 1;
@@ -1135,13 +1203,14 @@ static void ProcessCommands() {
             }
             break;
         default:
-            sprintf(reply, "500 Unknown command '%s'\r\n", cmd);
+            dynstr_append(&reply, "500 Unknown command '%s'\r\n", cmd);
             break;
         }
-        WriteSocket(reply, strlen(reply));
+        WriteSocket(client_socket, reply.str, reply.len);
+        dynstr_free(&reply);
 
         if (dumping) {
-            WriteSocket(dump, size);
+            WriteSocket(client_socket, dump, size);
         }
 
         if (save) {
@@ -1156,11 +1225,11 @@ void DebugCheckBP(u32 address, enum breakpoint_types type) {
 
     if (!debugger_active || reset)
         return;
-    
+
     for (bp = first; bp; bp = next_breakpoint(bp)) {
         if ((bp->type == type) && (bp->address == address)) {
             sprintf(reply, "030 %X@%08X\r\n", bp->number, psxRegs.pc);
-            WriteSocket(reply, strlen(reply));
+            WriteSocket(client_socket, reply, strlen(reply));
             paused = 1;
             return;
         }
@@ -1168,49 +1237,49 @@ void DebugCheckBP(u32 address, enum breakpoint_types type) {
     if (breakmp_e && type == BE) {
         if (!IsMapMarked(address, MAP_EXEC)) {
             sprintf(reply, "010 %08X@%08X\r\n", address, psxRegs.pc);
-            WriteSocket(reply, strlen(reply));
+            WriteSocket(client_socket, reply, strlen(reply));
             paused = 1;
         }
     }
     if (breakmp_r8 && type == BR1) {
         if (!IsMapMarked(address, MAP_R8)) {
             sprintf(reply, "011 %08X@%08X\r\n", address, psxRegs.pc);
-            WriteSocket(reply, strlen(reply));
+            WriteSocket(client_socket, reply, strlen(reply));
             paused = 1;
         }
     }
     if (breakmp_r16 && type == BR2) {
         if (!IsMapMarked(address, MAP_R16)) {
             sprintf(reply, "012 %08X@%08X\r\n", address, psxRegs.pc);
-            WriteSocket(reply, strlen(reply));
+            WriteSocket(client_socket, reply, strlen(reply));
             paused = 1;
         }
     }
     if (breakmp_r32 && type == BR4) {
         if (!IsMapMarked(address, MAP_R32)) {
             sprintf(reply, "013 %08X@%08X\r\n", address, psxRegs.pc);
-            WriteSocket(reply, strlen(reply));
+            WriteSocket(client_socket, reply, strlen(reply));
             paused = 1;
         }
     }
     if (breakmp_w8 && type == BW1) {
         if (!IsMapMarked(address, MAP_W8)) {
             sprintf(reply, "014 %08X@%08X\r\n", address, psxRegs.pc);
-            WriteSocket(reply, strlen(reply));
+            WriteSocket(client_socket, reply, strlen(reply));
             paused = 1;
         }
     }
     if (breakmp_w16 && type == BW2) {
         if (!IsMapMarked(address, MAP_W16)) {
             sprintf(reply, "015 %08X@%08X\r\n", address, psxRegs.pc);
-            WriteSocket(reply, strlen(reply));
+            WriteSocket(client_socket, reply, strlen(reply));
             paused = 1;
         }
     }
     if (breakmp_w32 && type == BW4) {
         if (!IsMapMarked(address, MAP_W32)) {
             sprintf(reply, "016 %08X@%08X\r\n", address, psxRegs.pc);
-            WriteSocket(reply, strlen(reply));
+            WriteSocket(client_socket, reply, strlen(reply));
             paused = 1;
         }
     }
diff --git a/libpcsxcore/debug.h b/libpcsxcore/debug.h
index f54c4883..4ca2e5ec 100644
--- a/libpcsxcore/debug.h
+++ b/libpcsxcore/debug.h
@@ -46,7 +46,7 @@ extern char *disRNameCP0[];
 
 char* disR3000AF(u32 code, u32 pc);
 
-/* 
+/*
  * Specficies which logs should be activated.
  */
 
diff --git a/libpcsxcore/pgxp_cpu.c b/libpcsxcore/pgxp_cpu.c
index 2b36da57..7f84f9a2 100644
--- a/libpcsxcore/pgxp_cpu.c
+++ b/libpcsxcore/pgxp_cpu.c
@@ -14,12 +14,12 @@ PGXP_value* CPU_reg = CPU_reg_mem;
 PGXP_value* CP0_reg = CP0_reg_mem;
 
 // Instruction register decoding
-#define op(_instr)		(_instr >> 26)			// The op part of the instruction register 
-#define func(_instr)	((_instr) & 0x3F)		// The funct part of the instruction register 
+#define op(_instr)		(_instr >> 26)			// The op part of the instruction register
+#define func(_instr)	((_instr) & 0x3F)		// The funct part of the instruction register
 #define sa(_instr)		((_instr >>  6) & 0x1F) // The sa part of the instruction register
-#define rd(_instr)		((_instr >> 11) & 0x1F)	// The rd part of the instruction register 
-#define rt(_instr)		((_instr >> 16) & 0x1F)	// The rt part of the instruction register 
-#define rs(_instr)		((_instr >> 21) & 0x1F)	// The rs part of the instruction register 
+#define rd(_instr)		((_instr >> 11) & 0x1F)	// The rd part of the instruction register
+#define rt(_instr)		((_instr >> 16) & 0x1F)	// The rt part of the instruction register
+#define rs(_instr)		((_instr >> 21) & 0x1F)	// The rs part of the instruction register
 #define imm(_instr)		(_instr & 0xFFFF)		// The immediate part of the instruction register
 
 void PGXP_InitCPU()
@@ -31,7 +31,7 @@ void PGXP_InitCPU()
 // invalidate register (invalid 8 bit read)
 void InvalidLoad(u32 addr, u32 code, u32 value)
 {
-	u32 reg = ((code >> 16) & 0x1F); // The rt part of the instruction register 
+	u32 reg = ((code >> 16) & 0x1F); // The rt part of the instruction register
 	PGXP_value* pD = NULL;
 	PGXP_value p;
 
@@ -60,7 +60,7 @@ void InvalidLoad(u32 addr, u32 code, u32 value)
 // invalidate memory address (invalid 8 bit write)
 void InvalidStore(u32 addr, u32 code, u32 value)
 {
-	u32 reg = ((code >> 16) & 0x1F); // The rt part of the instruction register 
+	u32 reg = ((code >> 16) & 0x1F); // The rt part of the instruction register
 	PGXP_value* pD = NULL;
 	PGXP_value p;
 
@@ -86,7 +86,7 @@ void PGXP_CPU_ADDI(u32 instr, u32 rtVal, u32 rsVal)
 	// Rt = Rs + Imm (signed)
 	psx_value tempImm;
 	PGXP_value ret;
-	
+
 	Validate(&CPU_reg[rs(instr)], rsVal);
 	ret = CPU_reg[rs(instr)];
 	tempImm.d = imm(instr);
@@ -674,11 +674,11 @@ void PGXP_CPU_SLL(u32 instr, u32 rdVal, u32 rtVal)
 	PGXP_value ret;
 	u32 sh = sa(instr);
 	Validate(&CPU_reg[rt(instr)], rtVal);
-	
+
 	ret = CPU_reg[rt(instr)];
 
 	// TODO: Shift flags
-#if 1 
+#if 1
 	double x = f16Unsign(CPU_reg[rt(instr)].x);
 	double y = f16Unsign(CPU_reg[rt(instr)].y);
 	if (sh >= 32)
@@ -797,7 +797,7 @@ void PGXP_CPU_SRL(u32 instr, u32 rdVal, u32 rtVal)
 		else if ((valt.w.h & mask) == 0)
 			x = x;
 		else
-			x += y * (1 << (16 - sh));//f16Overflow(y);	
+			x += y * (1 << (16 - sh));//f16Overflow(y);
 
 		y = y / (1 << sh);
 		x = f16Sign(x);
@@ -882,7 +882,7 @@ void PGXP_CPU_SRA(u32 instr, u32 rdVal, u32 rtVal)
 	else
 	{
 		x = x / (1 << sh);
-		
+
 		// check for potential sign extension in overflow
 		psx_value valt;
 		valt.d = rtVal;
@@ -892,7 +892,7 @@ void PGXP_CPU_SRA(u32 instr, u32 rdVal, u32 rtVal)
 		else if ((valt.w.h & mask) == 0)
 			x = x;
 		else
-			x += y * (1 << (16 - sh));//f16Overflow(y);	
+			x += y * (1 << (16 - sh));//f16Overflow(y);
 
 		y = y / (1 << sh);
 		x = f16Sign(x);
@@ -1076,7 +1076,7 @@ void PGXP_CPU_SRLV(u32 instr, u32 rdVal, u32 rtVal, u32 rsVal)
 	else
 	{
 		x = x / (1 << sh);
-		
+
 		// check for potential sign extension in overflow
 		psx_value valt;
 		valt.d = rtVal;
@@ -1086,7 +1086,7 @@ void PGXP_CPU_SRLV(u32 instr, u32 rdVal, u32 rtVal, u32 rsVal)
 		else if ((valt.w.h & mask) == 0)
 			x = x;
 		else
-			x += y * (1 << (16 - sh));//f16Overflow(y);	
+			x += y * (1 << (16 - sh));//f16Overflow(y);
 
 		y = y / (1 << sh);
 		x = f16Sign(x);
@@ -1173,7 +1173,7 @@ void PGXP_CPU_SRAV(u32 instr, u32 rdVal, u32 rtVal, u32 rsVal)
 	else
 	{
 		x = x / (1 << sh);
-		
+
 		// check for potential sign extension in overflow
 		psx_value valt;
 		valt.d = rtVal;
@@ -1183,7 +1183,7 @@ void PGXP_CPU_SRAV(u32 instr, u32 rdVal, u32 rtVal, u32 rsVal)
 		else if ((valt.w.h & mask) == 0)
 			x = x;
 		else
-			x += y * (1 << (16 - sh));//f16Overflow(y);	
+			x += y * (1 << (16 - sh));//f16Overflow(y);
 
 		y = y / (1 << sh);
 		x = f16Sign(x);
@@ -1402,4 +1402,4 @@ void PGXP_CP0_CTC0(u32 instr, u32 rdVal, u32 rtVal)
 }
 
 void PGXP_CP0_RFE(u32 instr)
-{}
\ No newline at end of file
+{}
diff --git a/libpcsxcore/ppf.c b/libpcsxcore/ppf.c
index 3d2f9f30..a5d0eca8 100644
--- a/libpcsxcore/ppf.c
+++ b/libpcsxcore/ppf.c
@@ -23,6 +23,7 @@
 #include "psxcommon.h"
 #include "ppf.h"
 #include "cdrom.h"
+#include <dynstr.h>
 
 typedef struct tagPPF_DATA {
 	s32					addr;
@@ -184,7 +185,7 @@ void BuildPPFCache() {
 	char			method, undo = 0, blockcheck = 0;
 	int				dizlen = 0, dizyn;
 	unsigned char	ppfmem[512];
-	char			szPPF[MAXPATHLEN];
+	struct dynstr 	szPPF;
 	int				count, seekpos, pos;
 	u32				anz; // use 32-bit to avoid stupid overflows
 	s32				ladr, off, anx;
@@ -207,9 +208,10 @@ void BuildPPFCache() {
 	buffer[10] = CdromId[8];
 	buffer[11] = '\0';
 
-	sprintf(szPPF, "%s/%s", Config.PatchesDir, buffer);
-
-	ppffile = fopen(szPPF, "rb");
+	dynstr_init(&szPPF);
+	dynstr_append(&szPPF, "%s/%s", Config.PatchesDir, buffer);
+	ppffile = fopen(szPPF.str, "rb");
+	dynstr_free(&szPPF);
 	if (ppffile == NULL) return;
 
 	memset(buffer, 0, 5);
@@ -297,7 +299,7 @@ void BuildPPFCache() {
 	}
 
 	// now do the data reading
-	do {                                                
+	do {
 		fseek(ppffile, seekpos, SEEK_SET);
 		fread(&pos, 4, 1, ppffile);
 		pos = SWAP32(pos);
@@ -305,7 +307,7 @@ void BuildPPFCache() {
 		if (method == 2) fread(buffer, 4, 1, ppffile); // skip 4 bytes on ppf3 (no int64 support here)
 
 		anz = fgetc(ppffile);
-		fread(ppfmem, anz, 1, ppffile);   
+		fread(ppfmem, anz, 1, ppffile);
 
 		ladr = pos / CD_FRAMESIZE_RAW;
 		off = pos % CD_FRAMESIZE_RAW;
@@ -391,8 +393,8 @@ boolean CheckSBI(const u8 *time) {
 
 	// both BCD format
 	for (lcv = 0; lcv < sbicount; lcv++) {
-		if (time[0] == sbitime[lcv][0] && 
-				time[1] == sbitime[lcv][1] && 
+		if (time[0] == sbitime[lcv][0] &&
+				time[1] == sbitime[lcv][1] &&
 				time[2] == sbitime[lcv][2])
 			return TRUE;
 	}
diff --git a/libpcsxcore/psxcommon.h b/libpcsxcore/psxcommon.h
index f2fba819..c6deaa9f 100644
--- a/libpcsxcore/psxcommon.h
+++ b/libpcsxcore/psxcommon.h
@@ -17,8 +17,8 @@
  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.           *
  ***************************************************************************/
 
-/* 
-* This file contains common definitions and includes for all parts of the 
+/*
+* This file contains common definitions and includes for all parts of the
 * emulator core.
 */
 
@@ -172,6 +172,7 @@ typedef struct {
 	boolean PGXP_Cache;
 	boolean PGXP_Texture;
 	u32		PGXP_Mode;
+	boolean GdbServer;
 #ifdef _WIN32
 	char Lang[256];
 #endif
diff --git a/libpcsxcore/psxcounters.c b/libpcsxcore/psxcounters.c
index a6d7e10e..9203d62d 100644
--- a/libpcsxcore/psxcounters.c
+++ b/libpcsxcore/psxcounters.c
@@ -323,7 +323,7 @@ void psxRcntUpdate()
         }
     }
 
-    DebugVSync();
+    if (Config.Debug) DebugVSync();
 }
 
 /******************************************************************************/
diff --git a/libpcsxcore/psxinterpreter.c b/libpcsxcore/psxinterpreter.c
index a4f38e6d..941fda4b 100644
--- a/libpcsxcore/psxinterpreter.c
+++ b/libpcsxcore/psxinterpreter.c
@@ -28,6 +28,7 @@
 #include "pgxp_debug.h"
 #include "pgxp_cpu.h"
 #include "pgxp_gte.h"
+#include "../gdbstub/gdbstub_sys.h"
 
 static int branch = 0;
 static int branch2 = 0;
@@ -152,12 +153,12 @@ static void delayReadWrite(int reg, u32 bpc) {
 	psxBranchTest();
 }
 
-// this defines shall be used with the tmp 
+// this defines shall be used with the tmp
 // of the next func (instead of _Funct_...)
-#define _tFunct_  ((tmp      ) & 0x3F)  // The funct part of the instruction register 
-#define _tRd_     ((tmp >> 11) & 0x1F)  // The rd part of the instruction register 
-#define _tRt_     ((tmp >> 16) & 0x1F)  // The rt part of the instruction register 
-#define _tRs_     ((tmp >> 21) & 0x1F)  // The rs part of the instruction register 
+#define _tFunct_  ((tmp      ) & 0x3F)  // The funct part of the instruction register
+#define _tRd_     ((tmp >> 11) & 0x1F)  // The rd part of the instruction register
+#define _tRt_     ((tmp >> 16) & 0x1F)  // The rt part of the instruction register
+#define _tRs_     ((tmp >> 21) & 0x1F)  // The rs part of the instruction register
 #define _tSa_     ((tmp >>  6) & 0x1F)  // The sa part of the instruction register
 
 int psxTestLoadDelay(int reg, u32 tmp) {
@@ -184,7 +185,7 @@ int psxTestLoadDelay(int reg, u32 tmp) {
 				// SYSCALL/BREAK just a break;
 
 				case 0x20: case 0x21: case 0x22: case 0x23:
-				case 0x24: case 0x25: case 0x26: case 0x27: 
+				case 0x24: case 0x25: case 0x26: case 0x27:
 				case 0x2a: case 0x2b: // ADD/ADDU...
 				case 0x04: case 0x06: case 0x07: // SLLV...
 					if (_tRd_ == reg && (_tRt_ == reg || _tRs_ == reg)) return 1; else
@@ -271,7 +272,7 @@ int psxTestLoadDelay(int reg, u32 tmp) {
 
 		case 0x12: // COP2
 			switch (_tFunct_) {
-				case 0x00: 
+				case 0x00:
 					switch (_tRs_) {
 						case 0x00: // MFC2
 							if (_tRt_ == reg) return 3;
@@ -721,9 +722,9 @@ void psxLB() {
 
 
 	if (_Rt_) {
-		_i32(_rRt_) = (signed char)psxMemRead8(_oB_); 
+		_i32(_rRt_) = (signed char)psxMemRead8(_oB_);
 	} else {
-		psxMemRead8(_oB_); 
+		psxMemRead8(_oB_);
 	}
 }
 
@@ -743,7 +744,7 @@ void psxLBU() {
 	if (_Rt_) {
 		_u32(_rRt_) = psxMemRead8(_oB_);
 	} else {
-		psxMemRead8(_oB_); 
+		psxMemRead8(_oB_);
 	}
 }
 
@@ -828,7 +829,7 @@ void psxLWL() {
 
 
 	if (!_Rt_) return;
-	_u32(_rRt_) =	( _u32(_rRt_) & LWL_MASK[shift]) | 
+	_u32(_rRt_) =	( _u32(_rRt_) & LWL_MASK[shift]) |
 					( mem << LWL_SHIFT[shift]);
 
 	/*
@@ -850,7 +851,7 @@ void psxLWR() {
 	u32 mem = psxMemRead32(addr & ~3);
 
 
-	
+
 	// load delay = 1 latency
 	if( branch == 0 )
 	{
@@ -864,7 +865,7 @@ void psxLWR() {
 
 
 	if (!_Rt_) return;
-	_u32(_rRt_) =	( _u32(_rRt_) & LWR_MASK[shift]) | 
+	_u32(_rRt_) =	( _u32(_rRt_) & LWR_MASK[shift]) |
 					( mem >> LWR_SHIFT[shift]);
 
 	/*
@@ -940,7 +941,7 @@ void psxMFC0()
 
 
 	if (!_Rt_) return;
-	
+
 	_i32(_rRt_) = (int)_rFs_;
 }
 
@@ -958,7 +959,7 @@ void psxCFC0()
 
 
 	if (!_Rt_) return;
-	
+
 	_i32(_rRt_) = (int)_rFs_;
 }
 
@@ -1031,7 +1032,7 @@ void psxCFC2()
 * Unknow instruction (would generate an exception)       *
 * Format:  ?                                             *
 *********************************************************/
-void psxNULL() { 
+void psxNULL() {
 #ifdef PSXCPU_LOG
 	PSXCPU_LOG("psx: Unimplemented op %x\n", psxRegs.code);
 #endif
@@ -1071,9 +1072,9 @@ void (*psxBSC[64])() = {
 	psxCOP0   , psxNULL  , psxCOP2, psxNULL , psxNULL, psxNULL, psxNULL, psxNULL,
 	psxNULL   , psxNULL  , psxNULL, psxNULL , psxNULL, psxNULL, psxNULL, psxNULL,
 	psxLB     , psxLH    , psxLWL , psxLW   , psxLBU , psxLHU , psxLWR , psxNULL,
-	psxSB     , psxSH    , psxSWL , psxSW   , psxNULL, psxNULL, psxSWR , psxNULL, 
+	psxSB     , psxSH    , psxSWL , psxSW   , psxNULL, psxNULL, psxSWR , psxNULL,
 	psxNULL   , psxNULL  , gteLWC2, psxNULL , psxNULL, psxNULL, psxNULL, psxNULL,
-	psxNULL   , psxNULL  , gteSWC2, psxHLE  , psxNULL, psxNULL, psxNULL, psxNULL 
+	psxNULL   , psxNULL  , gteSWC2, psxHLE  , psxNULL, psxNULL, psxNULL, psxNULL
 };
 
 
@@ -1108,7 +1109,7 @@ void (*psxCP2[64])() = {
 	gteDPCS , gteINTPL, gteMVMVA, gteNCDS, gteCDP , psxNULL , gteNCDT , psxNULL, // 10
 	psxNULL , psxNULL , psxNULL , gteNCCS, gteCC  , psxNULL , gteNCS  , psxNULL, // 18
 	gteNCT  , psxNULL , psxNULL , psxNULL, psxNULL, psxNULL , psxNULL , psxNULL, // 20
-	gteSQR  , gteDCPL , gteDPCT , psxNULL, psxNULL, gteAVSZ3, gteAVSZ4, psxNULL, // 28 
+	gteSQR  , gteDCPL , gteDPCT , psxNULL, psxNULL, gteAVSZ3, gteAVSZ4, psxNULL, // 28
 	gteRTPT , psxNULL , psxNULL , psxNULL, psxNULL, psxNULL , psxNULL , psxNULL, // 30
 	psxNULL , psxNULL , psxNULL , psxNULL, psxNULL, gteGPF  , gteGPL  , gteNCCT  // 38
 };
@@ -1182,7 +1183,7 @@ static void intReset() {
 }
 
 static void intExecute() {
-	for (;;) 
+	for (;;)
 		execI();
 }
 
@@ -1197,14 +1198,77 @@ static void intClear(u32 Addr, u32 Size) {
 static void intShutdown() {
 }
 
+static void process_gdb(void) {
+	static int shutdown;
+	static u32 tgt_addr;
+	static int step, must_continue;
+	struct msg msg;
+
+	if (shutdown)
+		return;
+
+	if (step || (must_continue && tgt_addr && tgt_addr == psxRegs.pc)) {
+		msg.type = MSG_TYPE_HIT;
+#if DEBUG == 1
+		printf("hit address 0x%08X\n", psxRegs.pc);
+#endif
+		gdbstub_sys_send(&msg);
+		must_continue = 0;
+		step = 0;
+	}
+
+	if (!must_continue) {
+		gdbstub_sys_recv(&msg);
+
+		switch (msg.type) {
+			case MSG_TYPE_CONTINUE:
+				must_continue = 1;
+				break;
+
+			case MSG_TYPE_STEP:
+				step = 1;
+				break;
+
+			case MSG_TYPE_REMOVE_BREAKPOINT: {
+				struct msg out;
+
+				tgt_addr = 0;
+				out.type = MSG_TYPE_ACK;
+
+				gdbstub_sys_send(&out);
+			}
+				break;
+
+			case MSG_TYPE_BREAKPOINT: {
+				struct msg out;
+
+				tgt_addr = msg.data.breakpoint.addr;
+				out.type = MSG_TYPE_ACK;
+
+				gdbstub_sys_send(&out);
+			}
+				break;
+
+			case MSG_TYPE_SHUTDOWN:
+				shutdown = 1;
+				break;
+
+			default:
+				fprintf(stderr, "unknown msg.type %d\n", msg.type);
+				break;
+		}
+	}
+}
+
 // interpreter execution
-static inline void execI() { 
+static inline void execI() {
 	u32 *code = Read_ICache(psxRegs.pc, FALSE);
 	psxRegs.code = ((code == NULL) ? 0 : SWAP32(*code));
 
 	debugI();
 
-	if (Config.Debug) ProcessDebug();
+	if (Config.GdbServer) process_gdb();
+	else if (Config.Debug) ProcessDebug();
 
 	psxRegs.pc += 4;
 	psxRegs.cycle += BIAS;
diff --git a/libpcsxcore/socket.c b/libpcsxcore/socket.c
index f0b19853..eec4c96a 100644
--- a/libpcsxcore/socket.c
+++ b/libpcsxcore/socket.c
@@ -21,6 +21,7 @@
 
 #include "psxcommon.h"
 #include "socket.h"
+#include "config.h"
 
 #ifndef _WIN32
 #include <sys/socket.h>
@@ -31,17 +32,10 @@
 #include <fcntl.h>
 #endif
 
-static int server_socket = 0;
-static int client_socket = 0;
-
-static char tbuf[513];
-static int ptr = 0;
-
-#define PORT_NUMBER 12345
-
-int StartServer() {
+int StartServer(unsigned short port) {
     struct in_addr localhostaddr;
     struct sockaddr_in localsocketaddr;
+    int ret;
 
 #ifdef _WIN32
     WSADATA wsaData;
@@ -50,17 +44,17 @@ int StartServer() {
         return -1;
 #endif
 
-    server_socket = socket(AF_INET, SOCK_STREAM, 0);
+    ret = socket(AF_INET, SOCK_STREAM, 0);
 
 #ifdef _WIN32
-    if (server_socket == INVALID_SOCKET)
+    if (ret == INVALID_SOCKET)
         return -1;
 #else
-    if (server_socket == -1)
-        return -1;
+    if (ret == -1)
+        return ret;
 #endif
 
-    SetsNonblock();
+    SetsNonblock(ret);
 
     memset((void *)&localhostaddr, 0, sizeof(localhostaddr));
     memset(&localsocketaddr, 0, sizeof(struct sockaddr_in));
@@ -72,59 +66,51 @@ int StartServer() {
 #endif
     localsocketaddr.sin_family = AF_INET;
     localsocketaddr.sin_addr = localhostaddr;
-    localsocketaddr.sin_port = htons(PORT_NUMBER);
+    localsocketaddr.sin_port = htons(port);
 
-    if (bind(server_socket, (struct sockaddr *) &localsocketaddr, sizeof(localsocketaddr)) < 0)
+    if (bind(ret, (struct sockaddr *) &localsocketaddr, sizeof(localsocketaddr)) < 0)
         return -1;
 
-    if (listen(server_socket, 1) != 0)
+    if (listen(ret, 1) != 0)
         return -1;
 
-    return 0;
+    return ret;
 }
 
-void StopServer() {
+void StopServer(int s_socket) {
 #ifdef _WIN32
-    shutdown(server_socket, SD_BOTH);
-    closesocket(server_socket);
+    shutdown(s_socket, SD_BOTH);
+    closesocket(s_socket);
     WSACleanup();
 #else
-    shutdown(server_socket, SHUT_RDWR);
-    close(server_socket);
+    shutdown(s_socket, SHUT_RDWR);
+    close(s_socket);
 #endif
 }
 
-void GetClient() {
-    int new_socket;
-    char hello[256];
+int GetClient(int s_socket, int blocking) {
+    int new_socket = accept(s_socket, NULL, NULL);
 
-    new_socket = accept(server_socket, 0, 0);
-    
 #ifdef _WIN32
     if (new_socket == INVALID_SOCKET)
-        return;
+        return -1;
 #else
     if (new_socket == -1)
-        return;
+        return -1;
 #endif
-    if (client_socket)
-        CloseClient();
-    client_socket = new_socket;
 
 #ifndef _WIN32
+    if (!blocking)
     {
         int flags;
-        flags = fcntl(client_socket, F_GETFL, 0);
-        fcntl(client_socket, F_SETFL, flags | O_NONBLOCK);
+        flags = fcntl(new_socket, F_GETFL, 0);
+        fcntl(new_socket, F_SETFL, flags | O_NONBLOCK);
+        return new_socket;
     }
 #endif
-
-    sprintf(hello, "000 PCSXR Version %s - Debug console\r\n", PACKAGE_VERSION);
-    WriteSocket(hello, strlen(hello));
-    ptr = 0;
 }
 
-void CloseClient() {
+void CloseClient(int client_socket) {
     if (client_socket) {
 #ifdef _WIN32
         shutdown(client_socket, SD_BOTH);
@@ -133,28 +119,69 @@ void CloseClient() {
         shutdown(client_socket, SHUT_RDWR);
         close(client_socket);
 #endif
-        client_socket = 0;
     }
 }
 
-int HasClient() {
-    return client_socket ? 1 : 0;
+int HasClient(int client_socket) {
+    return client_socket > 0;
 }
 
-int ReadSocket(char * buffer, int len) {
-    int r;
-    char * endl;
+#ifdef _WIN32
 
-    if (!client_socket)
-        return -1;
+static enum read_socket_err ReadSocketOS(SOCKET client_socket, char *buf, size_t *const len)
+{
+    const int res = recv(client_socket, buf, len, 0);
 
-    r = recv(client_socket, tbuf + ptr, 512 - ptr, 0);
+    switch (res)
+    {
+        case SOCKET_ERROR:
+            return READ_SOCKET_ERR_RECV;
 
-    if (r == 0) {
-        client_socket = 0;
-        if (!ptr)
-            return 0;
+        case 0:
+            return READ_SOCKET_SHUTDOWN;
+
+        default:
+            *len = res;
+
+            break;
+    }
+
+    return READ_SOCKET_OK;
+}
+
+#elif defined(_POSIX_VERSION)
+
+static enum read_socket_err ReadSocketOS(int client_socket, char *buf, size_t *const len)
+{
+    const ssize_t res = recv(client_socket, buf, *len, 0);
+
+    switch (res)
+    {
+        case -1:
+            return READ_SOCKET_ERR_RECV;
+
+        case 0:
+            return READ_SOCKET_SHUTDOWN;
+
+        default:
+            *len = res;
+            break;
     }
+
+    return READ_SOCKET_OK;
+}
+
+#endif /* _WIN32 */
+
+enum read_socket_err ReadSocket(int client_socket, char *buf, size_t *const len) {
+    char * endl;
+
+    if (!client_socket || !buf || !len || !*len)
+        return READ_SOCKET_ERR_INVALID_ARG;
+
+    return ReadSocketOS(client_socket, buf, len);
+
+#if 0
 #ifdef _WIN32
     if (r == SOCKET_ERROR)
 #else
@@ -185,11 +212,11 @@ int ReadSocket(char * buffer, int len) {
     }
 
     buffer[r] = 0;
-
-    return r;
+#endif
 }
 
-int RawReadSocket(char * buffer, int len) {
+int RawReadSocket(int client_socket, char *buffer, size_t len) {
+#if 0
     int r = 0;
     int mlen = len < ptr ? len : ptr;
 
@@ -206,7 +233,6 @@ int RawReadSocket(char * buffer, int len) {
         r = recv(client_socket, buffer + mlen, len - mlen, 0);
 
     if (r == 0) {
-        client_socket = 0;
         if (!ptr)
             return 0;
     }
@@ -224,31 +250,34 @@ int RawReadSocket(char * buffer, int len) {
     r += mlen;
 
     return r;
+#endif
 }
 
-void WriteSocket(char * buffer, int len) {
-    if (!client_socket)
+void WriteSocket(int client_socket, const void *buffer, size_t len) {
+    if (client_socket <= 0)
         return;
 
-    send(client_socket, buffer, len, 0);
+    if (send(client_socket, buffer, len, 0) == -1) {
+        perror("send():");
+    }
 }
 
-void SetsBlock() {
+void SetsBlock(int s_socket) {
 #ifdef _WIN32
     u_long b = 0;
-    ioctlsocket(server_socket, FIONBIO, &b);
+    ioctlsocket(s_socket, FIONBIO, &b);
 #else
-    int flags = fcntl(server_socket, F_GETFL, 0);
-    fcntl(server_socket, F_SETFL, flags & ~O_NONBLOCK);
+    int flags = fcntl(s_socket, F_GETFL, 0);
+    fcntl(s_socket, F_SETFL, flags & ~O_NONBLOCK);
 #endif
 }
 
-void SetsNonblock() {
+void SetsNonblock(int s_socket) {
 #ifdef _WIN32
     u_long b = 1;
-    ioctlsocket(server_socket, FIONBIO, &b);
+    ioctlsocket(s_socket, FIONBIO, &b);
 #else
-    int flags = fcntl(server_socket, F_GETFL, 0);
-    fcntl(server_socket, F_SETFL, flags | O_NONBLOCK);
+    int flags = fcntl(s_socket, F_GETFL, 0);
+    fcntl(s_socket, F_SETFL, flags | O_NONBLOCK);
 #endif
 }
diff --git a/libpcsxcore/socket.h b/libpcsxcore/socket.h
index 7ee0deb4..852c76a4 100644
--- a/libpcsxcore/socket.h
+++ b/libpcsxcore/socket.h
@@ -22,20 +22,30 @@
 extern "C" {
 #endif
 
-int StartServer();
-void StopServer();
+#include <stddef.h>
 
-void GetClient();
-void CloseClient();
+enum read_socket_err
+{
+    READ_SOCKET_OK,
+    READ_SOCKET_ERR_INVALID_ARG,
+    READ_SOCKET_ERR_RECV,
+    READ_SOCKET_SHUTDOWN
+};
 
-int HasClient();
+int StartServer(unsigned short port);
+void StopServer(int s_socket);
 
-int ReadSocket(char * buffer, int len);
-int RawReadSocket(char * buffer, int len);
-void WriteSocket(char * buffer, int len);
+int GetClient(int s_socket, int blocking);
+void CloseClient(int client_socket);
 
-void SetsBlock();
-void SetsNonblock();
+int HasClient(int client_socket);
+
+enum read_socket_err ReadSocket(int client_socket, char *buffer, size_t *len);
+int RawReadSocket(int client_socket, char *buffer, size_t len);
+void WriteSocket(int client_socket, const void *buffer, size_t len);
+
+void SetsBlock(int s_socket);
+void SetsNonblock(int s_socket);
 
 #ifdef __cplusplus
 }