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