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