[patches.git] / f.patch

Index: target_bfin_new.c
===================================================================
--- target_bfin_new.c	(revision 2656)
+++ target_bfin_new.c	(working copy)
@@ -21,6 +21,7 @@
 #include <config.h>
 #endif /* HAVE_CONFIG_H */
 
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
@@ -30,8 +31,11 @@
 #include <time.h>
 #include <stdarg.h>
 #include <getopt.h>
+#include <pthread.h>
+#include <fcntl.h>
 
 #include "gdbproxy.h"
+#include "rpmisc.h"
 
 #include "part.h"
 #include "chain.h"
@@ -4672,6 +4676,177 @@ bfin_out_treg (char *in, unsigned int re
   return bfin_out_treg_value (in, reg_no, value);
 }
 \f
+#define DR_OUT (cpu->chain->parts->parts[cpu->chain->active_part]->active_instruction->data_register->out)
+#define DR_IN (cpu->chain->parts->parts[cpu->chain->active_part]->active_instruction->data_register->in)
+
+static unsigned int btc_port = 2001;
+static int btc_listen_sock = -1;
+
+static pthread_t btc_thread;
+
+static char *btc_read_buff = NULL;
+static size_t btc_read_len = 0;
+static inline void btc_read_maybe_queue(void)
+{
+	if (DR_OUT->data[40 - 1 - 7] == 0)
+		return;
+
+	size_t i;
+	uint32_t data = 0;
+	for (i = 0; i < 32; ++i)
+		data |= DR_OUT->data[i] << (32 - 1 - i);
+
+	printf("got from Blackfin: 0x%08x\n", data);
+
+	btc_read_buff = realloc(btc_read_buff, btc_read_len + 4);
+	memcpy(btc_read_buff + btc_read_len, &data, 4);
+	btc_read_len += 4;
+}
+
+static inline int jtag_strdup_parse_line(char *buf)
+{
+	int ret;
+	buf = strdup(buf);
+	ret = jtag_parse_line(cpu->chain, buf);
+	free(buf);
+	return ret;
+}
+
+static size_t btc_write(size_t length, void *data)
+{
+	size_t i, j, b;
+	char *buf = data;
+	char dr_cmd[] = "dr 0000000000000000000000000000000000000000"; /* need 40bits */
+
+	/* in full duplex, we need to look at 7th bit
+	 * to see if Blackfin is sending to us
+	 */
+	for (i = 0; i < length; i += 4) {
+		dr_cmd[3 + 6] = '0';
+		jtag_strdup_parse_line(dr_cmd);
+		while (1) {
+			jtag_strdup_parse_line("shift dr");
+			//jtag_strdup_parse_line("dr");
+			//printf("{ in:%s\n out:%s}\n", register_get_string(DR_IN), register_get_string(DR_OUT));
+
+			btc_read_maybe_queue();
+
+			if (DR_OUT->data[40 - 1 - 6] == 0)
+				break;
+		}
+
+		dr_cmd[3 + 6] = '1';
+		for (j = 0; j < 4; ++j) {
+			//printf("byte: %c (0x%02x): 0y", buf[i+j], buf[i+j]);
+			for (b = 0; b < 8; ++b) {
+				char bit = ((buf[i+j] >> b) & 0x1) + '0';
+				dr_cmd[3 + 8 + 8*j + b] = bit;
+				//printf("%c", bit);
+			}
+			//printf("\n");
+		}
+		//printf("dr_cmd: %s\n", dr_cmd);
+		jtag_strdup_parse_line(dr_cmd);
+		jtag_strdup_parse_line("shift dr");
+		btc_read_maybe_queue();
+	}
+
+	return 0;
+}
+
+static void *btc_thread_main(void *arg)
+{
+	int btc_sock;
+	ssize_t io_ret;
+	char buf[1024];
+
+	{
+		int fd = open("/dev/null", O_WRONLY);
+		dup2(fd, STDOUT_FILENO);
+		close(fd);
+	}
+
+	while (1) {
+		btc_sock = sock_accept(btc_listen_sock);
+		fcntl(btc_sock, F_SETFL, fcntl(btc_sock, F_GETFL) | O_NONBLOCK);
+//		dup2(btc_sock, STDOUT_FILENO);
+
+		jtag_strdup_parse_line("instruction EMUDAT_40_SCAN");
+		jtag_strdup_parse_line("shift ir");
+
+		while (1) {
+#if 0
+			memset(buf, 'a', sizeof(buf));
+			io_ret = read(btc_sock, buf, sizeof(buf)-1);
+			if (io_ret <= 0)
+				break;
+			while (io_ret > 0)
+				if (buf[io_ret-1] == '\n' || buf[io_ret-1] == '\r')
+					--io_ret;
+				else
+					break;
+			if (io_ret <= 0)
+				continue;
+			buf[io_ret] = '\0';
+			printf("SOCKET: '%s'\n", buf);
+
+			if (buf[0] == '!')
+				printf("jtag_parse_line: %i\n", jtag_parse_line(cpu->chain, buf+1));
+			else
+				btc_write(io_ret, buf);
+#else
+			char byte;
+			io_ret = read(btc_sock, &byte, 1);
+			if (io_ret == 0 || (io_ret == -1 && errno != EAGAIN))
+				break;
+
+			if (io_ret > 0)
+				btc_write(1, &byte);
+			else {
+				jtag_strdup_parse_line("dr 0000000000000000000000000000000000000000");
+				jtag_strdup_parse_line("shift dr");
+				btc_read_maybe_queue();
+			}
+
+			if (btc_read_len) {
+				write(btc_sock, btc_read_buff, 1);
+				btc_read_len = 0;
+			}
+#endif
+		}
+
+		close(btc_sock);
+	}
+
+	return NULL;
+}
+
+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+static void bfin_btc_init(void)
+{
+	size_t i;
+	char *btc_command_init[] = {
+		/* declare a 40bit version of emudat */
+		"register EMUDAT_40 40",
+		"instruction EMUDAT_40_SCAN 10100 EMUDAT_40",
+
+		/* set emudat to 40bits */
+		"instruction DBGCTL_SCAN",
+		"shift ir",
+		"shift dr",
+		"dr 0000000100000000",
+		"shift dr"
+	};
+
+	btc_listen_sock = listen_sock_open(&btc_port);
+	if (btc_listen_sock == -1)
+		return;
+
+	pthread_create(&btc_thread, NULL, btc_thread_main, NULL);
+	for (i = 0; i < ARRAY_SIZE(btc_command_init); ++i)
+		jtag_strdup_parse_line(btc_command_init[i]);
+}
+\f
 
 /* Target method */
 static void
