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