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