?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winedbg: Use nameless unions/structs.
[wine.git] / programs / winedbg / gdbproxy.c
blob18e18289bee5c58077d09027d7eaa8657fc4364b
1 /*
2 * A Win32 based proxy implementing the GBD remote protocol.
3 * This makes it possible to debug Wine (and any "emulated"
4 * program) under Linux using GDB.
5 *
6 * Copyright (c) Eric Pouech 2002-2004
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 /* Protocol specification can be found here:
24 * http://sources.redhat.com/gdb/onlinedocs/gdb/Maintenance-Commands.html
25 */
26
27 #include <assert.h>
28 #include <fcntl.h>
29 #include <stdarg.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32
33 #include "debugger.h"
34
35 #include "windef.h"
36 #include "winbase.h"
37 #include "winsock2.h"
38 #include "tlhelp32.h"
39 #include "wine/debug.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(winedbg);
42
43 struct gdb_xpoint
44 {
45 struct list entry;
46 int pid;
47 int tid;
48 enum be_xpoint_type type;
49 void *addr;
50 int size;
51 unsigned int value;
52 };
53
54 struct reply_buffer
55 {
56 unsigned char* base;
57 size_t len;
58 size_t alloc;
59 };
60
61 #define QX_NAME_SIZE 32
62 #define QX_ANNEX_SIZE MAX_PATH
63
64 struct gdb_context
65 {
66 /* gdb information */
67 SOCKET sock;
68 /* incoming buffer */
69 char* in_buf;
70 int in_buf_alloc;
71 int in_len;
72 /* split into individual packet */
73 char* in_packet;
74 int in_packet_len;
75 /* outgoing buffer */
76 struct reply_buffer out_buf;
77 int out_curr_packet;
78 /* generic GDB thread information */
79 int exec_tid; /* tid used in step & continue */
80 int other_tid; /* tid to be used in any other operation */
81 struct list xpoint_list;
82 /* current Win32 trap env */
83 DEBUG_EVENT de;
84 DWORD de_reply;
85 /* Win32 information */
86 struct dbg_process* process;
87 /* Unix environment */
88 ULONG_PTR wine_segs[3]; /* load addresses of the ELF wine exec segments (text, bss and data) */
89 BOOL no_ack_mode;
90 int qxfer_object_idx;
91 char qxfer_object_annex[QX_ANNEX_SIZE];
92 struct reply_buffer qxfer_buffer;
93 };
94
95 /* assume standard signal and errno values */
96 enum host_error
97 {
98 HOST_EPERM = 1,
99 HOST_ENOENT = 2,
100 HOST_ESRCH = 3,
101 HOST_ENOMEM = 12,
102 HOST_EFAULT = 14,
103 HOST_EINVAL = 22,
104 };
105
106 enum host_signal
107 {
108 HOST_SIGINT = 2,
109 HOST_SIGILL = 4,
110 HOST_SIGTRAP = 5,
111 HOST_SIGABRT = 6,
112 HOST_SIGFPE = 8,
113 HOST_SIGBUS = 10,
114 HOST_SIGSEGV = 11,
115 HOST_SIGALRM = 14,
116 HOST_SIGTERM = 15,
117 };
118
119 static void gdbctx_delete_xpoint(struct gdb_context *gdbctx, struct dbg_thread *thread,
120 dbg_ctx_t *ctx, struct gdb_xpoint *x)
121 {
122 struct dbg_process *process = gdbctx->process;
123 struct backend_cpu *cpu = process->be_cpu;
124
125 if (!cpu->remove_Xpoint(process->handle, process->process_io, ctx, x->type, x->addr, x->value, x->size))
126 ERR("%04lx:%04lx: Couldn't remove breakpoint at:%p/%x type:%d\n", process->pid, thread ? thread->tid : ~0, x->addr, x->size, x->type);
127
128 list_remove(&x->entry);
129 free(x);
130 }
131
132 static void gdbctx_insert_xpoint(struct gdb_context *gdbctx, struct dbg_thread *thread,
133 dbg_ctx_t *ctx, enum be_xpoint_type type, void *addr, int size)
134 {
135 struct dbg_process *process = thread->process;
136 struct backend_cpu *cpu = process->be_cpu;
137 struct gdb_xpoint *x;
138 unsigned int value;
139
140 if (!cpu->insert_Xpoint(process->handle, process->process_io, ctx, type, addr, &value, size))
141 {
142 ERR("%04lx:%04lx: Couldn't insert breakpoint at:%p/%x type:%d\n", process->pid, thread->tid, addr, size, type);
143 return;
144 }
145
146 if (!(x = malloc(sizeof(struct gdb_xpoint))))
147 {
148 ERR("%04lx:%04lx: Couldn't allocate memory for breakpoint at:%p/%x type:%d\n", process->pid, thread->tid, addr, size, type);
149 return;
150 }
151
152 x->pid = process->pid;
153 x->tid = thread->tid;
154 x->type = type;
155 x->addr = addr;
156 x->size = size;
157 x->value = value;
158 list_add_head(&gdbctx->xpoint_list, &x->entry);
159 }
160
161 static struct gdb_xpoint *gdb_find_xpoint(struct gdb_context *gdbctx, struct dbg_thread *thread,
162 enum be_xpoint_type type, void *addr, int size)
163 {
164 struct gdb_xpoint *x;
165
166 LIST_FOR_EACH_ENTRY(x, &gdbctx->xpoint_list, struct gdb_xpoint, entry)
167 {
168 if (thread && (x->pid != thread->process->pid || x->tid != thread->tid))
169 continue;
170 if (x->type == type && x->addr == addr && x->size == size)
171 return x;
172 }
173
174 return NULL;
175 }
176
177 static BOOL tgt_process_gdbproxy_read(HANDLE hProcess, const void* addr,
178 void* buffer, SIZE_T len, SIZE_T* rlen)
179 {
180 return ReadProcessMemory( hProcess, addr, buffer, len, rlen );
181 }
182
183 static BOOL tgt_process_gdbproxy_write(HANDLE hProcess, void* addr,
184 const void* buffer, SIZE_T len, SIZE_T* wlen)
185 {
186 return WriteProcessMemory( hProcess, addr, buffer, len, wlen );
187 }
188
189 static struct be_process_io be_process_gdbproxy_io =
190 {
191 NULL, /* we shouldn't use close_process() in gdbproxy */
192 tgt_process_gdbproxy_read,
193 tgt_process_gdbproxy_write
194 };
195
196 /* =============================================== *
197 * B A S I C M A N I P U L A T I O N S *
198 * =============================================== *
199 */
200
201 static inline int hex_from0(char ch)
202 {
203 if (ch >= '0' && ch <= '9') return ch - '0';
204 if (ch >= 'A' && ch <= 'F') return ch - 'A' + 10;
205 if (ch >= 'a' && ch <= 'f') return ch - 'a' + 10;
206
207 assert(0);
208 return 0;
209 }
210
211 static inline unsigned char hex_to0(int x)
212 {
213 assert(x >= 0 && x < 16);
214 return "0123456789abcdef"[x];
215 }
216
217 static void hex_from(void* dst, const char* src, size_t len)
218 {
219 unsigned char *p = dst;
220 while (len--)
221 {
222 *p++ = (hex_from0(src[0]) << 4) | hex_from0(src[1]);
223 src += 2;
224 }
225 }
226
227 static void hex_to(char* dst, const void* src, size_t len)
228 {
229 const unsigned char *p = src;
230 while (len--)
231 {
232 *dst++ = hex_to0(*p >> 4);
233 *dst++ = hex_to0(*p & 0x0F);
234 p++;
235 }
236 }
237
238 static void reply_buffer_clear(struct reply_buffer* reply)
239 {
240 reply->len = 0;
241 }
242
243 static void reply_buffer_grow(struct reply_buffer* reply, size_t size)
244 {
245 size_t required_alloc = reply->len + size;
246
247 if (reply->alloc < required_alloc)
248 {
249 reply->alloc = reply->alloc * 3 / 2;
250 if (reply->alloc < required_alloc)
251 reply->alloc = required_alloc;
252
253 reply->base = realloc(reply->base, reply->alloc);
254 }
255 }
256
257 static void reply_buffer_append(struct reply_buffer* reply, const void* data, size_t size)
258 {
259 reply_buffer_grow(reply, size);
260 memcpy(reply->base + reply->len, data, size);
261 reply->len += size;
262 }
263
264 static inline void reply_buffer_append_str(struct reply_buffer* reply, const char* str)
265 {
266 reply_buffer_append(reply, str, strlen(str));
267 }
268
269 static inline void reply_buffer_append_wstr(struct reply_buffer* reply, const WCHAR* wstr)
270 {
271 char* str;
272 int len;
273
274 len = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL);
275 str = malloc(len);
276 if (str && WideCharToMultiByte(CP_ACP, 0, wstr, -1, str, len, NULL, NULL))
277 reply_buffer_append_str(reply, str);
278 free(str);
279 }
280
281 static inline void reply_buffer_append_hex(struct reply_buffer* reply, const void* src, size_t len)
282 {
283 reply_buffer_grow(reply, len * 2);
284 hex_to((char *)reply->base + reply->len, src, len);
285 reply->len += len * 2;
286 }
287
288 static inline void reply_buffer_append_uinthex(struct reply_buffer* reply, ULONG_PTR val, int len)
289 {
290 char buf[sizeof(ULONG_PTR) * 2], *ptr;
291
292 assert(len <= sizeof(ULONG_PTR));
293
294 ptr = buf + len * 2;
295 while (ptr != buf)
296 {
297 *--ptr = hex_to0(val & 0x0F);
298 val >>= 4;
299 }
300
301 reply_buffer_append(reply, ptr, len * 2);
302 }
303
304 static const unsigned char xml_special_chars_lookup_table[16] = {
305 /* The characters should be sorted by its value modulo table length. */
306
307 0x00, /* NUL */
308 0,
309 0x22, /* ": 0010|0010 */
310 0, 0, 0,
311 0x26, /* &: 0010|0110 */
312 0x27, /* ': 0010|0111 */
313 0, 0, 0, 0,
314 0x3C, /* <: 0011|1100 */
315 0,
316 0x3E, /* >: 0011|1110 */
317 0
318 };
319
320 static inline BOOL is_nul_or_xml_special_char(unsigned char val)
321 {
322 const size_t length = ARRAY_SIZE(xml_special_chars_lookup_table);
323 return xml_special_chars_lookup_table[val % length] == val;
324 }
325
326 static void reply_buffer_append_xmlstr(struct reply_buffer* reply, const char* str)
327 {
328 const char *ptr = str, *curr;
329
330 for (;;)
331 {
332 curr = ptr;
333
334 while (!is_nul_or_xml_special_char((unsigned char)*ptr))
335 ptr++;
336
337 reply_buffer_append(reply, curr, ptr - curr);
338
339 switch (*ptr++)
340 {
341 case '"': reply_buffer_append_str(reply, "&quot;"); break;
342 case '&': reply_buffer_append_str(reply, "&amp;"); break;
343 case '\'': reply_buffer_append_str(reply, "&apos;"); break;
344 case '<': reply_buffer_append_str(reply, "&lt;"); break;
345 case '>': reply_buffer_append_str(reply, "&gt;"); break;
346 case '\0':
347 default:
348 return;
349 }
350 }
351 }
352
353 static unsigned char checksum(const void* data, int len)
354 {
355 unsigned cksum = 0;
356 const unsigned char* ptr = data;
357
358 while (len-- > 0)
359 cksum += *ptr++;
360 return cksum;
361 }
362
363 static inline void* cpu_register_ptr(struct gdb_context *gdbctx,
364 dbg_ctx_t *ctx, unsigned idx)
365 {
366 assert(idx < gdbctx->process->be_cpu->gdb_num_regs);
367 return (char*)ctx + gdbctx->process->be_cpu->gdb_register_map[idx].offset;
368 }
369
370 static inline DWORD64 cpu_register(struct gdb_context *gdbctx,
371 dbg_ctx_t *ctx, unsigned idx)
372 {
373 switch (gdbctx->process->be_cpu->gdb_register_map[idx].length)
374 {
375 case 1: return *(BYTE*)cpu_register_ptr(gdbctx, ctx, idx);
376 case 2: return *(WORD*)cpu_register_ptr(gdbctx, ctx, idx);
377 case 4: return *(DWORD*)cpu_register_ptr(gdbctx, ctx, idx);
378 case 8: return *(DWORD64*)cpu_register_ptr(gdbctx, ctx, idx);
379 default:
380 ERR("got unexpected size: %u\n",
381 (unsigned)gdbctx->process->be_cpu->gdb_register_map[idx].length);
382 assert(0);
383 return 0;
384 }
385 }
386
387 static inline void cpu_register_hex_from(struct gdb_context *gdbctx,
388 dbg_ctx_t* ctx, unsigned idx, const char **phex)
389 {
390 const struct gdb_register *cpu_register_map = gdbctx->process->be_cpu->gdb_register_map;
391 hex_from(cpu_register_ptr(gdbctx, ctx, idx), *phex, cpu_register_map[idx].length);
392 }
393
394 /* =============================================== *
395 * W I N 3 2 D E B U G I N T E R F A C E *
396 * =============================================== *
397 */
398
399 static struct dbg_thread* dbg_thread_from_tid(struct gdb_context* gdbctx, int tid)
400 {
401 struct dbg_process *process = gdbctx->process;
402 struct dbg_thread *thread;
403
404 if (!process) return NULL;
405
406 if (tid == 0) tid = gdbctx->de.dwThreadId;
407 LIST_FOR_EACH_ENTRY(thread, &process->threads, struct dbg_thread, entry)
408 {
409 if (tid > 0 && thread->tid != tid) continue;
410 return thread;
411 }
412
413 return NULL;
414 }
415
416 static void dbg_thread_set_single_step(struct dbg_thread *thread, BOOL enable)
417 {
418 struct backend_cpu *backend;
419 dbg_ctx_t ctx;
420
421 if (!thread) return;
422 if (!thread->process) return;
423 if (!(backend = thread->process->be_cpu)) return;
424
425 if (!backend->get_context(thread->handle, &ctx))
426 {
427 ERR("get_context failed for thread %04lx:%04lx\n", thread->process->pid, thread->tid);
428 return;
429 }
430 backend->single_step(&ctx, enable);
431 if (!backend->set_context(thread->handle, &ctx))
432 ERR("set_context failed for thread %04lx:%04lx\n", thread->process->pid, thread->tid);
433 }
434
435 static unsigned char signal_from_debug_event(DEBUG_EVENT* de)
436 {
437 DWORD ec;
438
439 if (de->dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
440 return HOST_SIGTERM;
441 if (de->dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
442 return HOST_SIGTRAP;
443
444 ec = de->u.Exception.ExceptionRecord.ExceptionCode;
445 switch (ec)
446 {
447 case EXCEPTION_ACCESS_VIOLATION:
448 case EXCEPTION_PRIV_INSTRUCTION:
449 case EXCEPTION_STACK_OVERFLOW:
450 case EXCEPTION_GUARD_PAGE:
451 return HOST_SIGSEGV;
452 case EXCEPTION_DATATYPE_MISALIGNMENT:
453 return HOST_SIGBUS;
454 case EXCEPTION_SINGLE_STEP:
455 case EXCEPTION_BREAKPOINT:
456 return HOST_SIGTRAP;
457 case EXCEPTION_FLT_DENORMAL_OPERAND:
458 case EXCEPTION_FLT_DIVIDE_BY_ZERO:
459 case EXCEPTION_FLT_INEXACT_RESULT:
460 case EXCEPTION_FLT_INVALID_OPERATION:
461 case EXCEPTION_FLT_OVERFLOW:
462 case EXCEPTION_FLT_STACK_CHECK:
463 case EXCEPTION_FLT_UNDERFLOW:
464 return HOST_SIGFPE;
465 case EXCEPTION_INT_DIVIDE_BY_ZERO:
466 case EXCEPTION_INT_OVERFLOW:
467 return HOST_SIGFPE;
468 case EXCEPTION_ILLEGAL_INSTRUCTION:
469 return HOST_SIGILL;
470 case CONTROL_C_EXIT:
471 return HOST_SIGINT;
472 case STATUS_POSSIBLE_DEADLOCK:
473 return HOST_SIGALRM;
474 /* should not be here */
475 case EXCEPTION_INVALID_HANDLE:
476 case EXCEPTION_WINE_NAME_THREAD:
477 return HOST_SIGTRAP;
478 default:
479 ERR("Unknown exception code 0x%08lx\n", ec);
480 return HOST_SIGABRT;
481 }
482 }
483
484 static BOOL handle_exception(struct gdb_context* gdbctx, EXCEPTION_DEBUG_INFO* exc)
485 {
486 EXCEPTION_RECORD* rec = &exc->ExceptionRecord;
487
488 switch (rec->ExceptionCode)
489 {
490 case EXCEPTION_WINE_NAME_THREAD:
491 {
492 const THREADNAME_INFO *threadname = (const THREADNAME_INFO *)rec->ExceptionInformation;
493 struct dbg_thread *thread;
494 char name[9];
495 SIZE_T read;
496
497 if (threadname->dwType != 0x1000)
498 return FALSE;
499 if (threadname->dwThreadID == -1)
500 thread = dbg_get_thread(gdbctx->process, gdbctx->de.dwThreadId);
501 else
502 thread = dbg_get_thread(gdbctx->process, threadname->dwThreadID);
503 if (thread)
504 {
505 if (gdbctx->process->process_io->read( gdbctx->process->handle,
506 threadname->szName, name, sizeof(name), &read) && read == sizeof(name))
507 {
508 fprintf(stderr, "Thread ID=%04lx renamed to \"%.9s\"\n",
509 threadname->dwThreadID, name);
510 }
511 }
512 else
513 ERR("Cannot set name of thread %04lx\n", threadname->dwThreadID);
514 return TRUE;
515 }
516 case EXCEPTION_INVALID_HANDLE:
517 return TRUE;
518 default:
519 return FALSE;
520 }
521 }
522
523 static BOOL handle_debug_event(struct gdb_context* gdbctx, BOOL stop_on_dll_load_unload)
524 {
525 DEBUG_EVENT *de = &gdbctx->de;
526 struct dbg_thread *thread;
527
528 union {
529 char bufferA[256];
530 WCHAR buffer[256];
531 } u;
532 DWORD size;
533
534 gdbctx->exec_tid = de->dwThreadId;
535 gdbctx->other_tid = de->dwThreadId;
536 gdbctx->de_reply = DBG_REPLY_LATER;
537
538 switch (de->dwDebugEventCode)
539 {
540 case CREATE_PROCESS_DEBUG_EVENT:
541 gdbctx->process = dbg_add_process(&be_process_gdbproxy_io, de->dwProcessId,
542 de->u.CreateProcessInfo.hProcess);
543 if (!gdbctx->process)
544 return TRUE;
545
546 size = ARRAY_SIZE(u.buffer);
547 QueryFullProcessImageNameW( gdbctx->process->handle, 0, u.buffer, &size );
548 dbg_set_process_name(gdbctx->process, u.buffer);
549
550 fprintf(stderr, "%04lx:%04lx: create process '%ls'/%p @%p (%lu<%lu>)\n",
551 de->dwProcessId, de->dwThreadId,
552 u.buffer,
553 de->u.CreateProcessInfo.lpImageName,
554 de->u.CreateProcessInfo.lpStartAddress,
555 de->u.CreateProcessInfo.dwDebugInfoFileOffset,
556 de->u.CreateProcessInfo.nDebugInfoSize);
557
558 /* de->u.CreateProcessInfo.lpStartAddress; */
559 if (!dbg_init(gdbctx->process->handle, u.buffer, TRUE))
560 ERR("Couldn't initiate DbgHelp\n");
561
562 fprintf(stderr, "%04lx:%04lx: create thread I @%p\n", de->dwProcessId,
563 de->dwThreadId, de->u.CreateProcessInfo.lpStartAddress);
564
565 dbg_load_module(gdbctx->process->handle, de->u.CreateProcessInfo.hFile, u.buffer,
566 (DWORD_PTR)de->u.CreateProcessInfo.lpBaseOfImage, 0);
567
568 dbg_add_thread(gdbctx->process, de->dwThreadId,
569 de->u.CreateProcessInfo.hThread,
570 de->u.CreateProcessInfo.lpThreadLocalBase);
571 return TRUE;
572
573 case LOAD_DLL_DEBUG_EVENT:
574 fetch_module_name( de->u.LoadDll.lpImageName, de->u.LoadDll.lpBaseOfDll,
575 u.buffer, ARRAY_SIZE(u.buffer) );
576 fprintf(stderr, "%04lx:%04lx: loads DLL %ls @%p (%lu<%lu>)\n",
577 de->dwProcessId, de->dwThreadId,
578 u.buffer,
579 de->u.LoadDll.lpBaseOfDll,
580 de->u.LoadDll.dwDebugInfoFileOffset,
581 de->u.LoadDll.nDebugInfoSize);
582 dbg_load_module(gdbctx->process->handle, de->u.LoadDll.hFile, u.buffer,
583 (DWORD_PTR)de->u.LoadDll.lpBaseOfDll, 0);
584 if (stop_on_dll_load_unload)
585 break;
586 return TRUE;
587
588 case UNLOAD_DLL_DEBUG_EVENT:
589 fprintf(stderr, "%08lx:%08lx: unload DLL @%p\n",
590 de->dwProcessId, de->dwThreadId, de->u.UnloadDll.lpBaseOfDll);
591 SymUnloadModule(gdbctx->process->handle,
592 (DWORD_PTR)de->u.UnloadDll.lpBaseOfDll);
593 if (stop_on_dll_load_unload)
594 break;
595 return TRUE;
596
597 case EXCEPTION_DEBUG_EVENT:
598 TRACE("%08lx:%08lx: exception code=0x%08lx\n", de->dwProcessId,
599 de->dwThreadId, de->u.Exception.ExceptionRecord.ExceptionCode);
600
601 if (handle_exception(gdbctx, &de->u.Exception))
602 return TRUE;
603 break;
604
605 case CREATE_THREAD_DEBUG_EVENT:
606 fprintf(stderr, "%08lx:%08lx: create thread D @%p\n", de->dwProcessId,
607 de->dwThreadId, de->u.CreateThread.lpStartAddress);
608
609 dbg_add_thread(gdbctx->process,
610 de->dwThreadId,
611 de->u.CreateThread.hThread,
612 de->u.CreateThread.lpThreadLocalBase);
613 return TRUE;
614
615 case EXIT_THREAD_DEBUG_EVENT:
616 fprintf(stderr, "%08lx:%08lx: exit thread (%lu)\n",
617 de->dwProcessId, de->dwThreadId, de->u.ExitThread.dwExitCode);
618 if ((thread = dbg_get_thread(gdbctx->process, de->dwThreadId)))
619 dbg_del_thread(thread);
620 return TRUE;
621
622 case EXIT_PROCESS_DEBUG_EVENT:
623 fprintf(stderr, "%08lx:%08lx: exit process (%lu)\n",
624 de->dwProcessId, de->dwThreadId, de->u.ExitProcess.dwExitCode);
625
626 dbg_del_process(gdbctx->process);
627 gdbctx->process = NULL;
628 return FALSE;
629
630 case OUTPUT_DEBUG_STRING_EVENT:
631 memory_get_string(gdbctx->process,
632 de->u.DebugString.lpDebugStringData, TRUE,
633 de->u.DebugString.fUnicode, u.bufferA, sizeof(u.bufferA));
634 fprintf(stderr, "%08lx:%08lx: output debug string (%s)\n",
635 de->dwProcessId, de->dwThreadId, debugstr_a(u.bufferA));
636 return TRUE;
637
638 case RIP_EVENT:
639 fprintf(stderr, "%08lx:%08lx: rip error=%lu type=%lu\n", de->dwProcessId,
640 de->dwThreadId, de->u.RipInfo.dwError, de->u.RipInfo.dwType);
641 return TRUE;
642
643 default:
644 FIXME("%08lx:%08lx: unknown event (%lu)\n",
645 de->dwProcessId, de->dwThreadId, de->dwDebugEventCode);
646 }
647
648 LIST_FOR_EACH_ENTRY(thread, &gdbctx->process->threads, struct dbg_thread, entry)
649 {
650 if (!thread->suspended) SuspendThread(thread->handle);
651 thread->suspended = TRUE;
652 }
653
654 return FALSE;
655 }
656
657 static void handle_step_or_continue(struct gdb_context* gdbctx, int tid, BOOL step, int sig)
658 {
659 struct dbg_process *process = gdbctx->process;
660 struct dbg_thread *thread;
661
662 if (tid == 0) tid = gdbctx->de.dwThreadId;
663 LIST_FOR_EACH_ENTRY(thread, &process->threads, struct dbg_thread, entry)
664 {
665 if (tid != -1 && thread->tid != tid) continue;
666 if (!thread->suspended) continue;
667 thread->suspended = FALSE;
668
669 if (process->pid == gdbctx->de.dwProcessId && thread->tid == gdbctx->de.dwThreadId)
670 gdbctx->de_reply = (sig == -1 ? DBG_CONTINUE : DBG_EXCEPTION_NOT_HANDLED);
671
672 dbg_thread_set_single_step(thread, step);
673 ResumeThread(thread->handle);
674 }
675 }
676
677 static BOOL check_for_interrupt(struct gdb_context* gdbctx)
678 {
679 char pkt;
680 fd_set read_fds;
681 struct timeval tv = { 0, 0 };
682
683 FD_ZERO( &read_fds );
684 FD_SET( gdbctx->sock, &read_fds );
685
686 if (select( 0, &read_fds, NULL, NULL, &tv ) > 0)
687 {
688 if (recv(gdbctx->sock, &pkt, 1, 0) != 1) {
689 ERR("read failed\n");
690 return FALSE;
691 }
692 if (pkt != '\003') {
693 ERR("Unexpected break packet %#02x\n", pkt);
694 return FALSE;
695 }
696 return TRUE;
697 }
698 return FALSE;
699 }
700
701 static void wait_for_debuggee(struct gdb_context* gdbctx)
702 {
703 if (gdbctx->de.dwDebugEventCode)
704 ContinueDebugEvent(gdbctx->de.dwProcessId, gdbctx->de.dwThreadId, gdbctx->de_reply);
705
706 for (;;)
707 {
708 if (!WaitForDebugEvent(&gdbctx->de, 10))
709 {
710 if (GetLastError() == ERROR_SEM_TIMEOUT)
711 {
712 if (check_for_interrupt(gdbctx)) {
713 if (!DebugBreakProcess(gdbctx->process->handle)) {
714 ERR("Failed to break into debuggee\n");
715 break;
716 }
717 WaitForDebugEvent(&gdbctx->de, INFINITE);
718 } else {
719 continue;
720 }
721 } else {
722 break;
723 }
724 }
725 if (!handle_debug_event(gdbctx, TRUE))
726 break;
727 ContinueDebugEvent(gdbctx->de.dwProcessId, gdbctx->de.dwThreadId, DBG_CONTINUE);
728 }
729 }
730
731 static void detach_debuggee(struct gdb_context* gdbctx, BOOL kill)
732 {
733 handle_step_or_continue(gdbctx, -1, FALSE, -1);
734
735 if (gdbctx->de.dwDebugEventCode)
736 ContinueDebugEvent(gdbctx->de.dwProcessId, gdbctx->de.dwThreadId, DBG_CONTINUE);
737
738 if (!kill)
739 DebugActiveProcessStop(gdbctx->process->pid);
740 dbg_del_process(gdbctx->process);
741 gdbctx->process = NULL;
742 }
743
744 static void get_process_info(struct gdb_context* gdbctx, char* buffer, size_t len)
745 {
746 DWORD status;
747
748 if (!GetExitCodeProcess(gdbctx->process->handle, &status))
749 {
750 strcpy(buffer, "Unknown process");
751 return;
752 }
753 if (status == STILL_ACTIVE)
754 {
755 strcpy(buffer, "Running");
756 }
757 else
758 snprintf(buffer, len, "Terminated (%lu)", status);
759
760 switch (GetPriorityClass(gdbctx->process->handle))
761 {
762 case 0: break;
763 case ABOVE_NORMAL_PRIORITY_CLASS: strcat(buffer, ", above normal priority"); break;
764 case BELOW_NORMAL_PRIORITY_CLASS: strcat(buffer, ", below normal priority"); break;
765 case HIGH_PRIORITY_CLASS: strcat(buffer, ", high priority"); break;
766 case IDLE_PRIORITY_CLASS: strcat(buffer, ", idle priority"); break;
767 case NORMAL_PRIORITY_CLASS: strcat(buffer, ", normal priority"); break;
768 case REALTIME_PRIORITY_CLASS: strcat(buffer, ", realtime priority"); break;
769 }
770 strcat(buffer, "\n");
771 }
772
773 static void get_thread_info(struct gdb_context* gdbctx, unsigned tid,
774 char* buffer, size_t len)
775 {
776 struct dbg_thread* thd;
777 DWORD status;
778 int prio;
779
780 /* FIXME: use the size of buffer */
781 thd = dbg_get_thread(gdbctx->process, tid);
782 if (thd == NULL)
783 {
784 strcpy(buffer, "No information");
785 return;
786 }
787 if (GetExitCodeThread(thd->handle, &status))
788 {
789 if (status == STILL_ACTIVE)
790 {
791 /* FIXME: this is a bit brutal... some nicer way shall be found */
792 switch (status = SuspendThread(thd->handle))
793 {
794 case -1: break;
795 case 0: strcpy(buffer, "Running"); break;
796 default: snprintf(buffer, len, "Suspended (%lu)", status - 1);
797 }
798 ResumeThread(thd->handle);
799 }
800 else
801 snprintf(buffer, len, "Terminated (exit code = %lu)", status);
802 }
803 else
804 {
805 strcpy(buffer, "Unknown threadID");
806 }
807 switch (prio = GetThreadPriority(thd->handle))
808 {
809 case THREAD_PRIORITY_ERROR_RETURN: break;
810 case THREAD_PRIORITY_ABOVE_NORMAL: strcat(buffer, ", priority +1 above normal"); break;
811 case THREAD_PRIORITY_BELOW_NORMAL: strcat(buffer, ", priority -1 below normal"); break;
812 case THREAD_PRIORITY_HIGHEST: strcat(buffer, ", priority +2 above normal"); break;
813 case THREAD_PRIORITY_LOWEST: strcat(buffer, ", priority -2 below normal"); break;
814 case THREAD_PRIORITY_IDLE: strcat(buffer, ", priority idle"); break;
815 case THREAD_PRIORITY_NORMAL: strcat(buffer, ", priority normal"); break;
816 case THREAD_PRIORITY_TIME_CRITICAL: strcat(buffer, ", priority time-critical"); break;
817 default: snprintf(buffer + strlen(buffer), len - strlen(buffer), ", priority = %d", prio);
818 }
819 assert(strlen(buffer) < len);
820 }
821
822 /* =============================================== *
823 * P A C K E T U T I L S *
824 * =============================================== *
825 */
826
827 static int addr_width(struct gdb_context* gdbctx)
828 {
829 int sz = (gdbctx && gdbctx->process && gdbctx->process->be_cpu) ?
830 gdbctx->process->be_cpu->pointer_size : (int)sizeof(void*);
831 return sz * 2;
832 }
833
834 enum packet_return {packet_error = 0x00, packet_ok = 0x01, packet_done = 0x02,
835 packet_send_buffer = 0x03, packet_last_f = 0x80};
836
837 static void packet_reply_hex_to(struct gdb_context* gdbctx, const void* src, int len)
838 {
839 reply_buffer_append_hex(&gdbctx->out_buf, src, len);
840 }
841
842 static inline void packet_reply_hex_to_str(struct gdb_context* gdbctx, const char* src)
843 {
844 packet_reply_hex_to(gdbctx, src, strlen(src));
845 }
846
847 static void packet_reply_val(struct gdb_context* gdbctx, ULONG_PTR val, int len)
848 {
849 reply_buffer_append_uinthex(&gdbctx->out_buf, val, len);
850 }
851
852 static const unsigned char gdb_special_chars_lookup_table[4] = {
853 /* The characters should be indexed by its value modulo table length. */
854
855 0x24, /* $: 001001|00 */
856 0x7D, /* }: 011111|01 */
857 0x2A, /* *: 001010|10 */
858 0x23 /* #: 001000|11 */
859 };
860
861 static inline BOOL is_gdb_special_char(unsigned char val)
862 {
863 /* A note on the GDB special character scanning code:
864 *
865 * We cannot use strcspn() since we plan to transmit binary data in
866 * packet reply, which can contain NULL (0x00) bytes. We also don't want
867 * to slow down memory dump transfers. Therefore, we use a tiny lookup
868 * table that contains all the four special characters to speed up scanning.
869 */
870 const size_t length = ARRAY_SIZE(gdb_special_chars_lookup_table);
871 return gdb_special_chars_lookup_table[val % length] == val;
872 }
873
874 static void packet_reply_add_data(struct gdb_context* gdbctx, const void* data, size_t len)
875 {
876 const unsigned char *ptr = data, *end = ptr + len, *curr;
877 unsigned char esc_seq[2];
878
879 while (ptr != end)
880 {
881 curr = ptr;
882
883 while (ptr != end && !is_gdb_special_char(*ptr))
884 ptr++;
885
886 reply_buffer_append(&gdbctx->out_buf, curr, ptr - curr);
887 if (ptr == end) break;
888
889 esc_seq[0] = 0x7D;
890 esc_seq[1] = 0x20 ^ *ptr++;
891 reply_buffer_append(&gdbctx->out_buf, esc_seq, 2);
892 }
893 }
894
895 static inline void packet_reply_add(struct gdb_context* gdbctx, const char* str)
896 {
897 packet_reply_add_data(gdbctx, str, strlen(str));
898 }
899
900 static void packet_reply_open(struct gdb_context* gdbctx)
901 {
902 assert(gdbctx->out_curr_packet == -1);
903 reply_buffer_append(&gdbctx->out_buf, "$", 1);
904 gdbctx->out_curr_packet = gdbctx->out_buf.len;
905 }
906
907 static void packet_reply_close(struct gdb_context* gdbctx)
908 {
909 unsigned char cksum;
910 int plen;
911
912 plen = gdbctx->out_buf.len - gdbctx->out_curr_packet;
913 reply_buffer_append(&gdbctx->out_buf, "#", 1);
914 cksum = checksum(gdbctx->out_buf.base + gdbctx->out_curr_packet, plen);
915 packet_reply_hex_to(gdbctx, &cksum, 1);
916 gdbctx->out_curr_packet = -1;
917 }
918
919 static enum packet_return packet_reply(struct gdb_context* gdbctx, const char* packet)
920 {
921 packet_reply_open(gdbctx);
922
923 packet_reply_add(gdbctx, packet);
924
925 packet_reply_close(gdbctx);
926
927 return packet_done;
928 }
929
930 static enum packet_return packet_reply_error(struct gdb_context* gdbctx, int error)
931 {
932 packet_reply_open(gdbctx);
933
934 packet_reply_add(gdbctx, "E");
935 packet_reply_val(gdbctx, error, 1);
936
937 packet_reply_close(gdbctx);
938
939 return packet_done;
940 }
941
942 static inline void packet_reply_register_hex_to(struct gdb_context* gdbctx, dbg_ctx_t* ctx, unsigned idx)
943 {
944 const struct gdb_register *cpu_register_map = gdbctx->process->be_cpu->gdb_register_map;
945 packet_reply_hex_to(gdbctx, cpu_register_ptr(gdbctx, ctx, idx), cpu_register_map[idx].length);
946 }
947
948 static void packet_reply_xfer(struct gdb_context* gdbctx, size_t off, size_t len, BOOL* more_p)
949 {
950 BOOL more;
951 size_t data_len, trunc_len;
952
953 packet_reply_open(gdbctx);
954 data_len = gdbctx->qxfer_buffer.len;
955
956 /* check if off + len would overflow */
957 more = off < data_len && off + len < data_len;
958 if (more)
959 packet_reply_add(gdbctx, "m");
960 else
961 packet_reply_add(gdbctx, "l");
962
963 if (off < data_len)
964 {
965 trunc_len = min(len, data_len - off);
966 packet_reply_add_data(gdbctx, gdbctx->qxfer_buffer.base + off, trunc_len);
967 }
968
969 packet_reply_close(gdbctx);
970
971 *more_p = more;
972 }
973
974 /* =============================================== *
975 * P A C K E T H A N D L E R S *
976 * =============================================== *
977 */
978
979 static void packet_reply_status_xpoints(struct gdb_context* gdbctx, struct dbg_thread *thread,
980 dbg_ctx_t *ctx)
981 {
982 struct dbg_process *process = thread->process;
983 struct backend_cpu *cpu = process->be_cpu;
984 struct gdb_xpoint *x;
985
986 LIST_FOR_EACH_ENTRY(x, &gdbctx->xpoint_list, struct gdb_xpoint, entry)
987 {
988 if (x->pid != process->pid || x->tid != thread->tid)
989 continue;
990 if (!cpu->is_watchpoint_set(ctx, x->value))
991 continue;
992 if (x->type == be_xpoint_watch_write)
993 {
994 packet_reply_add(gdbctx, "watch:");
995 packet_reply_val(gdbctx, (ULONG_PTR)x->addr, sizeof(x->addr));
996 packet_reply_add(gdbctx, ";");
997 }
998 if (x->type == be_xpoint_watch_read)
999 {
1000 packet_reply_add(gdbctx, "rwatch:");
1001 packet_reply_val(gdbctx, (ULONG_PTR)x->addr, sizeof(x->addr));
1002 packet_reply_add(gdbctx, ";");
1003 }
1004 }
1005 }
1006
1007 static void packet_reply_begin_stop_reply(struct gdb_context* gdbctx, unsigned char signal)
1008 {
1009 packet_reply_add(gdbctx, "T");
1010 packet_reply_val(gdbctx, signal, 1);
1011
1012 /* We should always report the current thread ID for all stop replies.
1013 * Otherwise, GDB complains with the following message:
1014 *
1015 * Warning: multi-threaded target stopped without sending a thread-id,
1016 * using first non-exited thread
1017 */
1018 packet_reply_add(gdbctx, "thread:");
1019 packet_reply_val(gdbctx, gdbctx->de.dwThreadId, 4);
1020 packet_reply_add(gdbctx, ";");
1021 }
1022
1023 static enum packet_return packet_reply_status(struct gdb_context* gdbctx)
1024 {
1025 struct dbg_process *process = gdbctx->process;
1026 struct dbg_thread *thread;
1027 struct backend_cpu *backend;
1028 dbg_ctx_t ctx;
1029 size_t i;
1030
1031 switch (gdbctx->de.dwDebugEventCode)
1032 {
1033 default:
1034 if (!process) return packet_error;
1035 if (!(backend = process->be_cpu)) return packet_error;
1036 if (!(thread = dbg_get_thread(process, gdbctx->de.dwThreadId)) ||
1037 !backend->get_context(thread->handle, &ctx))
1038 return packet_error;
1039
1040 packet_reply_open(gdbctx);
1041 packet_reply_begin_stop_reply(gdbctx, signal_from_debug_event(&gdbctx->de));
1042 packet_reply_status_xpoints(gdbctx, thread, &ctx);
1043
1044 for (i = 0; i < backend->gdb_num_regs; i++)
1045 {
1046 packet_reply_val(gdbctx, i, 1);
1047 packet_reply_add(gdbctx, ":");
1048 packet_reply_register_hex_to(gdbctx, &ctx, i);
1049 packet_reply_add(gdbctx, ";");
1050 }
1051
1052 packet_reply_close(gdbctx);
1053 return packet_done;
1054
1055 case EXIT_PROCESS_DEBUG_EVENT:
1056 packet_reply_open(gdbctx);
1057 packet_reply_add(gdbctx, "W");
1058 packet_reply_val(gdbctx, gdbctx->de.u.ExitProcess.dwExitCode, 4);
1059 packet_reply_close(gdbctx);
1060 return packet_done | packet_last_f;
1061
1062 case LOAD_DLL_DEBUG_EVENT:
1063 case UNLOAD_DLL_DEBUG_EVENT:
1064 packet_reply_open(gdbctx);
1065 packet_reply_begin_stop_reply(gdbctx, HOST_SIGTRAP);
1066 packet_reply_add(gdbctx, "library:;");
1067 packet_reply_close(gdbctx);
1068 return packet_done;
1069 }
1070 }
1071
1072 static enum packet_return packet_last_signal(struct gdb_context* gdbctx)
1073 {
1074 assert(gdbctx->in_packet_len == 0);
1075 return packet_reply_status(gdbctx);
1076 }
1077
1078 static enum packet_return packet_continue(struct gdb_context* gdbctx)
1079 {
1080 void *addr;
1081
1082 if (sscanf(gdbctx->in_packet, "%p", &addr) == 1)
1083 FIXME("Continue at address %p not supported\n", addr);
1084
1085 handle_step_or_continue(gdbctx, gdbctx->exec_tid, FALSE, -1);
1086
1087 wait_for_debuggee(gdbctx);
1088 return packet_reply_status(gdbctx);
1089 }
1090
1091 static enum packet_return packet_verbose_cont(struct gdb_context* gdbctx)
1092 {
1093 char *buf = gdbctx->in_packet, *end = gdbctx->in_packet + gdbctx->in_packet_len;
1094
1095 if (gdbctx->in_packet[4] == '?')
1096 {
1097 packet_reply_open(gdbctx);
1098 packet_reply_add(gdbctx, "vCont");
1099 packet_reply_add(gdbctx, ";c");
1100 packet_reply_add(gdbctx, ";C");
1101 packet_reply_add(gdbctx, ";s");
1102 packet_reply_add(gdbctx, ";S");
1103 packet_reply_close(gdbctx);
1104 return packet_done;
1105 }
1106
1107 while (buf < end && (buf = memchr(buf + 1, ';', end - buf - 1)))
1108 {
1109 int tid = -1, sig = -1;
1110 int action, n;
1111
1112 switch ((action = buf[1]))
1113 {
1114 default:
1115 return packet_error;
1116 case 'c':
1117 case 's':
1118 buf += 2;
1119 break;
1120 case 'C':
1121 case 'S':
1122 if (sscanf(buf, ";%*c%2x", &sig) <= 0 ||
1123 sig != signal_from_debug_event(&gdbctx->de))
1124 return packet_error;
1125 buf += 4;
1126 break;
1127 }
1128
1129 if (buf > end)
1130 return packet_error;
1131 if (buf < end && *buf == ':' && (n = sscanf(buf, ":%x", &tid)) <= 0)
1132 return packet_error;
1133
1134 handle_step_or_continue(gdbctx, tid, action == 's' || action == 'S', sig);
1135 }
1136
1137 wait_for_debuggee(gdbctx);
1138 return packet_reply_status(gdbctx);
1139 }
1140
1141 static enum packet_return packet_verbose(struct gdb_context* gdbctx)
1142 {
1143 if (gdbctx->in_packet_len >= 4 && !memcmp(gdbctx->in_packet, "Cont", 4))
1144 {
1145 return packet_verbose_cont(gdbctx);
1146 }
1147
1148 if (gdbctx->in_packet_len == 14 && !memcmp(gdbctx->in_packet, "MustReplyEmpty", 14))
1149 return packet_reply(gdbctx, "");
1150
1151 return packet_error;
1152 }
1153
1154 static enum packet_return packet_continue_signal(struct gdb_context* gdbctx)
1155 {
1156 void *addr;
1157 int sig, n;
1158
1159 if ((n = sscanf(gdbctx->in_packet, "%x;%p", &sig, &addr)) == 2)
1160 FIXME("Continue at address %p not supported\n", addr);
1161 if (n < 1) return packet_error;
1162
1163 if (sig != signal_from_debug_event(&gdbctx->de))
1164 {
1165 ERR("Changing signals is not supported.\n");
1166 return packet_error;
1167 }
1168
1169 handle_step_or_continue(gdbctx, gdbctx->exec_tid, FALSE, sig);
1170
1171 wait_for_debuggee(gdbctx);
1172 return packet_reply_status(gdbctx);
1173 }
1174
1175 static enum packet_return packet_delete_breakpoint(struct gdb_context* gdbctx)
1176 {
1177 struct dbg_process *process = gdbctx->process;
1178 struct dbg_thread *thread;
1179 struct backend_cpu *cpu;
1180 struct gdb_xpoint *x;
1181 dbg_ctx_t ctx;
1182 char type;
1183 void *addr;
1184 int size;
1185
1186 if (!process) return packet_error;
1187 if (!(cpu = process->be_cpu)) return packet_error;
1188
1189 if (sscanf(gdbctx->in_packet, "%c,%p,%x", &type, &addr, &size) < 3)
1190 return packet_error;
1191
1192 if (type == '0')
1193 return packet_error;
1194
1195 LIST_FOR_EACH_ENTRY(thread, &process->threads, struct dbg_thread, entry)
1196 {
1197 if (!cpu->get_context(thread->handle, &ctx))
1198 continue;
1199 if ((type == '1') && (x = gdb_find_xpoint(gdbctx, thread, be_xpoint_watch_exec, addr, size)))
1200 gdbctx_delete_xpoint(gdbctx, thread, &ctx, x);
1201 if ((type == '2' || type == '4') && (x = gdb_find_xpoint(gdbctx, thread, be_xpoint_watch_read, addr, size)))
1202 gdbctx_delete_xpoint(gdbctx, thread, &ctx, x);
1203 if ((type == '3' || type == '4') && (x = gdb_find_xpoint(gdbctx, thread, be_xpoint_watch_write, addr, size)))
1204 gdbctx_delete_xpoint(gdbctx, thread, &ctx, x);
1205 cpu->set_context(thread->handle, &ctx);
1206 }
1207
1208 while ((type == '1') && (x = gdb_find_xpoint(gdbctx, NULL, be_xpoint_watch_exec, addr, size)))
1209 gdbctx_delete_xpoint(gdbctx, NULL, NULL, x);
1210 while ((type == '2' || type == '4') && (x = gdb_find_xpoint(gdbctx, NULL, be_xpoint_watch_read, addr, size)))
1211 gdbctx_delete_xpoint(gdbctx, NULL, NULL, x);
1212 while ((type == '3' || type == '4') && (x = gdb_find_xpoint(gdbctx, NULL, be_xpoint_watch_write, addr, size)))
1213 gdbctx_delete_xpoint(gdbctx, NULL, NULL, x);
1214
1215 return packet_ok;
1216 }
1217
1218 static enum packet_return packet_insert_breakpoint(struct gdb_context* gdbctx)
1219 {
1220 struct dbg_process *process = gdbctx->process;
1221 struct dbg_thread *thread;
1222 struct backend_cpu *cpu;
1223 dbg_ctx_t ctx;
1224 char type;
1225 void *addr;
1226 int size;
1227
1228 if (!process) return packet_error;
1229 if (!(cpu = process->be_cpu)) return packet_error;
1230
1231 if (memchr(gdbctx->in_packet, ';', gdbctx->in_packet_len))
1232 {
1233 FIXME("breakpoint commands not supported\n");
1234 return packet_error;
1235 }
1236
1237 if (sscanf(gdbctx->in_packet, "%c,%p,%x", &type, &addr, &size) < 3)
1238 return packet_error;
1239
1240 if (type == '0')
1241 return packet_error;
1242
1243 LIST_FOR_EACH_ENTRY(thread, &process->threads, struct dbg_thread, entry)
1244 {
1245 if (!cpu->get_context(thread->handle, &ctx))
1246 continue;
1247 if (type == '1')
1248 gdbctx_insert_xpoint(gdbctx, thread, &ctx, be_xpoint_watch_exec, addr, size);
1249 if (type == '2' || type == '4')
1250 gdbctx_insert_xpoint(gdbctx, thread, &ctx, be_xpoint_watch_read, addr, size);
1251 if (type == '3' || type == '4')
1252 gdbctx_insert_xpoint(gdbctx, thread, &ctx, be_xpoint_watch_write, addr, size);
1253 cpu->set_context(thread->handle, &ctx);
1254 }
1255
1256 return packet_ok;
1257 }
1258
1259 static enum packet_return packet_detach(struct gdb_context* gdbctx)
1260 {
1261 detach_debuggee(gdbctx, FALSE);
1262 return packet_ok | packet_last_f;
1263 }
1264
1265 static enum packet_return packet_read_registers(struct gdb_context* gdbctx)
1266 {
1267 struct dbg_thread *thread = dbg_thread_from_tid(gdbctx, gdbctx->other_tid);
1268 struct backend_cpu *backend;
1269 dbg_ctx_t ctx;
1270 size_t i;
1271
1272 if (!thread) return packet_error;
1273 if (!thread->process) return packet_error;
1274 if (!(backend = thread->process->be_cpu)) return packet_error;
1275
1276 if (!backend->get_context(thread->handle, &ctx))
1277 return packet_error;
1278
1279 packet_reply_open(gdbctx);
1280 for (i = 0; i < backend->gdb_num_regs; i++)
1281 packet_reply_register_hex_to(gdbctx, &ctx, i);
1282
1283 packet_reply_close(gdbctx);
1284 return packet_done;
1285 }
1286
1287 static enum packet_return packet_write_registers(struct gdb_context* gdbctx)
1288 {
1289 struct dbg_thread *thread = dbg_thread_from_tid(gdbctx, gdbctx->other_tid);
1290 struct backend_cpu *backend;
1291 dbg_ctx_t ctx;
1292 const char *ptr;
1293 size_t i;
1294
1295 if (!thread) return packet_error;
1296 if (!thread->process) return packet_error;
1297 if (!(backend = thread->process->be_cpu)) return packet_error;
1298
1299 if (!backend->get_context(thread->handle, &ctx))
1300 return packet_error;
1301
1302 if (gdbctx->in_packet_len < backend->gdb_num_regs * 2)
1303 return packet_error;
1304
1305 ptr = gdbctx->in_packet;
1306 for (i = 0; i < backend->gdb_num_regs; i++)
1307 cpu_register_hex_from(gdbctx, &ctx, i, &ptr);
1308
1309 if (!backend->set_context(thread->handle, &ctx))
1310 {
1311 ERR("Failed to set context for tid %04lx, error %lu\n", thread->tid, GetLastError());
1312 return packet_error;
1313 }
1314
1315 return packet_ok;
1316 }
1317
1318 static enum packet_return packet_kill(struct gdb_context* gdbctx)
1319 {
1320 detach_debuggee(gdbctx, TRUE);
1321 return packet_ok | packet_last_f;
1322 }
1323
1324 static enum packet_return packet_thread(struct gdb_context* gdbctx)
1325 {
1326 switch (gdbctx->in_packet[0])
1327 {
1328 case 'c':
1329 if (sscanf(gdbctx->in_packet, "c%x", &gdbctx->exec_tid) == 1)
1330 return packet_ok;
1331 return packet_error;
1332 case 'g':
1333 if (sscanf(gdbctx->in_packet, "g%x", &gdbctx->other_tid) == 1)
1334 return packet_ok;
1335 return packet_error;
1336 default:
1337 FIXME("Unknown thread sub-command %c\n", gdbctx->in_packet[0]);
1338 return packet_error;
1339 }
1340 }
1341
1342 static enum packet_return packet_read_memory(struct gdb_context* gdbctx)
1343 {
1344 char *addr;
1345 unsigned int len, blk_len, nread;
1346 char buffer[32];
1347 SIZE_T r = 0;
1348
1349 if (sscanf(gdbctx->in_packet, "%p,%x", &addr, &len) != 2) return packet_error;
1350 if (len <= 0) return packet_error;
1351 TRACE("Read %u bytes at %p\n", len, addr);
1352 for (nread = 0; nread < len; nread += r, addr += r)
1353 {
1354 blk_len = min(sizeof(buffer), len - nread);
1355 if (!gdbctx->process->process_io->read(gdbctx->process->handle, addr,
1356 buffer, blk_len, &r) || r == 0)
1357 {
1358 /* fail at first address, return error */
1359 if (nread == 0) return packet_reply_error(gdbctx, HOST_EFAULT );
1360 /* something has already been read, return partial information */
1361 break;
1362 }
1363 if (nread == 0) packet_reply_open(gdbctx);
1364 packet_reply_hex_to(gdbctx, buffer, r);
1365 }
1366 packet_reply_close(gdbctx);
1367 return packet_done;
1368 }
1369
1370 static enum packet_return packet_write_memory(struct gdb_context* gdbctx)
1371 {
1372 char* addr;
1373 unsigned int len, blk_len;
1374 char* ptr;
1375 char buffer[32];
1376 SIZE_T w;
1377
1378 ptr = memchr(gdbctx->in_packet, ':', gdbctx->in_packet_len);
1379 if (ptr == NULL)
1380 {
1381 ERR("Cannot find ':' in %s\n", debugstr_an(gdbctx->in_packet, gdbctx->in_packet_len));
1382 return packet_error;
1383 }
1384 *ptr++ = '\0';
1385
1386 if (sscanf(gdbctx->in_packet, "%p,%x", &addr, &len) != 2)
1387 {
1388 ERR("Failed to parse %s\n", debugstr_a(gdbctx->in_packet));
1389 return packet_error;
1390 }
1391 if (ptr - gdbctx->in_packet + len * 2 != gdbctx->in_packet_len)
1392 {
1393 ERR("Length %u does not match packet length %u\n",
1394 (int)(ptr - gdbctx->in_packet) + len * 2, gdbctx->in_packet_len);
1395 return packet_error;
1396 }
1397 TRACE("Write %u bytes at %p\n", len, addr);
1398 while (len > 0)
1399 {
1400 blk_len = min(sizeof(buffer), len);
1401 hex_from(buffer, ptr, blk_len);
1402 if (!gdbctx->process->process_io->write(gdbctx->process->handle, addr, buffer, blk_len, &w) ||
1403 w != blk_len)
1404 break;
1405 addr += blk_len;
1406 len -= blk_len;
1407 ptr += blk_len;
1408 }
1409 return packet_ok; /* FIXME: error while writing ? */
1410 }
1411
1412 static enum packet_return packet_read_register(struct gdb_context* gdbctx)
1413 {
1414 struct dbg_thread *thread = dbg_thread_from_tid(gdbctx, gdbctx->other_tid);
1415 struct backend_cpu *backend;
1416 dbg_ctx_t ctx;
1417 size_t reg;
1418
1419 if (!thread) return packet_error;
1420 if (!thread->process) return packet_error;
1421 if (!(backend = thread->process->be_cpu)) return packet_error;
1422
1423 if (!backend->get_context(thread->handle, &ctx))
1424 return packet_error;
1425
1426 if (sscanf(gdbctx->in_packet, "%Ix", &reg) != 1)
1427 return packet_error;
1428 if (reg >= backend->gdb_num_regs)
1429 {
1430 WARN("Unhandled register %Iu\n", reg);
1431 return packet_error;
1432 }
1433
1434 TRACE("%Iu => %I64x\n", reg, cpu_register(gdbctx, &ctx, reg));
1435
1436 packet_reply_open(gdbctx);
1437 packet_reply_register_hex_to(gdbctx, &ctx, reg);
1438 packet_reply_close(gdbctx);
1439 return packet_done;
1440 }
1441
1442 static enum packet_return packet_write_register(struct gdb_context* gdbctx)
1443 {
1444 struct dbg_thread *thread = dbg_thread_from_tid(gdbctx, gdbctx->other_tid);
1445 struct backend_cpu *backend;
1446 dbg_ctx_t ctx;
1447 size_t reg;
1448 char *ptr;
1449
1450 if (!thread) return packet_error;
1451 if (!thread->process) return packet_error;
1452 if (!(backend = thread->process->be_cpu)) return packet_error;
1453
1454 if (!backend->get_context(thread->handle, &ctx))
1455 return packet_error;
1456
1457 if (!(ptr = strchr(gdbctx->in_packet, '=')))
1458 return packet_error;
1459 *ptr++ = '\0';
1460
1461 if (sscanf(gdbctx->in_packet, "%Ix", &reg) != 1)
1462 return packet_error;
1463 if (reg >= backend->gdb_num_regs)
1464 {
1465 /* FIXME: if just the reg is above cpu_num_regs, don't tell gdb
1466 * it wouldn't matter too much, and it fakes our support for all regs
1467 */
1468 WARN("Unhandled register %Iu\n", reg);
1469 return packet_ok;
1470 }
1471
1472 TRACE("%Iu <= %s\n", reg, debugstr_an(ptr, (int)(gdbctx->in_packet_len - (ptr - gdbctx->in_packet))));
1473
1474 cpu_register_hex_from(gdbctx, &ctx, reg, (const char**)&ptr);
1475 if (!backend->set_context(thread->handle, &ctx))
1476 {
1477 ERR("Failed to set context for tid %04lx, error %lu\n", thread->tid, GetLastError());
1478 return packet_error;
1479 }
1480
1481 return packet_ok;
1482 }
1483
1484 static void packet_query_monitor_wnd_helper(struct gdb_context* gdbctx, HWND hWnd, int indent)
1485 {
1486 char buffer[128];
1487 char clsName[128];
1488 char wndName[128];
1489 HWND child;
1490
1491 do {
1492 if (!GetClassNameA(hWnd, clsName, sizeof(clsName)))
1493 strcpy(clsName, "-- Unknown --");
1494 if (!GetWindowTextA(hWnd, wndName, sizeof(wndName)))
1495 strcpy(wndName, "-- Empty --");
1496
1497 packet_reply_open(gdbctx);
1498 packet_reply_add(gdbctx, "O");
1499 snprintf(buffer, sizeof(buffer),
1500 "%*s%04Ix%*s%-17.17s %08lx %0*Ix %.14s\n",
1501 indent, "", (ULONG_PTR)hWnd, 13 - indent, "",
1502 clsName, GetWindowLongW(hWnd, GWL_STYLE),
1503 addr_width(gdbctx), (ULONG_PTR)GetWindowLongPtrW(hWnd, GWLP_WNDPROC),
1504 wndName);
1505 packet_reply_hex_to_str(gdbctx, buffer);
1506 packet_reply_close(gdbctx);
1507
1508 if ((child = GetWindow(hWnd, GW_CHILD)) != 0)
1509 packet_query_monitor_wnd_helper(gdbctx, child, indent + 1);
1510 } while ((hWnd = GetWindow(hWnd, GW_HWNDNEXT)) != 0);
1511 }
1512
1513 static void packet_query_monitor_wnd(struct gdb_context* gdbctx, int len, const char* str)
1514 {
1515 char buffer[128];
1516
1517 /* we do the output in several 'O' packets, with the last one being just OK for
1518 * marking the end of the output */
1519 packet_reply_open(gdbctx);
1520 packet_reply_add(gdbctx, "O");
1521 snprintf(buffer, sizeof(buffer),
1522 "%-16.16s %-17.17s %-8.8s %s\n",
1523 "hwnd", "Class Name", " Style", " WndProc Text");
1524 packet_reply_hex_to_str(gdbctx, buffer);
1525 packet_reply_close(gdbctx);
1526
1527 /* FIXME: could also add a pmt to this command in str... */
1528 packet_query_monitor_wnd_helper(gdbctx, GetDesktopWindow(), 0);
1529 packet_reply(gdbctx, "OK");
1530 }
1531
1532 static void packet_query_monitor_process(struct gdb_context* gdbctx, int len, const char* str)
1533 {
1534 HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
1535 char buffer[31+MAX_PATH];
1536 char deco;
1537 PROCESSENTRY32 entry;
1538 BOOL ok;
1539
1540 if (snap == INVALID_HANDLE_VALUE)
1541 return;
1542
1543 entry.dwSize = sizeof(entry);
1544 ok = Process32First(snap, &entry);
1545
1546 /* we do the output in several 'O' packets, with the last one being just OK for
1547 * marking the end of the output */
1548
1549 packet_reply_open(gdbctx);
1550 packet_reply_add(gdbctx, "O");
1551 snprintf(buffer, sizeof(buffer),
1552 " %-8.8s %-8.8s %-8.8s %s\n",
1553 "pid", "threads", "parent", "executable");
1554 packet_reply_hex_to_str(gdbctx, buffer);
1555 packet_reply_close(gdbctx);
1556
1557 while (ok)
1558 {
1559 deco = ' ';
1560 if (entry.th32ProcessID == gdbctx->process->pid) deco = '>';
1561 packet_reply_open(gdbctx);
1562 packet_reply_add(gdbctx, "O");
1563 snprintf(buffer, sizeof(buffer),
1564 "%c%08lx %-8ld %08lx '%s'\n",
1565 deco, entry.th32ProcessID, entry.cntThreads,
1566 entry.th32ParentProcessID, entry.szExeFile);
1567 packet_reply_hex_to_str(gdbctx, buffer);
1568 packet_reply_close(gdbctx);
1569 ok = Process32Next(snap, &entry);
1570 }
1571 CloseHandle(snap);
1572 packet_reply(gdbctx, "OK");
1573 }
1574
1575 static void packet_query_monitor_mem(struct gdb_context* gdbctx, int len, const char* str)
1576 {
1577 MEMORY_BASIC_INFORMATION mbi;
1578 char* addr = 0;
1579 const char* state;
1580 const char* type;
1581 char prot[3+1];
1582 char buffer[128];
1583
1584 /* we do the output in several 'O' packets, with the last one being just OK for
1585 * marking the end of the output */
1586 packet_reply_open(gdbctx);
1587 packet_reply_add(gdbctx, "O");
1588 packet_reply_hex_to_str(gdbctx, "Address Size State Type RWX\n");
1589 packet_reply_close(gdbctx);
1590
1591 while (VirtualQueryEx(gdbctx->process->handle, addr, &mbi, sizeof(mbi)) >= sizeof(mbi))
1592 {
1593 switch (mbi.State)
1594 {
1595 case MEM_COMMIT: state = "commit "; break;
1596 case MEM_FREE: state = "free "; break;
1597 case MEM_RESERVE: state = "reserve"; break;
1598 default: state = "??? "; break;
1599 }
1600 if (mbi.State != MEM_FREE)
1601 {
1602 switch (mbi.Type)
1603 {
1604 case MEM_IMAGE: type = "image "; break;
1605 case MEM_MAPPED: type = "mapped "; break;
1606 case MEM_PRIVATE: type = "private"; break;
1607 case 0: type = " "; break;
1608 default: type = "??? "; break;
1609 }
1610 memset(prot, ' ' , sizeof(prot)-1);
1611 prot[sizeof(prot)-1] = '\0';
1612 if (mbi.AllocationProtect & (PAGE_READONLY|PAGE_READWRITE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE|PAGE_WRITECOPY|PAGE_EXECUTE_WRITECOPY))
1613 prot[0] = 'R';
1614 if (mbi.AllocationProtect & (PAGE_READWRITE|PAGE_EXECUTE_READWRITE))
1615 prot[1] = 'W';
1616 if (mbi.AllocationProtect & (PAGE_WRITECOPY|PAGE_EXECUTE_WRITECOPY))
1617 prot[1] = 'C';
1618 if (mbi.AllocationProtect & (PAGE_EXECUTE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE|PAGE_EXECUTE_WRITECOPY))
1619 prot[2] = 'X';
1620 }
1621 else
1622 {
1623 type = "";
1624 prot[0] = '\0';
1625 }
1626 packet_reply_open(gdbctx);
1627 snprintf(buffer, sizeof(buffer), "%0*Ix %0*Ix %s %s %s\n",
1628 addr_width(gdbctx), (DWORD_PTR)addr,
1629 addr_width(gdbctx), mbi.RegionSize, state, type, prot);
1630 packet_reply_add(gdbctx, "O");
1631 packet_reply_hex_to_str(gdbctx, buffer);
1632 packet_reply_close(gdbctx);
1633
1634 if (addr + mbi.RegionSize < addr) /* wrap around ? */
1635 break;
1636 addr += mbi.RegionSize;
1637 }
1638 packet_reply(gdbctx, "OK");
1639 }
1640
1641 struct query_detail
1642 {
1643 int with_arg;
1644 const char* name;
1645 size_t len;
1646 void (*handler)(struct gdb_context*, int, const char*);
1647 } query_details[] =
1648 {
1649 {0, "wnd", 3, packet_query_monitor_wnd},
1650 {0, "window", 6, packet_query_monitor_wnd},
1651 {0, "proc", 4, packet_query_monitor_process},
1652 {0, "process", 7, packet_query_monitor_process},
1653 {0, "mem", 3, packet_query_monitor_mem},
1654 {0, NULL, 0, NULL},
1655 };
1656
1657 static enum packet_return packet_query_remote_command(struct gdb_context* gdbctx,
1658 const char* hxcmd, size_t len)
1659 {
1660 char buffer[128];
1661 struct query_detail* qd;
1662
1663 assert((len & 1) == 0 && len < 2 * sizeof(buffer));
1664 len /= 2;
1665 hex_from(buffer, hxcmd, len);
1666
1667 for (qd = query_details; qd->name != NULL; qd++)
1668 {
1669 if (len < qd->len || strncmp(buffer, qd->name, qd->len) != 0) continue;
1670 if (!qd->with_arg && len != qd->len) continue;
1671
1672 (qd->handler)(gdbctx, len - qd->len, buffer + qd->len);
1673 return packet_done;
1674 }
1675 return packet_reply_error(gdbctx, HOST_EINVAL );
1676 }
1677
1678 static BOOL CALLBACK packet_query_libraries_cb(PCSTR mod_name, DWORD64 base, PVOID ctx)
1679 {
1680 struct gdb_context* gdbctx = ctx;
1681 struct reply_buffer* reply = &gdbctx->qxfer_buffer;
1682 MEMORY_BASIC_INFORMATION mbi;
1683 IMAGE_SECTION_HEADER *sec;
1684 IMAGE_DOS_HEADER *dos = NULL;
1685 IMAGE_NT_HEADERS *nth = NULL;
1686 IMAGEHLP_MODULE64 mod;
1687 SIZE_T size, i;
1688 BOOL is_wow64;
1689 char buffer[0x400];
1690
1691 mod.SizeOfStruct = sizeof(mod);
1692 if (!SymGetModuleInfo64(gdbctx->process->handle, base, &mod) ||
1693 mod.MachineType != gdbctx->process->be_cpu->machine)
1694 return TRUE;
1695
1696 reply_buffer_append_str(reply, "<library name=\"");
1697 if (strcmp(mod.LoadedImageName, "[vdso].so") == 0)
1698 reply_buffer_append_xmlstr(reply, "linux-vdso.so.1");
1699 else if (mod.LoadedImageName[0] == '/')
1700 reply_buffer_append_xmlstr(reply, mod.LoadedImageName);
1701 else
1702 {
1703 UNICODE_STRING nt_name;
1704 ANSI_STRING ansi_name;
1705 char *unix_path, *tmp;
1706
1707 RtlInitAnsiString(&ansi_name, mod.LoadedImageName);
1708 RtlAnsiStringToUnicodeString(&nt_name, &ansi_name, TRUE);
1709
1710 if ((unix_path = wine_get_unix_file_name(nt_name.Buffer)))
1711 {
1712 if (IsWow64Process(gdbctx->process->handle, &is_wow64) &&
1713 is_wow64 && (tmp = strstr(unix_path, "system32")))
1714 memcpy(tmp, "syswow64", 8);
1715 reply_buffer_append_xmlstr(reply, unix_path);
1716 }
1717 else
1718 reply_buffer_append_xmlstr(reply, mod.LoadedImageName);
1719
1720 HeapFree(GetProcessHeap(), 0, unix_path);
1721 RtlFreeUnicodeString(&nt_name);
1722 }
1723 reply_buffer_append_str(reply, "\">");
1724
1725 size = sizeof(buffer);
1726 if (VirtualQueryEx(gdbctx->process->handle, (void *)(UINT_PTR)mod.BaseOfImage, &mbi, sizeof(mbi)) >= sizeof(mbi) &&
1727 mbi.Type == MEM_IMAGE && mbi.State != MEM_FREE)
1728 {
1729 if (ReadProcessMemory(gdbctx->process->handle, (void *)(UINT_PTR)mod.BaseOfImage, buffer, size, &size) &&
1730 size >= sizeof(IMAGE_DOS_HEADER))
1731 dos = (IMAGE_DOS_HEADER *)buffer;
1732
1733 if (dos && dos->e_magic == IMAGE_DOS_SIGNATURE && dos->e_lfanew < size)
1734 nth = (IMAGE_NT_HEADERS *)(buffer + dos->e_lfanew);
1735
1736 if (nth && memcmp(&nth->Signature, "PE\0\0", 4))
1737 nth = NULL;
1738 }
1739
1740 if (!nth) memset(buffer, 0, sizeof(buffer));
1741
1742 /* if the module is not PE we have cleared buffer with 0, this makes
1743 * the following computation valid in all cases. */
1744 dos = (IMAGE_DOS_HEADER *)buffer;
1745 nth = (IMAGE_NT_HEADERS *)(buffer + dos->e_lfanew);
1746 if (IsWow64Process(gdbctx->process->handle, &is_wow64) && is_wow64)
1747 sec = IMAGE_FIRST_SECTION((IMAGE_NT_HEADERS32 *)nth);
1748 else
1749 sec = IMAGE_FIRST_SECTION((IMAGE_NT_HEADERS64 *)nth);
1750
1751 for (i = 0; i < max(nth->FileHeader.NumberOfSections, 1); ++i)
1752 {
1753 if ((char *)(sec + i) >= buffer + size) break;
1754 reply_buffer_append_str(reply, "<segment address=\"0x");
1755 reply_buffer_append_uinthex(reply, mod.BaseOfImage + sec[i].VirtualAddress, sizeof(ULONG_PTR));
1756 reply_buffer_append_str(reply, "\"/>");
1757 }
1758
1759 reply_buffer_append_str(reply, "</library>");
1760
1761 return TRUE;
1762 }
1763
1764 static enum packet_return packet_query_libraries(struct gdb_context* gdbctx)
1765 {
1766 struct reply_buffer* reply = &gdbctx->qxfer_buffer;
1767 BOOL opt_native, opt_real_path;
1768
1769 if (!gdbctx->process) return packet_error;
1770
1771 if (gdbctx->qxfer_object_annex[0])
1772 return packet_reply_error(gdbctx, 0);
1773
1774 /* this will resynchronize builtin dbghelp's internal ELF module list */
1775 SymLoadModule(gdbctx->process->handle, 0, 0, 0, 0, 0);
1776
1777 reply_buffer_append_str(reply, "<library-list>");
1778 /* request also ELF modules, and also real path to loaded modules */
1779 opt_native = SymSetExtendedOption(SYMOPT_EX_WINE_NATIVE_MODULES, TRUE);
1780 opt_real_path = SymSetExtendedOption(SYMOPT_EX_WINE_MODULE_REAL_PATH, TRUE);
1781 SymEnumerateModules64(gdbctx->process->handle, packet_query_libraries_cb, gdbctx);
1782 SymSetExtendedOption(SYMOPT_EX_WINE_NATIVE_MODULES, opt_native);
1783 SymSetExtendedOption(SYMOPT_EX_WINE_MODULE_REAL_PATH, opt_real_path);
1784 reply_buffer_append_str(reply, "</library-list>");
1785
1786 return packet_send_buffer;
1787 }
1788
1789 static enum packet_return packet_query_threads(struct gdb_context* gdbctx)
1790 {
1791 struct reply_buffer* reply = &gdbctx->qxfer_buffer;
1792 struct dbg_process* process = gdbctx->process;
1793 struct dbg_thread* thread;
1794 WCHAR* description;
1795
1796 if (!process) return packet_error;
1797
1798 if (gdbctx->qxfer_object_annex[0])
1799 return packet_reply_error(gdbctx, 0);
1800
1801 reply_buffer_append_str(reply, "<threads>");
1802 LIST_FOR_EACH_ENTRY(thread, &process->threads, struct dbg_thread, entry)
1803 {
1804 reply_buffer_append_str(reply, "<thread ");
1805 reply_buffer_append_str(reply, "id=\"");
1806 reply_buffer_append_uinthex(reply, thread->tid, 4);
1807 reply_buffer_append_str(reply, "\" name=\"");
1808 if ((description = fetch_thread_description(thread->tid)))
1809 {
1810 reply_buffer_append_wstr(reply, description);
1811 LocalFree(description);
1812 }
1813 else if (strlen(thread->name))
1814 {
1815 reply_buffer_append_str(reply, thread->name);
1816 }
1817 else
1818 {
1819 char tid[5];
1820 snprintf(tid, sizeof(tid), "%04lx", thread->tid);
1821 reply_buffer_append_str(reply, tid);
1822 }
1823 reply_buffer_append_str(reply, "\"/>");
1824 }
1825 reply_buffer_append_str(reply, "</threads>");
1826
1827 return packet_send_buffer;
1828 }
1829
1830 static void packet_query_target_xml(struct gdb_context* gdbctx, struct reply_buffer* reply, struct backend_cpu* cpu)
1831 {
1832 const char* feature_prefix = NULL;
1833 const char* feature = NULL;
1834 char buffer[256];
1835 int i;
1836
1837 reply_buffer_append_str(reply, "<target>");
1838 switch (cpu->machine)
1839 {
1840 case IMAGE_FILE_MACHINE_AMD64:
1841 reply_buffer_append_str(reply, "<architecture>i386:x86-64</architecture>");
1842 feature_prefix = "org.gnu.gdb.i386.";
1843 break;
1844 case IMAGE_FILE_MACHINE_I386:
1845 reply_buffer_append_str(reply, "<architecture>i386</architecture>");
1846 feature_prefix = "org.gnu.gdb.i386.";
1847 break;
1848 case IMAGE_FILE_MACHINE_ARMNT:
1849 reply_buffer_append_str(reply, "<architecture>arm</architecture>");
1850 feature_prefix = "org.gnu.gdb.arm.";
1851 break;
1852 case IMAGE_FILE_MACHINE_ARM64:
1853 reply_buffer_append_str(reply, "<architecture>aarch64</architecture>");
1854 feature_prefix = "org.gnu.gdb.aarch64.";
1855 break;
1856 }
1857
1858 for (i = 0; i < cpu->gdb_num_regs; ++i)
1859 {
1860 if (cpu->gdb_register_map[i].feature)
1861 {
1862 if (feature) reply_buffer_append_str(reply, "</feature>");
1863 feature = cpu->gdb_register_map[i].feature;
1864
1865 reply_buffer_append_str(reply, "<feature name=\"");
1866 if (feature_prefix) reply_buffer_append_xmlstr(reply, feature_prefix);
1867 reply_buffer_append_xmlstr(reply, feature);
1868 reply_buffer_append_str(reply, "\">");
1869
1870 if (strcmp(feature_prefix, "org.gnu.gdb.i386.") == 0 &&
1871 strcmp(feature, "core") == 0)
1872 reply_buffer_append_str(reply, "<flags id=\"i386_eflags\" size=\"4\">"
1873 "<field name=\"CF\" start=\"0\" end=\"0\"/>"
1874 "<field name=\"\" start=\"1\" end=\"1\"/>"
1875 "<field name=\"PF\" start=\"2\" end=\"2\"/>"
1876 "<field name=\"AF\" start=\"4\" end=\"4\"/>"
1877 "<field name=\"ZF\" start=\"6\" end=\"6\"/>"
1878 "<field name=\"SF\" start=\"7\" end=\"7\"/>"
1879 "<field name=\"TF\" start=\"8\" end=\"8\"/>"
1880 "<field name=\"IF\" start=\"9\" end=\"9\"/>"
1881 "<field name=\"DF\" start=\"10\" end=\"10\"/>"
1882 "<field name=\"OF\" start=\"11\" end=\"11\"/>"
1883 "<field name=\"NT\" start=\"14\" end=\"14\"/>"
1884 "<field name=\"RF\" start=\"16\" end=\"16\"/>"
1885 "<field name=\"VM\" start=\"17\" end=\"17\"/>"
1886 "<field name=\"AC\" start=\"18\" end=\"18\"/>"
1887 "<field name=\"VIF\" start=\"19\" end=\"19\"/>"
1888 "<field name=\"VIP\" start=\"20\" end=\"20\"/>"
1889 "<field name=\"ID\" start=\"21\" end=\"21\"/>"
1890 "</flags>");
1891
1892 if (strcmp(feature_prefix, "org.gnu.gdb.i386.") == 0 &&
1893 strcmp(feature, "sse") == 0)
1894 reply_buffer_append_str(reply, "<vector id=\"v4f\" type=\"ieee_single\" count=\"4\"/>"
1895 "<vector id=\"v2d\" type=\"ieee_double\" count=\"2\"/>"
1896 "<vector id=\"v16i8\" type=\"int8\" count=\"16\"/>"
1897 "<vector id=\"v8i16\" type=\"int16\" count=\"8\"/>"
1898 "<vector id=\"v4i32\" type=\"int32\" count=\"4\"/>"
1899 "<vector id=\"v2i64\" type=\"int64\" count=\"2\"/>"
1900 "<union id=\"vec128\">"
1901 "<field name=\"v4_float\" type=\"v4f\"/>"
1902 "<field name=\"v2_double\" type=\"v2d\"/>"
1903 "<field name=\"v16_int8\" type=\"v16i8\"/>"
1904 "<field name=\"v8_int16\" type=\"v8i16\"/>"
1905 "<field name=\"v4_int32\" type=\"v4i32\"/>"
1906 "<field name=\"v2_int64\" type=\"v2i64\"/>"
1907 "<field name=\"uint128\" type=\"uint128\"/>"
1908 "</union>"
1909 "<flags id=\"i386_mxcsr\" size=\"4\">"
1910 "<field name=\"IE\" start=\"0\" end=\"0\"/>"
1911 "<field name=\"DE\" start=\"1\" end=\"1\"/>"
1912 "<field name=\"ZE\" start=\"2\" end=\"2\"/>"
1913 "<field name=\"OE\" start=\"3\" end=\"3\"/>"
1914 "<field name=\"UE\" start=\"4\" end=\"4\"/>"
1915 "<field name=\"PE\" start=\"5\" end=\"5\"/>"
1916 "<field name=\"DAZ\" start=\"6\" end=\"6\"/>"
1917 "<field name=\"IM\" start=\"7\" end=\"7\"/>"
1918 "<field name=\"DM\" start=\"8\" end=\"8\"/>"
1919 "<field name=\"ZM\" start=\"9\" end=\"9\"/>"
1920 "<field name=\"OM\" start=\"10\" end=\"10\"/>"
1921 "<field name=\"UM\" start=\"11\" end=\"11\"/>"
1922 "<field name=\"PM\" start=\"12\" end=\"12\"/>"
1923 "<field name=\"FZ\" start=\"15\" end=\"15\"/>"
1924 "</flags>");
1925 }
1926
1927 snprintf(buffer, ARRAY_SIZE(buffer), "<reg name=\"%s\" bitsize=\"%Iu\"",
1928 cpu->gdb_register_map[i].name, 8 * cpu->gdb_register_map[i].length);
1929 reply_buffer_append_str(reply, buffer);
1930
1931 if (cpu->gdb_register_map[i].type)
1932 {
1933 reply_buffer_append_str(reply, " type=\"");
1934 reply_buffer_append_xmlstr(reply, cpu->gdb_register_map[i].type);
1935 reply_buffer_append_str(reply, "\"");
1936 }
1937
1938 reply_buffer_append_str(reply, "/>");
1939 }
1940
1941 if (feature) reply_buffer_append_str(reply, "</feature>");
1942 reply_buffer_append_str(reply, "</target>");
1943 }
1944
1945 static enum packet_return packet_query_features(struct gdb_context* gdbctx)
1946 {
1947 struct reply_buffer* reply = &gdbctx->qxfer_buffer;
1948 struct dbg_process* process = gdbctx->process;
1949
1950 if (!process) return packet_error;
1951
1952 if (strncmp(gdbctx->qxfer_object_annex, "target.xml", QX_ANNEX_SIZE) == 0)
1953 {
1954 struct backend_cpu *cpu = process->be_cpu;
1955 if (!cpu) return packet_error;
1956
1957 packet_query_target_xml(gdbctx, reply, cpu);
1958
1959 return packet_send_buffer;
1960 }
1961
1962 return packet_reply_error(gdbctx, 0);
1963 }
1964
1965 static enum packet_return packet_query_exec_file(struct gdb_context* gdbctx)
1966 {
1967 struct reply_buffer* reply = &gdbctx->qxfer_buffer;
1968 struct dbg_process* process = gdbctx->process;
1969 char *unix_path;
1970 BOOL is_wow64;
1971 char *tmp;
1972
1973 if (!process) return packet_error;
1974
1975 if (gdbctx->qxfer_object_annex[0] || !process->imageName)
1976 return packet_reply_error(gdbctx, HOST_EPERM);
1977
1978 if (!(unix_path = wine_get_unix_file_name(process->imageName)))
1979 return packet_reply_error(gdbctx, GetLastError() == ERROR_NOT_ENOUGH_MEMORY ? HOST_ENOMEM : HOST_ENOENT);
1980
1981 if (IsWow64Process(process->handle, &is_wow64) &&
1982 is_wow64 && (tmp = strstr(unix_path, "system32")))
1983 memcpy(tmp, "syswow64", 8);
1984
1985 reply_buffer_append_str(reply, unix_path);
1986
1987 HeapFree(GetProcessHeap(), 0, unix_path);
1988
1989 return packet_send_buffer;
1990 }
1991
1992 struct qxfer
1993 {
1994 const char* name;
1995 enum packet_return (*handler)(struct gdb_context* gdbctx);
1996 } qxfer_handlers[] =
1997 {
1998 {"libraries", packet_query_libraries},
1999 {"threads" , packet_query_threads },
2000 {"features" , packet_query_features },
2001 {"exec-file", packet_query_exec_file},
2002 };
2003
2004 static enum packet_return packet_query(struct gdb_context* gdbctx)
2005 {
2006 char object_name[QX_NAME_SIZE], annex[QX_ANNEX_SIZE];
2007 unsigned int off, len;
2008
2009 switch (gdbctx->in_packet[0])
2010 {
2011 case 'f':
2012 if (strncmp(gdbctx->in_packet + 1, "ThreadInfo", gdbctx->in_packet_len - 1) == 0)
2013 {
2014 struct dbg_thread* thd;
2015
2016 packet_reply_open(gdbctx);
2017 packet_reply_add(gdbctx, "m");
2018 LIST_FOR_EACH_ENTRY(thd, &gdbctx->process->threads, struct dbg_thread, entry)
2019 {
2020 packet_reply_val(gdbctx, thd->tid, 4);
2021 if (list_next(&gdbctx->process->threads, &thd->entry) != NULL)
2022 packet_reply_add(gdbctx, ",");
2023 }
2024 packet_reply_close(gdbctx);
2025 return packet_done;
2026 }
2027 else if (strncmp(gdbctx->in_packet + 1, "ProcessInfo", gdbctx->in_packet_len - 1) == 0)
2028 {
2029 char result[128];
2030
2031 packet_reply_open(gdbctx);
2032 packet_reply_add(gdbctx, "O");
2033 get_process_info(gdbctx, result, sizeof(result));
2034 packet_reply_hex_to_str(gdbctx, result);
2035 packet_reply_close(gdbctx);
2036 return packet_done;
2037 }
2038 break;
2039 case 's':
2040 if (strncmp(gdbctx->in_packet + 1, "ThreadInfo", gdbctx->in_packet_len - 1) == 0)
2041 {
2042 packet_reply(gdbctx, "l");
2043 return packet_done;
2044 }
2045 else if (strncmp(gdbctx->in_packet + 1, "ProcessInfo", gdbctx->in_packet_len - 1) == 0)
2046 {
2047 packet_reply(gdbctx, "l");
2048 return packet_done;
2049 }
2050 break;
2051 case 'A':
2052 if (strncmp(gdbctx->in_packet, "Attached", gdbctx->in_packet_len) == 0)
2053 return packet_reply(gdbctx, "1");
2054 break;
2055 case 'C':
2056 if (gdbctx->in_packet_len == 1)
2057 {
2058 struct dbg_thread* thd;
2059 /* FIXME: doc says 16 bit val ??? */
2060 /* grab first created thread, aka last in list */
2061 assert(gdbctx->process && !list_empty(&gdbctx->process->threads));
2062 thd = LIST_ENTRY(list_tail(&gdbctx->process->threads), struct dbg_thread, entry);
2063 packet_reply_open(gdbctx);
2064 packet_reply_add(gdbctx, "QC");
2065 packet_reply_val(gdbctx, thd->tid, 4);
2066 packet_reply_close(gdbctx);
2067 return packet_done;
2068 }
2069 break;
2070 case 'G':
2071 if (gdbctx->in_packet_len > 10 &&
2072 strncmp(gdbctx->in_packet, "GetTIBAddr", 10) == 0 &&
2073 gdbctx->in_packet[10] == ':')
2074 {
2075 unsigned tid;
2076 char* end;
2077 struct dbg_thread* thd;
2078
2079 tid = strtol(gdbctx->in_packet + 11, &end, 16);
2080 if (end == NULL) break;
2081
2082 thd = dbg_get_thread(gdbctx->process, tid);
2083 if (thd == NULL)
2084 return packet_reply_error(gdbctx, HOST_EINVAL);
2085 packet_reply_open(gdbctx);
2086 packet_reply_val(gdbctx, (ULONG_PTR)thd->teb, sizeof(thd->teb));
2087 packet_reply_close(gdbctx);
2088 return packet_done;
2089 }
2090 break;
2091 case 'O':
2092 if (strncmp(gdbctx->in_packet, "Offsets", gdbctx->in_packet_len) == 0)
2093 {
2094 char buf[64];
2095
2096 snprintf(buf, sizeof(buf),
2097 "Text=%08Ix;Data=%08Ix;Bss=%08Ix",
2098 gdbctx->wine_segs[0], gdbctx->wine_segs[1],
2099 gdbctx->wine_segs[2]);
2100 return packet_reply(gdbctx, buf);
2101 }
2102 break;
2103 case 'R':
2104 if (gdbctx->in_packet_len > 5 && strncmp(gdbctx->in_packet, "Rcmd,", 5) == 0)
2105 {
2106 return packet_query_remote_command(gdbctx, gdbctx->in_packet + 5,
2107 gdbctx->in_packet_len - 5);
2108 }
2109 break;
2110 case 'S':
2111 if (strncmp(gdbctx->in_packet, "Symbol::", gdbctx->in_packet_len) == 0)
2112 return packet_ok;
2113 if (strncmp(gdbctx->in_packet, "Supported", 9) == 0)
2114 {
2115 size_t i;
2116
2117 packet_reply_open(gdbctx);
2118 packet_reply_add(gdbctx, "QStartNoAckMode+;");
2119 for (i = 0; i < ARRAY_SIZE(qxfer_handlers); i++)
2120 {
2121 packet_reply_add(gdbctx, "qXfer:");
2122 packet_reply_add(gdbctx, qxfer_handlers[i].name);
2123 packet_reply_add(gdbctx, ":read+;");
2124 }
2125 packet_reply_close(gdbctx);
2126 return packet_done;
2127 }
2128 break;
2129 case 'T':
2130 if (gdbctx->in_packet_len > 15 &&
2131 strncmp(gdbctx->in_packet, "ThreadExtraInfo", 15) == 0 &&
2132 gdbctx->in_packet[15] == ',')
2133 {
2134 unsigned tid;
2135 char* end;
2136 char result[128];
2137
2138 tid = strtol(gdbctx->in_packet + 16, &end, 16);
2139 if (end == NULL) break;
2140 get_thread_info(gdbctx, tid, result, sizeof(result));
2141 packet_reply_open(gdbctx);
2142 packet_reply_hex_to_str(gdbctx, result);
2143 packet_reply_close(gdbctx);
2144 return packet_done;
2145 }
2146 if (strncmp(gdbctx->in_packet, "TStatus", 7) == 0)
2147 {
2148 /* Tracepoints not supported */
2149 packet_reply_open(gdbctx);
2150 packet_reply_close(gdbctx);
2151 return packet_done;
2152 }
2153 break;
2154 case 'X':
2155 annex[0] = '\0';
2156 if (sscanf(gdbctx->in_packet, "Xfer:%31[^:]:read::%x,%x", object_name, &off, &len) == 3 ||
2157 sscanf(gdbctx->in_packet, "Xfer:%31[^:]:read:%255[^:]:%x,%x", object_name, annex, &off, &len) == 4)
2158 {
2159 enum packet_return result;
2160 int i;
2161 BOOL more;
2162
2163 for (i = 0; i < ARRAY_SIZE(qxfer_handlers); i++)
2164 {
2165 if (strcmp(qxfer_handlers[i].name, object_name) == 0)
2166 break;
2167 }
2168
2169 if (i >= ARRAY_SIZE(qxfer_handlers))
2170 {
2171 ERR("unhandled qXfer %s read %s %u,%u\n", debugstr_a(object_name), debugstr_a(annex), off, len);
2172 return packet_error;
2173 }
2174
2175 TRACE("qXfer %s read %s %u,%u\n", debugstr_a(object_name), debugstr_a(annex), off, len);
2176
2177 if (off > 0 &&
2178 gdbctx->qxfer_buffer.len > 0 &&
2179 gdbctx->qxfer_object_idx == i &&
2180 strcmp(gdbctx->qxfer_object_annex, annex) == 0)
2181 {
2182 result = packet_send_buffer;
2183 TRACE("qXfer read result = %d (cached)\n", result);
2184 }
2185 else
2186 {
2187 reply_buffer_clear(&gdbctx->qxfer_buffer);
2188
2189 gdbctx->qxfer_object_idx = i;
2190 strcpy(gdbctx->qxfer_object_annex, annex);
2191
2192 result = (*qxfer_handlers[i].handler)(gdbctx);
2193 TRACE("qXfer read result = %d\n", result);
2194 }
2195
2196 more = FALSE;
2197 if ((result & ~packet_last_f) == packet_send_buffer)
2198 {
2199 packet_reply_xfer(gdbctx, off, len, &more);
2200 result = (result & packet_last_f) | packet_done;
2201 }
2202
2203 if (!more)
2204 {
2205 gdbctx->qxfer_object_idx = -1;
2206 gdbctx->qxfer_object_annex[0] = '\0';
2207 reply_buffer_clear(&gdbctx->qxfer_buffer);
2208 }
2209
2210 return result;
2211 }
2212 break;
2213 }
2214 ERR("Unhandled query %s\n", debugstr_an(gdbctx->in_packet, gdbctx->in_packet_len));
2215 return packet_error;
2216 }
2217
2218 static enum packet_return packet_set(struct gdb_context* gdbctx)
2219 {
2220 if (strncmp(gdbctx->in_packet, "StartNoAckMode", 14) == 0)
2221 {
2222 gdbctx->no_ack_mode = TRUE;
2223 return packet_ok;
2224 }
2225
2226 return packet_error;
2227 }
2228
2229 static enum packet_return packet_step(struct gdb_context* gdbctx)
2230 {
2231 void *addr;
2232
2233 if (sscanf(gdbctx->in_packet, "%p", &addr) == 1)
2234 FIXME("Continue at address %p not supported\n", addr);
2235
2236 handle_step_or_continue(gdbctx, gdbctx->exec_tid, TRUE, -1);
2237
2238 wait_for_debuggee(gdbctx);
2239 return packet_reply_status(gdbctx);
2240 }
2241
2242 static enum packet_return packet_thread_alive(struct gdb_context* gdbctx)
2243 {
2244 char* end;
2245 unsigned tid;
2246
2247 tid = strtol(gdbctx->in_packet, &end, 16);
2248 if (tid == -1 || tid == 0)
2249 return packet_reply_error(gdbctx, HOST_EINVAL );
2250 if (dbg_get_thread(gdbctx->process, tid) != NULL)
2251 return packet_ok;
2252 return packet_reply_error(gdbctx, HOST_ESRCH );
2253 }
2254
2255 /* =============================================== *
2256 * P A C K E T I N F R A S T R U C T U R E *
2257 * =============================================== *
2258 */
2259
2260 struct packet_entry
2261 {
2262 char key;
2263 enum packet_return (*handler)(struct gdb_context* gdbctx);
2264 };
2265
2266 static struct packet_entry packet_entries[] =
2267 {
2268 {'?', packet_last_signal},
2269 {'c', packet_continue},
2270 {'C', packet_continue_signal},
2271 {'D', packet_detach},
2272 {'g', packet_read_registers},
2273 {'G', packet_write_registers},
2274 {'k', packet_kill},
2275 {'H', packet_thread},
2276 {'m', packet_read_memory},
2277 {'M', packet_write_memory},
2278 {'p', packet_read_register},
2279 {'P', packet_write_register},
2280 {'q', packet_query},
2281 {'Q', packet_set},
2282 {'s', packet_step},
2283 {'T', packet_thread_alive},
2284 {'v', packet_verbose},
2285 {'z', packet_delete_breakpoint},
2286 {'Z', packet_insert_breakpoint},
2287 };
2288
2289 static BOOL extract_packets(struct gdb_context* gdbctx)
2290 {
2291 char *ptr, *sum = gdbctx->in_buf, *end = gdbctx->in_buf + gdbctx->in_len;
2292 enum packet_return ret = packet_error;
2293 unsigned int cksum;
2294 int i, len;
2295
2296 /* ptr points to the beginning ('$') of the current packet
2297 * sum points to the beginning ('#') of the current packet checksum ("#xx")
2298 * len is the length of the current packet data (sum - ptr - 1)
2299 * end points to the end of the received data buffer
2300 */
2301
2302 while (!gdbctx->no_ack_mode &&
2303 (ptr = memchr(sum, '$', end - sum)) &&
2304 (sum = memchr(ptr, '#', end - ptr)) &&
2305 (end - sum >= 3) && sscanf(sum, "#%02x", &cksum) == 1)
2306 {
2307 len = sum - ptr - 1;
2308 sum += 3;
2309
2310 if (cksum == checksum(ptr + 1, len))
2311 {
2312 TRACE("Acking: %s\n", debugstr_an(ptr, sum - ptr));
2313 send(gdbctx->sock, "+", 1, 0);
2314 }
2315 else
2316 {
2317 ERR("Nacking: %s (checksum: %d != %d)\n", debugstr_an(ptr, sum - ptr),
2318 cksum, checksum(ptr + 1, len));
2319 send(gdbctx->sock, "-", 1, 0);
2320 }
2321 }
2322
2323 while ((ret & packet_last_f) == 0 &&
2324 (ptr = memchr(gdbctx->in_buf, '$', gdbctx->in_len)) &&
2325 (sum = memchr(ptr, '#', end - ptr)) &&
2326 (end - sum >= 3) && sscanf(sum, "#%02x", &cksum) == 1)
2327 {
2328 if (ptr != gdbctx->in_buf)
2329 WARN("Ignoring: %s\n", debugstr_an(gdbctx->in_buf, ptr - gdbctx->in_buf));
2330
2331 len = sum - ptr - 1;
2332 sum += 3;
2333
2334 if (cksum == checksum(ptr + 1, len))
2335 {
2336 TRACE("Handling: %s\n", debugstr_an(ptr, sum - ptr));
2337
2338 ret = packet_error;
2339 gdbctx->in_packet = ptr + 2;
2340 gdbctx->in_packet_len = len - 1;
2341 gdbctx->in_packet[gdbctx->in_packet_len] = '\0';
2342
2343 for (i = 0; i < ARRAY_SIZE(packet_entries); i++)
2344 if (packet_entries[i].key == ptr[1])
2345 break;
2346
2347 if (i == ARRAY_SIZE(packet_entries))
2348 WARN("Unhandled: %s\n", debugstr_an(ptr + 1, len));
2349 else if (((ret = (packet_entries[i].handler)(gdbctx)) & ~packet_last_f) == packet_error)
2350 WARN("Failed: %s\n", debugstr_an(ptr + 1, len));
2351
2352 switch (ret & ~packet_last_f)
2353 {
2354 case packet_error: packet_reply(gdbctx, ""); break;
2355 case packet_ok: packet_reply(gdbctx, "OK"); break;
2356 case packet_done: break;
2357 }
2358
2359 TRACE("Reply: %s\n", debugstr_an((char *)gdbctx->out_buf.base, gdbctx->out_buf.len));
2360 i = send(gdbctx->sock, (char *)gdbctx->out_buf.base, gdbctx->out_buf.len, 0);
2361 assert(i == gdbctx->out_buf.len);
2362 reply_buffer_clear(&gdbctx->out_buf);
2363 }
2364 else
2365 WARN("Ignoring: %s (checksum: %d != %d)\n", debugstr_an(ptr, sum - ptr),
2366 cksum, checksum(ptr + 1, len));
2367
2368 gdbctx->in_len = end - sum;
2369 memmove(gdbctx->in_buf, sum, end - sum);
2370 end = gdbctx->in_buf + gdbctx->in_len;
2371 }
2372
2373 return (ret & packet_last_f);
2374 }
2375
2376 static int fetch_data(struct gdb_context* gdbctx)
2377 {
2378 int len, in_len = gdbctx->in_len;
2379
2380 assert(gdbctx->in_len <= gdbctx->in_buf_alloc);
2381 for (;;)
2382 {
2383 #define STEP 128
2384 if (gdbctx->in_len + STEP > gdbctx->in_buf_alloc)
2385 gdbctx->in_buf = realloc(gdbctx->in_buf, gdbctx->in_buf_alloc += STEP);
2386 #undef STEP
2387 len = recv(gdbctx->sock, gdbctx->in_buf + gdbctx->in_len, gdbctx->in_buf_alloc - gdbctx->in_len - 1, 0);
2388 if (len <= 0) break;
2389 gdbctx->in_len += len;
2390 assert(gdbctx->in_len <= gdbctx->in_buf_alloc);
2391 if (len < gdbctx->in_buf_alloc - gdbctx->in_len) break;
2392 }
2393
2394 gdbctx->in_buf[gdbctx->in_len] = '\0';
2395 return gdbctx->in_len - in_len;
2396 }
2397
2398 #define FLAG_NO_START 1
2399 #define FLAG_WITH_XTERM 2
2400
2401 static BOOL gdb_exec(unsigned port, unsigned flags)
2402 {
2403 WCHAR tmp[MAX_PATH], buf[MAX_PATH];
2404 const char *argv[6];
2405 char *unix_tmp;
2406 const char *gdb_path;
2407 FILE* f;
2408
2409 if (!(gdb_path = getenv("WINE_GDB"))) gdb_path = "gdb";
2410 GetTempPathW( MAX_PATH, buf );
2411 GetTempFileNameW( buf, L"gdb", 0, tmp );
2412 if ((f = _wfopen( tmp, L"w+" )) == NULL) return FALSE;
2413 unix_tmp = wine_get_unix_file_name( tmp );
2414 fprintf(f, "target remote localhost:%d\n", ntohs(port));
2415 fprintf(f, "set prompt Wine-gdb>\\ \n");
2416 /* gdb 5.1 seems to require it, won't hurt anyway */
2417 fprintf(f, "sharedlibrary\n");
2418 /* This is needed (but not a decent & final fix)
2419 * Without this, gdb would skip our inter-DLL relay code (because
2420 * we don't have any line number information for the relay code)
2421 * With this, we will stop on first instruction of the stub, and
2422 * reusing step, will get us through the relay stub at the actual
2423 * function we're looking at.
2424 */
2425 fprintf(f, "set step-mode on\n");
2426 /* tell gdb to delete this file when done handling it... */
2427 fprintf(f, "shell rm -f \"%s\"\n", unix_tmp);
2428 fclose(f);
2429 argv[0] = "xterm";
2430 argv[1] = "-e";
2431 argv[2] = gdb_path;
2432 argv[3] = "-x";
2433 argv[4] = unix_tmp;
2434 argv[5] = NULL;
2435 if (flags & FLAG_WITH_XTERM)
2436 __wine_unix_spawnvp( (char **)argv, FALSE );
2437 else
2438 __wine_unix_spawnvp( (char **)argv + 2, FALSE );
2439 HeapFree( GetProcessHeap(), 0, unix_tmp );
2440 return TRUE;
2441 }
2442
2443 static BOOL gdb_startup(struct gdb_context* gdbctx, unsigned flags, unsigned port)
2444 {
2445 SOCKET sock;
2446 BOOL reuseaddr = TRUE;
2447 struct sockaddr_in s_addrs = {0};
2448 int s_len = sizeof(s_addrs);
2449 fd_set read_fds;
2450 WSADATA data;
2451 BOOL ret = FALSE;
2452
2453 WSAStartup( MAKEWORD(2, 2), &data );
2454
2455 /* step 1: create socket for gdb connection request */
2456 if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
2457 {
2458 ERR("Failed to create socket: %u\n", WSAGetLastError());
2459 return FALSE;
2460 }
2461
2462 setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char*)&reuseaddr, sizeof(reuseaddr));
2463
2464 s_addrs.sin_family = AF_INET;
2465 s_addrs.sin_addr.S_un.S_addr = INADDR_ANY;
2466 s_addrs.sin_port = htons(port);
2467 if (bind(sock, (struct sockaddr *)&s_addrs, sizeof(s_addrs)) == -1)
2468 goto cleanup;
2469
2470 if (listen(sock, 1) == -1 || getsockname(sock, (struct sockaddr *)&s_addrs, &s_len) == -1)
2471 goto cleanup;
2472
2473 /* step 2: do the process internal creation */
2474 handle_debug_event(gdbctx, FALSE);
2475
2476 /* step 3: fire up gdb (if requested) */
2477 if (flags & FLAG_NO_START)
2478 fprintf(stderr, "target remote localhost:%d\n", ntohs(s_addrs.sin_port));
2479 else
2480 gdb_exec(s_addrs.sin_port, flags);
2481
2482 /* step 4: wait for gdb to connect actually */
2483 FD_ZERO( &read_fds );
2484 FD_SET( sock, &read_fds );
2485
2486 if (select( 0, &read_fds, NULL, NULL, NULL ) > 0)
2487 {
2488 int dummy = 1;
2489
2490 gdbctx->sock = accept(sock, (struct sockaddr *)&s_addrs, &s_len);
2491 if (gdbctx->sock != INVALID_SOCKET)
2492 {
2493 ret = TRUE;
2494 TRACE("connected on %Iu\n", gdbctx->sock);
2495 /* don't keep our small packets too long: send them ASAP back to GDB
2496 * without this, GDB really crawls
2497 */
2498 setsockopt(gdbctx->sock, IPPROTO_TCP, TCP_NODELAY, (char*)&dummy, sizeof(dummy));
2499 }
2500 }
2501 else ERR("Failed to connect to gdb: %u\n", WSAGetLastError());
2502
2503 cleanup:
2504 closesocket(sock);
2505 return ret;
2506 }
2507
2508 static BOOL gdb_init_context(struct gdb_context* gdbctx, unsigned flags, unsigned port)
2509 {
2510 int i;
2511
2512 gdbctx->sock = INVALID_SOCKET;
2513 gdbctx->in_buf = NULL;
2514 gdbctx->in_buf_alloc = 0;
2515 gdbctx->in_len = 0;
2516 memset(&gdbctx->out_buf, 0, sizeof(gdbctx->out_buf));
2517 gdbctx->out_curr_packet = -1;
2518
2519 gdbctx->exec_tid = -1;
2520 gdbctx->other_tid = -1;
2521 list_init(&gdbctx->xpoint_list);
2522 gdbctx->process = NULL;
2523 gdbctx->no_ack_mode = FALSE;
2524 for (i = 0; i < ARRAY_SIZE(gdbctx->wine_segs); i++)
2525 gdbctx->wine_segs[i] = 0;
2526
2527 gdbctx->qxfer_object_idx = -1;
2528 memset(gdbctx->qxfer_object_annex, 0, sizeof(gdbctx->qxfer_object_annex));
2529 memset(&gdbctx->qxfer_buffer, 0, sizeof(gdbctx->qxfer_buffer));
2530
2531 /* wait for first trap */
2532 while (WaitForDebugEvent(&gdbctx->de, INFINITE))
2533 {
2534 if (gdbctx->de.dwDebugEventCode == CREATE_PROCESS_DEBUG_EVENT)
2535 {
2536 /* this should be the first event we get,
2537 * and the only one of this type */
2538 assert(gdbctx->process == NULL && gdbctx->de.dwProcessId == dbg_curr_pid);
2539 /* gdbctx->dwProcessId = pid; */
2540 if (!gdb_startup(gdbctx, flags, port)) return FALSE;
2541 }
2542 else if (!handle_debug_event(gdbctx, FALSE))
2543 break;
2544 ContinueDebugEvent(gdbctx->de.dwProcessId, gdbctx->de.dwThreadId, DBG_CONTINUE);
2545 }
2546 return TRUE;
2547 }
2548
2549 static int gdb_remote(unsigned flags, unsigned port)
2550 {
2551 struct gdb_context gdbctx;
2552
2553 if (!gdb_init_context(&gdbctx, flags, port)) return 0;
2554 /* don't handle ctrl-c, but let gdb do the job */
2555 SetConsoleCtrlHandler(NULL, TRUE);
2556 for (;;)
2557 {
2558 fd_set read_fds, err_fds;
2559
2560 FD_ZERO( &read_fds );
2561 FD_ZERO( &err_fds );
2562 FD_SET( gdbctx.sock, &read_fds );
2563 FD_SET( gdbctx.sock, &err_fds );
2564
2565 if (select( 0, &read_fds, NULL, &err_fds, NULL ) == -1) break;
2566
2567 if (FD_ISSET( gdbctx.sock, &err_fds ))
2568 {
2569 ERR("gdb hung up\n");
2570 /* kill also debuggee process - questionnable - */
2571 detach_debuggee(&gdbctx, TRUE);
2572 break;
2573 }
2574 if (FD_ISSET( gdbctx.sock, &read_fds ))
2575 {
2576 if (fetch_data(&gdbctx) > 0)
2577 {
2578 if (extract_packets(&gdbctx)) break;
2579 }
2580 }
2581 }
2582 return 0;
2583 }
2584
2585 int gdb_main(int argc, char* argv[])
2586 {
2587 unsigned gdb_flags = 0, port = 0;
2588 char *port_end;
2589
2590 argc--; argv++;
2591 while (argc > 0 && argv[0][0] == '-')
2592 {
2593 if (strcmp(argv[0], "--no-start") == 0)
2594 {
2595 gdb_flags |= FLAG_NO_START;
2596 argc--; argv++;
2597 continue;
2598 }
2599 if (strcmp(argv[0], "--with-xterm") == 0)
2600 {
2601 gdb_flags |= FLAG_WITH_XTERM;
2602 argc--; argv++;
2603 continue;
2604 }
2605 if (strcmp(argv[0], "--port") == 0 && argc > 1)
2606 {
2607 port = strtoul(argv[1], &port_end, 10);
2608 if (*port_end)
2609 {
2610 fprintf(stderr, "Invalid port: %s\n", argv[1]);
2611 return -1;
2612 }
2613 argc -= 2; argv += 2;
2614 continue;
2615 }
2616 return -1;
2617 }
2618 if (dbg_active_attach(argc, argv) == start_ok ||
2619 dbg_active_launch(argc, argv) == start_ok)
2620 return gdb_remote(gdb_flags, port);
2621
2622 return -1;
2623 }
Windows API implementation