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