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