@@ -5208,6 +5383,8 @@ bfin_open (int argc,
       cpu->cores[0].name = "Core";
     }
 
+  bfin_btc_init();
+
   return RP_VAL_TARGETRET_OK;
 }
 
Index: rpmisc.c
===================================================================
--- rpmisc.c	(revision 2656)
+++ rpmisc.c	(working copy)
@@ -98,13 +98,14 @@
 
 
 /* Sockets */
-#if defined(WIN32)
+#if !defined(WIN32)
+# undef INVALID_SOCKET
+# define INVALID_SOCKET -1
+# undef SOCKET_ERROR
+# define SOCKET_ERROR -1
+#endif
 static int dbg_sock        = INVALID_SOCKET;
 static int dbg_listen_sock = INVALID_SOCKET;
-#else
-static int dbg_sock        = -1;
-static int dbg_listen_sock = -1;
-#endif
 
 /* Log functions */
 static void rp_log_local(int level, const char *fmt, ...);
@@ -140,29 +141,21 @@ void dbg_sock_cleanup(void)
 }
 
 /* Open listen socket in a mode expected by gdb */
-int dbg_listen_sock_open(unsigned int *port)
+int listen_sock_open(unsigned int *port)
 {
     struct sockaddr_in sa;
     int tmp;
     int ret;
     unsigned int p;
+	int sock;
 
     assert(port == NULL  ||  *port < 0x10000);
 
-#if defined(WIN32)
-    assert(dbg_sock == INVALID_SOCKET  &&  dbg_listen_sock == INVALID_SOCKET);
-
-    if ((dbg_listen_sock = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
-        return  FALSE;
-#else
-    assert(dbg_sock == -1  &&  dbg_listen_sock == -1);
-
-    if ((dbg_listen_sock = socket(PF_INET, SOCK_STREAM, 0)) < 0)
-        return  FALSE;
-#endif
+    if ((sock = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
+        return INVALID_SOCKET;
 
     tmp = 1;
-    setsockopt(dbg_listen_sock,
+    setsockopt(sock,
     	       SOL_SOCKET,
 	       SO_REUSEADDR,
 	       (char *) &tmp,
@@ -178,13 +171,8 @@ int dbg_listen_sock_open(unsigned int *p
         else
             sa.sin_port = htons((unsigned short int) *port);
 
-#if defined(WIN32)
-        if ((ret = bind(dbg_listen_sock, (struct sockaddr *) &sa, sizeof (sa))) == SOCKET_ERROR)
-            return  FALSE;
-#else
-        if ((ret = bind(dbg_listen_sock, (struct sockaddr *) &sa, sizeof (sa))) != 0)
-            return  FALSE;
-#endif
+        if ((ret = bind(sock, (struct sockaddr *) &sa, sizeof (sa))) == SOCKET_ERROR)
+            return INVALID_SOCKET;
     }
     else
     {
@@ -194,79 +182,68 @@ int dbg_listen_sock_open(unsigned int *p
         {
             sa.sin_port = htons(p);
 
-#if defined(WIN32)
-            if ((ret = bind(dbg_listen_sock, (struct sockaddr *) &sa, sizeof (sa))) != SOCKET_ERROR)
+            if ((ret = bind(sock, (struct sockaddr *) &sa, sizeof (sa))) != SOCKET_ERROR)
                 break;
-#else
-            if ((ret = bind(dbg_listen_sock, (struct sockaddr *) &sa, sizeof (sa))) == 0)
-                break;
-#endif
         }
 
         if (p == 0x10000)
         {
             /* No sockets available */
-            return  FALSE;
+            return INVALID_SOCKET;
         }
 
         *port = p;
     }
 
-#if defined(WIN32)
-    assert(dbg_listen_sock != INVALID_SOCKET);
+    assert(sock != INVALID_SOCKET);
 
-    if ((ret = listen(dbg_listen_sock, 1)) == SOCKET_ERROR)
-        return  FALSE;
-#else
-    assert(dbg_listen_sock >= 0);
+    if ((ret = listen(sock, 1)) == SOCKET_ERROR)
+        return INVALID_SOCKET;
 
-    if ((ret = listen(dbg_listen_sock, 1)) != 0)
-        return  FALSE;
-#endif
+    return sock;
+}
+int dbg_listen_sock_open(unsigned int *port)
+{
+    assert(dbg_sock == INVALID_SOCKET  &&  dbg_listen_sock == INVALID_SOCKET);
 
-    return  TRUE;
+    dbg_listen_sock = listen_sock_open(port);
+
+    return (dbg_listen_sock == INVALID_SOCKET ? FALSE : TRUE);
 }
 
 /* Accept incoming connection and set mode expected by gdb */
-int dbg_sock_accept(void)
+int sock_accept(int listen_sock)
 {
     socklen_t tmp;
     struct sockaddr_in sa;
     struct protoent *pe;
-
-#if defined(WIN32)
-    assert(dbg_sock == INVALID_SOCKET);
-    assert(dbg_listen_sock != INVALID_SOCKET);
+    int sock;
 
     tmp = sizeof(sa);
-    if ((dbg_sock = accept(dbg_listen_sock, (struct sockaddr *) &sa, &tmp))
+    if ((sock = accept(listen_sock, (struct sockaddr *) &sa, &tmp))
         == INVALID_SOCKET)
     {
-        return  FALSE;
+        return INVALID_SOCKET;
     }
 
     if ((pe = getprotobyname("tcp")) == NULL)
-        return  FALSE;
-#else
-    assert(dbg_sock < 0);
-    assert(dbg_listen_sock >= 0);
-
-    tmp = sizeof(sa);
-    if ((dbg_sock = accept(dbg_listen_sock, (struct sockaddr *) &sa, &tmp)) < 0)
-        return  FALSE;
-
-    if ((pe = getprotobyname("tcp")) == NULL)
-        return  FALSE;
-#endif
+        return INVALID_SOCKET;
 
     tmp = 1;
-    setsockopt(dbg_sock,
+    setsockopt(sock,
                pe->p_proto,
                TCP_NODELAY,
                (char *) &tmp,
                sizeof(tmp));
 
-    return  TRUE;
+    return sock;
+}
+int dbg_sock_accept(void)
+{
+    assert(dbg_sock == INVALID_SOCKET);
+    assert(dbg_listen_sock != INVALID_SOCKET);
+    dbg_sock = sock_accept(dbg_listen_sock);
+    return (dbg_sock == INVALID_SOCKET ? FALSE : TRUE);
 }
 
 /* Close connection to debugger side */
Index: rpmisc.h
===================================================================
--- rpmisc.h	(revision 2656)
+++ rpmisc.h	(working copy)
@@ -39,6 +39,9 @@ int  dbg_sock_accept(void);
 int  dbg_sock_readchar(int ms);
 int  dbg_listen_sock_open(unsigned int *port);
 
+int  listen_sock_open(unsigned int *port);
+int  sock_accept(int listen_sock);
+
 /* Return values for readchar: either character
    code or one of the following*/
 #define RP_VAL_MISCREADCHARRET_TMOUT (-2)
Commit	Line	Data
	1	Index: target_bfin_new.c
	2	===================================================================
	3	--- target_bfin_new.c (revision 2656)
	4	+++ target_bfin_new.c (working copy)
	5	@@ -21,6 +21,7 @@
	6	#include <config.h>
	7	#endif /* HAVE_CONFIG_H */
	8
	9	+#include <errno.h>
	10	#include <stdio.h>
	11	#include <stdlib.h>
	12	#include <stdint.h>
	13	@@ -30,8 +31,11 @@
	14	#include <time.h>
	15	#include <stdarg.h>
	16	#include <getopt.h>
	17	+#include <pthread.h>
	18	+#include <fcntl.h>
	19
	20	#include "gdbproxy.h"
	21	+#include "rpmisc.h"
	22
	23	#include "part.h"
	24	#include "chain.h"
	25	@@ -4672,6 +4676,177 @@ bfin_out_treg (char *in, unsigned int re
	26	return bfin_out_treg_value (in, reg_no, value);
	27	}
	28	\f
	29	+#define DR_OUT (cpu->chain->parts->parts[cpu->chain->active_part]->active_instruction->data_register->out)
	30	+#define DR_IN (cpu->chain->parts->parts[cpu->chain->active_part]->active_instruction->data_register->in)
	31	+
	32	+static unsigned int btc_port = 2001;
	33	+static int btc_listen_sock = -1;
	34	+
	35	+static pthread_t btc_thread;
	36	+
	37	+static char *btc_read_buff = NULL;
	38	+static size_t btc_read_len = 0;
	39	+static inline void btc_read_maybe_queue(void)
	40	+{
	41	+ if (DR_OUT->data[40 - 1 - 7] == 0)
	42	+ return;
	43	+
	44	+ size_t i;
	45	+ uint32_t data = 0;
	46	+ for (i = 0; i < 32; ++i)
	47	+ data \|= DR_OUT->data[i] << (32 - 1 - i);
	48	+
	49	+ printf("got from Blackfin: 0x%08x\n", data);
	50	+
	51	+ btc_read_buff = realloc(btc_read_buff, btc_read_len + 4);
	52	+ memcpy(btc_read_buff + btc_read_len, &data, 4);
	53	+ btc_read_len += 4;
	54	+}
	55	+
	56	+static inline int jtag_strdup_parse_line(char *buf)
	57	+{
	58	+ int ret;
	59	+ buf = strdup(buf);
	60	+ ret = jtag_parse_line(cpu->chain, buf);
	61	+ free(buf);
	62	+ return ret;
	63	+}
	64	+
	65	+static size_t btc_write(size_t length, void *data)
	66	+{
	67	+ size_t i, j, b;
	68	+ char *buf = data;
	69	+ char dr_cmd[] = "dr 0000000000000000000000000000000000000000"; /* need 40bits */
	70	+
	71	+ /* in full duplex, we need to look at 7th bit
	72	+ * to see if Blackfin is sending to us
	73	+ */
	74	+ for (i = 0; i < length; i += 4) {
	75	+ dr_cmd[3 + 6] = '0';
	76	+ jtag_strdup_parse_line(dr_cmd);
	77	+ while (1) {
	78	+ jtag_strdup_parse_line("shift dr");
	79	+ //jtag_strdup_parse_line("dr");
	80	+ //printf("{ in:%s\n out:%s}\n", register_get_string(DR_IN), register_get_string(DR_OUT));
	81	+
	82	+ btc_read_maybe_queue();
	83	+
	84	+ if (DR_OUT->data[40 - 1 - 6] == 0)
	85	+ break;
	86	+ }
	87	+
	88	+ dr_cmd[3 + 6] = '1';
	89	+ for (j = 0; j < 4; ++j) {
	90	+ //printf("byte: %c (0x%02x): 0y", buf[i+j], buf[i+j]);
	91	+ for (b = 0; b < 8; ++b) {
	92	+ char bit = ((buf[i+j] >> b) & 0x1) + '0';
	93	+ dr_cmd[3 + 8 + 8*j + b] = bit;
	94	+ //printf("%c", bit);
	95	+ }
	96	+ //printf("\n");
	97	+ }
	98	+ //printf("dr_cmd: %s\n", dr_cmd);
	99	+ jtag_strdup_parse_line(dr_cmd);
	100	+ jtag_strdup_parse_line("shift dr");
	101	+ btc_read_maybe_queue();
	102	+ }
	103	+
	104	+ return 0;
	105	+}
	106	+
	107	+static void btc_thread_main(void arg)
	108	+{
	109	+ int btc_sock;
	110	+ ssize_t io_ret;
	111	+ char buf[1024];
	112	+
	113	+ {
	114	+ int fd = open("/dev/null", O_WRONLY);
	115	+ dup2(fd, STDOUT_FILENO);
	116	+ close(fd);
	117	+ }
	118	+
	119	+ while (1) {
	120	+ btc_sock = sock_accept(btc_listen_sock);
	121	+ fcntl(btc_sock, F_SETFL, fcntl(btc_sock, F_GETFL) \| O_NONBLOCK);
	122	+// dup2(btc_sock, STDOUT_FILENO);
	123	+
	124	+ jtag_strdup_parse_line("instruction EMUDAT_40_SCAN");
	125	+ jtag_strdup_parse_line("shift ir");
	126	+
	127	+ while (1) {
	128	+#if 0
	129	+ memset(buf, 'a', sizeof(buf));
	130	+ io_ret = read(btc_sock, buf, sizeof(buf)-1);
	131	+ if (io_ret <= 0)
	132	+ break;
	133	+ while (io_ret > 0)
	134	+ if (buf[io_ret-1] == '\n' \|\| buf[io_ret-1] == '\r')
	135	+ --io_ret;
	136	+ else
	137	+ break;
	138	+ if (io_ret <= 0)
	139	+ continue;
	140	+ buf[io_ret] = '\0';
	141	+ printf("SOCKET: '%s'\n", buf);
	142	+
	143	+ if (buf[0] == '!')
	144	+ printf("jtag_parse_line: %i\n", jtag_parse_line(cpu->chain, buf+1));
	145	+ else
	146	+ btc_write(io_ret, buf);
	147	+#else
	148	+ char byte;
	149	+ io_ret = read(btc_sock, &byte, 1);
	150	+ if (io_ret == 0 \|\| (io_ret == -1 && errno != EAGAIN))
	151	+ break;
	152	+
	153	+ if (io_ret > 0)
	154	+ btc_write(1, &byte);
	155	+ else {
	156	+ jtag_strdup_parse_line("dr 0000000000000000000000000000000000000000");
	157	+ jtag_strdup_parse_line("shift dr");
	158	+ btc_read_maybe_queue();
	159	+ }
	160	+
	161	+ if (btc_read_len) {
	162	+ write(btc_sock, btc_read_buff, 1);
	163	+ btc_read_len = 0;
	164	+ }
	165	+#endif
	166	+ }
	167	+
	168	+ close(btc_sock);
	169	+ }
	170	+
	171	+ return NULL;
	172	+}
	173	+
	174	+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
	175	+static void bfin_btc_init(void)
	176	+{
	177	+ size_t i;
	178	+ char *btc_command_init[] = {
	179	+ /* declare a 40bit version of emudat */
	180	+ "register EMUDAT_40 40",
	181	+ "instruction EMUDAT_40_SCAN 10100 EMUDAT_40",
	182	+
	183	+ /* set emudat to 40bits */
	184	+ "instruction DBGCTL_SCAN",
	185	+ "shift ir",
	186	+ "shift dr",
	187	+ "dr 0000000100000000",
	188	+ "shift dr"
	189	+ };
	190	+
	191	+ btc_listen_sock = listen_sock_open(&btc_port);
	192	+ if (btc_listen_sock == -1)
	193	+ return;
	194	+
	195	+ pthread_create(&btc_thread, NULL, btc_thread_main, NULL);
	196	+ for (i = 0; i < ARRAY_SIZE(btc_command_init); ++i)
	197	+ jtag_strdup_parse_line(btc_command_init[i]);
	198	+}
	199	+\f
	200
	201	/* Target method */
	202	static void
	203	@@ -5208,6 +5383,8 @@ bfin_open (int argc,
	204	cpu->cores[0].name = "Core";
	205	}
	206
	207	+ bfin_btc_init();
	208	+
	209	return RP_VAL_TARGETRET_OK;
	210	}
	211
	212	Index: rpmisc.c
	213	===================================================================
	214	--- rpmisc.c (revision 2656)
	215	+++ rpmisc.c (working copy)
	216	@@ -98,13 +98,14 @@
	217
	218
	219	/* Sockets */
	220	-#if defined(WIN32)
	221	+#if !defined(WIN32)
	222	+# undef INVALID_SOCKET
	223	+# define INVALID_SOCKET -1
	224	+# undef SOCKET_ERROR
	225	+# define SOCKET_ERROR -1
	226	+#endif
	227	static int dbg_sock = INVALID_SOCKET;
	228	static int dbg_listen_sock = INVALID_SOCKET;
	229	-#else
	230	-static int dbg_sock = -1;
	231	-static int dbg_listen_sock = -1;
	232	-#endif
	233
	234	/* Log functions */
	235	static void rp_log_local(int level, const char *fmt, ...);
	236	@@ -140,29 +141,21 @@ void dbg_sock_cleanup(void)
	237	}
	238
	239	/* Open listen socket in a mode expected by gdb */
	240	-int dbg_listen_sock_open(unsigned int *port)
	241	+int listen_sock_open(unsigned int *port)
	242	{
	243	struct sockaddr_in sa;
	244	int tmp;
	245	int ret;
	246	unsigned int p;
	247	+ int sock;
	248
	249	assert(port == NULL \|\| *port < 0x10000);
	250
	251	-#if defined(WIN32)
	252	- assert(dbg_sock == INVALID_SOCKET && dbg_listen_sock == INVALID_SOCKET);
	253	-
	254	- if ((dbg_listen_sock = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
	255	- return FALSE;
	256	-#else
	257	- assert(dbg_sock == -1 && dbg_listen_sock == -1);
	258	-
	259	- if ((dbg_listen_sock = socket(PF_INET, SOCK_STREAM, 0)) < 0)
	260	- return FALSE;
	261	-#endif
	262	+ if ((sock = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
	263	+ return INVALID_SOCKET;
	264
	265	tmp = 1;
	266	- setsockopt(dbg_listen_sock,
	267	+ setsockopt(sock,
	268	SOL_SOCKET,
	269	SO_REUSEADDR,
	270	(char *) &tmp,
	271	@@ -178,13 +171,8 @@ int dbg_listen_sock_open(unsigned int *p
	272	else
	273	sa.sin_port = htons((unsigned short int) *port);
	274
	275	-#if defined(WIN32)
	276	- if ((ret = bind(dbg_listen_sock, (struct sockaddr *) &sa, sizeof (sa))) == SOCKET_ERROR)
	277	- return FALSE;
	278	-#else
	279	- if ((ret = bind(dbg_listen_sock, (struct sockaddr *) &sa, sizeof (sa))) != 0)
	280	- return FALSE;
	281	-#endif
	282	+ if ((ret = bind(sock, (struct sockaddr *) &sa, sizeof (sa))) == SOCKET_ERROR)
	283	+ return INVALID_SOCKET;
	284	}
	285	else
	286	{
	287	@@ -194,79 +182,68 @@ int dbg_listen_sock_open(unsigned int *p
	288	{
	289	sa.sin_port = htons(p);
	290
	291	-#if defined(WIN32)
	292	- if ((ret = bind(dbg_listen_sock, (struct sockaddr *) &sa, sizeof (sa))) != SOCKET_ERROR)
	293	+ if ((ret = bind(sock, (struct sockaddr *) &sa, sizeof (sa))) != SOCKET_ERROR)
	294	break;
	295	-#else
	296	- if ((ret = bind(dbg_listen_sock, (struct sockaddr *) &sa, sizeof (sa))) == 0)
	297	- break;
	298	-#endif
	299	}
	300
	301	if (p == 0x10000)
	302	{
	303	/* No sockets available */
	304	- return FALSE;
	305	+ return INVALID_SOCKET;
	306	}
	307
	308	*port = p;
	309	}
	310
	311	-#if defined(WIN32)
	312	- assert(dbg_listen_sock != INVALID_SOCKET);
	313	+ assert(sock != INVALID_SOCKET);
	314
	315	- if ((ret = listen(dbg_listen_sock, 1)) == SOCKET_ERROR)
	316	- return FALSE;
	317	-#else
	318	- assert(dbg_listen_sock >= 0);
	319	+ if ((ret = listen(sock, 1)) == SOCKET_ERROR)
	320	+ return INVALID_SOCKET;
	321
	322	- if ((ret = listen(dbg_listen_sock, 1)) != 0)
	323	- return FALSE;
	324	-#endif
	325	+ return sock;
	326	+}
	327	+int dbg_listen_sock_open(unsigned int *port)
	328	+{
	329	+ assert(dbg_sock == INVALID_SOCKET && dbg_listen_sock == INVALID_SOCKET);
	330
	331	- return TRUE;
	332	+ dbg_listen_sock = listen_sock_open(port);
	333	+
	334	+ return (dbg_listen_sock == INVALID_SOCKET ? FALSE : TRUE);
	335	}
	336
	337	/* Accept incoming connection and set mode expected by gdb */
	338	-int dbg_sock_accept(void)
	339	+int sock_accept(int listen_sock)
	340	{
	341	socklen_t tmp;
	342	struct sockaddr_in sa;
	343	struct protoent *pe;
	344	-
	345	-#if defined(WIN32)
	346	- assert(dbg_sock == INVALID_SOCKET);
	347	- assert(dbg_listen_sock != INVALID_SOCKET);
	348	+ int sock;
	349
	350	tmp = sizeof(sa);
	351	- if ((dbg_sock = accept(dbg_listen_sock, (struct sockaddr *) &sa, &tmp))
	352	+ if ((sock = accept(listen_sock, (struct sockaddr *) &sa, &tmp))
	353	== INVALID_SOCKET)
	354	{
	355	- return FALSE;
	356	+ return INVALID_SOCKET;
	357	}
	358
	359	if ((pe = getprotobyname("tcp")) == NULL)
	360	- return FALSE;
	361	-#else
	362	- assert(dbg_sock < 0);
	363	- assert(dbg_listen_sock >= 0);
	364	-
	365	- tmp = sizeof(sa);
	366	- if ((dbg_sock = accept(dbg_listen_sock, (struct sockaddr *) &sa, &tmp)) < 0)
	367	- return FALSE;
	368	-
	369	- if ((pe = getprotobyname("tcp")) == NULL)
	370	- return FALSE;
	371	-#endif
	372	+ return INVALID_SOCKET;
	373
	374	tmp = 1;
	375	- setsockopt(dbg_sock,
	376	+ setsockopt(sock,
	377	pe->p_proto,
	378	TCP_NODELAY,
	379	(char *) &tmp,
	380	sizeof(tmp));
	381
	382	- return TRUE;
	383	+ return sock;
	384	+}
	385	+int dbg_sock_accept(void)
	386	+{
	387	+ assert(dbg_sock == INVALID_SOCKET);
	388	+ assert(dbg_listen_sock != INVALID_SOCKET);
	389	+ dbg_sock = sock_accept(dbg_listen_sock);
	390	+ return (dbg_sock == INVALID_SOCKET ? FALSE : TRUE);
	391	}
	392
	393	/* Close connection to debugger side */
	394	Index: rpmisc.h
	395	===================================================================
	396	--- rpmisc.h (revision 2656)
	397	+++ rpmisc.h (working copy)
	398	@@ -39,6 +39,9 @@ int dbg_sock_accept(void);
	399	int dbg_sock_readchar(int ms);
	400	int dbg_listen_sock_open(unsigned int *port);
	401
	402	+int listen_sock_open(unsigned int *port);
	403	+int sock_accept(int listen_sock);
	404	+
	405	/* Return values for readchar: either character
	406	code or one of the following*/
	407	#define RP_VAL_MISCREADCHARRET_TMOUT (-2)