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