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