git.oblomov.eu Git - wine/blob - debugger/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
   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include "config.h"
  24
  25 #include <assert.h>
  26 #include <errno.h>
  27 #include <fcntl.h>
  28 #include <signal.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <sys/poll.h>
  32 #include <sys/wait.h>
  33 #ifdef HAVE_SYS_SOCKET_H
  34 # include <sys/socket.h>
  35 #endif
  36 #include <netinet/in.h>
  37 #include <netinet/tcp.h>
  38 #include <unistd.h>
  39
  40 #include "windef.h"
  41 #include "winbase.h"
  42 #include "tlhelp32.h"
  43
  44 /* those two are needed only for the SHOWNORMAL flag */
  45 #include "wingdi.h"
  46 #include "winuser.h"
  47
  48 #include "debugger.h"
  49
  50 #define GDBPXY_TRC_LOWLEVEL             0x01
  51 #define GDBPXY_TRC_PACKET               0x02
  52 #define GDBPXY_TRC_COMMAND              0x04
  53 #define GDBPXY_TRC_COMMAND_ERROR        0x08
  54 #define GDBPXY_TRC_WIN32_EVENT          0x10
  55 #define GDBPXY_TRC_WIN32_ERROR          0x20
  56
  57 struct gdb_ctx_Xpoint
  58 {
  59     int                         type;   /* -1 means free */
  60     void*                       addr;
  61     unsigned long               val;
  62 };
  63
  64 struct gdb_context
  65 {
  66     /* gdb information */
  67     int                         sock;
  68     /* incoming buffer */
  69     char*                       in_buf;
  70     int                         in_buf_alloc;
  71     int                         in_len;
  72     /* split into individual packet */
  73     char*                       in_packet;
  74     int                         in_packet_len;
  75     /* outgoing buffer */
  76     char*                       out_buf;
  77     int                         out_buf_alloc;
  78     int                         out_len;
  79     int                         out_curr_packet;
  80     /* generic GDB thread information */
  81     unsigned                    exec_thread;    /* thread used in step & continue */
  82     unsigned                    other_thread;   /* thread to be used in any other operation */
  83     unsigned                    trace;
  84     /* current Win32 trap env */
  85     unsigned                    last_sig;
  86     BOOL                        in_trap;
  87     CONTEXT                     context;
  88     /* Win32 information */
  89     DBG_PROCESS*                process;
  90 #define NUM_XPOINT      32
  91     struct gdb_ctx_Xpoint       Xpoints[NUM_XPOINT];
  92     /* Unix environment */
  93     unsigned long               wine_segs[3];   /* load addresses of the ELF wine exec segments (text, bss and data) */
  94 };
  95
  96 extern int read_elf_info(const char* filename, unsigned long tab[]);
  97
  98 /* =============================================== *
  99  *       B A S I C   M A N I P U L A T I O N S     *
 100  * =============================================== *
 101  */
 102
 103 static inline int hex_from0(char ch)
 104 {
 105     if (ch >= '0' && ch <= '9') return ch - '0';
 106     if (ch >= 'A' && ch <= 'F') return ch - 'A' + 10;
 107     if (ch >= 'a' && ch <= 'f') return ch - 'a' + 10;
 108     assert(0);
 109 }
 110
 111 static inline unsigned char hex_to0(int x)
 112 {
 113     assert(x >= 0 && x < 16);
 114     return "0123456789abcdef"[x];
 115 }
 116
 117 static void hex_from(void* dst, const char* src, size_t len)
 118 {
 119     while (len--)
 120     {
 121         *(unsigned char*)dst++ = (hex_from0(src[0]) << 4) | hex_from0(src[1]);
 122         src += 2;
 123     }
 124 }
 125
 126 static void hex_to(char* dst, const void* src, size_t len)
 127 {
 128     while (len--)
 129     {
 130         *dst++ = hex_to0(*(const unsigned char*)src >> 4);
 131         *dst++ = hex_to0(*(const unsigned char*)src & 0x0F);
 132         src++;
 133     }
 134 }
 135
 136 static unsigned char checksum(const char* ptr, int len)
 137 {
 138     unsigned cksum = 0;
 139
 140     while (len-- > 0)
 141         cksum += (unsigned char)*ptr++;
 142     return cksum;
 143 }
 144
 145 /* =============================================== *
 146  *              C P U   H A N D L E R S            *
 147  * =============================================== *
 148  */
 149
 150 #define OFFSET_OF(__c,__f)      ((int)(((char*)&(((__c*)0)->__f))-((char*)0)))
 151
 152 #ifdef __i386__
 153 static size_t cpu_register_map[] = {
 154     OFFSET_OF(CONTEXT, Eax),
 155     OFFSET_OF(CONTEXT, Ecx),
 156     OFFSET_OF(CONTEXT, Edx),
 157     OFFSET_OF(CONTEXT, Ebx),
 158     OFFSET_OF(CONTEXT, Esp),
 159     OFFSET_OF(CONTEXT, Ebp),
 160     OFFSET_OF(CONTEXT, Esi),
 161     OFFSET_OF(CONTEXT, Edi),
 162     OFFSET_OF(CONTEXT, Eip),
 163     OFFSET_OF(CONTEXT, EFlags),
 164     OFFSET_OF(CONTEXT, SegCs),
 165     OFFSET_OF(CONTEXT, SegSs),
 166     OFFSET_OF(CONTEXT, SegDs),
 167     OFFSET_OF(CONTEXT, SegEs),
 168     OFFSET_OF(CONTEXT, SegFs),
 169     OFFSET_OF(CONTEXT, SegGs),
 170 };
 171 #else
 172 #error "Define the registers map for your CPU"
 173 #endif
 174 #undef OFFSET_OF
 175
 176 static const size_t cpu_num_regs = (sizeof(cpu_register_map) / sizeof(cpu_register_map[0]));
 177
 178 static inline unsigned long* cpu_register(struct gdb_context* gdbctx, unsigned idx)
 179 {
 180     assert(idx < cpu_num_regs);
 181     return (unsigned long*)((char*)&gdbctx->context + cpu_register_map[idx]);
 182 }
 183
 184 static inline BOOL     cpu_enter_stepping(struct gdb_context* gdbctx)
 185 {
 186 #ifdef __i386__
 187     gdbctx->context.EFlags |= 0x100;
 188     return TRUE;
 189 #else
 190 #error "Define step mode enter for your CPU"
 191 #endif
 192     return FALSE;
 193 }
 194
 195 static inline BOOL     cpu_leave_stepping(struct gdb_context* gdbctx)
 196 {
 197 #ifdef __i386__
 198     /* The Win32 debug API always resets the Step bit in EFlags after
 199      * a single step instruction, so we don't need to clear when the
 200      * step is done.
 201      */
 202     return TRUE;
 203 #else
 204 #error "Define step mode leave for your CPU"
 205 #endif
 206     return FALSE;
 207 }
 208
 209 #ifdef __i386__
 210 #define DR7_CONTROL_SHIFT       16
 211 #define DR7_CONTROL_SIZE        4
 212
 213 #define DR7_RW_EXECUTE          (0x0)
 214 #define DR7_RW_WRITE            (0x1)
 215 #define DR7_RW_READ             (0x3)
 216
 217 #define DR7_LEN_1               (0x0)
 218 #define DR7_LEN_2               (0x4)
 219 #define DR7_LEN_4               (0xC)
 220
 221 #define DR7_LOCAL_ENABLE_SHIFT  0
 222 #define DR7_GLOBAL_ENABLE_SHIFT 1
 223 #define DR7_ENABLE_SIZE         2
 224
 225 #define DR7_LOCAL_ENABLE_MASK   (0x55)
 226 #define DR7_GLOBAL_ENABLE_MASK  (0xAA)
 227
 228 #define DR7_CONTROL_RESERVED    (0xFC00)
 229 #define DR7_LOCAL_SLOWDOWN      (0x100)
 230 #define DR7_GLOBAL_SLOWDOWN     (0x200)
 231
 232 #define DR7_ENABLE_MASK(dr)     (1<<(DR7_LOCAL_ENABLE_SHIFT+DR7_ENABLE_SIZE*(dr)))
 233 #define IS_DR7_SET(ctrl,dr)     ((ctrl)&DR7_ENABLE_MASK(dr))
 234
 235 static inline int       i386_get_unused_DR(struct gdb_context* gdbctx,
 236                                            unsigned long** r)
 237 {
 238     if (!IS_DR7_SET(gdbctx->context.Dr7, 0))
 239     {
 240         *r = &gdbctx->context.Dr0;
 241         return 0;
 242     }
 243     if (!IS_DR7_SET(gdbctx->context.Dr7, 1))
 244     {
 245         *r = &gdbctx->context.Dr1;
 246         return 1;
 247     }
 248     if (!IS_DR7_SET(gdbctx->context.Dr7, 2))
 249     {
 250         *r = &gdbctx->context.Dr2;
 251         return 2;
 252     }
 253     if (!IS_DR7_SET(gdbctx->context.Dr7, 3))
 254     {
 255         *r = &gdbctx->context.Dr3;
 256         return 3;
 257     }
 258     return -1;
 259 }
 260 #endif
 261
 262 /******************************************************************
 263  *              cpu_insert_Xpoint
 264  *
 265  * returns  1 if ok
 266  *          0 if error
 267  *         -1 if operation isn't supported by CPU
 268  */
 269 static inline int      cpu_insert_Xpoint(struct gdb_context* gdbctx,
 270                                          struct gdb_ctx_Xpoint* xpt, size_t len)
 271 {
 272 #ifdef __i386__
 273     unsigned char       ch;
 274     unsigned long       sz;
 275     unsigned long*      pr;
 276     int                 reg;
 277     unsigned long       bits;
 278
 279     switch (xpt->type)
 280     {
 281     case '0':
 282         if (len != 1) return 0;
 283         if (!ReadProcessMemory(gdbctx->process->handle, xpt->addr, &ch, 1, &sz) || sz != 1) return 0;
 284         xpt->val = ch;
 285         ch = 0xcc;
 286         if (!WriteProcessMemory(gdbctx->process->handle, xpt->addr, &ch, 1, &sz) || sz != 1) return 0;
 287         break;
 288     case '1':
 289         bits = DR7_RW_EXECUTE;
 290         goto hw_bp;
 291     case '2':
 292         bits = DR7_RW_READ;
 293         goto hw_bp;
 294     case '3':
 295         bits = DR7_RW_WRITE;
 296     hw_bp:
 297         if ((reg = i386_get_unused_DR(gdbctx, &pr)) == -1) return 0;
 298         *pr = (unsigned long)xpt->addr;
 299         if (xpt->type != '1') switch (len)
 300         {
 301         case 4: bits |= DR7_LEN_4; break;
 302         case 2: bits |= DR7_LEN_2; break;
 303         case 1: bits |= DR7_LEN_1; break;
 304         default: return 0;
 305         }
 306         xpt->val = reg;
 307         /* clear old values */
 308         gdbctx->context.Dr7 &= ~(0x0F << (DR7_CONTROL_SHIFT + DR7_CONTROL_SIZE * reg));
 309         /* set the correct ones */
 310         gdbctx->context.Dr7 |= bits << (DR7_CONTROL_SHIFT + DR7_CONTROL_SIZE * reg);
 311         gdbctx->context.Dr7 |= DR7_ENABLE_MASK(reg) | DR7_LOCAL_SLOWDOWN;
 312         break;
 313     default:
 314         fprintf(stderr, "Unknown bp type %c\n", xpt->type);
 315         return 0;
 316     }
 317     return 1;
 318 #else
 319 #error "Define insert Xpoint for your CPU"
 320 #endif
 321     return -1;
 322 }
 323
 324 /******************************************************************
 325  *              cpu_remove_Xpoint
 326  *
 327  * returns  1 if ok
 328  *          0 if error
 329  *         -1 if operation isn't supported by CPU
 330  */
 331 static inline BOOL      cpu_remove_Xpoint(struct gdb_context* gdbctx,
 332                                           struct gdb_ctx_Xpoint* xpt, size_t len)
 333 {
 334 #ifdef __i386__
 335     unsigned long       sz;
 336     unsigned char       ch;
 337
 338     switch (xpt->type)
 339     {
 340     case '0':
 341         if (len != 1) return 0;
 342         ch = (unsigned char)xpt->val;
 343         if (!WriteProcessMemory(gdbctx->process->handle, xpt->addr, &ch, 1, &sz) || sz != 1) return 0;
 344         break;
 345     case '1':
 346     case '2':
 347     case '3':
 348         /* simply disable the entry */
 349         gdbctx->context.Dr7 &= ~DR7_ENABLE_MASK(xpt->val);
 350         break;
 351     default:
 352         fprintf(stderr, "Unknown bp type %c\n", xpt->type);
 353         return 0;
 354     }
 355     return 1;
 356 #else
 357 #error "Define remove Xpoint for your CPU"
 358 #endif
 359     return -1;
 360 }
 361 /* =============================================== *
 362  *    W I N 3 2   D E B U G   I N T E R F A C E    *
 363  * =============================================== *
 364  */
 365
 366 static BOOL handle_exception(struct gdb_context* gdbctx, EXCEPTION_DEBUG_INFO* exc)
 367 {
 368     EXCEPTION_RECORD*   rec = &exc->ExceptionRecord;
 369     BOOL                ret = FALSE;
 370
 371     switch (rec->ExceptionCode)
 372     {
 373     case EXCEPTION_ACCESS_VIOLATION:
 374     case EXCEPTION_PRIV_INSTRUCTION:
 375     case EXCEPTION_STACK_OVERFLOW:
 376     case EXCEPTION_GUARD_PAGE:
 377         gdbctx->last_sig = SIGSEGV;
 378         ret = TRUE;
 379         break;
 380     case EXCEPTION_DATATYPE_MISALIGNMENT:
 381         gdbctx->last_sig = SIGBUS;
 382         ret = TRUE;
 383         break;
 384     case EXCEPTION_SINGLE_STEP:
 385         /* fall thru */
 386     case EXCEPTION_BREAKPOINT:
 387         gdbctx->last_sig = SIGTRAP;
 388         ret = TRUE;
 389         break;
 390     case EXCEPTION_FLT_DENORMAL_OPERAND:
 391     case EXCEPTION_FLT_DIVIDE_BY_ZERO:
 392     case EXCEPTION_FLT_INEXACT_RESULT:
 393     case EXCEPTION_FLT_INVALID_OPERATION:
 394     case EXCEPTION_FLT_OVERFLOW:
 395     case EXCEPTION_FLT_STACK_CHECK:
 396     case EXCEPTION_FLT_UNDERFLOW:
 397         gdbctx->last_sig = SIGFPE;
 398         ret = TRUE;
 399         break;
 400     case EXCEPTION_INT_DIVIDE_BY_ZERO:
 401     case EXCEPTION_INT_OVERFLOW:
 402         gdbctx->last_sig = SIGFPE;
 403         ret = TRUE;
 404         break;
 405     case EXCEPTION_ILLEGAL_INSTRUCTION:
 406         gdbctx->last_sig = SIGILL;
 407         ret = TRUE;
 408         break;
 409     case CONTROL_C_EXIT:
 410         gdbctx->last_sig = SIGINT;
 411         ret = TRUE;
 412         break;
 413     case EXCEPTION_CRITICAL_SECTION_WAIT:
 414         gdbctx->last_sig = SIGALRM;
 415         ret = TRUE;
 416         /* FIXME: we could also add here a O packet with additional information */
 417         break;
 418     default:
 419         if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
 420             fprintf(stderr, "unhandled exception code %08lx\n", rec->ExceptionCode);
 421         gdbctx->last_sig = SIGABRT;
 422         ret = TRUE;
 423         break;
 424     }
 425     return ret;
 426 }
 427
 428 static  void    handle_debug_event(struct gdb_context* gdbctx, DEBUG_EVENT* de)
 429 {
 430     char                buffer[256];
 431
 432     DEBUG_CurrThread = DEBUG_GetThread(gdbctx->process, de->dwThreadId);
 433
 434     switch (de->dwDebugEventCode)
 435     {
 436     case CREATE_PROCESS_DEBUG_EVENT:
 437         DEBUG_ProcessGetStringIndirect(buffer, sizeof(buffer),
 438                                        de->u.CreateProcessInfo.hProcess,
 439                                        de->u.CreateProcessInfo.lpImageName);
 440
 441         /* FIXME unicode ? de->u.CreateProcessInfo.fUnicode */
 442         if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
 443             fprintf(stderr, "%08lx:%08lx: create process '%s'/%p @%08lx (%ld<%ld>)\n",
 444                     de->dwProcessId, de->dwThreadId,
 445                     buffer, de->u.CreateProcessInfo.lpImageName,
 446                     (unsigned long)(LPVOID)de->u.CreateProcessInfo.lpStartAddress,
 447                     de->u.CreateProcessInfo.dwDebugInfoFileOffset,
 448                     de->u.CreateProcessInfo.nDebugInfoSize);
 449
 450         gdbctx->process = DEBUG_AddProcess(de->dwProcessId,
 451                                            de->u.CreateProcessInfo.hProcess,
 452                                            buffer);
 453         /* de->u.CreateProcessInfo.lpStartAddress; */
 454
 455         if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
 456             fprintf(stderr, "%08lx:%08lx: create thread I @%08lx\n",
 457                     de->dwProcessId, de->dwThreadId,
 458                     (unsigned long)(LPVOID)de->u.CreateProcessInfo.lpStartAddress);
 459
 460         assert(DEBUG_CurrThread == NULL); /* shouldn't be there */
 461         DEBUG_AddThread(gdbctx->process, de->dwThreadId,
 462                         de->u.CreateProcessInfo.hThread,
 463                         de->u.CreateProcessInfo.lpStartAddress,
 464                         de->u.CreateProcessInfo.lpThreadLocalBase);
 465 #if 0
 466         DEBUG_LoadModule32(DEBUG_CurrProcess->imageName, de->u.CreateProcessInfo.hFile,
 467                            (DWORD)de->u.CreateProcessInfo.lpBaseOfImage);
 468
 469         if (buffer[0])  /* we got a process name */
 470         {
 471             DWORD type;
 472             if (!GetBinaryTypeA( buffer, &type ))
 473             {
 474                 /* not a Windows binary, assume it's a Unix executable then */
 475                 char unixname[MAX_PATH];
 476                 /* HACK!! should fix DEBUG_ReadExecutableDbgInfo to accept DOS filenames */
 477                 if (wine_get_unix_file_name( buffer, unixname, sizeof(unixname) ))
 478                 {
 479                     DEBUG_ReadExecutableDbgInfo( unixname );
 480                     break;
 481                 }
 482             }
 483         }
 484         /* if it is a Windows binary, or an invalid or missing file name,
 485          * we use wine itself as the main executable */
 486         DEBUG_ReadExecutableDbgInfo( "wine" );
 487 #endif
 488         break;
 489
 490     case LOAD_DLL_DEBUG_EVENT:
 491         assert(DEBUG_CurrThread);
 492         DEBUG_ProcessGetStringIndirect(buffer, sizeof(buffer),
 493                                        gdbctx->process->handle,
 494                                        de->u.LoadDll.lpImageName);
 495
 496         /* FIXME unicode: de->u.LoadDll.fUnicode */
 497         if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
 498             fprintf(stderr, "%08lx:%08lx: loads DLL %s @%08lx (%ld<%ld>)\n",
 499                     de->dwProcessId, de->dwThreadId,
 500                     buffer, (unsigned long)de->u.LoadDll.lpBaseOfDll,
 501                     de->u.LoadDll.dwDebugInfoFileOffset,
 502                     de->u.LoadDll.nDebugInfoSize);
 503 #if 0
 504         _strupr(buffer);
 505         DEBUG_LoadModule32(buffer, de->u.LoadDll.hFile, (DWORD)de->u.LoadDll.lpBaseOfDll);
 506         DEBUG_CheckDelayedBP();
 507         if (DBG_IVAR(BreakOnDllLoad))
 508         {
 509             DEBUG_Printf(DBG_CHN_MESG, "Stopping on DLL %s loading at %08lx\n",
 510                          buffer, (unsigned long)de->u.LoadDll.lpBaseOfDll);
 511             DEBUG_Parser();
 512         }
 513 #endif
 514         break;
 515
 516     case UNLOAD_DLL_DEBUG_EVENT:
 517         if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
 518             fprintf(stderr, "%08lx:%08lx: unload DLL @%08lx\n",
 519                     de->dwProcessId, de->dwThreadId, (unsigned long)de->u.UnloadDll.lpBaseOfDll);
 520         break;
 521
 522     case EXCEPTION_DEBUG_EVENT:
 523         assert(DEBUG_CurrThread);
 524         if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
 525             fprintf(stderr, "%08lx:%08lx: exception code=%08lx\n",
 526                     de->dwProcessId, de->dwThreadId,
 527                     de->u.Exception.ExceptionRecord.ExceptionCode);
 528
 529         gdbctx->context.ContextFlags =  CONTEXT_CONTROL
 530                                       | CONTEXT_INTEGER
 531 #ifdef CONTEXT_SEGMENTS
 532                                       | CONTEXT_SEGMENTS
 533 #endif
 534 #ifdef CONTEXT_DEBUG_REGISTERS
 535                                       | CONTEXT_DEBUG_REGISTERS
 536 #endif
 537                                       ;
 538         if (!GetThreadContext(DEBUG_CurrThread->handle, &gdbctx->context))
 539         {
 540             if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
 541                 fprintf(stderr, "Can't get thread's context\n");
 542             break;
 543         }
 544         gdbctx->in_trap = handle_exception(gdbctx, &de->u.Exception);
 545         break;
 546
 547     case CREATE_THREAD_DEBUG_EVENT:
 548         if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
 549             fprintf(stderr, "%08lx:%08lx: create thread D @%08lx\n",
 550                     de->dwProcessId, de->dwThreadId, (unsigned long)(LPVOID)de->u.CreateThread.lpStartAddress);
 551
 552         DEBUG_AddThread(gdbctx->process,
 553                         de->dwThreadId,
 554                         de->u.CreateThread.hThread,
 555                         de->u.CreateThread.lpStartAddress,
 556                         de->u.CreateThread.lpThreadLocalBase);
 557         break;
 558
 559     case EXIT_THREAD_DEBUG_EVENT:
 560         if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
 561             fprintf(stderr, "%08lx:%08lx: exit thread (%ld)\n",
 562                     de->dwProcessId, de->dwThreadId, de->u.ExitThread.dwExitCode);
 563
 564         assert(DEBUG_CurrThread);
 565         DEBUG_DelThread(DEBUG_CurrThread);
 566         break;
 567
 568     case EXIT_PROCESS_DEBUG_EVENT:
 569         if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
 570             fprintf(stderr, "%08lx:%08lx: exit process (%ld)\n",
 571                     de->dwProcessId, de->dwThreadId, de->u.ExitProcess.dwExitCode);
 572
 573         DEBUG_DelProcess(gdbctx->process);
 574         gdbctx->process = NULL;
 575         /* now signal gdb that we're done */
 576         gdbctx->last_sig = SIGTERM;
 577         gdbctx->in_trap = TRUE;
 578         break;
 579
 580     case OUTPUT_DEBUG_STRING_EVENT:
 581         assert(DEBUG_CurrThread);
 582         DEBUG_ProcessGetString(buffer, sizeof(buffer),
 583                                gdbctx->process->handle,
 584                                de->u.DebugString.lpDebugStringData);
 585         /* FIXME unicode de->u.DebugString.fUnicode ? */
 586         if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
 587             fprintf(stderr, "%08lx:%08lx: output debug string (%s)\n",
 588                     de->dwProcessId, de->dwThreadId, buffer);
 589         break;
 590
 591     case RIP_EVENT:
 592         if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
 593             fprintf(stderr, "%08lx:%08lx: rip error=%ld type=%ld\n",
 594                     de->dwProcessId, de->dwThreadId, de->u.RipInfo.dwError,
 595                     de->u.RipInfo.dwType);
 596         break;
 597
 598     default:
 599         if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
 600             fprintf(stderr, "%08lx:%08lx: unknown event (%ld)\n",
 601                     de->dwProcessId, de->dwThreadId, de->dwDebugEventCode);
 602     }
 603 }
 604
 605 static void    resume_debuggee(struct gdb_context* gdbctx, unsigned long cont)
 606 {
 607     if (DEBUG_CurrThread)
 608     {
 609         if (!SetThreadContext(DEBUG_CurrThread->handle, &gdbctx->context))
 610             if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
 611                 fprintf(stderr, "cannot set ctx on %lu\n", DEBUG_CurrThread->tid);
 612         if (!ContinueDebugEvent(gdbctx->process->pid, DEBUG_CurrThread->tid, cont))
 613             if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
 614                 fprintf(stderr, "cannot continue on %lu (%lu)\n",
 615                         DEBUG_CurrThread->tid, cont);
 616     }
 617     else if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
 618         fprintf(stderr, "cannot find last thread (%lu)\n", DEBUG_CurrThread->tid);
 619 }
 620
 621 static void    wait_for_debuggee(struct gdb_context* gdbctx)
 622 {
 623     DEBUG_EVENT         de;
 624
 625     gdbctx->in_trap = FALSE;
 626     while (WaitForDebugEvent(&de, INFINITE))
 627     {
 628         handle_debug_event(gdbctx, &de);
 629         assert(!gdbctx->process ||
 630                gdbctx->process->pid == 0 ||
 631                de.dwProcessId == gdbctx->process->pid);
 632         assert(!DEBUG_CurrThread || de.dwThreadId == DEBUG_CurrThread->tid);
 633         if (gdbctx->in_trap) break;
 634         ContinueDebugEvent(de.dwProcessId, de.dwThreadId, DBG_CONTINUE);
 635     }
 636 }
 637
 638 static void detach_debuggee(struct gdb_context* gdbctx, BOOL kill)
 639 {
 640     cpu_leave_stepping(gdbctx);
 641     resume_debuggee(gdbctx, DBG_CONTINUE);
 642     if (!kill)
 643         DebugActiveProcessStop(gdbctx->process->pid);
 644     DEBUG_DelProcess(gdbctx->process);
 645     gdbctx->process = NULL;
 646 }
 647
 648 static void get_process_info(struct gdb_context* gdbctx, char* buffer, size_t len)
 649 {
 650     unsigned long       status;
 651
 652     if (!GetExitCodeProcess(gdbctx->process->handle, &status))
 653     {
 654         strcpy(buffer, "Unknown process");
 655         return;
 656     }
 657     if (status == STILL_ACTIVE)
 658     {
 659         strcpy(buffer, "Running");
 660     }
 661     else
 662         sprintf(buffer, "Terminated (%lu)", status);
 663
 664     switch (GetPriorityClass(gdbctx->process->handle))
 665     {
 666     case 0: break;
 667 #ifdef ABOVE_NORMAL_PRIORITY_CLASS
 668     case ABOVE_NORMAL_PRIORITY_CLASS:   strcat(buffer, ", above normal priority");      break;
 669 #endif
 670 #ifdef BELOW_NORMAL_PRIORITY_CLASS
 671     case BELOW_NORMAL_PRIORITY_CLASS:   strcat(buffer, ", below normal priotity");      break;
 672 #endif
 673     case HIGH_PRIORITY_CLASS:           strcat(buffer, ", high priority");              break;
 674     case IDLE_PRIORITY_CLASS:           strcat(buffer, ", idle priority");              break;
 675     case NORMAL_PRIORITY_CLASS:         strcat(buffer, ", normal priority");            break;
 676     case REALTIME_PRIORITY_CLASS:       strcat(buffer, ", realtime priority");          break;
 677     }
 678     strcat(buffer, "\n");
 679 }
 680
 681 static void get_thread_info(struct gdb_context* gdbctx, unsigned tid,
 682                             char* buffer, size_t len)
 683 {
 684     DBG_THREAD*         thd;
 685     unsigned long       status;
 686     int                 prio;
 687
 688     /* FIXME: use the size of buffer */
 689     thd = DEBUG_GetThread(gdbctx->process, tid);
 690     if (thd == NULL)
 691     {
 692         strcpy(buffer, "No information");
 693         return;
 694     }
 695     if (GetExitCodeThread(thd->handle, &status))
 696     {
 697         if (status == STILL_ACTIVE)
 698         {
 699             /* FIXME: this is a bit brutal... some nicer way shall be found */
 700             switch (status = SuspendThread(thd->handle))
 701             {
 702             case -1: break;
 703             case 0:  strcpy(buffer, "Running"); break;
 704             default: sprintf(buffer, "Suspended (%lu)", status - 1);
 705             }
 706             ResumeThread(thd->handle);
 707         }
 708         else
 709             sprintf(buffer, "Terminated (exit code = %lu)", status);
 710     }
 711     else
 712     {
 713         strcpy(buffer, "Unknown threadID");
 714     }
 715     switch (prio = GetThreadPriority(thd->handle))
 716     {
 717     case THREAD_PRIORITY_ERROR_RETURN:  break;
 718     case THREAD_PRIORITY_ABOVE_NORMAL:  strcat(buffer, ", priority +1 above normal"); break;
 719     case THREAD_PRIORITY_BELOW_NORMAL:  strcat(buffer, ", priority -1 below normal"); break;
 720     case THREAD_PRIORITY_HIGHEST:       strcat(buffer, ", priority +2 above normal"); break;
 721     case THREAD_PRIORITY_LOWEST:        strcat(buffer, ", priority -2 below normal"); break;
 722     case THREAD_PRIORITY_IDLE:          strcat(buffer, ", priority idle"); break;
 723     case THREAD_PRIORITY_NORMAL:        strcat(buffer, ", priority normal"); break;
 724     case THREAD_PRIORITY_TIME_CRITICAL: strcat(buffer, ", priority time-critical"); break;
 725     default: sprintf(buffer + strlen(buffer), ", priority = %d", prio);
 726     }
 727     assert(strlen(buffer) < len);
 728 }
 729
 730 /* =============================================== *
 731  *          P A C K E T        U T I L S           *
 732  * =============================================== *
 733  */
 734
 735 enum packet_return {packet_error = 0x00, packet_ok = 0x01, packet_done = 0x02,
 736                     packet_last_f = 0x80};
 737
 738 static void packet_reply_grow(struct gdb_context* gdbctx, size_t size)
 739 {
 740     if (gdbctx->out_buf_alloc < gdbctx->out_len + size)
 741     {
 742         gdbctx->out_buf_alloc = ((gdbctx->out_len + size) / 32 + 1) * 32;
 743         gdbctx->out_buf = realloc(gdbctx->out_buf, gdbctx->out_buf_alloc);
 744     }
 745 }
 746
 747 static void packet_reply_hex_to(struct gdb_context* gdbctx, const void* src, int len)
 748 {
 749     packet_reply_grow(gdbctx, len * 2);
 750     hex_to(&gdbctx->out_buf[gdbctx->out_len], src, len);
 751     gdbctx->out_len += len * 2;
 752 }
 753
 754 static void packet_reply_val(struct gdb_context* gdbctx, unsigned long val, int len)
 755 {
 756     int i, shift;
 757
 758     shift = (len - 1) * 8;
 759     packet_reply_grow(gdbctx, len * 2);
 760     for (i = 0; i < len; i++, shift -= 8)
 761     {
 762         gdbctx->out_buf[gdbctx->out_len++] = hex_to0((val >> (shift + 4)) & 0x0F);
 763         gdbctx->out_buf[gdbctx->out_len++] = hex_to0((val >>  shift     ) & 0x0F);
 764     }
 765 }
 766
 767 static inline void packet_reply_add(struct gdb_context* gdbctx, const char* str, int len)
 768 {
 769     packet_reply_grow(gdbctx, len);
 770     memcpy(&gdbctx->out_buf[gdbctx->out_len], str, len);
 771     gdbctx->out_len += len;
 772 }
 773
 774 static inline void packet_reply_cat(struct gdb_context* gdbctx, const char* str)
 775 {
 776     packet_reply_add(gdbctx, str, strlen(str));
 777 }
 778
 779 static inline void packet_reply_catc(struct gdb_context* gdbctx, char ch)
 780 {
 781     packet_reply_add(gdbctx, &ch, 1);
 782 }
 783
 784 static void packet_reply_open(struct gdb_context* gdbctx)
 785 {
 786     assert(gdbctx->out_curr_packet == -1);
 787     packet_reply_catc(gdbctx, '$');
 788     gdbctx->out_curr_packet = gdbctx->out_len;
 789 }
 790
 791 static void packet_reply_close(struct gdb_context* gdbctx)
 792 {
 793     unsigned char       cksum;
 794     int plen;
 795
 796     plen = gdbctx->out_len - gdbctx->out_curr_packet;
 797     packet_reply_catc(gdbctx, '#');
 798     cksum = checksum(&gdbctx->out_buf[gdbctx->out_curr_packet], plen);
 799     packet_reply_hex_to(gdbctx, &cksum, 1);
 800     if (gdbctx->trace & GDBPXY_TRC_PACKET)
 801         fprintf(stderr, "Reply : %*.*s\n",
 802                 plen, plen, &gdbctx->out_buf[gdbctx->out_curr_packet]);
 803     gdbctx->out_curr_packet = -1;
 804 }
 805
 806 static enum packet_return packet_reply(struct gdb_context* gdbctx, const char* packet, int len)
 807 {
 808     packet_reply_open(gdbctx);
 809
 810     if (len == -1) len = strlen(packet);
 811     assert(memchr(packet, '$', len) == NULL && memchr(packet, '#', len) == NULL);
 812
 813     packet_reply_add(gdbctx, packet, len);
 814
 815     packet_reply_close(gdbctx);
 816
 817     return packet_done;
 818 }
 819
 820 static enum packet_return packet_reply_error(struct gdb_context* gdbctx, int error)
 821 {
 822     packet_reply_open(gdbctx);
 823
 824     packet_reply_add(gdbctx, "E", 1);
 825     packet_reply_val(gdbctx, error, 1);
 826
 827     packet_reply_close(gdbctx);
 828
 829     return packet_done;
 830 }
 831
 832 /* =============================================== *
 833  *          P A C K E T   H A N D L E R S          *
 834  * =============================================== *
 835  */
 836
 837 static enum packet_return packet_reply_status(struct gdb_context* gdbctx)
 838 {
 839     enum packet_return ret = packet_done;
 840
 841     packet_reply_open(gdbctx);
 842
 843     if (gdbctx->process != NULL)
 844     {
 845         unsigned char           sig;
 846         unsigned                i;
 847
 848         packet_reply_catc(gdbctx, 'T');
 849         sig = gdbctx->last_sig;
 850         packet_reply_val(gdbctx, sig, 1);
 851         packet_reply_add(gdbctx, "thread:", 7);
 852         packet_reply_val(gdbctx, DEBUG_CurrThread->tid, 4);
 853         packet_reply_catc(gdbctx, ';');
 854
 855         for (i = 0; i < cpu_num_regs; i++)
 856         {
 857             /* FIXME: this call will also grow the buffer...
 858              * unneeded, but not harmful
 859              */
 860             packet_reply_val(gdbctx, i, 1);
 861             packet_reply_catc(gdbctx, ':');
 862             packet_reply_hex_to(gdbctx, cpu_register(gdbctx, i), 4);
 863             packet_reply_catc(gdbctx, ';');
 864         }
 865     }
 866     else
 867     {
 868         /* Try to put an exit code
 869          * Cannot use GetExitCodeProcess, wouldn't fit in a 8 bit value, so
 870          * just indicate the end of process and exit */
 871         packet_reply_add(gdbctx, "W00", 3);
 872         /*if (!gdbctx->extended)*/ ret |= packet_last_f;
 873     }
 874
 875     packet_reply_close(gdbctx);
 876
 877     return ret;
 878 }
 879
 880 #if 0
 881 static enum packet_return packet_extended(struct gdb_context* gdbctx)
 882 {
 883     gdbctx->extended = 1;
 884     return packet_ok;
 885 }
 886 #endif
 887
 888 static enum packet_return packet_last_signal(struct gdb_context* gdbctx)
 889 {
 890     assert(gdbctx->in_packet_len == 0);
 891     return packet_reply_status(gdbctx);
 892 }
 893
 894 static enum packet_return packet_continue(struct gdb_context* gdbctx)
 895 {
 896     /* FIXME: add support for address in packet */
 897     assert(gdbctx->in_packet_len == 0);
 898     if (DEBUG_CurrThread->tid != gdbctx->exec_thread && gdbctx->exec_thread)
 899         if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
 900             fprintf(stderr, "NIY: cont on %u, while last thd is %lu\n",
 901                     gdbctx->exec_thread, DEBUG_CurrThread->tid);
 902     resume_debuggee(gdbctx, DBG_CONTINUE);
 903     wait_for_debuggee(gdbctx);
 904     return packet_reply_status(gdbctx);
 905 }
 906
 907 static enum packet_return packet_continue_signal(struct gdb_context* gdbctx)
 908 {
 909     unsigned char sig;
 910
 911     /* FIXME: add support for address in packet */
 912     assert(gdbctx->in_packet_len == 2);
 913     if (DEBUG_CurrThread->tid != gdbctx->exec_thread && gdbctx->exec_thread)
 914         if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
 915             fprintf(stderr, "NIY: cont/sig on %u, while last thd is %lu\n",
 916                     gdbctx->exec_thread, DEBUG_CurrThread->tid);
 917     hex_from(&sig, gdbctx->in_packet, 1);
 918     /* cannot change signals on the fly */
 919     if (gdbctx->trace & GDBPXY_TRC_COMMAND)
 920         fprintf(stderr, "sigs: %u %u\n", sig, gdbctx->last_sig);
 921     if (sig != gdbctx->last_sig)
 922         return packet_error;
 923     resume_debuggee(gdbctx, DBG_EXCEPTION_NOT_HANDLED);
 924     wait_for_debuggee(gdbctx);
 925     return packet_reply_status(gdbctx);
 926 }
 927
 928 static enum packet_return packet_detach(struct gdb_context* gdbctx)
 929 {
 930     detach_debuggee(gdbctx, FALSE);
 931     return packet_ok | packet_last_f;
 932 }
 933
 934 static enum packet_return packet_read_registers(struct gdb_context* gdbctx)
 935 {
 936     int                 i;
 937
 938     assert(gdbctx->in_trap);
 939     if (DEBUG_CurrThread->tid != gdbctx->other_thread && gdbctx->other_thread)
 940         if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
 941             fprintf(stderr, "NIY: read regs on %u, while last thd is %lu\n",
 942                     gdbctx->other_thread, DEBUG_CurrThread->tid);
 943
 944     packet_reply_open(gdbctx);
 945
 946     for (i = 0; i < cpu_num_regs; i++)
 947     {
 948         packet_reply_hex_to(gdbctx, cpu_register(gdbctx, i), 4);
 949     }
 950
 951     packet_reply_close(gdbctx);
 952     return packet_done;
 953 }
 954
 955 static enum packet_return packet_write_registers(struct gdb_context* gdbctx)
 956 {
 957     unsigned    i;
 958
 959     assert(gdbctx->in_trap);
 960     if (DEBUG_CurrThread->tid != gdbctx->other_thread && gdbctx->other_thread)
 961         if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
 962             fprintf(stderr, "NIY: write regs on %u, while last thd is %lu\n",
 963                     gdbctx->other_thread, DEBUG_CurrThread->tid);
 964     if (gdbctx->in_packet_len < cpu_num_regs * 2) return packet_error;
 965     for (i = 0; i < cpu_num_regs; i++)
 966         hex_from(cpu_register(gdbctx, i), &gdbctx->in_packet[8 * i], 4);
 967     return packet_ok;
 968 }
 969
 970 static enum packet_return packet_kill(struct gdb_context* gdbctx)
 971 {
 972     detach_debuggee(gdbctx, TRUE);
 973 #if 0
 974     if (!gdbctx->extended)
 975         /* dunno whether GDB cares or not */
 976 #endif
 977     wait(NULL);
 978     exit(0);
 979     /* assume we can't really answer something here */
 980     /* return packet_done; */
 981 }
 982
 983 static enum packet_return packet_thread(struct gdb_context* gdbctx)
 984 {
 985     char* end;
 986     unsigned thread;
 987
 988     switch (gdbctx->in_packet[0])
 989     {
 990     case 'c':
 991     case 'g':
 992         if (gdbctx->in_packet[1] == '-')
 993             thread = -strtol(gdbctx->in_packet + 2, &end, 16);
 994         else
 995             thread = strtol(gdbctx->in_packet + 1, &end, 16);
 996         if (end == NULL || end > gdbctx->in_packet + gdbctx->in_packet_len)
 997         {
 998             if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
 999                 fprintf(stderr, "Cannot get threadid %*.*s\n",
1000                         gdbctx->in_packet_len - 1, gdbctx->in_packet_len - 1,
1001                         gdbctx->in_packet + 1);
1002             return packet_error;
1003         }
1004         if (gdbctx->in_packet[0] == 'c')
1005             gdbctx->exec_thread = thread;
1006         else
1007             gdbctx->other_thread = thread;
1008         return packet_ok;
1009     default:
1010         if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1011             fprintf(stderr, "Unknown thread sub-command %c\n", gdbctx->in_packet[0]);
1012         return packet_error;
1013     }
1014 }
1015
1016 static enum packet_return packet_read_memory(struct gdb_context* gdbctx)
1017 {
1018     char               *addr;
1019     size_t              len, blk_len, nread;
1020     char                buffer[32];
1021     unsigned long       r = 0;
1022
1023     assert(gdbctx->in_trap);
1024     /* FIXME:check in_packet_len for reading %p,%x */
1025     if (sscanf(gdbctx->in_packet, "%p,%x", &addr, &len) != 2) return packet_error;
1026     if (gdbctx->trace & GDBPXY_TRC_COMMAND)
1027         fprintf(stderr, "read mem at %p for %u bytes\n", addr, len);
1028     for (nread = 0; nread < len > 0; nread += r, addr += r)
1029     {
1030         blk_len = min(sizeof(buffer), len - nread);
1031         if (!ReadProcessMemory(gdbctx->process->handle, addr, buffer, blk_len, &r) ||
1032             r == 0)
1033         {
1034             /* fail at first address, return error */
1035             if (nread == 0) return packet_reply_error(gdbctx, EFAULT);
1036             /* something has already been read, return partial information */
1037             break;
1038         }
1039         if (nread == 0) packet_reply_open(gdbctx);
1040         packet_reply_hex_to(gdbctx, buffer, r);
1041     }
1042     packet_reply_close(gdbctx);
1043     return packet_done;
1044 }
1045
1046 static enum packet_return packet_write_memory(struct gdb_context* gdbctx)
1047 {
1048     char*               addr;
1049     size_t              len, blk_len;
1050     char*               ptr;
1051     char                buffer[32];
1052     unsigned long       w;
1053
1054     assert(gdbctx->in_trap);
1055     ptr = memchr(gdbctx->in_packet, ':', gdbctx->in_packet_len);
1056     if (ptr == NULL)
1057     {
1058         if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1059             fprintf(stderr, "cannot find ':' in %*.*s\n",
1060                     gdbctx->in_packet_len, gdbctx->in_packet_len, gdbctx->in_packet);
1061         return packet_error;
1062     }
1063     *ptr++ = '\0';
1064
1065     if (sscanf(gdbctx->in_packet, "%p,%x", &addr, &len) != 2)
1066     {
1067         if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1068             fprintf(stderr, "cannot scan addr,len in %s\n", gdbctx->in_packet);
1069         return packet_error;
1070     }
1071     if (ptr - gdbctx->in_packet + len * 2 != gdbctx->in_packet_len)
1072     {
1073         if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1074             fprintf(stderr, "wrong sizes %u <> %u\n",
1075                     ptr - gdbctx->in_packet + len * 2, gdbctx->in_packet_len);
1076         return packet_error;
1077     }
1078     if (gdbctx->trace & GDBPXY_TRC_COMMAND)
1079         fprintf(stderr, "write %u bytes at %p\n", len, addr);
1080     while (len > 0)
1081     {
1082         blk_len = min(sizeof(buffer), len);
1083         hex_from(buffer, ptr, blk_len);
1084         {
1085             BOOL ret;
1086
1087             ret = WriteProcessMemory(gdbctx->process->handle, addr, buffer, blk_len, &w);
1088             if (!ret || w != blk_len)
1089                 break;
1090         }
1091         addr += w;
1092         len -= w;
1093         ptr += w;
1094     }
1095     return packet_ok; /* FIXME: error while writing ? */
1096 }
1097
1098 static enum packet_return packet_write_register(struct gdb_context* gdbctx)
1099 {
1100     unsigned            reg;
1101     char*               ptr;
1102     char*               end;
1103
1104     assert(gdbctx->in_trap);
1105     if (DEBUG_CurrThread->tid != gdbctx->other_thread && gdbctx->other_thread)
1106         if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1107             fprintf(stderr, "NIY: read reg on %u, while last thd is %lu\n",
1108                     gdbctx->other_thread, DEBUG_CurrThread->tid);
1109
1110     ptr = memchr(gdbctx->in_packet, '=', gdbctx->in_packet_len);
1111     *ptr++ = '\0';
1112     reg = strtoul(gdbctx->in_packet, &end, 16);
1113     if (end == NULL || reg > cpu_num_regs)
1114     {
1115         if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1116             fprintf(stderr, "invalid register index %s\n", gdbctx->in_packet);
1117         /* FIXME: if just the reg is above cpu_num_regs, don't tell gdb
1118          *        it wouldn't matter too much, and it fakes our support for all regs
1119          */
1120         return (end == NULL) ? packet_error : packet_ok;
1121     }
1122     if (ptr + 8 - gdbctx->in_packet != gdbctx->in_packet_len)
1123     {
1124         if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1125             fprintf(stderr, "wrong sizes %u <> %u\n",
1126                     ptr + 8 - gdbctx->in_packet, gdbctx->in_packet_len);
1127         return packet_error;
1128     }
1129     if (gdbctx->trace & GDBPXY_TRC_COMMAND)
1130         fprintf(stderr, "Writing reg %u <= %*.*s\n",
1131                 reg, gdbctx->in_packet_len - (ptr - gdbctx->in_packet),
1132                 gdbctx->in_packet_len - (ptr - gdbctx->in_packet), ptr);
1133     hex_from(cpu_register(gdbctx, reg), ptr, 4);
1134     return packet_ok;
1135 }
1136
1137 static void packet_query_monitor_wnd_helper(struct gdb_context* gdbctx, HWND hWnd, int indent)
1138 {
1139     char        buffer[128];
1140     char        clsName[128];
1141     char        wndName[128];
1142     HWND        child;
1143
1144     do {
1145        if (!GetClassName(hWnd, clsName, sizeof(clsName)))
1146           strcpy(clsName, "-- Unknown --");
1147        if (!GetWindowText(hWnd, wndName, sizeof(wndName)))
1148           strcpy(wndName, "-- Empty --");
1149
1150        packet_reply_open(gdbctx);
1151        packet_reply_catc(gdbctx, 'O');
1152        sprintf(buffer, "%*s%04x%*s%-17.17s %08lx %08lx %.14s\n",
1153                indent, "", (UINT)hWnd, 13 - indent, "",
1154                clsName, GetWindowLong(hWnd, GWL_STYLE),
1155                GetWindowLong(hWnd, GWL_WNDPROC), wndName);
1156        packet_reply_hex_to(gdbctx, buffer, strlen(buffer));
1157        packet_reply_close(gdbctx);
1158
1159        if ((child = GetWindow(hWnd, GW_CHILD)) != 0)
1160           packet_query_monitor_wnd_helper(gdbctx, child, indent + 1);
1161     } while ((hWnd = GetWindow(hWnd, GW_HWNDNEXT)) != 0);
1162 }
1163
1164 static void packet_query_monitor_wnd(struct gdb_context* gdbctx, int len, const char* str)
1165 {
1166     char        buffer[128];
1167
1168     /* we do the output in several 'O' packets, with the last one being just OK for
1169      * marking the end of the output */
1170     packet_reply_open(gdbctx);
1171     packet_reply_catc(gdbctx, 'O');
1172     sprintf(buffer, "%-16.16s %-17.17s %-8.8s %s\n",
1173             "hwnd", "Class Name", " Style", " WndProc Text");
1174     packet_reply_hex_to(gdbctx, buffer, strlen(buffer));
1175     packet_reply_close(gdbctx);
1176
1177     /* FIXME: could also add a pmt to this command in str... */
1178     packet_query_monitor_wnd_helper(gdbctx, GetDesktopWindow(), 0);
1179     packet_reply(gdbctx, "OK", 2);
1180 }
1181
1182 static void packet_query_monitor_process(struct gdb_context* gdbctx, int len, const char* str)
1183 {
1184     HANDLE              snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
1185     char                buffer[128];
1186     char                deco;
1187     PROCESSENTRY32      entry;
1188     BOOL                ok;
1189
1190     if (snap == INVALID_HANDLE_VALUE)
1191         return;
1192
1193     entry.dwSize = sizeof(entry);
1194     ok = Process32First( snap, &entry );
1195
1196     /* we do the output in several 'O' packets, with the last one being just OK for
1197      * marking the end of the output */
1198
1199     packet_reply_open(gdbctx);
1200     packet_reply_catc(gdbctx, 'O');
1201     sprintf(buffer, " %-8.8s %-8.8s %-8.8s %s\n",
1202             "pid", "threads", "parent", "executable" );
1203     packet_reply_hex_to(gdbctx, buffer, strlen(buffer));
1204     packet_reply_close(gdbctx);
1205
1206     while (ok)
1207     {
1208         deco = ' ';
1209         if (entry.th32ProcessID == gdbctx->process->pid) deco = '>';
1210         packet_reply_open(gdbctx);
1211         packet_reply_catc(gdbctx, 'O');
1212         sprintf(buffer, "%c%08lx %-8ld %08lx '%s'\n",
1213                 deco, entry.th32ProcessID, entry.cntThreads,
1214                 entry.th32ParentProcessID, entry.szExeFile);
1215         packet_reply_hex_to(gdbctx, buffer, strlen(buffer));
1216         packet_reply_close(gdbctx);
1217         ok = Process32Next(snap, &entry);
1218     }
1219     CloseHandle(snap);
1220     packet_reply(gdbctx, "OK", 2);
1221 }
1222
1223 static void packet_query_monitor_mem(struct gdb_context* gdbctx, int len, const char* str)
1224 {
1225     MEMORY_BASIC_INFORMATION    mbi;
1226     char*                       addr = 0;
1227     char*                       state;
1228     char*                       type;
1229     char                        prot[3+1];
1230     char                        buffer[128];
1231
1232     /* we do the output in several 'O' packets, with the last one being just OK for
1233      * marking the end of the output */
1234     packet_reply_open(gdbctx);
1235     packet_reply_catc(gdbctx, 'O');
1236     sprintf(buffer, "Address  Size     State   Type    RWX\n");
1237     packet_reply_hex_to(gdbctx, buffer, strlen(buffer));
1238     packet_reply_close(gdbctx);
1239
1240     while (VirtualQueryEx(gdbctx->process->handle, addr, &mbi, sizeof(mbi)) >= sizeof(mbi))
1241     {
1242         switch (mbi.State)
1243         {
1244         case MEM_COMMIT:        state = "commit "; break;
1245         case MEM_FREE:          state = "free   "; break;
1246         case MEM_RESERVE:       state = "reserve"; break;
1247         default:                state = "???    "; break;
1248         }
1249         if (mbi.State != MEM_FREE)
1250         {
1251             switch (mbi.Type)
1252             {
1253             case MEM_IMAGE:         type = "image  "; break;
1254             case MEM_MAPPED:        type = "mapped "; break;
1255             case MEM_PRIVATE:       type = "private"; break;
1256             case 0:                 type = "       "; break;
1257             default:                type = "???    "; break;
1258             }
1259             memset(prot, ' ' , sizeof(prot)-1);
1260             prot[sizeof(prot)-1] = '\0';
1261             if (mbi.AllocationProtect & (PAGE_READONLY|PAGE_READWRITE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE))
1262                 prot[0] = 'R';
1263             if (mbi.AllocationProtect & (PAGE_READWRITE|PAGE_EXECUTE_READWRITE))
1264                 prot[1] = 'W';
1265             if (mbi.AllocationProtect & (PAGE_WRITECOPY|PAGE_EXECUTE_WRITECOPY))
1266                 prot[1] = 'C';
1267             if (mbi.AllocationProtect & (PAGE_EXECUTE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE))
1268                 prot[2] = 'X';
1269         }
1270         else
1271         {
1272             type = "";
1273             prot[0] = '\0';
1274         }
1275         packet_reply_open(gdbctx);
1276         sprintf(buffer, "%08lx %08lx %s %s %s\n",
1277                 (DWORD)addr, mbi.RegionSize, state, type, prot);
1278         packet_reply_catc(gdbctx, 'O');
1279         packet_reply_hex_to(gdbctx, buffer, strlen(buffer));
1280         packet_reply_close(gdbctx);
1281
1282         if (addr + mbi.RegionSize < addr) /* wrap around ? */
1283             break;
1284         addr += mbi.RegionSize;
1285     }
1286     packet_reply(gdbctx, "OK", 2);
1287 }
1288
1289 static void packet_query_monitor_trace(struct gdb_context* gdbctx,
1290                                        int len, const char* str)
1291 {
1292     char        buffer[128];
1293
1294     if (len == 0)
1295     {
1296         sprintf(buffer, "trace=%x\n", gdbctx->trace);
1297     }
1298     else if (len >= 2 && str[0] == '=')
1299     {
1300         unsigned val = atoi(&str[1]);
1301         sprintf(buffer, "trace: %x => %x\n", gdbctx->trace, val);
1302         gdbctx->trace = val;
1303     }
1304     else
1305     {
1306         /* FIXME: ugly but can use error packet here */
1307         packet_reply_cat(gdbctx, "E00");
1308         return;
1309     }
1310     packet_reply_open(gdbctx);
1311     packet_reply_hex_to(gdbctx, buffer, strlen(buffer));
1312     packet_reply_close(gdbctx);
1313 }
1314
1315 #ifdef __i386__
1316 static void packet_query_monitor_linear(struct gdb_context* gdbctx,
1317                                        int len, const char* str)
1318 {
1319     unsigned    seg, ofs;
1320     LDT_ENTRY   le;
1321     unsigned    linear;
1322     char        buffer[32];
1323
1324     while (len > 0 && (*str == ' ' || *str == '\t'))
1325     {
1326         str++; len--;
1327     }
1328     /* FIXME: do a better scanning (allow both decimal and hex numbers) */
1329     if (!len || sscanf(str, "%x:%x", &seg, &ofs) != 2)
1330     {
1331         packet_reply_error(gdbctx, 0);
1332         return;
1333     }
1334
1335     /* V86 mode ? */
1336     if (gdbctx->context.EFlags & 0x00020000) linear = (LOWORD(seg) << 4) + ofs;
1337     /* linux system selector ? */
1338     else if (!(seg & 4) || ((seg >> 3) < 17)) linear = ofs;
1339     /* standard selector */
1340     else if (GetThreadSelectorEntry(gdbctx->process->threads->handle, seg, &le))
1341         linear = (le.HighWord.Bits.BaseHi << 24) + (le.HighWord.Bits.BaseMid << 16) +
1342             le.BaseLow + ofs;
1343     /* error */
1344     else linear = 0;
1345     sprintf(buffer, "0x%x", linear);
1346     packet_reply_open(gdbctx);
1347     packet_reply_hex_to(gdbctx, buffer, strlen(buffer));
1348     packet_reply_close(gdbctx);
1349 }
1350 #endif
1351
1352 struct query_detail
1353 {
1354     int         with_arg;
1355     const char* name;
1356     size_t      len;
1357     void        (*handler)(struct gdb_context*, int, const char*);
1358 } query_details[] =
1359 {
1360     {0, "wnd",     3, packet_query_monitor_wnd},
1361     {0, "window",  6, packet_query_monitor_wnd},
1362     {0, "proc",    4, packet_query_monitor_process},
1363     {0, "process", 7, packet_query_monitor_process},
1364     {0, "mem",     3, packet_query_monitor_mem},
1365     {1, "trace",   5, packet_query_monitor_trace},
1366 #ifdef __i386__
1367     {1, "linear",  6, packet_query_monitor_linear},
1368 #endif
1369     {0, NULL,      0, NULL},
1370 };
1371
1372 static enum packet_return packet_query_remote_command(struct gdb_context* gdbctx,
1373                                                       const char* hxcmd, size_t len)
1374 {
1375     char                        buffer[128];
1376     struct query_detail*        qd;
1377
1378     assert((len & 1) == 0 && len < 2 * sizeof(buffer));
1379     len /= 2;
1380     hex_from(buffer, hxcmd, len);
1381
1382     for (qd = &query_details[0]; qd->name != NULL; qd++)
1383     {
1384         if (len < qd->len || strncmp(buffer, qd->name, qd->len) != 0) continue;
1385         if (!qd->with_arg && len != qd->len) continue;
1386
1387         (qd->handler)(gdbctx, len - qd->len, buffer + qd->len);
1388         return packet_done;
1389     }
1390     return packet_reply_error(gdbctx, EINVAL);
1391 }
1392
1393 static enum packet_return packet_query(struct gdb_context* gdbctx)
1394 {
1395     switch (gdbctx->in_packet[0])
1396     {
1397     case 'f':
1398         if (strncmp(gdbctx->in_packet + 1, "ThreadInfo", gdbctx->in_packet_len - 1) == 0)
1399         {
1400             DBG_THREAD* thd;
1401
1402             packet_reply_open(gdbctx);
1403             packet_reply_add(gdbctx, "m", 1);
1404             for (thd = gdbctx->process->threads; thd; thd = thd->next)
1405             {
1406                 packet_reply_val(gdbctx, thd->tid, 4);
1407                 if (thd->next != NULL)
1408                     packet_reply_add(gdbctx, ",", 1);
1409             }
1410             packet_reply_close(gdbctx);
1411             return packet_done;
1412         }
1413         else if (strncmp(gdbctx->in_packet + 1, "ProcessInfo", gdbctx->in_packet_len - 1) == 0)
1414         {
1415             char        result[128];
1416
1417             packet_reply_open(gdbctx);
1418             packet_reply_catc(gdbctx, 'O');
1419             get_process_info(gdbctx, result, sizeof(result));
1420             packet_reply_hex_to(gdbctx, result, strlen(result));
1421             packet_reply_close(gdbctx);
1422             return packet_done;
1423         }
1424         break;
1425     case 's':
1426         if (strncmp(gdbctx->in_packet + 1, "ThreadInfo", gdbctx->in_packet_len - 1) == 0)
1427         {
1428             packet_reply(gdbctx, "l", 1);
1429             return packet_done;
1430         }
1431         else if (strncmp(gdbctx->in_packet + 1, "ProcessInfo", gdbctx->in_packet_len - 1) == 0)
1432         {
1433             packet_reply(gdbctx, "l", 1);
1434             return packet_done;
1435         }
1436         break;
1437     case 'C':
1438         if (gdbctx->in_packet_len == 1)
1439         {
1440             DBG_THREAD* thd;
1441             /* FIXME: doc says 16 bit val ??? */
1442             /* grab first created thread, aka last in list */
1443             assert(gdbctx->process && gdbctx->process->threads);
1444             for (thd = gdbctx->process->threads; thd->next; thd = thd->next);
1445             packet_reply_open(gdbctx);
1446             packet_reply_add(gdbctx, "QC", 2);
1447             packet_reply_val(gdbctx, thd->tid, 4);
1448             packet_reply_close(gdbctx);
1449             return packet_done;
1450         }
1451         break;
1452     case 'O':
1453         if (strncmp(gdbctx->in_packet, "Offsets", gdbctx->in_packet_len) == 0)
1454         {
1455             char    buf[64];
1456
1457             if (gdbctx->wine_segs[0] == 0 && gdbctx->wine_segs[1] == 0 &&
1458                 gdbctx->wine_segs[2] == 0)
1459                 return packet_error;
1460             sprintf(buf, "Text=%08lx;Data=%08lx;Bss=%08lx",
1461                     gdbctx->wine_segs[0], gdbctx->wine_segs[1],
1462                     gdbctx->wine_segs[2]);
1463             return packet_reply(gdbctx, buf, -1);
1464         }
1465         break;
1466     case 'R':
1467         if (gdbctx->in_packet_len > 5 && strncmp(gdbctx->in_packet, "Rcmd,", 5) == 0)
1468         {
1469             return packet_query_remote_command(gdbctx, gdbctx->in_packet + 5,
1470                                                gdbctx->in_packet_len - 5);
1471         }
1472         break;
1473     case 'S':
1474         if (strncmp(gdbctx->in_packet, "Symbol::", gdbctx->in_packet_len) == 0)
1475             return packet_ok;
1476         break;
1477     case 'T':
1478         if (gdbctx->in_packet_len > 15 &&
1479             strncmp(gdbctx->in_packet, "ThreadExtraInfo", 15) == 0 &&
1480             gdbctx->in_packet[15] == ',')
1481         {
1482             unsigned    tid;
1483             char*       end;
1484             char        result[128];
1485
1486             tid = strtol(gdbctx->in_packet + 16, &end, 16);
1487             if (end == NULL) break;
1488             get_thread_info(gdbctx, tid, result, sizeof(result));
1489             packet_reply_open(gdbctx);
1490             packet_reply_hex_to(gdbctx, result, strlen(result));
1491             packet_reply_close(gdbctx);
1492             return packet_done;
1493         }
1494         break;
1495     }
1496     if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1497         fprintf(stderr, "Unknown or malformed query %*.*s\n",
1498                 gdbctx->in_packet_len, gdbctx->in_packet_len, gdbctx->in_packet);
1499     return packet_error;
1500 }
1501
1502 static enum packet_return packet_step(struct gdb_context* gdbctx)
1503 {
1504     /* FIXME: add support for address in packet */
1505     assert(gdbctx->in_packet_len == 0);
1506     if (DEBUG_CurrThread->tid != gdbctx->exec_thread && gdbctx->exec_thread)
1507         if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1508             fprintf(stderr, "NIY: step on %u, while last thd is %lu\n",
1509                     gdbctx->exec_thread, DEBUG_CurrThread->tid);
1510     if (!cpu_enter_stepping(gdbctx)) return packet_error;
1511     resume_debuggee(gdbctx, DBG_CONTINUE);
1512     wait_for_debuggee(gdbctx);
1513     if (!cpu_leave_stepping(gdbctx)) return packet_error;
1514     return packet_reply_status(gdbctx);
1515 }
1516
1517 #if 0
1518 static enum packet_return packet_step_signal(struct gdb_context* gdbctx)
1519 {
1520     unsigned char sig;
1521
1522     /* FIXME: add support for address in packet */
1523     assert(gdbctx->in_packet_len == 2);
1524     if (DEBUG_CurrThread->tid != gdbctx->exec_thread && gdbctx->exec_thread)
1525         if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1526             fprintf(stderr, "NIY: step/sig on %u, while last thd is %u\n",
1527                     gdbctx->exec_thread, DEBUG_CurrThread->tid);
1528     hex_from(&sig, gdbctx->in_packet, 1);
1529     /* cannot change signals on the fly */
1530     if (gdbctx->trace & GDBPXY_TRC_COMMAND)
1531         fprintf(stderr, "sigs: %u %u\n", sig, gdbctx->last_sig);
1532     if (sig != gdbctx->last_sig)
1533         return packet_error;
1534     resume_debuggee(gdbctx, DBG_EXCEPTION_NOT_HANDLED);
1535     wait_for_debuggee(gdbctx);
1536     return packet_reply_status(gdbctx);
1537 }
1538 #endif
1539
1540 static enum packet_return packet_thread_alive(struct gdb_context* gdbctx)
1541 {
1542     char*       end;
1543     unsigned    tid;
1544
1545     tid = strtol(gdbctx->in_packet, &end, 16);
1546     if (tid == -1 || tid == 0)
1547         return packet_reply_error(gdbctx, EINVAL);
1548     if (DEBUG_GetThread(gdbctx->process, tid) != NULL)
1549         return packet_ok;
1550     return packet_reply_error(gdbctx, ESRCH);
1551 }
1552
1553 static enum packet_return packet_remove_breakpoint(struct gdb_context* gdbctx)
1554 {
1555     void*                       addr;
1556     unsigned                    len;
1557     struct gdb_ctx_Xpoint*      xpt;
1558
1559     /* FIXME: check packet_len */
1560     if (gdbctx->in_packet[0] < '0' || gdbctx->in_packet[0] > '4' ||
1561         gdbctx->in_packet[1] != ',' ||
1562         sscanf(gdbctx->in_packet + 2, "%p,%x", &addr, &len) != 2)
1563         return packet_error;
1564     if (gdbctx->trace & GDBPXY_TRC_COMMAND)
1565         fprintf(stderr, "remove bp %p[%u] typ=%c\n",
1566                 addr, len, gdbctx->in_packet[0]);
1567     for (xpt = &gdbctx->Xpoints[NUM_XPOINT - 1]; xpt >= gdbctx->Xpoints; xpt--)
1568     {
1569         if (xpt->addr == addr && xpt->type == gdbctx->in_packet[0])
1570         {
1571             switch (cpu_remove_Xpoint(gdbctx, xpt, len))
1572             {
1573             case  1:    xpt->type = -1; return packet_ok;
1574             case  0:                    return packet_error;
1575             case -1:                    return packet_done;
1576             default:                    assert(0);
1577             }
1578         }
1579     }
1580     return packet_error;
1581 }
1582
1583 static enum packet_return packet_set_breakpoint(struct gdb_context* gdbctx)
1584 {
1585     void*                       addr;
1586     unsigned                    len;
1587     struct gdb_ctx_Xpoint*      xpt;
1588
1589     /* FIXME: check packet_len */
1590     if (gdbctx->in_packet[0] < '0' || gdbctx->in_packet[0] > '4' ||
1591         gdbctx->in_packet[1] != ',' ||
1592         sscanf(gdbctx->in_packet + 2, "%p,%x", &addr, &len) != 2)
1593         return packet_error;
1594     if (gdbctx->trace & GDBPXY_TRC_COMMAND)
1595         fprintf(stderr, "set bp %p[%u] typ=%c\n",
1596                 addr, len, gdbctx->in_packet[0]);
1597     /* because of packet command handling, this should be made idempotent */
1598     for (xpt = &gdbctx->Xpoints[NUM_XPOINT - 1]; xpt >= gdbctx->Xpoints; xpt--)
1599     {
1600         if (xpt->addr == addr && xpt->type == gdbctx->in_packet[0])
1601             return packet_ok; /* nothing to do */
1602     }
1603     /* really set the Xpoint */
1604     for (xpt = &gdbctx->Xpoints[NUM_XPOINT - 1]; xpt >= gdbctx->Xpoints; xpt--)
1605     {
1606         if (xpt->type == -1)
1607         {
1608             xpt->addr = addr;
1609             xpt->type = gdbctx->in_packet[0];
1610             switch (cpu_insert_Xpoint(gdbctx, xpt, len))
1611             {
1612             case  1:    return packet_ok;
1613             case  0:    return packet_error;
1614             case -1:    return packet_done;
1615             default: assert(0);
1616             }
1617         }
1618     }
1619     /* no more entries... eech */
1620     fprintf(stderr, "Running out of spot for {break|watcgh}points\n");
1621     return packet_error;
1622 }
1623
1624 /* =============================================== *
1625  *    P A C K E T  I N F R A S T R U C T U R E     *
1626  * =============================================== *
1627  */
1628
1629 struct packet_entry
1630 {
1631     char                key;
1632     enum packet_return  (*handler)(struct gdb_context* gdbctx);
1633 };
1634
1635 static struct packet_entry packet_entries[] =
1636 {
1637 /*        {'!', packet_extended}, */
1638         {'?', packet_last_signal},
1639         {'c', packet_continue},
1640         {'C', packet_continue_signal},
1641         {'D', packet_detach},
1642         {'g', packet_read_registers},
1643         {'G', packet_write_registers},
1644         {'k', packet_kill},
1645         {'H', packet_thread},
1646         {'m', packet_read_memory},
1647         {'M', packet_write_memory},
1648         /* {'p', packet_read_register}, doesn't seem needed */
1649         {'P', packet_write_register},
1650         {'q', packet_query},
1651         {'s', packet_step},
1652         /*{'S', packet_step_signal}, hard(er) to implement */
1653         {'T', packet_thread_alive},
1654         {'z', packet_remove_breakpoint},
1655         {'Z', packet_set_breakpoint},
1656 };
1657
1658 static BOOL extract_packets(struct gdb_context* gdbctx)
1659 {
1660     char*               end;
1661     int                 plen;
1662     unsigned char       in_cksum, loc_cksum;
1663     char*               ptr;
1664     enum packet_return  ret = packet_error;
1665
1666     while ((ret & packet_last_f) == 0)
1667     {
1668         if (gdbctx->in_len && (gdbctx->trace & GDBPXY_TRC_LOWLEVEL))
1669             fprintf(stderr, "in-buf: %*.*s\n",
1670                     gdbctx->in_len, gdbctx->in_len, gdbctx->in_buf);
1671         ptr = memchr(gdbctx->in_buf, '$', gdbctx->in_len);
1672         if (ptr == NULL) return FALSE;
1673         if (ptr != gdbctx->in_buf)
1674         {
1675             int glen = ptr - gdbctx->in_buf; /* garbage len */
1676             if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
1677                 fprintf(stderr, "removing garbage: %*.*s\n",
1678                         glen, glen, gdbctx->in_buf);
1679             gdbctx->in_len -= glen;
1680             memmove(gdbctx->in_buf, ptr, gdbctx->in_len);
1681         }
1682         end = memchr(gdbctx->in_buf + 1, '#', gdbctx->in_len);
1683         if (end == NULL) return FALSE;
1684         /* no checksum yet */
1685         if (end + 3 > gdbctx->in_buf + gdbctx->in_len) return FALSE;
1686         plen = end - gdbctx->in_buf - 1;
1687         hex_from(&in_cksum, end + 1, 1);
1688         loc_cksum = checksum(gdbctx->in_buf + 1, plen);
1689         if (loc_cksum == in_cksum)
1690         {
1691             int                 i;
1692
1693             ret = packet_error;
1694
1695             write(gdbctx->sock, "+", 1);
1696             assert(plen);
1697
1698             /* FIXME: should use bsearch if packet_entries was sorted */
1699             for (i = 0; i < sizeof(packet_entries)/sizeof(packet_entries[0]); i++)
1700             {
1701                 if (packet_entries[i].key == gdbctx->in_buf[1]) break;
1702             }
1703             if (i == sizeof(packet_entries)/sizeof(packet_entries[0]))
1704             {
1705                 if (gdbctx->trace & GDBPXY_TRC_PACKET)
1706                     fprintf(stderr, "Unknown packet request %*.*s\n",
1707                             plen, plen, &gdbctx->in_buf[1]);
1708             }
1709             else
1710             {
1711                 gdbctx->in_packet = gdbctx->in_buf + 2;
1712                 gdbctx->in_packet_len = plen - 1;
1713                 if (gdbctx->trace & GDBPXY_TRC_PACKET)
1714                     fprintf(stderr, "Packet: %c%*.*s\n",
1715                             gdbctx->in_buf[1],
1716                             gdbctx->in_packet_len, gdbctx->in_packet_len,
1717                             gdbctx->in_packet);
1718                 ret = (packet_entries[i].handler)(gdbctx);
1719             }
1720             switch (ret & ~packet_last_f)
1721             {
1722             case packet_error:  packet_reply(gdbctx, "", 0); break;
1723             case packet_ok:     packet_reply(gdbctx, "OK", 2); break;
1724             case packet_done:   break;
1725             }
1726             if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
1727                 fprintf(stderr, "reply-full: %*.*s\n",
1728                         gdbctx->out_len, gdbctx->out_len, gdbctx->out_buf);
1729             i = write(gdbctx->sock, gdbctx->out_buf, gdbctx->out_len);
1730             assert(i == gdbctx->out_len);
1731             /* if this fails, we'll have to use POLLOUT...
1732              */
1733             gdbctx->out_len = 0;
1734         }
1735         else if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
1736         {
1737             write(gdbctx->sock, "+", 1);
1738             fprintf(stderr, "dropping packet, invalid checksum %d <> %d\n", in_cksum, loc_cksum);
1739         }
1740         gdbctx->in_len -= plen + 4;
1741         memmove(gdbctx->in_buf, end + 3, gdbctx->in_len);
1742     }
1743     return TRUE;
1744 }
1745
1746 static int fetch_data(struct gdb_context* gdbctx)
1747 {
1748     int len, in_len = gdbctx->in_len;
1749
1750     assert(gdbctx->in_len <= gdbctx->in_buf_alloc);
1751     for (;;)
1752     {
1753 #define STEP 128
1754         if (gdbctx->in_len + STEP > gdbctx->in_buf_alloc)
1755             gdbctx->in_buf = realloc(gdbctx->in_buf, gdbctx->in_buf_alloc += STEP);
1756 #undef STEP
1757         if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
1758             fprintf(stderr, "%d %d %*.*s\n",
1759                     gdbctx->in_len, gdbctx->in_buf_alloc,
1760                     gdbctx->in_len, gdbctx->in_len, gdbctx->in_buf);
1761         len = read(gdbctx->sock, gdbctx->in_buf + gdbctx->in_len, gdbctx->in_buf_alloc - gdbctx->in_len);
1762         if (len <= 0) break;
1763         gdbctx->in_len += len;
1764         assert(gdbctx->in_len <= gdbctx->in_buf_alloc);
1765         if (len < gdbctx->in_buf_alloc - gdbctx->in_len) break;
1766     }
1767     if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
1768         fprintf(stderr, "=> %d\n", gdbctx->in_len - in_len);
1769     return gdbctx->in_len - in_len;
1770 }
1771
1772 static BOOL gdb_startup(struct gdb_context* gdbctx, DEBUG_EVENT* de, unsigned flags)
1773 {
1774     int                 sock;
1775     struct sockaddr_in  s_addr;
1776     socklen_t           s_len = sizeof(s_addr);
1777     struct pollfd       pollfd;
1778     char                wine_path[MAX_PATH];
1779     char*               ptr;
1780
1781     /* step 1: create socket for gdb connection request */
1782     if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
1783     {
1784         if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
1785             fprintf(stderr, "Can't create socket");
1786         return FALSE;
1787     }
1788
1789     if (listen(sock, 1) == -1 ||
1790         getsockname(sock, (struct sockaddr*)&s_addr, &s_len) == -1)
1791         return FALSE;
1792
1793     /* step 2: find out wine executable location (as a Unix filename) */
1794     ptr = getenv("WINELOADER");
1795     strcpy(wine_path, ptr ? ptr : "wine");
1796
1797     fprintf(stderr, "using wine_path: %s\n", wine_path);
1798     read_elf_info(wine_path, gdbctx->wine_segs);
1799
1800     /* step 3: fire up gdb (if requested) */
1801     if (flags & 1)
1802         fprintf(stderr, "target remote localhost:%d\n", ntohs(s_addr.sin_port));
1803     else
1804         switch (fork())
1805         {
1806         case -1: /* error in parent... */
1807             fprintf(stderr, "Cannot create gdb\n");
1808             return FALSE;
1809             break;
1810         default: /* in parent... success */
1811             break;
1812         case 0: /* in child... and alive */
1813             {
1814                 char    buf[MAX_PATH];
1815                 char*   gdb_path;
1816                 FILE*   f;
1817
1818                 if (!(gdb_path = getenv("WINE_GDB"))) gdb_path = "gdb";
1819                 if (!tmpnam(buf) || (f = fopen(buf, "w+")) == NULL) return FALSE;
1820                 fprintf(f, "file %s\n", wine_path);
1821                 fprintf(f, "target remote localhost:%d\n", ntohs(s_addr.sin_port));
1822                 fprintf(f, "monitor trace=0\n");
1823                 fprintf(f, "set prompt Wine-gdb>\\ \n");
1824                 /* tell gdb to delete this file when done handling it... */
1825                 fprintf(f, "shell rm -f \"%s\"\n", buf);
1826                 fclose(f);
1827                 if (flags & 2)
1828                     execlp("xterm", "xterm", "-e", gdb_path, "-x", buf, NULL);
1829                 else
1830                     execlp(gdb_path, gdb_path, "-x", buf, NULL);
1831                 assert(0); /* never reached */
1832                 break;
1833             }
1834             break;
1835         }
1836
1837     /* step 4: do the process internal creation */
1838     handle_debug_event(gdbctx, de);
1839
1840     /* step 5: wait for gdb to connect actually */
1841     pollfd.fd = sock;
1842     pollfd.events = POLLIN;
1843     pollfd.revents = 0;
1844
1845     switch (poll(&pollfd, 1, -1))
1846     {
1847     case 1:
1848         if (pollfd.revents & POLLIN)
1849         {
1850             int dummy = 1;
1851             gdbctx->sock = accept(sock, (struct sockaddr*)&s_addr, &s_len);
1852             if (gdbctx->sock == -1)
1853                 break;
1854             if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
1855                 fprintf(stderr, "Connected on %d\n", gdbctx->sock);
1856             /* don't keep our small packets too long: send them ASAP back to GDB
1857              * without this, GDB really crawls
1858              */
1859             setsockopt(gdbctx->sock, IPPROTO_TCP, TCP_NODELAY, (char*)&dummy, sizeof(dummy));
1860         }
1861         break;
1862     case 0:
1863         if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
1864             fprintf(stderr, "poll for cnx failed (timeout)\n");
1865         return FALSE;
1866     case -1:
1867         if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
1868             fprintf(stderr, "poll for cnx failed (error)\n");
1869         return FALSE;
1870     default:
1871         assert(0);
1872     }
1873
1874     close(sock);
1875     return TRUE;
1876 }
1877
1878 static BOOL gdb_init_context(struct gdb_context* gdbctx, unsigned flags)
1879 {
1880     DEBUG_EVENT         de;
1881     int                 i;
1882
1883     gdbctx->sock = -1;
1884     gdbctx->in_buf = NULL;
1885     gdbctx->in_buf_alloc = 0;
1886     gdbctx->in_len = 0;
1887     gdbctx->out_buf = NULL;
1888     gdbctx->out_buf_alloc = 0;
1889     gdbctx->out_len = 0;
1890     gdbctx->out_curr_packet = -1;
1891
1892     gdbctx->exec_thread = gdbctx->other_thread = 0;
1893     gdbctx->last_sig = 0;
1894     gdbctx->in_trap = FALSE;
1895     gdbctx->trace = /*GDBPXY_TRC_PACKET | GDBPXY_TRC_COMMAND |*/ GDBPXY_TRC_COMMAND_ERROR | GDBPXY_TRC_WIN32_EVENT;
1896     gdbctx->process = NULL;
1897     for (i = 0; i < NUM_XPOINT; i++)
1898         gdbctx->Xpoints[i].type = -1;
1899
1900     /* wait for first trap */
1901     while (WaitForDebugEvent(&de, INFINITE))
1902     {
1903         if (de.dwDebugEventCode == CREATE_PROCESS_DEBUG_EVENT)
1904         {
1905             /* this should be the first event we get,
1906              * and the only one of this type  */
1907             assert(gdbctx->process == NULL && de.dwProcessId == DEBUG_CurrPid);
1908             //gdbctx->dwProcessId = pid;
1909             if (!gdb_startup(gdbctx, &de, flags)) return FALSE;
1910             assert(!gdbctx->in_trap);
1911         }
1912         else
1913         {
1914             handle_debug_event(gdbctx, &de);
1915             if (gdbctx->in_trap) break;
1916         }
1917         ContinueDebugEvent(de.dwProcessId, de.dwThreadId, DBG_CONTINUE);
1918     }
1919     return TRUE;
1920 }
1921
1922 BOOL DEBUG_GdbRemote(unsigned flags)
1923 {
1924     struct pollfd       pollfd;
1925     struct gdb_context  gdbctx;
1926     BOOL                doLoop;
1927
1928     for (doLoop = gdb_init_context(&gdbctx, flags); doLoop;)
1929     {
1930         pollfd.fd = gdbctx.sock;
1931         pollfd.events = POLLIN;
1932         pollfd.revents = 0;
1933
1934         switch (poll(&pollfd, 1, -1))
1935         {
1936         case 1:
1937             /* got something */
1938             if (pollfd.revents & (POLLHUP | POLLERR))
1939             {
1940                 if (gdbctx.trace & GDBPXY_TRC_LOWLEVEL)
1941                     fprintf(stderr, "Gdb hung up\n");
1942                 /* kill also debuggee process - questionnable - */
1943                 detach_debuggee(&gdbctx, TRUE);
1944                 doLoop = FALSE;
1945                 break;
1946             }
1947             if ((pollfd.revents & POLLIN) && fetch_data(&gdbctx) > 0)
1948             {
1949                 if (extract_packets(&gdbctx)) doLoop = FALSE;
1950             }
1951             break;
1952         case 0:
1953             /* timeout, should never happen (infinite timeout) */
1954             break;
1955         case -1:
1956             if (gdbctx.trace & GDBPXY_TRC_LOWLEVEL)
1957                 fprintf(stderr, "poll failed\n");
1958             doLoop = FALSE;
1959             break;
1960         }
1961     }
1962     wait(NULL);
1963     return 0;
1964 }