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