?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
new 818051de2c8769029049ce3d36c6b856f47496c9
[wine/hacks.git] / programs / winedbg / gdbproxy.c
blob4f83c72941f27f222247cb79dee93561d0b26236
1 /*
2 * A Win32 based proxy implementing the GBD remote protocol
3 * This allows to debug Wine (and any "emulated" program) under
4 * Linux using GDB
5 *
6 * Copyright (c) Eric Pouech 2002-2004
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 /* Protocol specification can be found here:
24 * http://sources.redhat.com/gdb/onlinedocs/gdb_32.html
25 */
26
27 #include "config.h"
28 #include "wine/port.h"
29
30 #include <assert.h>
31 #include <errno.h>
32 #include <fcntl.h>
33 #include <signal.h>
34 #include <stdarg.h>
35 #include <stdio.h>
36 #include <stdlib.h>
37 #ifdef HAVE_SYS_POLL_H
38 # include <sys/poll.h>
39 #endif
40 #ifdef HAVE_SYS_WAIT_H
41 # include <sys/wait.h>
42 #endif
43 #ifdef HAVE_SYS_SOCKET_H
44 # include <sys/socket.h>
45 #endif
46 #ifdef HAVE_NETINET_IN_H
47 # include <netinet/in.h>
48 #endif
49 #ifdef HAVE_NETINET_TCP_H
50 # include <netinet/tcp.h>
51 #endif
52 #ifdef HAVE_UNISTD_H
53 # include <unistd.h>
54 #endif
55
56 /* if we don't have poll support on this system
57 * we won't provide gdb proxy support here...
58 */
59 #ifdef HAVE_POLL
60
61 #include "debugger.h"
62
63 #include "windef.h"
64 #include "winbase.h"
65 #include "tlhelp32.h"
66
67 #define GDBPXY_TRC_LOWLEVEL 0x01
68 #define GDBPXY_TRC_PACKET 0x02
69 #define GDBPXY_TRC_COMMAND 0x04
70 #define GDBPXY_TRC_COMMAND_ERROR 0x08
71 #define GDBPXY_TRC_WIN32_EVENT 0x10
72 #define GDBPXY_TRC_WIN32_ERROR 0x20
73 #define GDBPXY_TRC_COMMAND_FIXME 0x80
74
75 struct gdb_ctx_Xpoint
76 {
77 enum be_xpoint_type type; /* -1 means free */
78 void* addr;
79 unsigned long val;
80 };
81
82 struct gdb_context
83 {
84 /* gdb information */
85 int sock;
86 /* incoming buffer */
87 char* in_buf;
88 int in_buf_alloc;
89 int in_len;
90 /* split into individual packet */
91 char* in_packet;
92 int in_packet_len;
93 /* outgoing buffer */
94 char* out_buf;
95 int out_buf_alloc;
96 int out_len;
97 int out_curr_packet;
98 /* generic GDB thread information */
99 struct dbg_thread* exec_thread; /* thread used in step & continue */
100 struct dbg_thread* other_thread; /* thread to be used in any other operation */
101 unsigned trace;
102 /* current Win32 trap env */
103 unsigned last_sig;
104 BOOL in_trap;
105 CONTEXT context;
106 /* Win32 information */
107 struct dbg_process* process;
108 #define NUM_XPOINT 32
109 struct gdb_ctx_Xpoint Xpoints[NUM_XPOINT];
110 /* Unix environment */
111 unsigned long wine_segs[3]; /* load addresses of the ELF wine exec segments (text, bss and data) */
112 };
113
114 static struct be_process_io be_process_gdbproxy_io;
115
116 /* =============================================== *
117 * B A S I C M A N I P U L A T I O N S *
118 * =============================================== *
119 */
120
121 static inline int hex_from0(char ch)
122 {
123 if (ch >= '0' && ch <= '9') return ch - '0';
124 if (ch >= 'A' && ch <= 'F') return ch - 'A' + 10;
125 if (ch >= 'a' && ch <= 'f') return ch - 'a' + 10;
126
127 assert(0);
128 return 0;
129 }
130
131 static inline unsigned char hex_to0(int x)
132 {
133 assert(x >= 0 && x < 16);
134 return "0123456789abcdef"[x];
135 }
136
137 static int hex_to_int(const char* src, size_t len)
138 {
139 unsigned int returnval = 0;
140 while (len--)
141 {
142 returnval <<= 4;
143 returnval |= hex_from0(*src++);
144 }
145 return returnval;
146 }
147
148 static void hex_from(void* dst, const char* src, size_t len)
149 {
150 unsigned char *p = dst;
151 while (len--)
152 {
153 *p++ = (hex_from0(src[0]) << 4) | hex_from0(src[1]);
154 src += 2;
155 }
156 }
157
158 static void hex_to(char* dst, const void* src, size_t len)
159 {
160 const unsigned char *p = src;
161 while (len--)
162 {
163 *dst++ = hex_to0(*p >> 4);
164 *dst++ = hex_to0(*p & 0x0F);
165 p++;
166 }
167 }
168
169 static unsigned char checksum(const char* ptr, int len)
170 {
171 unsigned cksum = 0;
172
173 while (len-- > 0)
174 cksum += (unsigned char)*ptr++;
175 return cksum;
176 }
177
178 /* =============================================== *
179 * C P U H A N D L E R S *
180 * =============================================== *
181 */
182
183 #ifdef __i386__
184 static size_t cpu_register_map[] = {
185 FIELD_OFFSET(CONTEXT, Eax),
186 FIELD_OFFSET(CONTEXT, Ecx),
187 FIELD_OFFSET(CONTEXT, Edx),
188 FIELD_OFFSET(CONTEXT, Ebx),
189 FIELD_OFFSET(CONTEXT, Esp),
190 FIELD_OFFSET(CONTEXT, Ebp),
191 FIELD_OFFSET(CONTEXT, Esi),
192 FIELD_OFFSET(CONTEXT, Edi),
193 FIELD_OFFSET(CONTEXT, Eip),
194 FIELD_OFFSET(CONTEXT, EFlags),
195 FIELD_OFFSET(CONTEXT, SegCs),
196 FIELD_OFFSET(CONTEXT, SegSs),
197 FIELD_OFFSET(CONTEXT, SegDs),
198 FIELD_OFFSET(CONTEXT, SegEs),
199 FIELD_OFFSET(CONTEXT, SegFs),
200 FIELD_OFFSET(CONTEXT, SegGs),
201 };
202 #elif defined(__powerpc__)
203 static size_t cpu_register_map[] = {
204 FIELD_OFFSET(CONTEXT, Gpr0),
205 FIELD_OFFSET(CONTEXT, Gpr1),
206 FIELD_OFFSET(CONTEXT, Gpr2),
207 FIELD_OFFSET(CONTEXT, Gpr3),
208 FIELD_OFFSET(CONTEXT, Gpr4),
209 FIELD_OFFSET(CONTEXT, Gpr5),
210 FIELD_OFFSET(CONTEXT, Gpr6),
211 FIELD_OFFSET(CONTEXT, Gpr7),
212 FIELD_OFFSET(CONTEXT, Gpr8),
213 FIELD_OFFSET(CONTEXT, Gpr9),
214 FIELD_OFFSET(CONTEXT, Gpr10),
215 FIELD_OFFSET(CONTEXT, Gpr11),
216 FIELD_OFFSET(CONTEXT, Gpr12),
217 FIELD_OFFSET(CONTEXT, Gpr13),
218 FIELD_OFFSET(CONTEXT, Gpr14),
219 FIELD_OFFSET(CONTEXT, Gpr15),
220 FIELD_OFFSET(CONTEXT, Gpr16),
221 FIELD_OFFSET(CONTEXT, Gpr17),
222 FIELD_OFFSET(CONTEXT, Gpr18),
223 FIELD_OFFSET(CONTEXT, Gpr19),
224 FIELD_OFFSET(CONTEXT, Gpr20),
225 FIELD_OFFSET(CONTEXT, Gpr21),
226 FIELD_OFFSET(CONTEXT, Gpr22),
227 FIELD_OFFSET(CONTEXT, Gpr23),
228 FIELD_OFFSET(CONTEXT, Gpr24),
229 FIELD_OFFSET(CONTEXT, Gpr25),
230 FIELD_OFFSET(CONTEXT, Gpr26),
231 FIELD_OFFSET(CONTEXT, Gpr27),
232 FIELD_OFFSET(CONTEXT, Gpr28),
233 FIELD_OFFSET(CONTEXT, Gpr29),
234 FIELD_OFFSET(CONTEXT, Gpr30),
235 FIELD_OFFSET(CONTEXT, Gpr31),
236 FIELD_OFFSET(CONTEXT, Fpr0),
237 FIELD_OFFSET(CONTEXT, Fpr1),
238 FIELD_OFFSET(CONTEXT, Fpr2),
239 FIELD_OFFSET(CONTEXT, Fpr3),
240 FIELD_OFFSET(CONTEXT, Fpr4),
241 FIELD_OFFSET(CONTEXT, Fpr5),
242 FIELD_OFFSET(CONTEXT, Fpr6),
243 FIELD_OFFSET(CONTEXT, Fpr7),
244 FIELD_OFFSET(CONTEXT, Fpr8),
245 FIELD_OFFSET(CONTEXT, Fpr9),
246 FIELD_OFFSET(CONTEXT, Fpr10),
247 FIELD_OFFSET(CONTEXT, Fpr11),
248 FIELD_OFFSET(CONTEXT, Fpr12),
249 FIELD_OFFSET(CONTEXT, Fpr13),
250 FIELD_OFFSET(CONTEXT, Fpr14),
251 FIELD_OFFSET(CONTEXT, Fpr15),
252 FIELD_OFFSET(CONTEXT, Fpr16),
253 FIELD_OFFSET(CONTEXT, Fpr17),
254 FIELD_OFFSET(CONTEXT, Fpr18),
255 FIELD_OFFSET(CONTEXT, Fpr19),
256 FIELD_OFFSET(CONTEXT, Fpr20),
257 FIELD_OFFSET(CONTEXT, Fpr21),
258 FIELD_OFFSET(CONTEXT, Fpr22),
259 FIELD_OFFSET(CONTEXT, Fpr23),
260 FIELD_OFFSET(CONTEXT, Fpr24),
261 FIELD_OFFSET(CONTEXT, Fpr25),
262 FIELD_OFFSET(CONTEXT, Fpr26),
263 FIELD_OFFSET(CONTEXT, Fpr27),
264 FIELD_OFFSET(CONTEXT, Fpr28),
265 FIELD_OFFSET(CONTEXT, Fpr29),
266 FIELD_OFFSET(CONTEXT, Fpr30),
267 FIELD_OFFSET(CONTEXT, Fpr31),
268
269 FIELD_OFFSET(CONTEXT, Iar),
270 FIELD_OFFSET(CONTEXT, Msr),
271 FIELD_OFFSET(CONTEXT, Cr),
272 FIELD_OFFSET(CONTEXT, Lr),
273 FIELD_OFFSET(CONTEXT, Ctr),
274 FIELD_OFFSET(CONTEXT, Xer),
275 /* FIXME: MQ is missing? FIELD_OFFSET(CONTEXT, Mq), */
276 /* see gdb/nlm/ppc.c */
277 };
278 #elif defined(__ALPHA__)
279 static size_t cpu_register_map[] = {
280 FIELD_OFFSET(CONTEXT, IntV0),
281 FIELD_OFFSET(CONTEXT, IntT0),
282 FIELD_OFFSET(CONTEXT, IntT1),
283 FIELD_OFFSET(CONTEXT, IntT2),
284 FIELD_OFFSET(CONTEXT, IntT3),
285 FIELD_OFFSET(CONTEXT, IntT4),
286 FIELD_OFFSET(CONTEXT, IntT5),
287 FIELD_OFFSET(CONTEXT, IntT6),
288 FIELD_OFFSET(CONTEXT, IntT7),
289 FIELD_OFFSET(CONTEXT, IntS0),
290 FIELD_OFFSET(CONTEXT, IntS1),
291 FIELD_OFFSET(CONTEXT, IntS2),
292 FIELD_OFFSET(CONTEXT, IntS3),
293 FIELD_OFFSET(CONTEXT, IntS4),
294 FIELD_OFFSET(CONTEXT, IntS5),
295 FIELD_OFFSET(CONTEXT, IntFp),
296 FIELD_OFFSET(CONTEXT, IntA0),
297 FIELD_OFFSET(CONTEXT, IntA1),
298 FIELD_OFFSET(CONTEXT, IntA2),
299 FIELD_OFFSET(CONTEXT, IntA3),
300 FIELD_OFFSET(CONTEXT, IntA4),
301 FIELD_OFFSET(CONTEXT, IntA5),
302 FIELD_OFFSET(CONTEXT, IntT8),
303 FIELD_OFFSET(CONTEXT, IntT9),
304 FIELD_OFFSET(CONTEXT, IntT10),
305 FIELD_OFFSET(CONTEXT, IntT11),
306 FIELD_OFFSET(CONTEXT, IntRa),
307 FIELD_OFFSET(CONTEXT, IntT12),
308 FIELD_OFFSET(CONTEXT, IntAt),
309 FIELD_OFFSET(CONTEXT, IntGp),
310 FIELD_OFFSET(CONTEXT, IntSp),
311 FIELD_OFFSET(CONTEXT, IntZero),
312 FIELD_OFFSET(CONTEXT, FltF0),
313 FIELD_OFFSET(CONTEXT, FltF1),
314 FIELD_OFFSET(CONTEXT, FltF2),
315 FIELD_OFFSET(CONTEXT, FltF3),
316 FIELD_OFFSET(CONTEXT, FltF4),
317 FIELD_OFFSET(CONTEXT, FltF5),
318 FIELD_OFFSET(CONTEXT, FltF6),
319 FIELD_OFFSET(CONTEXT, FltF7),
320 FIELD_OFFSET(CONTEXT, FltF8),
321 FIELD_OFFSET(CONTEXT, FltF9),
322 FIELD_OFFSET(CONTEXT, FltF10),
323 FIELD_OFFSET(CONTEXT, FltF11),
324 FIELD_OFFSET(CONTEXT, FltF12),
325 FIELD_OFFSET(CONTEXT, FltF13),
326 FIELD_OFFSET(CONTEXT, FltF14),
327 FIELD_OFFSET(CONTEXT, FltF15),
328 FIELD_OFFSET(CONTEXT, FltF16),
329 FIELD_OFFSET(CONTEXT, FltF17),
330 FIELD_OFFSET(CONTEXT, FltF18),
331 FIELD_OFFSET(CONTEXT, FltF19),
332 FIELD_OFFSET(CONTEXT, FltF20),
333 FIELD_OFFSET(CONTEXT, FltF21),
334 FIELD_OFFSET(CONTEXT, FltF22),
335 FIELD_OFFSET(CONTEXT, FltF23),
336 FIELD_OFFSET(CONTEXT, FltF24),
337 FIELD_OFFSET(CONTEXT, FltF25),
338 FIELD_OFFSET(CONTEXT, FltF26),
339 FIELD_OFFSET(CONTEXT, FltF27),
340 FIELD_OFFSET(CONTEXT, FltF28),
341 FIELD_OFFSET(CONTEXT, FltF29),
342 FIELD_OFFSET(CONTEXT, FltF30),
343 FIELD_OFFSET(CONTEXT, FltF31),
344
345 /* FIXME: Didn't look for the right order yet */
346 FIELD_OFFSET(CONTEXT, Fir),
347 FIELD_OFFSET(CONTEXT, Fpcr),
348 FIELD_OFFSET(CONTEXT, SoftFpcr),
349 };
350 #elif defined(__x86_64__)
351 static size_t cpu_register_map[] = {
352 FIELD_OFFSET(CONTEXT, Rax),
353 FIELD_OFFSET(CONTEXT, Rbx),
354 FIELD_OFFSET(CONTEXT, Rcx),
355 FIELD_OFFSET(CONTEXT, Rdx),
356 FIELD_OFFSET(CONTEXT, Rsi),
357 FIELD_OFFSET(CONTEXT, Rdi),
358 FIELD_OFFSET(CONTEXT, Rbp),
359 FIELD_OFFSET(CONTEXT, Rsp),
360 FIELD_OFFSET(CONTEXT, R8),
361 FIELD_OFFSET(CONTEXT, R9),
362 FIELD_OFFSET(CONTEXT, R10),
363 FIELD_OFFSET(CONTEXT, R11),
364 FIELD_OFFSET(CONTEXT, R12),
365 FIELD_OFFSET(CONTEXT, R13),
366 FIELD_OFFSET(CONTEXT, R14),
367 FIELD_OFFSET(CONTEXT, R15),
368 FIELD_OFFSET(CONTEXT, Rip),
369 FIELD_OFFSET(CONTEXT, EFlags),
370 FIELD_OFFSET(CONTEXT, SegCs),
371 FIELD_OFFSET(CONTEXT, SegSs),
372 FIELD_OFFSET(CONTEXT, SegDs),
373 FIELD_OFFSET(CONTEXT, SegEs),
374 FIELD_OFFSET(CONTEXT, SegFs),
375 FIELD_OFFSET(CONTEXT, SegGs),
376 };
377 #else
378 # error Define the registers map for your CPU
379 #endif
380
381 static const size_t cpu_num_regs = (sizeof(cpu_register_map) / sizeof(cpu_register_map[0]));
382
383 static inline unsigned long* cpu_register(CONTEXT* ctx, unsigned idx)
384 {
385 assert(idx < cpu_num_regs);
386 return (unsigned long*)((char*)ctx + cpu_register_map[idx]);
387 }
388
389 /* =============================================== *
390 * W I N 3 2 D E B U G I N T E R F A C E *
391 * =============================================== *
392 */
393
394 static BOOL fetch_context(struct gdb_context* gdbctx, HANDLE h, CONTEXT* ctx)
395 {
396 ctx->ContextFlags = CONTEXT_CONTROL
397 | CONTEXT_INTEGER
398 #ifdef CONTEXT_SEGMENTS
399 | CONTEXT_SEGMENTS
400 #endif
401 #ifdef CONTEXT_DEBUG_REGISTERS
402 | CONTEXT_DEBUG_REGISTERS
403 #endif
404 ;
405 if (!GetThreadContext(h, ctx))
406 {
407 if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
408 fprintf(stderr, "Can't get thread's context\n");
409 return FALSE;
410 }
411 return TRUE;
412 }
413
414 static BOOL handle_exception(struct gdb_context* gdbctx, EXCEPTION_DEBUG_INFO* exc)
415 {
416 EXCEPTION_RECORD* rec = &exc->ExceptionRecord;
417 BOOL ret = FALSE;
418
419 switch (rec->ExceptionCode)
420 {
421 case EXCEPTION_ACCESS_VIOLATION:
422 case EXCEPTION_PRIV_INSTRUCTION:
423 case EXCEPTION_STACK_OVERFLOW:
424 case EXCEPTION_GUARD_PAGE:
425 gdbctx->last_sig = SIGSEGV;
426 ret = TRUE;
427 break;
428 case EXCEPTION_DATATYPE_MISALIGNMENT:
429 gdbctx->last_sig = SIGBUS;
430 ret = TRUE;
431 break;
432 case EXCEPTION_SINGLE_STEP:
433 /* fall thru */
434 case EXCEPTION_BREAKPOINT:
435 gdbctx->last_sig = SIGTRAP;
436 ret = TRUE;
437 break;
438 case EXCEPTION_FLT_DENORMAL_OPERAND:
439 case EXCEPTION_FLT_DIVIDE_BY_ZERO:
440 case EXCEPTION_FLT_INEXACT_RESULT:
441 case EXCEPTION_FLT_INVALID_OPERATION:
442 case EXCEPTION_FLT_OVERFLOW:
443 case EXCEPTION_FLT_STACK_CHECK:
444 case EXCEPTION_FLT_UNDERFLOW:
445 gdbctx->last_sig = SIGFPE;
446 ret = TRUE;
447 break;
448 case EXCEPTION_INT_DIVIDE_BY_ZERO:
449 case EXCEPTION_INT_OVERFLOW:
450 gdbctx->last_sig = SIGFPE;
451 ret = TRUE;
452 break;
453 case EXCEPTION_ILLEGAL_INSTRUCTION:
454 gdbctx->last_sig = SIGILL;
455 ret = TRUE;
456 break;
457 case CONTROL_C_EXIT:
458 gdbctx->last_sig = SIGINT;
459 ret = TRUE;
460 break;
461 case STATUS_POSSIBLE_DEADLOCK:
462 gdbctx->last_sig = SIGALRM;
463 ret = TRUE;
464 /* FIXME: we could also add here a O packet with additional information */
465 break;
466 default:
467 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
468 fprintf(stderr, "Unhandled exception code 0x%08x\n", rec->ExceptionCode);
469 gdbctx->last_sig = SIGABRT;
470 ret = TRUE;
471 break;
472 }
473 return ret;
474 }
475
476 static void handle_debug_event(struct gdb_context* gdbctx, DEBUG_EVENT* de)
477 {
478 char buffer[256];
479
480 dbg_curr_thread = dbg_get_thread(gdbctx->process, de->dwThreadId);
481
482 switch (de->dwDebugEventCode)
483 {
484 case CREATE_PROCESS_DEBUG_EVENT:
485 gdbctx->process = dbg_add_process(&be_process_gdbproxy_io, de->dwProcessId,
486 de->u.CreateProcessInfo.hProcess);
487 if (!gdbctx->process) break;
488 memory_get_string_indirect(gdbctx->process,
489 de->u.CreateProcessInfo.lpImageName,
490 de->u.CreateProcessInfo.fUnicode,
491 buffer, sizeof(buffer));
492 dbg_set_process_name(gdbctx->process, buffer);
493
494 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
495 fprintf(stderr, "%04x:%04x: create process '%s'/%p @%p (%u<%u>)\n",
496 de->dwProcessId, de->dwThreadId,
497 buffer, de->u.CreateProcessInfo.lpImageName,
498 de->u.CreateProcessInfo.lpStartAddress,
499 de->u.CreateProcessInfo.dwDebugInfoFileOffset,
500 de->u.CreateProcessInfo.nDebugInfoSize);
501
502 /* de->u.CreateProcessInfo.lpStartAddress; */
503 if (!SymInitialize(gdbctx->process->handle, NULL, TRUE))
504 fprintf(stderr, "Couldn't initiate DbgHelp\n");
505
506 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
507 fprintf(stderr, "%04x:%04x: create thread I @%p\n",
508 de->dwProcessId, de->dwThreadId,
509 de->u.CreateProcessInfo.lpStartAddress);
510
511 assert(dbg_curr_thread == NULL); /* shouldn't be there */
512 dbg_add_thread(gdbctx->process, de->dwThreadId,
513 de->u.CreateProcessInfo.hThread,
514 de->u.CreateProcessInfo.lpThreadLocalBase);
515 break;
516
517 case LOAD_DLL_DEBUG_EVENT:
518 assert(dbg_curr_thread);
519 memory_get_string_indirect(gdbctx->process,
520 de->u.LoadDll.lpImageName,
521 de->u.LoadDll.fUnicode,
522 buffer, sizeof(buffer));
523 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
524 fprintf(stderr, "%04x:%04x: loads DLL %s @%p (%u<%u>)\n",
525 de->dwProcessId, de->dwThreadId,
526 buffer, de->u.LoadDll.lpBaseOfDll,
527 de->u.LoadDll.dwDebugInfoFileOffset,
528 de->u.LoadDll.nDebugInfoSize);
529 SymLoadModule(gdbctx->process->handle, de->u.LoadDll.hFile, buffer, NULL,
530 (unsigned long)de->u.LoadDll.lpBaseOfDll, 0);
531 break;
532
533 case UNLOAD_DLL_DEBUG_EVENT:
534 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
535 fprintf(stderr, "%08x:%08x: unload DLL @%p\n",
536 de->dwProcessId, de->dwThreadId, de->u.UnloadDll.lpBaseOfDll);
537 SymUnloadModule(gdbctx->process->handle,
538 (unsigned long)de->u.UnloadDll.lpBaseOfDll);
539 break;
540
541 case EXCEPTION_DEBUG_EVENT:
542 assert(dbg_curr_thread);
543 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
544 fprintf(stderr, "%08x:%08x: exception code=0x%08x\n",
545 de->dwProcessId, de->dwThreadId,
546 de->u.Exception.ExceptionRecord.ExceptionCode);
547
548 if (fetch_context(gdbctx, dbg_curr_thread->handle, &gdbctx->context))
549 {
550 gdbctx->in_trap = handle_exception(gdbctx, &de->u.Exception);
551 }
552 break;
553
554 case CREATE_THREAD_DEBUG_EVENT:
555 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
556 fprintf(stderr, "%08x:%08x: create thread D @%p\n",
557 de->dwProcessId, de->dwThreadId, de->u.CreateThread.lpStartAddress);
558
559 dbg_add_thread(gdbctx->process,
560 de->dwThreadId,
561 de->u.CreateThread.hThread,
562 de->u.CreateThread.lpThreadLocalBase);
563 break;
564
565 case EXIT_THREAD_DEBUG_EVENT:
566 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
567 fprintf(stderr, "%08x:%08x: exit thread (%u)\n",
568 de->dwProcessId, de->dwThreadId, de->u.ExitThread.dwExitCode);
569
570 assert(dbg_curr_thread);
571 if (dbg_curr_thread == gdbctx->exec_thread) gdbctx->exec_thread = NULL;
572 if (dbg_curr_thread == gdbctx->other_thread) gdbctx->other_thread = NULL;
573 dbg_del_thread(dbg_curr_thread);
574 break;
575
576 case EXIT_PROCESS_DEBUG_EVENT:
577 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
578 fprintf(stderr, "%08x:%08x: exit process (%u)\n",
579 de->dwProcessId, de->dwThreadId, de->u.ExitProcess.dwExitCode);
580
581 dbg_del_process(gdbctx->process);
582 gdbctx->process = NULL;
583 /* now signal gdb that we're done */
584 gdbctx->last_sig = SIGTERM;
585 gdbctx->in_trap = TRUE;
586 break;
587
588 case OUTPUT_DEBUG_STRING_EVENT:
589 assert(dbg_curr_thread);
590 memory_get_string(gdbctx->process,
591 de->u.DebugString.lpDebugStringData, TRUE,
592 de->u.DebugString.fUnicode, buffer, sizeof(buffer));
593 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
594 fprintf(stderr, "%08x:%08x: output debug string (%s)\n",
595 de->dwProcessId, de->dwThreadId, buffer);
596 break;
597
598 case RIP_EVENT:
599 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
600 fprintf(stderr, "%08x:%08x: rip error=%u type=%u\n",
601 de->dwProcessId, de->dwThreadId, de->u.RipInfo.dwError,
602 de->u.RipInfo.dwType);
603 break;
604
605 default:
606 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
607 fprintf(stderr, "%08x:%08x: unknown event (%u)\n",
608 de->dwProcessId, de->dwThreadId, de->dwDebugEventCode);
609 }
610 }
611
612 static void resume_debuggee(struct gdb_context* gdbctx, DWORD cont)
613 {
614 if (dbg_curr_thread)
615 {
616 if (!SetThreadContext(dbg_curr_thread->handle, &gdbctx->context))
617 if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
618 fprintf(stderr, "Cannot set context on thread %04x\n", dbg_curr_thread->tid);
619 if (!ContinueDebugEvent(gdbctx->process->pid, dbg_curr_thread->tid, cont))
620 if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
621 fprintf(stderr, "Cannot continue on %04x (%x)\n",
622 dbg_curr_thread->tid, cont);
623 }
624 else if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
625 fprintf(stderr, "Cannot find last thread\n");
626 }
627
628
629 static void resume_debuggee_thread(struct gdb_context* gdbctx, DWORD cont, unsigned int threadid)
630 {
631
632 if (dbg_curr_thread)
633 {
634 if(dbg_curr_thread->tid == threadid){
635 /* Windows debug and GDB don't seem to work well here, windows only likes ContinueDebugEvent being used on the reporter of the event */
636 if (!SetThreadContext(dbg_curr_thread->handle, &gdbctx->context))
637 if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
638 fprintf(stderr, "Cannot set context on thread %04x\n", dbg_curr_thread->tid);
639 if (!ContinueDebugEvent(gdbctx->process->pid, dbg_curr_thread->tid, cont))
640 if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
641 fprintf(stderr, "Cannot continue on %04x (%x)\n",
642 dbg_curr_thread->tid, cont);
643 }
644 }
645 else if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
646 fprintf(stderr, "Cannot find last thread\n");
647 }
648
649 static BOOL check_for_interrupt(struct gdb_context* gdbctx)
650 {
651 struct pollfd pollfd;
652 int ret;
653 char pkt;
654
655 pollfd.fd = gdbctx->sock;
656 pollfd.events = POLLIN;
657 pollfd.revents = 0;
658
659 if ((ret = poll(&pollfd, 1, 0)) == 1) {
660 ret = read(gdbctx->sock, &pkt, 1);
661 if (ret != 1) {
662 if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) {
663 fprintf(stderr, "read failed\n");
664 }
665 return FALSE;
666 }
667 if (pkt != '\003') {
668 if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR) {
669 fprintf(stderr, "Unexpected break packet (%c/0x%X)\n", pkt, pkt);
670 }
671 return FALSE;
672 }
673 return TRUE;
674 } else if (ret == -1) {
675 fprintf(stderr, "poll failed\n");
676 }
677 return FALSE;
678 }
679
680 static void wait_for_debuggee(struct gdb_context* gdbctx)
681 {
682 DEBUG_EVENT de;
683
684 gdbctx->in_trap = FALSE;
685 for (;;)
686 {
687 if (!WaitForDebugEvent(&de, 10))
688 {
689 if (GetLastError() == ERROR_SEM_TIMEOUT)
690 {
691 if (check_for_interrupt(gdbctx)) {
692 if (!DebugBreakProcess(gdbctx->process->handle)) {
693 if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) {
694 fprintf(stderr, "Failed to break into debugee\n");
695 }
696 break;
697 }
698 WaitForDebugEvent(&de, INFINITE);
699 } else {
700 continue;
701 }
702 } else {
703 break;
704 }
705 }
706 handle_debug_event(gdbctx, &de);
707 assert(!gdbctx->process ||
708 gdbctx->process->pid == 0 ||
709 de.dwProcessId == gdbctx->process->pid);
710 assert(!dbg_curr_thread || de.dwThreadId == dbg_curr_thread->tid);
711 if (gdbctx->in_trap) break;
712 ContinueDebugEvent(de.dwProcessId, de.dwThreadId, DBG_CONTINUE);
713 }
714 }
715
716 static void detach_debuggee(struct gdb_context* gdbctx, BOOL kill)
717 {
718 be_cpu->single_step(&gdbctx->context, FALSE);
719 resume_debuggee(gdbctx, DBG_CONTINUE);
720 if (!kill)
721 DebugActiveProcessStop(gdbctx->process->pid);
722 dbg_del_process(gdbctx->process);
723 gdbctx->process = NULL;
724 }
725
726 static void get_process_info(struct gdb_context* gdbctx, char* buffer, size_t len)
727 {
728 DWORD status;
729
730 if (!GetExitCodeProcess(gdbctx->process->handle, &status))
731 {
732 strcpy(buffer, "Unknown process");
733 return;
734 }
735 if (status == STILL_ACTIVE)
736 {
737 strcpy(buffer, "Running");
738 }
739 else
740 snprintf(buffer, len, "Terminated (%u)", status);
741
742 switch (GetPriorityClass(gdbctx->process->handle))
743 {
744 case 0: break;
745 #ifdef ABOVE_NORMAL_PRIORITY_CLASS
746 case ABOVE_NORMAL_PRIORITY_CLASS: strcat(buffer, ", above normal priority"); break;
747 #endif
748 #ifdef BELOW_NORMAL_PRIORITY_CLASS
749 case BELOW_NORMAL_PRIORITY_CLASS: strcat(buffer, ", below normal priotity"); break;
750 #endif
751 case HIGH_PRIORITY_CLASS: strcat(buffer, ", high priority"); break;
752 case IDLE_PRIORITY_CLASS: strcat(buffer, ", idle priority"); break;
753 case NORMAL_PRIORITY_CLASS: strcat(buffer, ", normal priority"); break;
754 case REALTIME_PRIORITY_CLASS: strcat(buffer, ", realtime priority"); break;
755 }
756 strcat(buffer, "\n");
757 }
758
759 static void get_thread_info(struct gdb_context* gdbctx, unsigned tid,
760 char* buffer, size_t len)
761 {
762 struct dbg_thread* thd;
763 DWORD status;
764 int prio;
765
766 /* FIXME: use the size of buffer */
767 thd = dbg_get_thread(gdbctx->process, tid);
768 if (thd == NULL)
769 {
770 strcpy(buffer, "No information");
771 return;
772 }
773 if (GetExitCodeThread(thd->handle, &status))
774 {
775 if (status == STILL_ACTIVE)
776 {
777 /* FIXME: this is a bit brutal... some nicer way shall be found */
778 switch (status = SuspendThread(thd->handle))
779 {
780 case -1: break;
781 case 0: strcpy(buffer, "Running"); break;
782 default: snprintf(buffer, len, "Suspended (%u)", status - 1);
783 }
784 ResumeThread(thd->handle);
785 }
786 else
787 snprintf(buffer, len, "Terminated (exit code = %u)", status);
788 }
789 else
790 {
791 strcpy(buffer, "Unknown threadID");
792 }
793 switch (prio = GetThreadPriority(thd->handle))
794 {
795 case THREAD_PRIORITY_ERROR_RETURN: break;
796 case THREAD_PRIORITY_ABOVE_NORMAL: strcat(buffer, ", priority +1 above normal"); break;
797 case THREAD_PRIORITY_BELOW_NORMAL: strcat(buffer, ", priority -1 below normal"); break;
798 case THREAD_PRIORITY_HIGHEST: strcat(buffer, ", priority +2 above normal"); break;
799 case THREAD_PRIORITY_LOWEST: strcat(buffer, ", priority -2 below normal"); break;
800 case THREAD_PRIORITY_IDLE: strcat(buffer, ", priority idle"); break;
801 case THREAD_PRIORITY_NORMAL: strcat(buffer, ", priority normal"); break;
802 case THREAD_PRIORITY_TIME_CRITICAL: strcat(buffer, ", priority time-critical"); break;
803 default: snprintf(buffer + strlen(buffer), len - strlen(buffer), ", priority = %d", prio);
804 }
805 assert(strlen(buffer) < len);
806 }
807
808 /* =============================================== *
809 * P A C K E T U T I L S *
810 * =============================================== *
811 */
812
813 enum packet_return {packet_error = 0x00, packet_ok = 0x01, packet_done = 0x02,
814 packet_last_f = 0x80};
815
816 static void packet_reply_grow(struct gdb_context* gdbctx, size_t size)
817 {
818 if (gdbctx->out_buf_alloc < gdbctx->out_len + size)
819 {
820 gdbctx->out_buf_alloc = ((gdbctx->out_len + size) / 32 + 1) * 32;
821 gdbctx->out_buf = realloc(gdbctx->out_buf, gdbctx->out_buf_alloc);
822 }
823 }
824
825 static void packet_reply_hex_to(struct gdb_context* gdbctx, const void* src, int len)
826 {
827 packet_reply_grow(gdbctx, len * 2);
828 hex_to(&gdbctx->out_buf[gdbctx->out_len], src, len);
829 gdbctx->out_len += len * 2;
830 }
831
832 static inline void packet_reply_hex_to_str(struct gdb_context* gdbctx, const char* src)
833 {
834 packet_reply_hex_to(gdbctx, src, strlen(src));
835 }
836
837 static void packet_reply_val(struct gdb_context* gdbctx, unsigned long val, int len)
838 {
839 int i, shift;
840
841 shift = (len - 1) * 8;
842 packet_reply_grow(gdbctx, len * 2);
843 for (i = 0; i < len; i++, shift -= 8)
844 {
845 gdbctx->out_buf[gdbctx->out_len++] = hex_to0((val >> (shift + 4)) & 0x0F);
846 gdbctx->out_buf[gdbctx->out_len++] = hex_to0((val >> shift ) & 0x0F);
847 }
848 }
849
850 static inline void packet_reply_add(struct gdb_context* gdbctx, const char* str, int len)
851 {
852 packet_reply_grow(gdbctx, len);
853 memcpy(&gdbctx->out_buf[gdbctx->out_len], str, len);
854 gdbctx->out_len += len;
855 }
856
857 static inline void packet_reply_cat(struct gdb_context* gdbctx, const char* str)
858 {
859 packet_reply_add(gdbctx, str, strlen(str));
860 }
861
862 static inline void packet_reply_catc(struct gdb_context* gdbctx, char ch)
863 {
864 packet_reply_add(gdbctx, &ch, 1);
865 }
866
867 static void packet_reply_open(struct gdb_context* gdbctx)
868 {
869 assert(gdbctx->out_curr_packet == -1);
870 packet_reply_catc(gdbctx, '$');
871 gdbctx->out_curr_packet = gdbctx->out_len;
872 }
873
874 static void packet_reply_close(struct gdb_context* gdbctx)
875 {
876 unsigned char cksum;
877 int plen;
878
879 plen = gdbctx->out_len - gdbctx->out_curr_packet;
880 packet_reply_catc(gdbctx, '#');
881 cksum = checksum(&gdbctx->out_buf[gdbctx->out_curr_packet], plen);
882 packet_reply_hex_to(gdbctx, &cksum, 1);
883 if (gdbctx->trace & GDBPXY_TRC_PACKET)
884 fprintf(stderr, "Reply : %*.*s\n",
885 plen, plen, &gdbctx->out_buf[gdbctx->out_curr_packet]);
886 gdbctx->out_curr_packet = -1;
887 }
888
889 static enum packet_return packet_reply(struct gdb_context* gdbctx, const char* packet, int len)
890 {
891 packet_reply_open(gdbctx);
892
893 if (len == -1) len = strlen(packet);
894 assert(memchr(packet, '$', len) == NULL && memchr(packet, '#', len) == NULL);
895
896 packet_reply_add(gdbctx, packet, len);
897
898 packet_reply_close(gdbctx);
899
900 return packet_done;
901 }
902
903 static enum packet_return packet_reply_error(struct gdb_context* gdbctx, int error)
904 {
905 packet_reply_open(gdbctx);
906
907 packet_reply_add(gdbctx, "E", 1);
908 packet_reply_val(gdbctx, error, 1);
909
910 packet_reply_close(gdbctx);
911
912 return packet_done;
913 }
914
915 /* =============================================== *
916 * P A C K E T H A N D L E R S *
917 * =============================================== *
918 */
919
920 static enum packet_return packet_reply_status(struct gdb_context* gdbctx)
921 {
922 enum packet_return ret = packet_done;
923
924 packet_reply_open(gdbctx);
925
926 if (gdbctx->process != NULL)
927 {
928 unsigned char sig;
929 unsigned i;
930
931 packet_reply_catc(gdbctx, 'T');
932 sig = gdbctx->last_sig;
933 packet_reply_val(gdbctx, sig, 1);
934 packet_reply_add(gdbctx, "thread:", 7);
935 packet_reply_val(gdbctx, dbg_curr_thread->tid, 4);
936 packet_reply_catc(gdbctx, ';');
937
938 for (i = 0; i < cpu_num_regs; i++)
939 {
940 /* FIXME: this call will also grow the buffer...
941 * unneeded, but not harmful
942 */
943 packet_reply_val(gdbctx, i, 1);
944 packet_reply_catc(gdbctx, ':');
945 packet_reply_hex_to(gdbctx, cpu_register(&gdbctx->context, i), 4);
946 packet_reply_catc(gdbctx, ';');
947 }
948 }
949 else
950 {
951 /* Try to put an exit code
952 * Cannot use GetExitCodeProcess, wouldn't fit in a 8 bit value, so
953 * just indicate the end of process and exit */
954 packet_reply_add(gdbctx, "W00", 3);
955 /*if (!gdbctx->extended)*/ ret |= packet_last_f;
956 }
957
958 packet_reply_close(gdbctx);
959
960 return ret;
961 }
962
963 #if 0
964 static enum packet_return packet_extended(struct gdb_context* gdbctx)
965 {
966 gdbctx->extended = 1;
967 return packet_ok;
968 }
969 #endif
970
971 static enum packet_return packet_last_signal(struct gdb_context* gdbctx)
972 {
973 assert(gdbctx->in_packet_len == 0);
974 return packet_reply_status(gdbctx);
975 }
976
977 static enum packet_return packet_continue(struct gdb_context* gdbctx)
978 {
979 /* FIXME: add support for address in packet */
980 assert(gdbctx->in_packet_len == 0);
981 if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread)
982 if (gdbctx->trace & GDBPXY_TRC_COMMAND_FIXME)
983 fprintf(stderr, "NIY: cont on %04x, while last thread is %04x\n",
984 gdbctx->exec_thread->tid, dbg_curr_thread->tid);
985 resume_debuggee(gdbctx, DBG_CONTINUE);
986 wait_for_debuggee(gdbctx);
987 return packet_reply_status(gdbctx);
988 }
989
990 static enum packet_return packet_verbose(struct gdb_context* gdbctx)
991 {
992 int i;
993 int defaultAction = -1; /* magic non action */
994 unsigned char sig;
995 int actions =0;
996 int actionIndex[20]; /* allow for up to 20 actions */
997 int threadIndex[20];
998 int threadCount = 0;
999 unsigned int threadIDs[100]; /* TODO: Should make this dynamic */
1000 unsigned int threadID = 0;
1001 struct dbg_thread* thd;
1002
1003 /* basic check */
1004 assert(gdbctx->in_packet_len >= 4);
1005
1006 /* OK we have vCont followed by..
1007 * ? for query
1008 * c for packet_continue
1009 * Csig for packet_continue_signal
1010 * s for step
1011 * Ssig for step signal
1012 * and then an optional thread ID at the end..
1013 * *******************************************/
1014
1015 fprintf(stderr, "trying to process a verbose packet\n");
1016 /* now check that we've got Cont */
1017 assert(strncmp(gdbctx->in_packet, "Cont", 4) == 0);
1018
1019 /* Query */
1020 if (gdbctx->in_packet[4] == '?')
1021 {
1022 /*
1023 Reply:
1024 `vCont[;action]...'
1025 The vCont packet is supported. Each action is a supported command in the vCont packet.
1026 `'
1027 The vCont packet is not supported. (this didn't seem to be obeyed!)
1028 */
1029 packet_reply_open(gdbctx);
1030 packet_reply_add(gdbctx, "vCont", 5);
1031 /* add all the supported actions to the reply (all of them for now) */
1032 packet_reply_add(gdbctx, ";c", 2);
1033 packet_reply_add(gdbctx, ";C", 2);
1034 packet_reply_add(gdbctx, ";s", 2);
1035 packet_reply_add(gdbctx, ";S", 2);
1036 packet_reply_close(gdbctx);
1037 return packet_done;
1038 }
1039
1040 /* This may not be the 'fastest' code in the world. but it should be nice and easy to debug.
1041 (as it's run when people are debugging break points I'm sure they won't notice the extra 100 cycles anyway)
1042 now if only gdb talked XML.... */
1043 #if 0 /* handy for debugging */
1044 fprintf(stderr, "no, but can we find a default packet %.*s %d\n", gdbctx->in_packet_len, gdbctx->in_packet, gdbctx->in_packet_len);
1045 #endif
1046
1047 /* go through the packet and identify where all the actions start at */
1048 for (i = 4; i < gdbctx->in_packet_len - 1; i++)
1049 {
1050 if (gdbctx->in_packet[i] == ';')
1051 {
1052 threadIndex[actions] = 0;
1053 actionIndex[actions++] = i;
1054 }
1055 else if (gdbctx->in_packet[i] == ':')
1056 {
1057 threadIndex[actions - 1] = i;
1058 }
1059 }
1060
1061 /* now look up the default action */
1062 for (i = 0 ; i < actions; i++)
1063 {
1064 if (threadIndex[i] == 0)
1065 {
1066 if (defaultAction != -1)
1067 {
1068 fprintf(stderr,"Too many default actions specified\n");
1069 return packet_error;
1070 }
1071 defaultAction = i;
1072 }
1073 }
1074
1075 /* Now, I have this default action thing that needs to be applied to all non counted threads */
1076
1077 /* go through all the threads and stick their ids in the to be done list. */
1078 for (thd = gdbctx->process->threads; thd; thd = thd->next)
1079 {
1080 threadIDs[threadCount++] = thd->tid;
1081 /* check to see if we have more threads than I counted on, and tell the user what to do
1082 * (they're running winedbg, so I'm sure they can fix the problem from the error message!) */
1083 if (threadCount == 100)
1084 {
1085 fprintf(stderr, "Wow, that's a lot of threads, change threadIDs in wine/programms/winedgb/gdbproxy.c to be higher\n");
1086 break;
1087 }
1088 }
1089
1090 /* Ok, now we have... actionIndex full of actions and we know what threads there are, so all
1091 * that remains is to apply the actions to the threads and the default action to any threads
1092 * left */
1093 if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread)
1094 if (gdbctx->trace & GDBPXY_TRC_COMMAND_FIXME)
1095 fprintf(stderr, "NIY: cont on %04x, while last thread is %04x\n",
1096 gdbctx->exec_thread->tid, dbg_curr_thread->tid);
1097
1098 /* deal with the threaded stuff first */
1099 for (i = 0; i < actions ; i++)
1100 {
1101 if (threadIndex[i] != 0)
1102 {
1103 int j, idLength = 0;
1104 if (i < actions - 1)
1105 {
1106 idLength = (actionIndex[i+1] - threadIndex[i]) - 1;
1107 }
1108 else
1109 {
1110 idLength = (gdbctx->in_packet_len - threadIndex[i]) - 1;
1111 }
1112
1113 threadID = hex_to_int(gdbctx->in_packet + threadIndex[i] + 1 , idLength);
1114 /* process the action */
1115 switch (gdbctx->in_packet[actionIndex[i] + 1])
1116 {
1117 case 's': /* step */
1118 be_cpu->single_step(&gdbctx->context, TRUE);
1119 /* fall through*/
1120 case 'c': /* continue */
1121 resume_debuggee_thread(gdbctx, DBG_CONTINUE, threadID);
1122 break;
1123 case 'S': /* step Sig, */
1124 be_cpu->single_step(&gdbctx->context, TRUE);
1125 /* fall through */
1126 case 'C': /* continue sig */
1127 hex_from(&sig, gdbctx->in_packet + actionIndex[i] + 2, 1);
1128 /* cannot change signals on the fly */
1129 if (gdbctx->trace & GDBPXY_TRC_COMMAND)
1130 fprintf(stderr, "sigs: %u %u\n", sig, gdbctx->last_sig);
1131 if (sig != gdbctx->last_sig)
1132 return packet_error;
1133 resume_debuggee_thread(gdbctx, DBG_EXCEPTION_NOT_HANDLED, threadID);
1134 break;
1135 }
1136 for (j = 0 ; j < threadCount; j++)
1137 {
1138 if (threadIDs[j] == threadID)
1139 {
1140 threadIDs[j] = 0;
1141 break;
1142 }
1143 }
1144 }
1145 } /* for i=0 ; i< actions */
1146
1147 /* now we have manage the default action */
1148 if (defaultAction >= 0)
1149 {
1150 for (i = 0 ; i< threadCount; i++)
1151 {
1152 /* check to see if we've already done something to the thread*/
1153 if (threadIDs[i] != 0)
1154 {
1155 /* if not apply the default action*/
1156 threadID = threadIDs[i];
1157 /* process the action (yes this is almost identical to the one above!) */
1158 switch (gdbctx->in_packet[actionIndex[defaultAction] + 1])
1159 {
1160 case 's': /* step */
1161 be_cpu->single_step(&gdbctx->context, TRUE);
1162 /* fall through */
1163 case 'c': /* continue */
1164 resume_debuggee_thread(gdbctx, DBG_CONTINUE, threadID);
1165 break;
1166 case 'S':
1167 be_cpu->single_step(&gdbctx->context, TRUE);
1168 /* fall through */
1169 case 'C': /* continue sig */
1170 hex_from(&sig, gdbctx->in_packet + actionIndex[defaultAction] + 2, 1);
1171 /* cannot change signals on the fly */
1172 if (gdbctx->trace & GDBPXY_TRC_COMMAND)
1173 fprintf(stderr, "sigs: %u %u\n", sig, gdbctx->last_sig);
1174 if (sig != gdbctx->last_sig)
1175 return packet_error;
1176 resume_debuggee_thread(gdbctx, DBG_EXCEPTION_NOT_HANDLED, threadID);
1177 break;
1178 }
1179 }
1180 }
1181 } /* if(defaultAction >=0) */
1182
1183 wait_for_debuggee(gdbctx);
1184 be_cpu->single_step(&gdbctx->context, FALSE);
1185 return packet_reply_status(gdbctx);
1186 }
1187
1188 static enum packet_return packet_continue_signal(struct gdb_context* gdbctx)
1189 {
1190 unsigned char sig;
1191
1192 /* FIXME: add support for address in packet */
1193 assert(gdbctx->in_packet_len == 2);
1194 if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread)
1195 if (gdbctx->trace & GDBPXY_TRC_COMMAND_FIXME)
1196 fprintf(stderr, "NIY: cont/sig on %04x, while last thread is %04x\n",
1197 gdbctx->exec_thread->tid, dbg_curr_thread->tid);
1198 hex_from(&sig, gdbctx->in_packet, 1);
1199 /* cannot change signals on the fly */
1200 if (gdbctx->trace & GDBPXY_TRC_COMMAND)
1201 fprintf(stderr, "sigs: %u %u\n", sig, gdbctx->last_sig);
1202 if (sig != gdbctx->last_sig)
1203 return packet_error;
1204 resume_debuggee(gdbctx, DBG_EXCEPTION_NOT_HANDLED);
1205 wait_for_debuggee(gdbctx);
1206 return packet_reply_status(gdbctx);
1207 }
1208
1209 static enum packet_return packet_detach(struct gdb_context* gdbctx)
1210 {
1211 detach_debuggee(gdbctx, FALSE);
1212 return packet_ok | packet_last_f;
1213 }
1214
1215 static enum packet_return packet_read_registers(struct gdb_context* gdbctx)
1216 {
1217 int i;
1218 CONTEXT ctx;
1219 CONTEXT* pctx = &gdbctx->context;
1220
1221 assert(gdbctx->in_trap);
1222
1223 if (dbg_curr_thread != gdbctx->other_thread && gdbctx->other_thread)
1224 {
1225 if (!fetch_context(gdbctx, gdbctx->other_thread->handle, pctx = &ctx))
1226 return packet_error;
1227 }
1228
1229 packet_reply_open(gdbctx);
1230 for (i = 0; i < cpu_num_regs; i++)
1231 {
1232 packet_reply_hex_to(gdbctx, cpu_register(pctx, i), 4);
1233 }
1234 packet_reply_close(gdbctx);
1235 return packet_done;
1236 }
1237
1238 static enum packet_return packet_write_registers(struct gdb_context* gdbctx)
1239 {
1240 unsigned i;
1241 CONTEXT ctx;
1242 CONTEXT* pctx = &gdbctx->context;
1243
1244 assert(gdbctx->in_trap);
1245 if (dbg_curr_thread != gdbctx->other_thread && gdbctx->other_thread)
1246 {
1247 if (!fetch_context(gdbctx, gdbctx->other_thread->handle, pctx = &ctx))
1248 return packet_error;
1249 }
1250 if (gdbctx->in_packet_len < cpu_num_regs * 2) return packet_error;
1251
1252 for (i = 0; i < cpu_num_regs; i++)
1253 hex_from(cpu_register(pctx, i), &gdbctx->in_packet[8 * i], 4);
1254 if (pctx != &gdbctx->context && !SetThreadContext(gdbctx->other_thread->handle, pctx))
1255 {
1256 if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
1257 fprintf(stderr, "Cannot set context on thread %04x\n", gdbctx->other_thread->tid);
1258 return packet_error;
1259 }
1260 return packet_ok;
1261 }
1262
1263 static enum packet_return packet_kill(struct gdb_context* gdbctx)
1264 {
1265 detach_debuggee(gdbctx, TRUE);
1266 #if 0
1267 if (!gdbctx->extended)
1268 /* dunno whether GDB cares or not */
1269 #endif
1270 wait(NULL);
1271 exit(0);
1272 /* assume we can't really answer something here */
1273 /* return packet_done; */
1274 }
1275
1276 static enum packet_return packet_thread(struct gdb_context* gdbctx)
1277 {
1278 char* end;
1279 unsigned thread;
1280
1281 switch (gdbctx->in_packet[0])
1282 {
1283 case 'c':
1284 case 'g':
1285 if (gdbctx->in_packet[1] == '-')
1286 thread = -strtol(gdbctx->in_packet + 2, &end, 16);
1287 else
1288 thread = strtol(gdbctx->in_packet + 1, &end, 16);
1289 if (end == NULL || end > gdbctx->in_packet + gdbctx->in_packet_len)
1290 {
1291 if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1292 fprintf(stderr, "Cannot get threadid %*.*s\n",
1293 gdbctx->in_packet_len - 1, gdbctx->in_packet_len - 1,
1294 gdbctx->in_packet + 1);
1295 return packet_error;
1296 }
1297 if (gdbctx->in_packet[0] == 'c')
1298 gdbctx->exec_thread = dbg_get_thread(gdbctx->process, thread);
1299 else
1300 gdbctx->other_thread = dbg_get_thread(gdbctx->process, thread);
1301 return packet_ok;
1302 default:
1303 if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1304 fprintf(stderr, "Unknown thread sub-command %c\n", gdbctx->in_packet[0]);
1305 return packet_error;
1306 }
1307 }
1308
1309 static enum packet_return packet_read_memory(struct gdb_context* gdbctx)
1310 {
1311 char *addr;
1312 unsigned int len, blk_len, nread;
1313 char buffer[32];
1314 SIZE_T r = 0;
1315
1316 assert(gdbctx->in_trap);
1317 /* FIXME:check in_packet_len for reading %p,%x */
1318 if (sscanf(gdbctx->in_packet, "%p,%x", &addr, &len) != 2) return packet_error;
1319 if (len <= 0) return packet_error;
1320 if (gdbctx->trace & GDBPXY_TRC_COMMAND)
1321 fprintf(stderr, "Read mem at %p for %u bytes\n", addr, len);
1322 for (nread = 0; nread < len; nread += r, addr += r)
1323 {
1324 blk_len = min(sizeof(buffer), len - nread);
1325 if (!gdbctx->process->process_io->read(gdbctx->process->handle, addr, buffer, blk_len, &r) ||
1326 r == 0)
1327 {
1328 /* fail at first address, return error */
1329 if (nread == 0) return packet_reply_error(gdbctx, EFAULT);
1330 /* something has already been read, return partial information */
1331 break;
1332 }
1333 if (nread == 0) packet_reply_open(gdbctx);
1334 packet_reply_hex_to(gdbctx, buffer, r);
1335 }
1336 packet_reply_close(gdbctx);
1337 return packet_done;
1338 }
1339
1340 static enum packet_return packet_write_memory(struct gdb_context* gdbctx)
1341 {
1342 char* addr;
1343 unsigned int len, blk_len;
1344 char* ptr;
1345 char buffer[32];
1346 SIZE_T w;
1347
1348 assert(gdbctx->in_trap);
1349 ptr = memchr(gdbctx->in_packet, ':', gdbctx->in_packet_len);
1350 if (ptr == NULL)
1351 {
1352 if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1353 fprintf(stderr, "Cannot find ':' in %*.*s\n",
1354 gdbctx->in_packet_len, gdbctx->in_packet_len, gdbctx->in_packet);
1355 return packet_error;
1356 }
1357 *ptr++ = '\0';
1358
1359 if (sscanf(gdbctx->in_packet, "%p,%x", &addr, &len) != 2)
1360 {
1361 if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1362 fprintf(stderr, "Cannot scan addr,len in %s\n", gdbctx->in_packet);
1363 return packet_error;
1364 }
1365 if (ptr - gdbctx->in_packet + len * 2 != gdbctx->in_packet_len)
1366 {
1367 if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1368 fprintf(stderr, "Wrong sizes %u <> %u\n",
1369 ptr - gdbctx->in_packet + len * 2, gdbctx->in_packet_len);
1370 return packet_error;
1371 }
1372 if (gdbctx->trace & GDBPXY_TRC_COMMAND)
1373 fprintf(stderr, "Write %u bytes at %p\n", len, addr);
1374 while (len > 0)
1375 {
1376 blk_len = min(sizeof(buffer), len);
1377 hex_from(buffer, ptr, blk_len);
1378 if (!gdbctx->process->process_io->write(gdbctx->process->handle, addr, buffer, blk_len, &w) ||
1379 w != blk_len)
1380 break;
1381 addr += blk_len;
1382 len -= blk_len;
1383 ptr += blk_len;
1384 }
1385 return packet_ok; /* FIXME: error while writing ? */
1386 }
1387
1388 static enum packet_return packet_write_register(struct gdb_context* gdbctx)
1389 {
1390 unsigned reg;
1391 char* ptr;
1392 char* end;
1393 CONTEXT ctx;
1394 CONTEXT* pctx = &gdbctx->context;
1395
1396 assert(gdbctx->in_trap);
1397
1398 ptr = memchr(gdbctx->in_packet, '=', gdbctx->in_packet_len);
1399 *ptr++ = '\0';
1400 reg = strtoul(gdbctx->in_packet, &end, 16);
1401 if (end == NULL || reg > cpu_num_regs)
1402 {
1403 if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1404 fprintf(stderr, "Invalid register index %s\n", gdbctx->in_packet);
1405 /* FIXME: if just the reg is above cpu_num_regs, don't tell gdb
1406 * it wouldn't matter too much, and it fakes our support for all regs
1407 */
1408 return (end == NULL) ? packet_error : packet_ok;
1409 }
1410 if (ptr + 8 - gdbctx->in_packet != gdbctx->in_packet_len)
1411 {
1412 if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1413 fprintf(stderr, "Wrong sizes %u <> %u\n",
1414 ptr + 8 - gdbctx->in_packet, gdbctx->in_packet_len);
1415 return packet_error;
1416 }
1417 if (gdbctx->trace & GDBPXY_TRC_COMMAND)
1418 fprintf(stderr, "Writing reg %u <= %*.*s\n",
1419 reg, gdbctx->in_packet_len - (ptr - gdbctx->in_packet),
1420 gdbctx->in_packet_len - (ptr - gdbctx->in_packet), ptr);
1421
1422 if (dbg_curr_thread != gdbctx->other_thread && gdbctx->other_thread)
1423 {
1424 if (!fetch_context(gdbctx, gdbctx->other_thread->handle, pctx = &ctx))
1425 return packet_error;
1426 }
1427
1428 hex_from(cpu_register(pctx, reg), ptr, 4);
1429 if (pctx != &gdbctx->context && !SetThreadContext(gdbctx->other_thread->handle, pctx))
1430 {
1431 if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
1432 fprintf(stderr, "Cannot set context for thread %04x\n", gdbctx->other_thread->tid);
1433 return packet_error;
1434 }
1435
1436 return packet_ok;
1437 }
1438
1439 static void packet_query_monitor_wnd_helper(struct gdb_context* gdbctx, HWND hWnd, int indent)
1440 {
1441 char buffer[128];
1442 char clsName[128];
1443 char wndName[128];
1444 HWND child;
1445
1446 do {
1447 if (!GetClassName(hWnd, clsName, sizeof(clsName)))
1448 strcpy(clsName, "-- Unknown --");
1449 if (!GetWindowText(hWnd, wndName, sizeof(wndName)))
1450 strcpy(wndName, "-- Empty --");
1451
1452 packet_reply_open(gdbctx);
1453 packet_reply_catc(gdbctx, 'O');
1454 snprintf(buffer, sizeof(buffer),
1455 "%*s%04lx%*s%-17.17s %08x %08x %.14s\n",
1456 indent, "", (ULONG_PTR)hWnd, 13 - indent, "",
1457 clsName, GetWindowLong(hWnd, GWL_STYLE),
1458 GetWindowLongPtr(hWnd, GWLP_WNDPROC), wndName);
1459 packet_reply_hex_to_str(gdbctx, buffer);
1460 packet_reply_close(gdbctx);
1461
1462 if ((child = GetWindow(hWnd, GW_CHILD)) != 0)
1463 packet_query_monitor_wnd_helper(gdbctx, child, indent + 1);
1464 } while ((hWnd = GetWindow(hWnd, GW_HWNDNEXT)) != 0);
1465 }
1466
1467 static void packet_query_monitor_wnd(struct gdb_context* gdbctx, int len, const char* str)
1468 {
1469 char buffer[128];
1470
1471 /* we do the output in several 'O' packets, with the last one being just OK for
1472 * marking the end of the output */
1473 packet_reply_open(gdbctx);
1474 packet_reply_catc(gdbctx, 'O');
1475 snprintf(buffer, sizeof(buffer),
1476 "%-16.16s %-17.17s %-8.8s %s\n",
1477 "hwnd", "Class Name", " Style", " WndProc Text");
1478 packet_reply_hex_to_str(gdbctx, buffer);
1479 packet_reply_close(gdbctx);
1480
1481 /* FIXME: could also add a pmt to this command in str... */
1482 packet_query_monitor_wnd_helper(gdbctx, GetDesktopWindow(), 0);
1483 packet_reply(gdbctx, "OK", 2);
1484 }
1485
1486 static void packet_query_monitor_process(struct gdb_context* gdbctx, int len, const char* str)
1487 {
1488 HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
1489 char buffer[128];
1490 char deco;
1491 PROCESSENTRY32 entry;
1492 BOOL ok;
1493
1494 if (snap == INVALID_HANDLE_VALUE)
1495 return;
1496
1497 entry.dwSize = sizeof(entry);
1498 ok = Process32First(snap, &entry);
1499
1500 /* we do the output in several 'O' packets, with the last one being just OK for
1501 * marking the end of the output */
1502
1503 packet_reply_open(gdbctx);
1504 packet_reply_catc(gdbctx, 'O');
1505 snprintf(buffer, sizeof(buffer),
1506 " %-8.8s %-8.8s %-8.8s %s\n",
1507 "pid", "threads", "parent", "executable");
1508 packet_reply_hex_to_str(gdbctx, buffer);
1509 packet_reply_close(gdbctx);
1510
1511 while (ok)
1512 {
1513 deco = ' ';
1514 if (entry.th32ProcessID == gdbctx->process->pid) deco = '>';
1515 packet_reply_open(gdbctx);
1516 packet_reply_catc(gdbctx, 'O');
1517 snprintf(buffer, sizeof(buffer),
1518 "%c%08x %-8d %08x '%s'\n",
1519 deco, entry.th32ProcessID, entry.cntThreads,
1520 entry.th32ParentProcessID, entry.szExeFile);
1521 packet_reply_hex_to_str(gdbctx, buffer);
1522 packet_reply_close(gdbctx);
1523 ok = Process32Next(snap, &entry);
1524 }
1525 CloseHandle(snap);
1526 packet_reply(gdbctx, "OK", 2);
1527 }
1528
1529 static void packet_query_monitor_mem(struct gdb_context* gdbctx, int len, const char* str)
1530 {
1531 MEMORY_BASIC_INFORMATION mbi;
1532 char* addr = 0;
1533 const char* state;
1534 const char* type;
1535 char prot[3+1];
1536 char buffer[128];
1537
1538 /* we do the output in several 'O' packets, with the last one being just OK for
1539 * marking the end of the output */
1540 packet_reply_open(gdbctx);
1541 packet_reply_catc(gdbctx, 'O');
1542 packet_reply_hex_to_str(gdbctx, "Address Size State Type RWX\n");
1543 packet_reply_close(gdbctx);
1544
1545 while (VirtualQueryEx(gdbctx->process->handle, addr, &mbi, sizeof(mbi)) >= sizeof(mbi))
1546 {
1547 switch (mbi.State)
1548 {
1549 case MEM_COMMIT: state = "commit "; break;
1550 case MEM_FREE: state = "free "; break;
1551 case MEM_RESERVE: state = "reserve"; break;
1552 default: state = "??? "; break;
1553 }
1554 if (mbi.State != MEM_FREE)
1555 {
1556 switch (mbi.Type)
1557 {
1558 case MEM_IMAGE: type = "image "; break;
1559 case MEM_MAPPED: type = "mapped "; break;
1560 case MEM_PRIVATE: type = "private"; break;
1561 case 0: type = " "; break;
1562 default: type = "??? "; break;
1563 }
1564 memset(prot, ' ' , sizeof(prot)-1);
1565 prot[sizeof(prot)-1] = '\0';
1566 if (mbi.AllocationProtect & (PAGE_READONLY|PAGE_READWRITE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE))
1567 prot[0] = 'R';
1568 if (mbi.AllocationProtect & (PAGE_READWRITE|PAGE_EXECUTE_READWRITE))
1569 prot[1] = 'W';
1570 if (mbi.AllocationProtect & (PAGE_WRITECOPY|PAGE_EXECUTE_WRITECOPY))
1571 prot[1] = 'C';
1572 if (mbi.AllocationProtect & (PAGE_EXECUTE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE))
1573 prot[2] = 'X';
1574 }
1575 else
1576 {
1577 type = "";
1578 prot[0] = '\0';
1579 }
1580 packet_reply_open(gdbctx);
1581 snprintf(buffer, sizeof(buffer), "%08lx %08lx %s %s %s\n",
1582 (DWORD_PTR)addr, mbi.RegionSize, state, type, prot);
1583 packet_reply_catc(gdbctx, 'O');
1584 packet_reply_hex_to_str(gdbctx, buffer);
1585 packet_reply_close(gdbctx);
1586
1587 if (addr + mbi.RegionSize < addr) /* wrap around ? */
1588 break;
1589 addr += mbi.RegionSize;
1590 }
1591 packet_reply(gdbctx, "OK", 2);
1592 }
1593
1594 static void packet_query_monitor_trace(struct gdb_context* gdbctx,
1595 int len, const char* str)
1596 {
1597 char buffer[128];
1598
1599 if (len == 0)
1600 {
1601 snprintf(buffer, sizeof(buffer), "trace=%x\n", gdbctx->trace);
1602 }
1603 else if (len >= 2 && str[0] == '=')
1604 {
1605 unsigned val = atoi(&str[1]);
1606 snprintf(buffer, sizeof(buffer), "trace: %x => %x\n", gdbctx->trace, val);
1607 gdbctx->trace = val;
1608 }
1609 else
1610 {
1611 /* FIXME: ugly but can use error packet here */
1612 packet_reply_cat(gdbctx, "E00");
1613 return;
1614 }
1615 packet_reply_open(gdbctx);
1616 packet_reply_hex_to_str(gdbctx, buffer);
1617 packet_reply_close(gdbctx);
1618 }
1619
1620 struct query_detail
1621 {
1622 int with_arg;
1623 const char* name;
1624 size_t len;
1625 void (*handler)(struct gdb_context*, int, const char*);
1626 } query_details[] =
1627 {
1628 {0, "wnd", 3, packet_query_monitor_wnd},
1629 {0, "window", 6, packet_query_monitor_wnd},
1630 {0, "proc", 4, packet_query_monitor_process},
1631 {0, "process", 7, packet_query_monitor_process},
1632 {0, "mem", 3, packet_query_monitor_mem},
1633 {1, "trace", 5, packet_query_monitor_trace},
1634 {0, NULL, 0, NULL},
1635 };
1636
1637 static enum packet_return packet_query_remote_command(struct gdb_context* gdbctx,
1638 const char* hxcmd, size_t len)
1639 {
1640 char buffer[128];
1641 struct query_detail* qd;
1642
1643 assert((len & 1) == 0 && len < 2 * sizeof(buffer));
1644 len /= 2;
1645 hex_from(buffer, hxcmd, len);
1646
1647 for (qd = &query_details[0]; qd->name != NULL; qd++)
1648 {
1649 if (len < qd->len || strncmp(buffer, qd->name, qd->len) != 0) continue;
1650 if (!qd->with_arg && len != qd->len) continue;
1651
1652 (qd->handler)(gdbctx, len - qd->len, buffer + qd->len);
1653 return packet_done;
1654 }
1655 return packet_reply_error(gdbctx, EINVAL);
1656 }
1657
1658 static enum packet_return packet_query(struct gdb_context* gdbctx)
1659 {
1660 switch (gdbctx->in_packet[0])
1661 {
1662 case 'f':
1663 if (strncmp(gdbctx->in_packet + 1, "ThreadInfo", gdbctx->in_packet_len - 1) == 0)
1664 {
1665 struct dbg_thread* thd;
1666
1667 packet_reply_open(gdbctx);
1668 packet_reply_add(gdbctx, "m", 1);
1669 for (thd = gdbctx->process->threads; thd; thd = thd->next)
1670 {
1671 packet_reply_val(gdbctx, thd->tid, 4);
1672 if (thd->next != NULL)
1673 packet_reply_add(gdbctx, ",", 1);
1674 }
1675 packet_reply_close(gdbctx);
1676 return packet_done;
1677 }
1678 else if (strncmp(gdbctx->in_packet + 1, "ProcessInfo", gdbctx->in_packet_len - 1) == 0)
1679 {
1680 char result[128];
1681
1682 packet_reply_open(gdbctx);
1683 packet_reply_catc(gdbctx, 'O');
1684 get_process_info(gdbctx, result, sizeof(result));
1685 packet_reply_hex_to_str(gdbctx, result);
1686 packet_reply_close(gdbctx);
1687 return packet_done;
1688 }
1689 break;
1690 case 's':
1691 if (strncmp(gdbctx->in_packet + 1, "ThreadInfo", gdbctx->in_packet_len - 1) == 0)
1692 {
1693 packet_reply(gdbctx, "l", 1);
1694 return packet_done;
1695 }
1696 else if (strncmp(gdbctx->in_packet + 1, "ProcessInfo", gdbctx->in_packet_len - 1) == 0)
1697 {
1698 packet_reply(gdbctx, "l", 1);
1699 return packet_done;
1700 }
1701 break;
1702 case 'C':
1703 if (gdbctx->in_packet_len == 1)
1704 {
1705 struct dbg_thread* thd;
1706 /* FIXME: doc says 16 bit val ??? */
1707 /* grab first created thread, aka last in list */
1708 assert(gdbctx->process && gdbctx->process->threads);
1709 for (thd = gdbctx->process->threads; thd->next; thd = thd->next);
1710 packet_reply_open(gdbctx);
1711 packet_reply_add(gdbctx, "QC", 2);
1712 packet_reply_val(gdbctx, thd->tid, 4);
1713 packet_reply_close(gdbctx);
1714 return packet_done;
1715 }
1716 break;
1717 case 'O':
1718 if (strncmp(gdbctx->in_packet, "Offsets", gdbctx->in_packet_len) == 0)
1719 {
1720 char buf[64];
1721
1722 if (gdbctx->wine_segs[0] == 0 && gdbctx->wine_segs[1] == 0 &&
1723 gdbctx->wine_segs[2] == 0)
1724 return packet_error;
1725 snprintf(buf, sizeof(buf),
1726 "Text=%08lx;Data=%08lx;Bss=%08lx",
1727 gdbctx->wine_segs[0], gdbctx->wine_segs[1],
1728 gdbctx->wine_segs[2]);
1729 return packet_reply(gdbctx, buf, -1);
1730 }
1731 break;
1732 case 'R':
1733 if (gdbctx->in_packet_len > 5 && strncmp(gdbctx->in_packet, "Rcmd,", 5) == 0)
1734 {
1735 return packet_query_remote_command(gdbctx, gdbctx->in_packet + 5,
1736 gdbctx->in_packet_len - 5);
1737 }
1738 break;
1739 case 'S':
1740 if (strncmp(gdbctx->in_packet, "Symbol::", gdbctx->in_packet_len) == 0)
1741 return packet_ok;
1742 break;
1743 case 'T':
1744 if (gdbctx->in_packet_len > 15 &&
1745 strncmp(gdbctx->in_packet, "ThreadExtraInfo", 15) == 0 &&
1746 gdbctx->in_packet[15] == ',')
1747 {
1748 unsigned tid;
1749 char* end;
1750 char result[128];
1751
1752 tid = strtol(gdbctx->in_packet + 16, &end, 16);
1753 if (end == NULL) break;
1754 get_thread_info(gdbctx, tid, result, sizeof(result));
1755 packet_reply_open(gdbctx);
1756 packet_reply_hex_to_str(gdbctx, result);
1757 packet_reply_close(gdbctx);
1758 return packet_done;
1759 }
1760 break;
1761 }
1762 if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1763 fprintf(stderr, "Unknown or malformed query %*.*s\n",
1764 gdbctx->in_packet_len, gdbctx->in_packet_len, gdbctx->in_packet);
1765 return packet_error;
1766 }
1767
1768 static enum packet_return packet_step(struct gdb_context* gdbctx)
1769 {
1770 /* FIXME: add support for address in packet */
1771 assert(gdbctx->in_packet_len == 0);
1772 if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread)
1773 if (gdbctx->trace & GDBPXY_TRC_COMMAND_FIXME)
1774 fprintf(stderr, "NIY: step on %04x, while last thread is %04x\n",
1775 gdbctx->exec_thread->tid, dbg_curr_thread->tid);
1776 be_cpu->single_step(&gdbctx->context, TRUE);
1777 resume_debuggee(gdbctx, DBG_CONTINUE);
1778 wait_for_debuggee(gdbctx);
1779 be_cpu->single_step(&gdbctx->context, FALSE);
1780 return packet_reply_status(gdbctx);
1781 }
1782
1783 #if 0
1784 static enum packet_return packet_step_signal(struct gdb_context* gdbctx)
1785 {
1786 unsigned char sig;
1787
1788 /* FIXME: add support for address in packet */
1789 assert(gdbctx->in_packet_len == 2);
1790 if (dbg_curr_thread->tid != gdbctx->exec_thread && gdbctx->exec_thread)
1791 if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1792 fprintf(stderr, "NIY: step/sig on %u, while last thread is %u\n",
1793 gdbctx->exec_thread, DEBUG_CurrThread->tid);
1794 hex_from(&sig, gdbctx->in_packet, 1);
1795 /* cannot change signals on the fly */
1796 if (gdbctx->trace & GDBPXY_TRC_COMMAND)
1797 fprintf(stderr, "sigs: %u %u\n", sig, gdbctx->last_sig);
1798 if (sig != gdbctx->last_sig)
1799 return packet_error;
1800 resume_debuggee(gdbctx, DBG_EXCEPTION_NOT_HANDLED);
1801 wait_for_debuggee(gdbctx);
1802 return packet_reply_status(gdbctx);
1803 }
1804 #endif
1805
1806 static enum packet_return packet_thread_alive(struct gdb_context* gdbctx)
1807 {
1808 char* end;
1809 unsigned tid;
1810
1811 tid = strtol(gdbctx->in_packet, &end, 16);
1812 if (tid == -1 || tid == 0)
1813 return packet_reply_error(gdbctx, EINVAL);
1814 if (dbg_get_thread(gdbctx->process, tid) != NULL)
1815 return packet_ok;
1816 return packet_reply_error(gdbctx, ESRCH);
1817 }
1818
1819 static enum packet_return packet_remove_breakpoint(struct gdb_context* gdbctx)
1820 {
1821 void* addr;
1822 unsigned len;
1823 struct gdb_ctx_Xpoint* xpt;
1824 enum be_xpoint_type t;
1825
1826 /* FIXME: check packet_len */
1827 if (gdbctx->in_packet[0] < '0' || gdbctx->in_packet[0] > '4' ||
1828 gdbctx->in_packet[1] != ',' ||
1829 sscanf(gdbctx->in_packet + 2, "%p,%x", &addr, &len) != 2)
1830 return packet_error;
1831 if (gdbctx->trace & GDBPXY_TRC_COMMAND)
1832 fprintf(stderr, "Remove bp %p[%u] typ=%c\n",
1833 addr, len, gdbctx->in_packet[0]);
1834 switch (gdbctx->in_packet[0])
1835 {
1836 case '0': t = be_xpoint_break; len = 0; break;
1837 case '1': t = be_xpoint_watch_exec; break;
1838 case '2': t = be_xpoint_watch_read; break;
1839 case '3': t = be_xpoint_watch_write; break;
1840 default: return packet_error;
1841 }
1842 for (xpt = &gdbctx->Xpoints[NUM_XPOINT - 1]; xpt >= gdbctx->Xpoints; xpt--)
1843 {
1844 if (xpt->addr == addr && xpt->type == t)
1845 {
1846 if (be_cpu->remove_Xpoint(gdbctx->process->handle,
1847 gdbctx->process->process_io, &gdbctx->context,
1848 t, xpt->addr, xpt->val, len))
1849 {
1850 xpt->type = -1;
1851 return packet_ok;
1852 }
1853 break;
1854 }
1855 }
1856 return packet_error;
1857 }
1858
1859 static enum packet_return packet_set_breakpoint(struct gdb_context* gdbctx)
1860 {
1861 void* addr;
1862 unsigned len;
1863 struct gdb_ctx_Xpoint* xpt;
1864 enum be_xpoint_type t;
1865
1866 /* FIXME: check packet_len */
1867 if (gdbctx->in_packet[0] < '0' || gdbctx->in_packet[0] > '4' ||
1868 gdbctx->in_packet[1] != ',' ||
1869 sscanf(gdbctx->in_packet + 2, "%p,%x", &addr, &len) != 2)
1870 return packet_error;
1871 if (gdbctx->trace & GDBPXY_TRC_COMMAND)
1872 fprintf(stderr, "Set bp %p[%u] typ=%c\n",
1873 addr, len, gdbctx->in_packet[0]);
1874 switch (gdbctx->in_packet[0])
1875 {
1876 case '0': t = be_xpoint_break; len = 0; break;
1877 case '1': t = be_xpoint_watch_exec; break;
1878 case '2': t = be_xpoint_watch_read; break;
1879 case '3': t = be_xpoint_watch_write; break;
1880 default: return packet_error;
1881 }
1882 /* because of packet command handling, this should be made idempotent */
1883 for (xpt = &gdbctx->Xpoints[NUM_XPOINT - 1]; xpt >= gdbctx->Xpoints; xpt--)
1884 {
1885 if (xpt->addr == addr && xpt->type == t)
1886 return packet_ok; /* nothing to do */
1887 }
1888 /* really set the Xpoint */
1889 for (xpt = &gdbctx->Xpoints[NUM_XPOINT - 1]; xpt >= gdbctx->Xpoints; xpt--)
1890 {
1891 if (xpt->type == -1)
1892 {
1893 if (be_cpu->insert_Xpoint(gdbctx->process->handle,
1894 gdbctx->process->process_io, &gdbctx->context,
1895 t, addr, &xpt->val, len))
1896 {
1897 xpt->addr = addr;
1898 xpt->type = t;
1899 return packet_ok;
1900 }
1901 fprintf(stderr, "cannot set xpoint\n");
1902 break;
1903 }
1904 }
1905 /* no more entries... eech */
1906 fprintf(stderr, "Running out of spots for {break|watch}points\n");
1907 return packet_error;
1908 }
1909
1910 /* =============================================== *
1911 * P A C K E T I N F R A S T R U C T U R E *
1912 * =============================================== *
1913 */
1914
1915 struct packet_entry
1916 {
1917 char key;
1918 enum packet_return (*handler)(struct gdb_context* gdbctx);
1919 };
1920
1921 static struct packet_entry packet_entries[] =
1922 {
1923 /*{'!', packet_extended}, */
1924 {'?', packet_last_signal},
1925 {'c', packet_continue},
1926 {'C', packet_continue_signal},
1927 {'D', packet_detach},
1928 {'g', packet_read_registers},
1929 {'G', packet_write_registers},
1930 {'k', packet_kill},
1931 {'H', packet_thread},
1932 {'m', packet_read_memory},
1933 {'M', packet_write_memory},
1934 /* {'p', packet_read_register}, doesn't seem needed */
1935 {'P', packet_write_register},
1936 {'q', packet_query},
1937 /* {'Q', packet_set}, */
1938 /* {'R', packet,restart}, only in extended mode ! */
1939 {'s', packet_step},
1940 /*{'S', packet_step_signal}, hard(er) to implement */
1941 {'T', packet_thread_alive},
1942 {'v', packet_verbose},
1943 {'z', packet_remove_breakpoint},
1944 {'Z', packet_set_breakpoint},
1945 };
1946
1947 static BOOL extract_packets(struct gdb_context* gdbctx)
1948 {
1949 char* end;
1950 int plen;
1951 unsigned char in_cksum, loc_cksum;
1952 char* ptr;
1953 enum packet_return ret = packet_error;
1954 int num_packet = 0;
1955
1956 while ((ret & packet_last_f) == 0)
1957 {
1958 if (gdbctx->in_len && (gdbctx->trace & GDBPXY_TRC_LOWLEVEL))
1959 fprintf(stderr, "In-buf: %*.*s\n",
1960 gdbctx->in_len, gdbctx->in_len, gdbctx->in_buf);
1961 ptr = memchr(gdbctx->in_buf, '$', gdbctx->in_len);
1962 if (ptr == NULL) return FALSE;
1963 if (ptr != gdbctx->in_buf)
1964 {
1965 int glen = ptr - gdbctx->in_buf; /* garbage len */
1966 if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
1967 fprintf(stderr, "Removing garbage: %*.*s\n",
1968 glen, glen, gdbctx->in_buf);
1969 gdbctx->in_len -= glen;
1970 memmove(gdbctx->in_buf, ptr, gdbctx->in_len);
1971 }
1972 end = memchr(gdbctx->in_buf + 1, '#', gdbctx->in_len);
1973 if (end == NULL) return FALSE;
1974 /* no checksum yet */
1975 if (end + 3 > gdbctx->in_buf + gdbctx->in_len) return FALSE;
1976 plen = end - gdbctx->in_buf - 1;
1977 hex_from(&in_cksum, end + 1, 1);
1978 loc_cksum = checksum(gdbctx->in_buf + 1, plen);
1979 if (loc_cksum == in_cksum)
1980 {
1981 if (num_packet == 0) {
1982 int i;
1983
1984 ret = packet_error;
1985
1986 write(gdbctx->sock, "+", 1);
1987 assert(plen);
1988
1989 /* FIXME: should use bsearch if packet_entries was sorted */
1990 for (i = 0; i < sizeof(packet_entries)/sizeof(packet_entries[0]); i++)
1991 {
1992 if (packet_entries[i].key == gdbctx->in_buf[1]) break;
1993 }
1994 if (i == sizeof(packet_entries)/sizeof(packet_entries[0]))
1995 {
1996 if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1997 fprintf(stderr, "Unknown packet request %*.*s\n",
1998 plen, plen, &gdbctx->in_buf[1]);
1999 }
2000 else
2001 {
2002 gdbctx->in_packet = gdbctx->in_buf + 2;
2003 gdbctx->in_packet_len = plen - 1;
2004 if (gdbctx->trace & GDBPXY_TRC_PACKET)
2005 fprintf(stderr, "Packet: %c%*.*s\n",
2006 gdbctx->in_buf[1],
2007 gdbctx->in_packet_len, gdbctx->in_packet_len,
2008 gdbctx->in_packet);
2009 ret = (packet_entries[i].handler)(gdbctx);
2010 }
2011 switch (ret & ~packet_last_f)
2012 {
2013 case packet_error: packet_reply(gdbctx, "", 0); break;
2014 case packet_ok: packet_reply(gdbctx, "OK", 2); break;
2015 case packet_done: break;
2016 }
2017 if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
2018 fprintf(stderr, "Reply-full: %*.*s\n",
2019 gdbctx->out_len, gdbctx->out_len, gdbctx->out_buf);
2020 i = write(gdbctx->sock, gdbctx->out_buf, gdbctx->out_len);
2021 assert(i == gdbctx->out_len);
2022 /* if this fails, we'll have to use POLLOUT...
2023 */
2024 gdbctx->out_len = 0;
2025 num_packet++;
2026 }
2027 else
2028 {
2029 /* FIXME: if we have in our input buffer more than one packet,
2030 * it's very likely that we took too long to answer to a given packet
2031 * and gdb is sending us again the same packet
2032 * We simply drop the second packet. This will lower the risk of error,
2033 * but there's still some race conditions here
2034 * A better fix (yet not perfect) would be to have two threads:
2035 * - one managing the packets for gdb
2036 * - the second one managing the commands...
2037 * This would allow us also the reply with the '+' character (Ack of
2038 * the command) way sooner than what we do now
2039 */
2040 if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
2041 fprintf(stderr, "Dropping packet, I was too slow to respond\n");
2042 }
2043 }
2044 else
2045 {
2046 write(gdbctx->sock, "+", 1);
2047 if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
2048 fprintf(stderr, "Dropping packet, invalid checksum %d <> %d\n", in_cksum, loc_cksum);
2049 }
2050 gdbctx->in_len -= plen + 4;
2051 memmove(gdbctx->in_buf, end + 3, gdbctx->in_len);
2052 }
2053 return TRUE;
2054 }
2055
2056 static int fetch_data(struct gdb_context* gdbctx)
2057 {
2058 int len, in_len = gdbctx->in_len;
2059
2060 assert(gdbctx->in_len <= gdbctx->in_buf_alloc);
2061 for (;;)
2062 {
2063 #define STEP 128
2064 if (gdbctx->in_len + STEP > gdbctx->in_buf_alloc)
2065 gdbctx->in_buf = realloc(gdbctx->in_buf, gdbctx->in_buf_alloc += STEP);
2066 #undef STEP
2067 if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
2068 fprintf(stderr, "%d %d %*.*s\n",
2069 gdbctx->in_len, gdbctx->in_buf_alloc,
2070 gdbctx->in_len, gdbctx->in_len, gdbctx->in_buf);
2071 len = read(gdbctx->sock, gdbctx->in_buf + gdbctx->in_len, gdbctx->in_buf_alloc - gdbctx->in_len);
2072 if (len <= 0) break;
2073 gdbctx->in_len += len;
2074 assert(gdbctx->in_len <= gdbctx->in_buf_alloc);
2075 if (len < gdbctx->in_buf_alloc - gdbctx->in_len) break;
2076 }
2077 if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
2078 fprintf(stderr, "=> %d\n", gdbctx->in_len - in_len);
2079 return gdbctx->in_len - in_len;
2080 }
2081
2082 #define FLAG_NO_START 1
2083 #define FLAG_WITH_XTERM 2
2084
2085 static BOOL gdb_exec(const char* wine_path, unsigned port, unsigned flags)
2086 {
2087 char buf[MAX_PATH];
2088 int fd;
2089 const char* gdb_path;
2090 FILE* f;
2091
2092 if (!(gdb_path = getenv("WINE_GDB"))) gdb_path = "gdb";
2093 strcpy(buf,"/tmp/winegdb.XXXXXX");
2094 fd = mkstemps(buf, 0);
2095 if (fd == -1) return FALSE;
2096 if ((f = fdopen(fd, "w+")) == NULL) return FALSE;
2097 fprintf(f, "file %s\n", wine_path);
2098 fprintf(f, "target remote localhost:%d\n", ntohs(port));
2099 fprintf(f, "monitor trace=%d\n", GDBPXY_TRC_COMMAND_FIXME);
2100 fprintf(f, "set prompt Wine-gdb>\\ \n");
2101 /* gdb 5.1 seems to require it, won't hurt anyway */
2102 fprintf(f, "sharedlibrary\n");
2103 /* This is needed (but not a decent & final fix)
2104 * Without this, gdb would skip our inter-DLL relay code (because
2105 * we don't have any line number information for the relay code)
2106 * With this, we will stop on first instruction of the stub, and
2107 * reusing step, will get us through the relay stub at the actual
2108 * function we're looking at.
2109 */
2110 fprintf(f, "set step-mode on\n");
2111 /* tell gdb to delete this file when done handling it... */
2112 fprintf(f, "shell rm -f \"%s\"\n", buf);
2113 fclose(f);
2114 if (flags & FLAG_WITH_XTERM)
2115 execlp("xterm", "xterm", "-e", gdb_path, "-x", buf, NULL);
2116 else
2117 execlp(gdb_path, gdb_path, "-x", buf, NULL);
2118 assert(0); /* never reached */
2119 return TRUE;
2120 }
2121
2122 static BOOL gdb_startup(struct gdb_context* gdbctx, DEBUG_EVENT* de, unsigned flags)
2123 {
2124 int sock;
2125 struct sockaddr_in s_addrs;
2126 unsigned int s_len = sizeof(s_addrs);
2127 struct pollfd pollfd;
2128 IMAGEHLP_MODULE imh_mod;
2129
2130 /* step 1: create socket for gdb connection request */
2131 if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
2132 {
2133 if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
2134 fprintf(stderr, "Can't create socket");
2135 return FALSE;
2136 }
2137
2138 if (listen(sock, 1) == -1 ||
2139 getsockname(sock, (struct sockaddr*)&s_addrs, &s_len) == -1)
2140 return FALSE;
2141
2142 /* step 2: do the process internal creation */
2143 handle_debug_event(gdbctx, de);
2144
2145 /* step3: get the wine loader name */
2146 if (!dbg_get_debuggee_info(gdbctx->process->handle, &imh_mod)) return FALSE;
2147
2148 /* step 4: fire up gdb (if requested) */
2149 if (flags & FLAG_NO_START)
2150 fprintf(stderr, "target remote localhost:%d\n", ntohs(s_addrs.sin_port));
2151 else
2152 switch (fork())
2153 {
2154 case -1: /* error in parent... */
2155 fprintf(stderr, "Cannot create gdb\n");
2156 return FALSE;
2157 default: /* in parent... success */
2158 break;
2159 case 0: /* in child... and alive */
2160 gdb_exec(imh_mod.LoadedImageName, s_addrs.sin_port, flags);
2161 /* if we're here, exec failed, so report failure */
2162 return FALSE;
2163 }
2164
2165 /* step 5: wait for gdb to connect actually */
2166 pollfd.fd = sock;
2167 pollfd.events = POLLIN;
2168 pollfd.revents = 0;
2169
2170 switch (poll(&pollfd, 1, -1))
2171 {
2172 case 1:
2173 if (pollfd.revents & POLLIN)
2174 {
2175 int dummy = 1;
2176 gdbctx->sock = accept(sock, (struct sockaddr*)&s_addrs, &s_len);
2177 if (gdbctx->sock == -1)
2178 break;
2179 if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
2180 fprintf(stderr, "Connected on %d\n", gdbctx->sock);
2181 /* don't keep our small packets too long: send them ASAP back to GDB
2182 * without this, GDB really crawls
2183 */
2184 setsockopt(gdbctx->sock, IPPROTO_TCP, TCP_NODELAY, (char*)&dummy, sizeof(dummy));
2185 }
2186 break;
2187 case 0:
2188 if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
2189 fprintf(stderr, "Poll for cnx failed (timeout)\n");
2190 return FALSE;
2191 case -1:
2192 if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
2193 fprintf(stderr, "Poll for cnx failed (error)\n");
2194 return FALSE;
2195 default:
2196 assert(0);
2197 }
2198
2199 close(sock);
2200 return TRUE;
2201 }
2202
2203 static BOOL gdb_init_context(struct gdb_context* gdbctx, unsigned flags)
2204 {
2205 DEBUG_EVENT de;
2206 int i;
2207
2208 gdbctx->sock = -1;
2209 gdbctx->in_buf = NULL;
2210 gdbctx->in_buf_alloc = 0;
2211 gdbctx->in_len = 0;
2212 gdbctx->out_buf = NULL;
2213 gdbctx->out_buf_alloc = 0;
2214 gdbctx->out_len = 0;
2215 gdbctx->out_curr_packet = -1;
2216
2217 gdbctx->exec_thread = gdbctx->other_thread = NULL;
2218 gdbctx->last_sig = 0;
2219 gdbctx->in_trap = FALSE;
2220 gdbctx->trace = /*GDBPXY_TRC_PACKET | GDBPXY_TRC_COMMAND |*/ GDBPXY_TRC_COMMAND_ERROR | GDBPXY_TRC_COMMAND_FIXME | GDBPXY_TRC_WIN32_EVENT;
2221 gdbctx->process = NULL;
2222 for (i = 0; i < NUM_XPOINT; i++)
2223 gdbctx->Xpoints[i].type = -1;
2224
2225 /* wait for first trap */
2226 while (WaitForDebugEvent(&de, INFINITE))
2227 {
2228 if (de.dwDebugEventCode == CREATE_PROCESS_DEBUG_EVENT)
2229 {
2230 /* this should be the first event we get,
2231 * and the only one of this type */
2232 assert(gdbctx->process == NULL && de.dwProcessId == dbg_curr_pid);
2233 /* gdbctx->dwProcessId = pid; */
2234 if (!gdb_startup(gdbctx, &de, flags)) return FALSE;
2235 assert(!gdbctx->in_trap);
2236 }
2237 else
2238 {
2239 handle_debug_event(gdbctx, &de);
2240 if (gdbctx->in_trap) break;
2241 }
2242 ContinueDebugEvent(de.dwProcessId, de.dwThreadId, DBG_CONTINUE);
2243 }
2244 return TRUE;
2245 }
2246
2247 static int gdb_remote(unsigned flags)
2248 {
2249 struct pollfd pollfd;
2250 struct gdb_context gdbctx;
2251 BOOL doLoop;
2252
2253 for (doLoop = gdb_init_context(&gdbctx, flags); doLoop;)
2254 {
2255 pollfd.fd = gdbctx.sock;
2256 pollfd.events = POLLIN;
2257 pollfd.revents = 0;
2258
2259 switch (poll(&pollfd, 1, -1))
2260 {
2261 case 1:
2262 /* got something */
2263 if (pollfd.revents & (POLLHUP | POLLERR))
2264 {
2265 if (gdbctx.trace & GDBPXY_TRC_LOWLEVEL)
2266 fprintf(stderr, "Gdb hung up\n");
2267 /* kill also debuggee process - questionnable - */
2268 detach_debuggee(&gdbctx, TRUE);
2269 doLoop = FALSE;
2270 break;
2271 }
2272 if ((pollfd.revents & POLLIN) && fetch_data(&gdbctx) > 0)
2273 {
2274 if (extract_packets(&gdbctx)) doLoop = FALSE;
2275 }
2276 break;
2277 case 0:
2278 /* timeout, should never happen (infinite timeout) */
2279 break;
2280 case -1:
2281 if (gdbctx.trace & GDBPXY_TRC_LOWLEVEL)
2282 fprintf(stderr, "Poll failed\n");
2283 doLoop = FALSE;
2284 break;
2285 }
2286 }
2287 wait(NULL);
2288 return 0;
2289 }
2290 #endif
2291
2292 int gdb_main(int argc, char* argv[])
2293 {
2294 #ifdef HAVE_POLL
2295 unsigned gdb_flags = 0;
2296
2297 argc--; argv++;
2298 while (argc > 0 && argv[0][0] == '-')
2299 {
2300 if (strcmp(argv[0], "--no-start") == 0)
2301 {
2302 gdb_flags |= FLAG_NO_START;
2303 argc--; argv++;
2304 continue;
2305 }
2306 if (strcmp(argv[0], "--with-xterm") == 0)
2307 {
2308 gdb_flags |= FLAG_WITH_XTERM;
2309 argc--; argv++;
2310 continue;
2311 }
2312 return -1;
2313 }
2314 if (dbg_active_attach(argc, argv) == start_ok ||
2315 dbg_active_launch(argc, argv) == start_ok)
2316 return gdb_remote(gdb_flags);
2317 #else
2318 fprintf(stderr, "GdbProxy mode not supported on this platform\n");
2319 #endif
2320 return -1;
2321 }
2322
2323 static struct be_process_io be_process_gdbproxy_io =
2324 {
2325 NULL, /* we shouldn't use close_process() in gdbproxy */
2326 ReadProcessMemory,
2327 WriteProcessMemory
2328 };
useful hacks and other patches not (yet) suitable for mainline