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