git.oblomov.eu Git - wine/blob - programs/winedbg/gdbproxy.c

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