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