gdb/gdbserver/server.c

   1 /* Main code for remote server for GDB.
   2    Copyright (C) 1989, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2002, 2003,
   3    2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "server.h"
  21
  22 #if HAVE_UNISTD_H
  23 #include <unistd.h>
  24 #endif
  25 #if HAVE_SIGNAL_H
  26 #include <signal.h>
  27 #endif
  28 #if HAVE_SYS_WAIT_H
  29 #include <sys/wait.h>
  30 #endif
  31 #if HAVE_MALLOC_H
  32 #include <malloc.h>
  33 #endif
  34
  35 unsigned long cont_thread;
  36 unsigned long general_thread;
  37 unsigned long step_thread;
  38 unsigned long thread_from_wait;
  39 unsigned long old_thread_from_wait;
  40 int server_waiting;
  41
  42 static int extended_protocol;
  43 static int attached;
  44 static int response_needed;
  45 static int exit_requested;
  46
  47 static char **program_argv, **wrapper_argv;
  48
  49 /* Enable miscellaneous debugging output.  The name is historical - it
  50    was originally used to debug LinuxThreads support.  */
  51 int debug_threads;
  52
  53 int pass_signals[TARGET_SIGNAL_LAST];
  54
  55 jmp_buf toplevel;
  56
  57 const char *gdbserver_xmltarget;
  58
  59 /* The PID of the originally created or attached inferior.  Used to
  60    send signals to the process when GDB sends us an asynchronous interrupt
  61    (user hitting Control-C in the client), and to wait for the child to exit
  62    when no longer debugging it.  */
  63
  64 unsigned long signal_pid;
  65
  66 #ifdef SIGTTOU
  67 /* A file descriptor for the controlling terminal.  */
  68 int terminal_fd;
  69
  70 /* TERMINAL_FD's original foreground group.  */
  71 pid_t old_foreground_pgrp;
  72
  73 /* Hand back terminal ownership to the original foreground group.  */
  74
  75 static void
  76 restore_old_foreground_pgrp (void)
  77 {
  78   tcsetpgrp (terminal_fd, old_foreground_pgrp);
  79 }
  80 #endif
  81
  82 /* Set if you want to disable optional thread related packets support
  83    in gdbserver, for the sake of testing GDB against stubs that don't
  84    support them.  */
  85 int disable_packet_vCont;
  86 int disable_packet_Tthread;
  87 int disable_packet_qC;
  88 int disable_packet_qfThreadInfo;
  89
  90 static int
  91 target_running (void)
  92 {
  93   return all_threads.head != NULL;
  94 }
  95
  96 static int
  97 start_inferior (char **argv, char *statusptr)
  98 {
  99   char **new_argv = argv;
 100   attached = 0;
 101
 102   if (wrapper_argv != NULL)
 103     {
 104       int i, count = 1;
 105
 106       for (i = 0; wrapper_argv[i] != NULL; i++)
 107         count++;
 108       for (i = 0; argv[i] != NULL; i++)
 109         count++;
 110       new_argv = alloca (sizeof (char *) * count);
 111       count = 0;
 112       for (i = 0; wrapper_argv[i] != NULL; i++)
 113         new_argv[count++] = wrapper_argv[i];
 114       for (i = 0; argv[i] != NULL; i++)
 115         new_argv[count++] = argv[i];
 116       new_argv[count] = NULL;
 117     }
 118
 119 #ifdef SIGTTOU
 120   signal (SIGTTOU, SIG_DFL);
 121   signal (SIGTTIN, SIG_DFL);
 122 #endif
 123
 124   signal_pid = create_inferior (new_argv[0], new_argv);
 125
 126   /* FIXME: we don't actually know at this point that the create
 127      actually succeeded.  We won't know that until we wait.  */
 128   fprintf (stderr, "Process %s created; pid = %ld\n", argv[0],
 129            signal_pid);
 130   fflush (stderr);
 131
 132 #ifdef SIGTTOU
 133   signal (SIGTTOU, SIG_IGN);
 134   signal (SIGTTIN, SIG_IGN);
 135   terminal_fd = fileno (stderr);
 136   old_foreground_pgrp = tcgetpgrp (terminal_fd);
 137   tcsetpgrp (terminal_fd, signal_pid);
 138   atexit (restore_old_foreground_pgrp);
 139 #endif
 140
 141   if (wrapper_argv != NULL)
 142     {
 143       struct thread_resume resume_info;
 144       int sig;
 145
 146       resume_info.thread = -1;
 147       resume_info.step = 0;
 148       resume_info.sig = 0;
 149       resume_info.leave_stopped = 0;
 150
 151       sig = mywait (statusptr, 0);
 152       if (*statusptr != 'T')
 153         return sig;
 154
 155       do
 156         {
 157           (*the_target->resume) (&resume_info);
 158
 159           sig = mywait (statusptr, 0);
 160           if (*statusptr != 'T')
 161             return sig;
 162         }
 163       while (sig != TARGET_SIGNAL_TRAP);
 164
 165       return sig;
 166     }
 167
 168   /* Wait till we are at 1st instruction in program, return signal
 169      number (assuming success).  */
 170   return mywait (statusptr, 0);
 171 }
 172
 173 static int
 174 attach_inferior (int pid, char *statusptr, int *sigptr)
 175 {
 176   /* myattach should return -1 if attaching is unsupported,
 177      0 if it succeeded, and call error() otherwise.  */
 178
 179   if (myattach (pid) != 0)
 180     return -1;
 181
 182   attached = 1;
 183
 184   fprintf (stderr, "Attached; pid = %d\n", pid);
 185   fflush (stderr);
 186
 187   /* FIXME - It may be that we should get the SIGNAL_PID from the
 188      attach function, so that it can be the main thread instead of
 189      whichever we were told to attach to.  */
 190   signal_pid = pid;
 191
 192   *sigptr = mywait (statusptr, 0);
 193
 194   /* GDB knows to ignore the first SIGSTOP after attaching to a running
 195      process using the "attach" command, but this is different; it's
 196      just using "target remote".  Pretend it's just starting up.  */
 197   if (*statusptr == 'T' && *sigptr == TARGET_SIGNAL_STOP)
 198     *sigptr = TARGET_SIGNAL_TRAP;
 199
 200   return 0;
 201 }
 202
 203 extern int remote_debug;
 204
 205 /* Decode a qXfer read request.  Return 0 if everything looks OK,
 206    or -1 otherwise.  */
 207
 208 static int
 209 decode_xfer_read (char *buf, char **annex, CORE_ADDR *ofs, unsigned int *len)
 210 {
 211   /* Extract and NUL-terminate the annex.  */
 212   *annex = buf;
 213   while (*buf && *buf != ':')
 214     buf++;
 215   if (*buf == '\0')
 216     return -1;
 217   *buf++ = 0;
 218
 219   /* After the read marker and annex, qXfer looks like a
 220      traditional 'm' packet.  */
 221   decode_m_packet (buf, ofs, len);
 222
 223   return 0;
 224 }
 225
 226 /* Write the response to a successful qXfer read.  Returns the
 227    length of the (binary) data stored in BUF, corresponding
 228    to as much of DATA/LEN as we could fit.  IS_MORE controls
 229    the first character of the response.  */
 230 static int
 231 write_qxfer_response (char *buf, const void *data, int len, int is_more)
 232 {
 233   int out_len;
 234
 235   if (is_more)
 236     buf[0] = 'm';
 237   else
 238     buf[0] = 'l';
 239
 240   return remote_escape_output (data, len, (unsigned char *) buf + 1, &out_len,
 241                                PBUFSIZ - 2) + 1;
 242 }
 243
 244 /* Handle all of the extended 'Q' packets.  */
 245 void
 246 handle_general_set (char *own_buf)
 247 {
 248   if (strncmp ("QPassSignals:", own_buf, strlen ("QPassSignals:")) == 0)
 249     {
 250       int numsigs = (int) TARGET_SIGNAL_LAST, i;
 251       const char *p = own_buf + strlen ("QPassSignals:");
 252       CORE_ADDR cursig;
 253
 254       p = decode_address_to_semicolon (&cursig, p);
 255       for (i = 0; i < numsigs; i++)
 256         {
 257           if (i == cursig)
 258             {
 259               pass_signals[i] = 1;
 260               if (*p == '\0')
 261                 /* Keep looping, to clear the remaining signals.  */
 262                 cursig = -1;
 263               else
 264                 p = decode_address_to_semicolon (&cursig, p);
 265             }
 266           else
 267             pass_signals[i] = 0;
 268         }
 269       strcpy (own_buf, "OK");
 270       return;
 271     }
 272
 273   if (strcmp (own_buf, "QStartNoAckMode") == 0)
 274     {
 275       if (remote_debug)
 276         {
 277           fprintf (stderr, "[noack mode enabled]\n");
 278           fflush (stderr);
 279         }
 280
 281       noack_mode = 1;
 282       write_ok (own_buf);
 283       return;
 284     }
 285
 286   /* Otherwise we didn't know what packet it was.  Say we didn't
 287      understand it.  */
 288   own_buf[0] = 0;
 289 }
 290
 291 static const char *
 292 get_features_xml (const char *annex)
 293 {
 294   /* gdbserver_xmltarget defines what to return when looking
 295      for the "target.xml" file.  Its contents can either be
 296      verbatim XML code (prefixed with a '@') or else the name
 297      of the actual XML file to be used in place of "target.xml".
 298
 299      This variable is set up from the auto-generated
 300      init_registers_... routine for the current target.  */
 301
 302   if (gdbserver_xmltarget
 303       && strcmp (annex, "target.xml") == 0)
 304     {
 305       if (*gdbserver_xmltarget == '@')
 306         return gdbserver_xmltarget + 1;
 307       else
 308         annex = gdbserver_xmltarget;
 309     }
 310
 311 #ifdef USE_XML
 312   {
 313     extern const char *const xml_builtin[][2];
 314     int i;
 315
 316     /* Look for the annex.  */
 317     for (i = 0; xml_builtin[i][0] != NULL; i++)
 318       if (strcmp (annex, xml_builtin[i][0]) == 0)
 319         break;
 320
 321     if (xml_builtin[i][0] != NULL)
 322       return xml_builtin[i][1];
 323   }
 324 #endif
 325
 326   return NULL;
 327 }
 328
 329 void
 330 monitor_show_help (void)
 331 {
 332   monitor_output ("The following monitor commands are supported:\n");
 333   monitor_output ("  set debug <0|1>\n");
 334   monitor_output ("    Enable general debugging messages\n");
 335   monitor_output ("  set remote-debug <0|1>\n");
 336   monitor_output ("    Enable remote protocol debugging messages\n");
 337   monitor_output ("  exit\n");
 338   monitor_output ("    Quit GDBserver\n");
 339 }
 340
 341 /* Subroutine of handle_search_memory to simplify it.  */
 342
 343 static int
 344 handle_search_memory_1 (CORE_ADDR start_addr, CORE_ADDR search_space_len,
 345                         gdb_byte *pattern, unsigned pattern_len,
 346                         gdb_byte *search_buf,
 347                         unsigned chunk_size, unsigned search_buf_size,
 348                         CORE_ADDR *found_addrp)
 349 {
 350   /* Prime the search buffer.  */
 351
 352   if (read_inferior_memory (start_addr, search_buf, search_buf_size) != 0)
 353     {
 354       warning ("Unable to access target memory at 0x%lx, halting search.",
 355                (long) start_addr);
 356       return -1;
 357     }
 358
 359   /* Perform the search.
 360
 361      The loop is kept simple by allocating [N + pattern-length - 1] bytes.
 362      When we've scanned N bytes we copy the trailing bytes to the start and
 363      read in another N bytes.  */
 364
 365   while (search_space_len >= pattern_len)
 366     {
 367       gdb_byte *found_ptr;
 368       unsigned nr_search_bytes = (search_space_len < search_buf_size
 369                                   ? search_space_len
 370                                   : search_buf_size);
 371
 372       found_ptr = memmem (search_buf, nr_search_bytes, pattern, pattern_len);
 373
 374       if (found_ptr != NULL)
 375         {
 376           CORE_ADDR found_addr = start_addr + (found_ptr - search_buf);
 377           *found_addrp = found_addr;
 378           return 1;
 379         }
 380
 381       /* Not found in this chunk, skip to next chunk.  */
 382
 383       /* Don't let search_space_len wrap here, it's unsigned.  */
 384       if (search_space_len >= chunk_size)
 385         search_space_len -= chunk_size;
 386       else
 387         search_space_len = 0;
 388
 389       if (search_space_len >= pattern_len)
 390         {
 391           unsigned keep_len = search_buf_size - chunk_size;
 392           CORE_ADDR read_addr = start_addr + keep_len;
 393           int nr_to_read;
 394
 395           /* Copy the trailing part of the previous iteration to the front
 396              of the buffer for the next iteration.  */
 397           memcpy (search_buf, search_buf + chunk_size, keep_len);
 398
 399           nr_to_read = (search_space_len - keep_len < chunk_size
 400                         ? search_space_len - keep_len
 401                         : chunk_size);
 402
 403           if (read_inferior_memory (read_addr, search_buf + keep_len,
 404                                     nr_to_read) != 0)
 405             {
 406               warning ("Unable to access target memory at 0x%lx, halting search.",
 407                        (long) read_addr);
 408               return -1;
 409             }
 410
 411           start_addr += chunk_size;
 412         }
 413     }
 414
 415   /* Not found.  */
 416
 417   return 0;
 418 }
 419
 420 /* Handle qSearch:memory packets.  */
 421
 422 static void
 423 handle_search_memory (char *own_buf, int packet_len)
 424 {
 425   CORE_ADDR start_addr;
 426   CORE_ADDR search_space_len;
 427   gdb_byte *pattern;
 428   unsigned int pattern_len;
 429   /* NOTE: also defined in find.c testcase.  */
 430 #define SEARCH_CHUNK_SIZE 16000
 431   const unsigned chunk_size = SEARCH_CHUNK_SIZE;
 432   /* Buffer to hold memory contents for searching.  */
 433   gdb_byte *search_buf;
 434   unsigned search_buf_size;
 435   int found;
 436   CORE_ADDR found_addr;
 437   int cmd_name_len = sizeof ("qSearch:memory:") - 1;
 438
 439   pattern = malloc (packet_len);
 440   if (pattern == NULL)
 441     {
 442       error ("Unable to allocate memory to perform the search");
 443       strcpy (own_buf, "E00");
 444       return;
 445     }
 446   if (decode_search_memory_packet (own_buf + cmd_name_len,
 447                                    packet_len - cmd_name_len,
 448                                    &start_addr, &search_space_len,
 449                                    pattern, &pattern_len) < 0)
 450     {
 451       free (pattern);
 452       error ("Error in parsing qSearch:memory packet");
 453       strcpy (own_buf, "E00");
 454       return;
 455     }
 456
 457   search_buf_size = chunk_size + pattern_len - 1;
 458
 459   /* No point in trying to allocate a buffer larger than the search space.  */
 460   if (search_space_len < search_buf_size)
 461     search_buf_size = search_space_len;
 462
 463   search_buf = malloc (search_buf_size);
 464   if (search_buf == NULL)
 465     {
 466       free (pattern);
 467       error ("Unable to allocate memory to perform the search");
 468       strcpy (own_buf, "E00");
 469       return;
 470     }
 471
 472   found = handle_search_memory_1 (start_addr, search_space_len,
 473                                   pattern, pattern_len,
 474                                   search_buf, chunk_size, search_buf_size,
 475                                   &found_addr);
 476
 477   if (found > 0)
 478     sprintf (own_buf, "1,%lx", (long) found_addr);
 479   else if (found == 0)
 480     strcpy (own_buf, "0");
 481   else
 482     strcpy (own_buf, "E00");
 483
 484   free (search_buf);
 485   free (pattern);
 486 }
 487
 488 #define require_running(BUF)                    \
 489   if (!target_running ())                       \
 490     {                                           \
 491       write_enn (BUF);                          \
 492       return;                                   \
 493     }
 494
 495 /* Handle all of the extended 'q' packets.  */
 496 void
 497 handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
 498 {
 499   static struct inferior_list_entry *thread_ptr;
 500
 501   /* Reply the current thread id.  */
 502   if (strcmp ("qC", own_buf) == 0 && !disable_packet_qC)
 503     {
 504       require_running (own_buf);
 505       thread_ptr = all_threads.head;
 506       sprintf (own_buf, "QC%x",
 507                thread_to_gdb_id ((struct thread_info *)thread_ptr));
 508       return;
 509     }
 510
 511   if (strcmp ("qSymbol::", own_buf) == 0)
 512     {
 513       if (target_running () && the_target->look_up_symbols != NULL)
 514         (*the_target->look_up_symbols) ();
 515
 516       strcpy (own_buf, "OK");
 517       return;
 518     }
 519
 520   if (!disable_packet_qfThreadInfo)
 521     {
 522       if (strcmp ("qfThreadInfo", own_buf) == 0)
 523         {
 524           require_running (own_buf);
 525           thread_ptr = all_threads.head;
 526           sprintf (own_buf, "m%x", thread_to_gdb_id ((struct thread_info *)thread_ptr));
 527           thread_ptr = thread_ptr->next;
 528           return;
 529         }
 530
 531       if (strcmp ("qsThreadInfo", own_buf) == 0)
 532         {
 533           require_running (own_buf);
 534           if (thread_ptr != NULL)
 535             {
 536               sprintf (own_buf, "m%x", thread_to_gdb_id ((struct thread_info *)thread_ptr));
 537               thread_ptr = thread_ptr->next;
 538               return;
 539             }
 540           else
 541             {
 542               sprintf (own_buf, "l");
 543               return;
 544             }
 545         }
 546     }
 547
 548   if (the_target->read_offsets != NULL
 549       && strcmp ("qOffsets", own_buf) == 0)
 550     {
 551       CORE_ADDR text, data;
 552
 553       require_running (own_buf);
 554       if (the_target->read_offsets (&text, &data))
 555         sprintf (own_buf, "Text=%lX;Data=%lX;Bss=%lX",
 556                  (long)text, (long)data, (long)data);
 557       else
 558         write_enn (own_buf);
 559
 560       return;
 561     }
 562
 563   if (the_target->qxfer_spu != NULL
 564       && strncmp ("qXfer:spu:read:", own_buf, 15) == 0)
 565     {
 566       char *annex;
 567       int n;
 568       unsigned int len;
 569       CORE_ADDR ofs;
 570       unsigned char *spu_buf;
 571
 572       require_running (own_buf);
 573       strcpy (own_buf, "E00");
 574       if (decode_xfer_read (own_buf + 15, &annex, &ofs, &len) < 0)
 575           return;
 576       if (len > PBUFSIZ - 2)
 577         len = PBUFSIZ - 2;
 578       spu_buf = malloc (len + 1);
 579       if (!spu_buf)
 580         return;
 581
 582       n = (*the_target->qxfer_spu) (annex, spu_buf, NULL, ofs, len + 1);
 583       if (n < 0)
 584         write_enn (own_buf);
 585       else if (n > len)
 586         *new_packet_len_p = write_qxfer_response
 587                               (own_buf, spu_buf, len, 1);
 588       else
 589         *new_packet_len_p = write_qxfer_response
 590                               (own_buf, spu_buf, n, 0);
 591
 592       free (spu_buf);
 593       return;
 594     }
 595
 596   if (the_target->qxfer_spu != NULL
 597       && strncmp ("qXfer:spu:write:", own_buf, 16) == 0)
 598     {
 599       char *annex;
 600       int n;
 601       unsigned int len;
 602       CORE_ADDR ofs;
 603       unsigned char *spu_buf;
 604
 605       require_running (own_buf);
 606       strcpy (own_buf, "E00");
 607       spu_buf = malloc (packet_len - 15);
 608       if (!spu_buf)
 609         return;
 610       if (decode_xfer_write (own_buf + 16, packet_len - 16, &annex,
 611                              &ofs, &len, spu_buf) < 0)
 612         {
 613           free (spu_buf);
 614           return;
 615         }
 616
 617       n = (*the_target->qxfer_spu)
 618         (annex, NULL, (unsigned const char *)spu_buf, ofs, len);
 619       if (n < 0)
 620         write_enn (own_buf);
 621       else
 622         sprintf (own_buf, "%x", n);
 623
 624       free (spu_buf);
 625       return;
 626     }
 627
 628   if (the_target->read_auxv != NULL
 629       && strncmp ("qXfer:auxv:read:", own_buf, 16) == 0)
 630     {
 631       unsigned char *data;
 632       int n;
 633       CORE_ADDR ofs;
 634       unsigned int len;
 635       char *annex;
 636
 637       require_running (own_buf);
 638
 639       /* Reject any annex; grab the offset and length.  */
 640       if (decode_xfer_read (own_buf + 16, &annex, &ofs, &len) < 0
 641           || annex[0] != '\0')
 642         {
 643           strcpy (own_buf, "E00");
 644           return;
 645         }
 646
 647       /* Read one extra byte, as an indicator of whether there is
 648          more.  */
 649       if (len > PBUFSIZ - 2)
 650         len = PBUFSIZ - 2;
 651       data = malloc (len + 1);
 652       n = (*the_target->read_auxv) (ofs, data, len + 1);
 653       if (n < 0)
 654         write_enn (own_buf);
 655       else if (n > len)
 656         *new_packet_len_p = write_qxfer_response (own_buf, data, len, 1);
 657       else
 658         *new_packet_len_p = write_qxfer_response (own_buf, data, n, 0);
 659
 660       free (data);
 661
 662       return;
 663     }
 664
 665   if (strncmp ("qXfer:features:read:", own_buf, 20) == 0)
 666     {
 667       CORE_ADDR ofs;
 668       unsigned int len, total_len;
 669       const char *document;
 670       char *annex;
 671
 672       require_running (own_buf);
 673
 674       /* Grab the annex, offset, and length.  */
 675       if (decode_xfer_read (own_buf + 20, &annex, &ofs, &len) < 0)
 676         {
 677           strcpy (own_buf, "E00");
 678           return;
 679         }
 680
 681       /* Now grab the correct annex.  */
 682       document = get_features_xml (annex);
 683       if (document == NULL)
 684         {
 685           strcpy (own_buf, "E00");
 686           return;
 687         }
 688
 689       total_len = strlen (document);
 690       if (len > PBUFSIZ - 2)
 691         len = PBUFSIZ - 2;
 692
 693       if (ofs > total_len)
 694         write_enn (own_buf);
 695       else if (len < total_len - ofs)
 696         *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
 697                                                   len, 1);
 698       else
 699         *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
 700                                                   total_len - ofs, 0);
 701
 702       return;
 703     }
 704
 705   if (strncmp ("qXfer:libraries:read:", own_buf, 21) == 0)
 706     {
 707       CORE_ADDR ofs;
 708       unsigned int len, total_len;
 709       char *document, *p;
 710       struct inferior_list_entry *dll_ptr;
 711       char *annex;
 712
 713       require_running (own_buf);
 714
 715       /* Reject any annex; grab the offset and length.  */
 716       if (decode_xfer_read (own_buf + 21, &annex, &ofs, &len) < 0
 717           || annex[0] != '\0')
 718         {
 719           strcpy (own_buf, "E00");
 720           return;
 721         }
 722
 723       /* Over-estimate the necessary memory.  Assume that every character
 724          in the library name must be escaped.  */
 725       total_len = 64;
 726       for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
 727         total_len += 128 + 6 * strlen (((struct dll_info *) dll_ptr)->name);
 728
 729       document = malloc (total_len);
 730       strcpy (document, "<library-list>\n");
 731       p = document + strlen (document);
 732
 733       for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
 734         {
 735           struct dll_info *dll = (struct dll_info *) dll_ptr;
 736           char *name;
 737
 738           strcpy (p, "  <library name=\"");
 739           p = p + strlen (p);
 740           name = xml_escape_text (dll->name);
 741           strcpy (p, name);
 742           free (name);
 743           p = p + strlen (p);
 744           strcpy (p, "\"><segment address=\"");
 745           p = p + strlen (p);
 746           sprintf (p, "0x%lx", (long) dll->base_addr);
 747           p = p + strlen (p);
 748           strcpy (p, "\"/></library>\n");
 749           p = p + strlen (p);
 750         }
 751
 752       strcpy (p, "</library-list>\n");
 753
 754       total_len = strlen (document);
 755       if (len > PBUFSIZ - 2)
 756         len = PBUFSIZ - 2;
 757
 758       if (ofs > total_len)
 759         write_enn (own_buf);
 760       else if (len < total_len - ofs)
 761         *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
 762                                                   len, 1);
 763       else
 764         *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
 765                                                   total_len - ofs, 0);
 766
 767       free (document);
 768       return;
 769     }
 770
 771   /* Protocol features query.  */
 772   if (strncmp ("qSupported", own_buf, 10) == 0
 773       && (own_buf[10] == ':' || own_buf[10] == '\0'))
 774     {
 775       sprintf (own_buf, "PacketSize=%x;QPassSignals+", PBUFSIZ - 1);
 776
 777       /* We do not have any hook to indicate whether the target backend
 778          supports qXfer:libraries:read, so always report it.  */
 779       strcat (own_buf, ";qXfer:libraries:read+");
 780
 781       if (the_target->read_auxv != NULL)
 782         strcat (own_buf, ";qXfer:auxv:read+");
 783
 784       if (the_target->qxfer_spu != NULL)
 785         strcat (own_buf, ";qXfer:spu:read+;qXfer:spu:write+");
 786
 787       /* We always report qXfer:features:read, as targets may
 788          install XML files on a subsequent call to arch_setup.
 789          If we reported to GDB on startup that we don't support
 790          qXfer:feature:read at all, we will never be re-queried.  */
 791       strcat (own_buf, ";qXfer:features:read+");
 792
 793       if (transport_is_reliable)
 794         strcat (own_buf, ";QStartNoAckMode+");
 795       return;
 796     }
 797
 798   /* Thread-local storage support.  */
 799   if (the_target->get_tls_address != NULL
 800       && strncmp ("qGetTLSAddr:", own_buf, 12) == 0)
 801     {
 802       char *p = own_buf + 12;
 803       CORE_ADDR parts[3], address = 0;
 804       int i, err;
 805
 806       require_running (own_buf);
 807
 808       for (i = 0; i < 3; i++)
 809         {
 810           char *p2;
 811           int len;
 812
 813           if (p == NULL)
 814             break;
 815
 816           p2 = strchr (p, ',');
 817           if (p2)
 818             {
 819               len = p2 - p;
 820               p2++;
 821             }
 822           else
 823             {
 824               len = strlen (p);
 825               p2 = NULL;
 826             }
 827
 828           decode_address (&parts[i], p, len);
 829           p = p2;
 830         }
 831
 832       if (p != NULL || i < 3)
 833         err = 1;
 834       else
 835         {
 836           struct thread_info *thread = gdb_id_to_thread (parts[0]);
 837
 838           if (thread == NULL)
 839             err = 2;
 840           else
 841             err = the_target->get_tls_address (thread, parts[1], parts[2],
 842                                                &address);
 843         }
 844
 845       if (err == 0)
 846         {
 847           sprintf (own_buf, "%llx", address);
 848           return;
 849         }
 850       else if (err > 0)
 851         {
 852           write_enn (own_buf);
 853           return;
 854         }
 855
 856       /* Otherwise, pretend we do not understand this packet.  */
 857     }
 858
 859   /* Handle "monitor" commands.  */
 860   if (strncmp ("qRcmd,", own_buf, 6) == 0)
 861     {
 862       char *mon = malloc (PBUFSIZ);
 863       int len = strlen (own_buf + 6);
 864
 865       if ((len % 2) != 0 || unhexify (mon, own_buf + 6, len / 2) != len / 2)
 866         {
 867           write_enn (own_buf);
 868           free (mon);
 869           return;
 870         }
 871       mon[len / 2] = '\0';
 872
 873       write_ok (own_buf);
 874
 875       if (strcmp (mon, "set debug 1") == 0)
 876         {
 877           debug_threads = 1;
 878           monitor_output ("Debug output enabled.\n");
 879         }
 880       else if (strcmp (mon, "set debug 0") == 0)
 881         {
 882           debug_threads = 0;
 883           monitor_output ("Debug output disabled.\n");
 884         }
 885       else if (strcmp (mon, "set remote-debug 1") == 0)
 886         {
 887           remote_debug = 1;
 888           monitor_output ("Protocol debug output enabled.\n");
 889         }
 890       else if (strcmp (mon, "set remote-debug 0") == 0)
 891         {
 892           remote_debug = 0;
 893           monitor_output ("Protocol debug output disabled.\n");
 894         }
 895       else if (strcmp (mon, "help") == 0)
 896         monitor_show_help ();
 897       else if (strcmp (mon, "exit") == 0)
 898         exit_requested = 1;
 899       else
 900         {
 901           monitor_output ("Unknown monitor command.\n\n");
 902           monitor_show_help ();
 903           write_enn (own_buf);
 904         }
 905
 906       free (mon);
 907       return;
 908     }
 909
 910   if (strncmp ("qSearch:memory:", own_buf, sizeof ("qSearch:memory:") - 1) == 0)
 911     {
 912       require_running (own_buf);
 913       handle_search_memory (own_buf, packet_len);
 914       return;
 915     }
 916
 917   /* Otherwise we didn't know what packet it was.  Say we didn't
 918      understand it.  */
 919   own_buf[0] = 0;
 920 }
 921
 922 /* Parse vCont packets.  */
 923 void
 924 handle_v_cont (char *own_buf, char *status, int *signal)
 925 {
 926   char *p, *q;
 927   int n = 0, i = 0;
 928   struct thread_resume *resume_info, default_action;
 929
 930   /* Count the number of semicolons in the packet.  There should be one
 931      for every action.  */
 932   p = &own_buf[5];
 933   while (p)
 934     {
 935       n++;
 936       p++;
 937       p = strchr (p, ';');
 938     }
 939   /* Allocate room for one extra action, for the default remain-stopped
 940      behavior; if no default action is in the list, we'll need the extra
 941      slot.  */
 942   resume_info = malloc ((n + 1) * sizeof (resume_info[0]));
 943
 944   default_action.thread = -1;
 945   default_action.leave_stopped = 1;
 946   default_action.step = 0;
 947   default_action.sig = 0;
 948
 949   p = &own_buf[5];
 950   i = 0;
 951   while (*p)
 952     {
 953       p++;
 954
 955       resume_info[i].leave_stopped = 0;
 956
 957       if (p[0] == 's' || p[0] == 'S')
 958         resume_info[i].step = 1;
 959       else if (p[0] == 'c' || p[0] == 'C')
 960         resume_info[i].step = 0;
 961       else
 962         goto err;
 963
 964       if (p[0] == 'S' || p[0] == 'C')
 965         {
 966           int sig;
 967           sig = strtol (p + 1, &q, 16);
 968           if (p == q)
 969             goto err;
 970           p = q;
 971
 972           if (!target_signal_to_host_p (sig))
 973             goto err;
 974           resume_info[i].sig = target_signal_to_host (sig);
 975         }
 976       else
 977         {
 978           resume_info[i].sig = 0;
 979           p = p + 1;
 980         }
 981
 982       if (p[0] == 0)
 983         {
 984           resume_info[i].thread = -1;
 985           default_action = resume_info[i];
 986
 987           /* Note: we don't increment i here, we'll overwrite this entry
 988              the next time through.  */
 989         }
 990       else if (p[0] == ':')
 991         {
 992           unsigned int gdb_id = strtoul (p + 1, &q, 16);
 993           unsigned long thread_id;
 994
 995           if (p == q)
 996             goto err;
 997           p = q;
 998           if (p[0] != ';' && p[0] != 0)
 999             goto err;
1000
1001           thread_id = gdb_id_to_thread_id (gdb_id);
1002           if (thread_id)
1003             resume_info[i].thread = thread_id;
1004           else
1005             goto err;
1006
1007           i++;
1008         }
1009     }
1010
1011   resume_info[i] = default_action;
1012
1013   /* Still used in occasional places in the backend.  */
1014   if (n == 1 && resume_info[0].thread != -1)
1015     cont_thread = resume_info[0].thread;
1016   else
1017     cont_thread = -1;
1018   set_desired_inferior (0);
1019
1020   enable_async_io ();
1021   (*the_target->resume) (resume_info);
1022
1023   free (resume_info);
1024
1025   *signal = mywait (status, 1);
1026   prepare_resume_reply (own_buf, *status, *signal);
1027   disable_async_io ();
1028   return;
1029
1030 err:
1031   write_enn (own_buf);
1032   free (resume_info);
1033   return;
1034 }
1035
1036 /* Attach to a new program.  Return 1 if successful, 0 if failure.  */
1037 int
1038 handle_v_attach (char *own_buf, char *status, int *signal)
1039 {
1040   int pid;
1041
1042   pid = strtol (own_buf + 8, NULL, 16);
1043   if (pid != 0 && attach_inferior (pid, status, signal) == 0)
1044     {
1045       /* Don't report shared library events after attaching, even if
1046          some libraries are preloaded.  GDB will always poll the
1047          library list.  Avoids the "stopped by shared library event"
1048          notice on the GDB side.  */
1049       dlls_changed = 0;
1050       prepare_resume_reply (own_buf, *status, *signal);
1051       return 1;
1052     }
1053   else
1054     {
1055       write_enn (own_buf);
1056       return 0;
1057     }
1058 }
1059
1060 /* Run a new program.  Return 1 if successful, 0 if failure.  */
1061 static int
1062 handle_v_run (char *own_buf, char *status, int *signal)
1063 {
1064   char *p, **pp, *next_p, **new_argv;
1065   int i, new_argc;
1066
1067   new_argc = 0;
1068   for (p = own_buf + strlen ("vRun;"); p && *p; p = strchr (p, ';'))
1069     {
1070       p++;
1071       new_argc++;
1072     }
1073
1074   new_argv = calloc (new_argc + 2, sizeof (char *));
1075   i = 0;
1076   for (p = own_buf + strlen ("vRun;"); *p; p = next_p)
1077     {
1078       next_p = strchr (p, ';');
1079       if (next_p == NULL)
1080         next_p = p + strlen (p);
1081
1082       if (i == 0 && p == next_p)
1083         new_argv[i] = NULL;
1084       else
1085         {
1086           new_argv[i] = malloc (1 + (next_p - p) / 2);
1087           unhexify (new_argv[i], p, (next_p - p) / 2);
1088           new_argv[i][(next_p - p) / 2] = '\0';
1089         }
1090
1091       if (*next_p)
1092         next_p++;
1093       i++;
1094     }
1095   new_argv[i] = NULL;
1096
1097   if (new_argv[0] == NULL)
1098     {
1099       /* GDB didn't specify a program to run.  Use the program from the
1100          last run with the new argument list.  */
1101
1102       if (program_argv == NULL)
1103         {
1104           write_enn (own_buf);
1105           return 0;
1106         }
1107
1108       new_argv[0] = strdup (program_argv[0]);
1109     }
1110
1111   /* Free the old argv.  */
1112   if (program_argv)
1113     {
1114       for (pp = program_argv; *pp != NULL; pp++)
1115         free (*pp);
1116       free (program_argv);
1117     }
1118   program_argv = new_argv;
1119
1120   *signal = start_inferior (program_argv, status);
1121   if (*status == 'T')
1122     {
1123       prepare_resume_reply (own_buf, *status, *signal);
1124       return 1;
1125     }
1126   else
1127     {
1128       write_enn (own_buf);
1129       return 0;
1130     }
1131 }
1132
1133 /* Handle all of the extended 'v' packets.  */
1134 void
1135 handle_v_requests (char *own_buf, char *status, int *signal,
1136                    int packet_len, int *new_packet_len)
1137 {
1138   if (!disable_packet_vCont)
1139     {
1140       if (strncmp (own_buf, "vCont;", 6) == 0)
1141         {
1142           require_running (own_buf);
1143           handle_v_cont (own_buf, status, signal);
1144           return;
1145         }
1146
1147       if (strncmp (own_buf, "vCont?", 6) == 0)
1148         {
1149           strcpy (own_buf, "vCont;c;C;s;S");
1150           return;
1151         }
1152     }
1153
1154   if (strncmp (own_buf, "vFile:", 6) == 0
1155       && handle_vFile (own_buf, packet_len, new_packet_len))
1156     return;
1157
1158   if (strncmp (own_buf, "vAttach;", 8) == 0)
1159     {
1160       if (target_running ())
1161         {
1162           fprintf (stderr, "Already debugging a process\n");
1163           write_enn (own_buf);
1164           return;
1165         }
1166       handle_v_attach (own_buf, status, signal);
1167       return;
1168     }
1169
1170   if (strncmp (own_buf, "vRun;", 5) == 0)
1171     {
1172       if (target_running ())
1173         {
1174           fprintf (stderr, "Already debugging a process\n");
1175           write_enn (own_buf);
1176           return;
1177         }
1178       handle_v_run (own_buf, status, signal);
1179       return;
1180     }
1181
1182   /* Otherwise we didn't know what packet it was.  Say we didn't
1183      understand it.  */
1184   own_buf[0] = 0;
1185   return;
1186 }
1187
1188 void
1189 myresume (char *own_buf, int step, int *signalp, char *statusp)
1190 {
1191   struct thread_resume resume_info[2];
1192   int n = 0;
1193   int sig = *signalp;
1194
1195   set_desired_inferior (0);
1196
1197   if (step || sig || (cont_thread != 0 && cont_thread != -1))
1198     {
1199       resume_info[0].thread
1200         = ((struct inferior_list_entry *) current_inferior)->id;
1201       resume_info[0].step = step;
1202       resume_info[0].sig = sig;
1203       resume_info[0].leave_stopped = 0;
1204       n++;
1205     }
1206   resume_info[n].thread = -1;
1207   resume_info[n].step = 0;
1208   resume_info[n].sig = 0;
1209   resume_info[n].leave_stopped = (cont_thread != 0 && cont_thread != -1);
1210
1211   enable_async_io ();
1212   (*the_target->resume) (resume_info);
1213   *signalp = mywait (statusp, 1);
1214   prepare_resume_reply (own_buf, *statusp, *signalp);
1215   disable_async_io ();
1216 }
1217
1218 static void
1219 gdbserver_version (void)
1220 {
1221   printf ("GNU gdbserver %s%s\n"
1222           "Copyright (C) 2007 Free Software Foundation, Inc.\n"
1223           "gdbserver is free software, covered by the GNU General Public License.\n"
1224           "This gdbserver was configured as \"%s\"\n",
1225           PKGVERSION, version, host_name);
1226 }
1227
1228 static void
1229 gdbserver_usage (FILE *stream)
1230 {
1231   fprintf (stream, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
1232            "\tgdbserver [OPTIONS] --attach COMM PID\n"
1233            "\tgdbserver [OPTIONS] --multi COMM\n"
1234            "\n"
1235            "COMM may either be a tty device (for serial debugging), or \n"
1236            "HOST:PORT to listen for a TCP connection.\n"
1237            "\n"
1238            "Options:\n"
1239            "  --debug\t\tEnable debugging output.\n"
1240            "  --version\t\tDisplay version information and exit.\n"
1241            "  --wrapper WRAPPER --\tRun WRAPPER to start new programs.\n");
1242   if (REPORT_BUGS_TO[0] && stream == stdout)
1243     fprintf (stream, "Report bugs to \"%s\".\n", REPORT_BUGS_TO);
1244 }
1245
1246 static void
1247 gdbserver_show_disableable (FILE *stream)
1248 {
1249   fprintf (stream, "Disableable packets:\n"
1250            "  vCont       \tAll vCont packets\n"
1251            "  qC          \tQuerying the current thread\n"
1252            "  qfThreadInfo\tThread listing\n"
1253            "  Tthread     \tPassing the thread specifier in the T stop reply packet\n"
1254            "  threads     \tAll of the above\n");
1255 }
1256
1257
1258 #undef require_running
1259 #define require_running(BUF)                    \
1260   if (!target_running ())                       \
1261     {                                           \
1262       write_enn (BUF);                          \
1263       break;                                    \
1264     }
1265
1266 int
1267 main (int argc, char *argv[])
1268 {
1269   char ch, status, *own_buf;
1270   unsigned char *mem_buf;
1271   int i = 0;
1272   int signal;
1273   unsigned int len;
1274   CORE_ADDR mem_addr;
1275   int bad_attach;
1276   int pid;
1277   char *arg_end, *port;
1278   char **next_arg = &argv[1];
1279   int multi_mode = 0;
1280   int attach = 0;
1281   int was_running;
1282
1283   while (*next_arg != NULL && **next_arg == '-')
1284     {
1285       if (strcmp (*next_arg, "--version") == 0)
1286         {
1287           gdbserver_version ();
1288           exit (0);
1289         }
1290       else if (strcmp (*next_arg, "--help") == 0)
1291         {
1292           gdbserver_usage (stdout);
1293           exit (0);
1294         }
1295       else if (strcmp (*next_arg, "--attach") == 0)
1296         attach = 1;
1297       else if (strcmp (*next_arg, "--multi") == 0)
1298         multi_mode = 1;
1299       else if (strcmp (*next_arg, "--wrapper") == 0)
1300         {
1301           next_arg++;
1302
1303           wrapper_argv = next_arg;
1304           while (*next_arg != NULL && strcmp (*next_arg, "--") != 0)
1305             next_arg++;
1306
1307           if (next_arg == wrapper_argv || *next_arg == NULL)
1308             {
1309               gdbserver_usage (stderr);
1310               exit (1);
1311             }
1312
1313           /* Consume the "--".  */
1314           *next_arg = NULL;
1315         }
1316       else if (strcmp (*next_arg, "--debug") == 0)
1317         debug_threads = 1;
1318       else if (strcmp (*next_arg, "--disable-packet") == 0)
1319         {
1320           gdbserver_show_disableable (stdout);
1321           exit (0);
1322         }
1323       else if (strncmp (*next_arg,
1324                         "--disable-packet=",
1325                         sizeof ("--disable-packet=") - 1) == 0)
1326         {
1327           char *packets, *tok;
1328
1329           packets = *next_arg += sizeof ("--disable-packet=") - 1;
1330           for (tok = strtok (packets, ",");
1331                tok != NULL;
1332                tok = strtok (NULL, ","))
1333             {
1334               if (strcmp ("vCont", tok) == 0)
1335                 disable_packet_vCont = 1;
1336               else if (strcmp ("Tthread", tok) == 0)
1337                 disable_packet_Tthread = 1;
1338               else if (strcmp ("qC", tok) == 0)
1339                 disable_packet_qC = 1;
1340               else if (strcmp ("qfThreadInfo", tok) == 0)
1341                 disable_packet_qfThreadInfo = 1;
1342               else if (strcmp ("threads", tok) == 0)
1343                 {
1344                   disable_packet_vCont = 1;
1345                   disable_packet_Tthread = 1;
1346                   disable_packet_qC = 1;
1347                   disable_packet_qfThreadInfo = 1;
1348                 }
1349               else
1350                 {
1351                   fprintf (stderr, "Don't know how to disable \"%s\".\n\n",
1352                            tok);
1353                   gdbserver_show_disableable (stderr);
1354                   exit (1);
1355                 }
1356             }
1357         }
1358       else
1359         {
1360           fprintf (stderr, "Unknown argument: %s\n", *next_arg);
1361           exit (1);
1362         }
1363
1364       next_arg++;
1365       continue;
1366     }
1367
1368   if (setjmp (toplevel))
1369     {
1370       fprintf (stderr, "Exiting\n");
1371       exit (1);
1372     }
1373
1374   port = *next_arg;
1375   next_arg++;
1376   if (port == NULL || (!attach && !multi_mode && *next_arg == NULL))
1377     {
1378       gdbserver_usage (stderr);
1379       exit (1);
1380     }
1381
1382   bad_attach = 0;
1383   pid = 0;
1384
1385   /* --attach used to come after PORT, so allow it there for
1386        compatibility.  */
1387   if (*next_arg != NULL && strcmp (*next_arg, "--attach") == 0)
1388     {
1389       attach = 1;
1390       next_arg++;
1391     }
1392
1393   if (attach
1394       && (*next_arg == NULL
1395           || (*next_arg)[0] == '\0'
1396           || (pid = strtoul (*next_arg, &arg_end, 0)) == 0
1397           || *arg_end != '\0'
1398           || next_arg[1] != NULL))
1399     bad_attach = 1;
1400
1401   if (bad_attach)
1402     {
1403       gdbserver_usage (stderr);
1404       exit (1);
1405     }
1406
1407   initialize_async_io ();
1408   initialize_low ();
1409
1410   own_buf = malloc (PBUFSIZ + 1);
1411   mem_buf = malloc (PBUFSIZ);
1412
1413   if (pid == 0 && *next_arg != NULL)
1414     {
1415       int i, n;
1416
1417       n = argc - (next_arg - argv);
1418       program_argv = malloc (sizeof (char *) * (n + 1));
1419       for (i = 0; i < n; i++)
1420         program_argv[i] = strdup (next_arg[i]);
1421       program_argv[i] = NULL;
1422
1423       /* Wait till we are at first instruction in program.  */
1424       signal = start_inferior (program_argv, &status);
1425
1426       /* We are now (hopefully) stopped at the first instruction of
1427          the target process.  This assumes that the target process was
1428          successfully created.  */
1429     }
1430   else if (pid != 0)
1431     {
1432       if (attach_inferior (pid, &status, &signal) == -1)
1433         error ("Attaching not supported on this target");
1434
1435       /* Otherwise succeeded.  */
1436     }
1437   else
1438     {
1439       status = 'W';
1440       signal = 0;
1441     }
1442
1443   /* Don't report shared library events on the initial connection,
1444      even if some libraries are preloaded.  Avoids the "stopped by
1445      shared library event" notice on gdb side.  */
1446   dlls_changed = 0;
1447
1448   if (setjmp (toplevel))
1449     {
1450       fprintf (stderr, "Killing inferior\n");
1451       kill_inferior ();
1452       exit (1);
1453     }
1454
1455   if (status == 'W' || status == 'X')
1456     was_running = 0;
1457   else
1458     was_running = 1;
1459
1460   if (!was_running && !multi_mode)
1461     {
1462       fprintf (stderr, "No program to debug.  GDBserver exiting.\n");
1463       exit (1);
1464     }
1465
1466   while (1)
1467     {
1468       noack_mode = 0;
1469       remote_open (port);
1470
1471     restart:
1472       if (setjmp (toplevel) != 0)
1473         {
1474           /* An error occurred.  */
1475           if (response_needed)
1476             {
1477               write_enn (own_buf);
1478               putpkt (own_buf);
1479             }
1480         }
1481
1482       disable_async_io ();
1483       while (!exit_requested)
1484         {
1485           unsigned char sig;
1486           int packet_len;
1487           int new_packet_len = -1;
1488
1489           response_needed = 0;
1490           packet_len = getpkt (own_buf);
1491           if (packet_len <= 0)
1492             break;
1493           response_needed = 1;
1494
1495           i = 0;
1496           ch = own_buf[i++];
1497           switch (ch)
1498             {
1499             case 'q':
1500               handle_query (own_buf, packet_len, &new_packet_len);
1501               break;
1502             case 'Q':
1503               handle_general_set (own_buf);
1504               break;
1505             case 'D':
1506               require_running (own_buf);
1507               fprintf (stderr, "Detaching from inferior\n");
1508               if (detach_inferior () != 0)
1509                 write_enn (own_buf);
1510               else
1511                 {
1512                   write_ok (own_buf);
1513
1514                   if (extended_protocol)
1515                     {
1516                       /* Treat this like a normal program exit.  */
1517                       signal = 0;
1518                       status = 'W';
1519                     }
1520                   else
1521                     {
1522                       putpkt (own_buf);
1523                       remote_close ();
1524
1525                       /* If we are attached, then we can exit.  Otherwise, we
1526                          need to hang around doing nothing, until the child
1527                          is gone.  */
1528                       if (!attached)
1529                         join_inferior ();
1530
1531                       exit (0);
1532                     }
1533                 }
1534               break;
1535             case '!':
1536               extended_protocol = 1;
1537               write_ok (own_buf);
1538               break;
1539             case '?':
1540               prepare_resume_reply (own_buf, status, signal);
1541               break;
1542             case 'H':
1543               if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
1544                 {
1545                   unsigned long gdb_id, thread_id;
1546
1547                   require_running (own_buf);
1548                   gdb_id = strtoul (&own_buf[2], NULL, 16);
1549                   if (gdb_id == 0 || gdb_id == -1)
1550                     thread_id = gdb_id;
1551                   else
1552                     {
1553                       thread_id = gdb_id_to_thread_id (gdb_id);
1554                       if (thread_id == 0)
1555                         {
1556                           write_enn (own_buf);
1557                           break;
1558                         }
1559                     }
1560
1561                   if (own_buf[1] == 'g')
1562                     {
1563                       general_thread = thread_id;
1564                       set_desired_inferior (1);
1565                     }
1566                   else if (own_buf[1] == 'c')
1567                     cont_thread = thread_id;
1568                   else if (own_buf[1] == 's')
1569                     step_thread = thread_id;
1570
1571                   write_ok (own_buf);
1572                 }
1573               else
1574                 {
1575                   /* Silently ignore it so that gdb can extend the protocol
1576                      without compatibility headaches.  */
1577                   own_buf[0] = '\0';
1578                 }
1579               break;
1580             case 'g':
1581               require_running (own_buf);
1582               set_desired_inferior (1);
1583               registers_to_string (own_buf);
1584               break;
1585             case 'G':
1586               require_running (own_buf);
1587               set_desired_inferior (1);
1588               registers_from_string (&own_buf[1]);
1589               write_ok (own_buf);
1590               break;
1591             case 'm':
1592               require_running (own_buf);
1593               decode_m_packet (&own_buf[1], &mem_addr, &len);
1594               if (read_inferior_memory (mem_addr, mem_buf, len) == 0)
1595                 convert_int_to_ascii (mem_buf, own_buf, len);
1596               else
1597                 write_enn (own_buf);
1598               break;
1599             case 'M':
1600               require_running (own_buf);
1601               decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
1602               if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
1603                 write_ok (own_buf);
1604               else
1605                 write_enn (own_buf);
1606               break;
1607             case 'X':
1608               require_running (own_buf);
1609               if (decode_X_packet (&own_buf[1], packet_len - 1,
1610                                    &mem_addr, &len, mem_buf) < 0
1611                   || write_inferior_memory (mem_addr, mem_buf, len) != 0)
1612                 write_enn (own_buf);
1613               else
1614                 write_ok (own_buf);
1615               break;
1616             case 'C':
1617               require_running (own_buf);
1618               convert_ascii_to_int (own_buf + 1, &sig, 1);
1619               if (target_signal_to_host_p (sig))
1620                 signal = target_signal_to_host (sig);
1621               else
1622                 signal = 0;
1623               myresume (own_buf, 0, &signal, &status);
1624               break;
1625             case 'S':
1626               require_running (own_buf);
1627               convert_ascii_to_int (own_buf + 1, &sig, 1);
1628               if (target_signal_to_host_p (sig))
1629                 signal = target_signal_to_host (sig);
1630               else
1631                 signal = 0;
1632               myresume (own_buf, 1, &signal, &status);
1633               break;
1634             case 'c':
1635               require_running (own_buf);
1636               signal = 0;
1637               myresume (own_buf, 0, &signal, &status);
1638               break;
1639             case 's':
1640               require_running (own_buf);
1641               signal = 0;
1642               myresume (own_buf, 1, &signal, &status);
1643               break;
1644             case 'Z':
1645               {
1646                 char *lenptr;
1647                 char *dataptr;
1648                 CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
1649                 int len = strtol (lenptr + 1, &dataptr, 16);
1650                 char type = own_buf[1];
1651
1652                 if (the_target->insert_watchpoint == NULL
1653                     || (type < '2' || type > '4'))
1654                   {
1655                     /* No watchpoint support or not a watchpoint command;
1656                        unrecognized either way.  */
1657                     own_buf[0] = '\0';
1658                   }
1659                 else
1660                   {
1661                     int res;
1662
1663                     require_running (own_buf);
1664                     res = (*the_target->insert_watchpoint) (type, addr, len);
1665                     if (res == 0)
1666                       write_ok (own_buf);
1667                     else if (res == 1)
1668                       /* Unsupported.  */
1669                       own_buf[0] = '\0';
1670                     else
1671                       write_enn (own_buf);
1672                   }
1673                 break;
1674               }
1675             case 'z':
1676               {
1677                 char *lenptr;
1678                 char *dataptr;
1679                 CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
1680                 int len = strtol (lenptr + 1, &dataptr, 16);
1681                 char type = own_buf[1];
1682
1683                 if (the_target->remove_watchpoint == NULL
1684                     || (type < '2' || type > '4'))
1685                   {
1686                     /* No watchpoint support or not a watchpoint command;
1687                        unrecognized either way.  */
1688                     own_buf[0] = '\0';
1689                   }
1690                 else
1691                   {
1692                     int res;
1693
1694                     require_running (own_buf);
1695                     res = (*the_target->remove_watchpoint) (type, addr, len);
1696                     if (res == 0)
1697                       write_ok (own_buf);
1698                     else if (res == 1)
1699                       /* Unsupported.  */
1700                       own_buf[0] = '\0';
1701                     else
1702                       write_enn (own_buf);
1703                   }
1704                 break;
1705               }
1706             case 'k':
1707               response_needed = 0;
1708               if (!target_running ())
1709                 /* The packet we received doesn't make sense - but we
1710                    can't reply to it, either.  */
1711                 goto restart;
1712
1713               fprintf (stderr, "Killing inferior\n");
1714               kill_inferior ();
1715
1716               /* When using the extended protocol, we wait with no
1717                  program running.  The traditional protocol will exit
1718                  instead.  */
1719               if (extended_protocol)
1720                 {
1721                   status = 'X';
1722                   signal = TARGET_SIGNAL_KILL;
1723                   was_running = 0;
1724                   goto restart;
1725                 }
1726               else
1727                 {
1728                   exit (0);
1729                   break;
1730                 }
1731             case 'T':
1732               {
1733                 unsigned long gdb_id, thread_id;
1734
1735                 require_running (own_buf);
1736                 gdb_id = strtoul (&own_buf[1], NULL, 16);
1737                 thread_id = gdb_id_to_thread_id (gdb_id);
1738                 if (thread_id == 0)
1739                   {
1740                     write_enn (own_buf);
1741                     break;
1742                   }
1743
1744                 if (mythread_alive (thread_id))
1745                   write_ok (own_buf);
1746                 else
1747                   write_enn (own_buf);
1748               }
1749               break;
1750             case 'R':
1751               response_needed = 0;
1752
1753               /* Restarting the inferior is only supported in the
1754                  extended protocol.  */
1755               if (extended_protocol)
1756                 {
1757                   if (target_running ())
1758                     kill_inferior ();
1759                   fprintf (stderr, "GDBserver restarting\n");
1760
1761                   /* Wait till we are at 1st instruction in prog.  */
1762                   if (program_argv != NULL)
1763                     signal = start_inferior (program_argv, &status);
1764                   else
1765                     {
1766                       status = 'X';
1767                       signal = TARGET_SIGNAL_KILL;
1768                     }
1769                   goto restart;
1770                 }
1771               else
1772                 {
1773                   /* It is a request we don't understand.  Respond with an
1774                      empty packet so that gdb knows that we don't support this
1775                      request.  */
1776                   own_buf[0] = '\0';
1777                   break;
1778                 }
1779             case 'v':
1780               /* Extended (long) request.  */
1781               handle_v_requests (own_buf, &status, &signal,
1782                                  packet_len, &new_packet_len);
1783               break;
1784
1785             default:
1786               /* It is a request we don't understand.  Respond with an
1787                  empty packet so that gdb knows that we don't support this
1788                  request.  */
1789               own_buf[0] = '\0';
1790               break;
1791             }
1792
1793           if (new_packet_len != -1)
1794             putpkt_binary (own_buf, new_packet_len);
1795           else
1796             putpkt (own_buf);
1797
1798           response_needed = 0;
1799
1800           if (was_running && (status == 'W' || status == 'X'))
1801             {
1802               was_running = 0;
1803
1804               if (status == 'W')
1805                 fprintf (stderr,
1806                          "\nChild exited with status %d\n", signal);
1807               if (status == 'X')
1808                 fprintf (stderr, "\nChild terminated with signal = 0x%x (%s)\n",
1809                          target_signal_to_host (signal),
1810                          target_signal_to_name (signal));
1811
1812               if (extended_protocol)
1813                 goto restart;
1814               else
1815                 {
1816                   fprintf (stderr, "GDBserver exiting\n");
1817                   exit (0);
1818                 }
1819             }
1820
1821           if (status != 'W' && status != 'X')
1822             was_running = 1;
1823         }
1824
1825       /* If an exit was requested (using the "monitor exit" command),
1826          terminate now.  The only other way to get here is for
1827          getpkt to fail; close the connection and reopen it at the
1828          top of the loop.  */
1829
1830       if (exit_requested)
1831         {
1832           remote_close ();
1833           if (attached && target_running ())
1834             detach_inferior ();
1835           else if (target_running ())
1836             kill_inferior ();
1837           exit (0);
1838         }
1839       else
1840         {
1841           fprintf (stderr, "Remote side has terminated connection.  "
1842                            "GDBserver will reopen the connection.\n");
1843           remote_close ();
1844         }
1845     }
1846 }