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%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           PKGVERSION, version, host_name);
1186 }
1187
1188 static void
1189 gdbserver_usage (FILE *stream)
1190 {
1191   fprintf (stream, "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            "  --version\t\tDisplay version information and exit.\n"
1201            "  --wrapper WRAPPER --\tRun WRAPPER to start new programs.\n");
1202   if (REPORT_BUGS_TO[0] && stream == stdout)
1203     fprintf (stream, "Report bugs to \"%s\".\n", REPORT_BUGS_TO);
1204 }
1205
1206 #undef require_running
1207 #define require_running(BUF)                    \
1208   if (!target_running ())                       \
1209     {                                           \
1210       write_enn (BUF);                          \
1211       break;                                    \
1212     }
1213
1214 int
1215 main (int argc, char *argv[])
1216 {
1217   char ch, status, *own_buf;
1218   unsigned char *mem_buf;
1219   int i = 0;
1220   int signal;
1221   unsigned int len;
1222   CORE_ADDR mem_addr;
1223   int bad_attach;
1224   int pid;
1225   char *arg_end, *port;
1226   char **next_arg = &argv[1];
1227   int multi_mode = 0;
1228   int attach = 0;
1229   int was_running;
1230
1231   while (*next_arg != NULL && **next_arg == '-')
1232     {
1233       if (strcmp (*next_arg, "--version") == 0)
1234         {
1235           gdbserver_version ();
1236           exit (0);
1237         }
1238       else if (strcmp (*next_arg, "--help") == 0)
1239         {
1240           gdbserver_usage (stdout);
1241           exit (0);
1242         }
1243       else if (strcmp (*next_arg, "--attach") == 0)
1244         attach = 1;
1245       else if (strcmp (*next_arg, "--multi") == 0)
1246         multi_mode = 1;
1247       else if (strcmp (*next_arg, "--wrapper") == 0)
1248         {
1249           next_arg++;
1250
1251           wrapper_argv = next_arg;
1252           while (*next_arg != NULL && strcmp (*next_arg, "--") != 0)
1253             next_arg++;
1254
1255           if (next_arg == wrapper_argv || *next_arg == NULL)
1256             {
1257               gdbserver_usage (stderr);
1258               exit (1);
1259             }
1260
1261           /* Consume the "--".  */
1262           *next_arg = NULL;
1263         }
1264       else if (strcmp (*next_arg, "--debug") == 0)
1265         debug_threads = 1;
1266       else
1267         {
1268           fprintf (stderr, "Unknown argument: %s\n", *next_arg);
1269           exit (1);
1270         }
1271
1272       next_arg++;
1273       continue;
1274     }
1275
1276   if (setjmp (toplevel))
1277     {
1278       fprintf (stderr, "Exiting\n");
1279       exit (1);
1280     }
1281
1282   port = *next_arg;
1283   next_arg++;
1284   if (port == NULL || (!attach && !multi_mode && *next_arg == NULL))
1285     {
1286       gdbserver_usage (stderr);
1287       exit (1);
1288     }
1289
1290   bad_attach = 0;
1291   pid = 0;
1292
1293   /* --attach used to come after PORT, so allow it there for
1294        compatibility.  */
1295   if (*next_arg != NULL && strcmp (*next_arg, "--attach") == 0)
1296     {
1297       attach = 1;
1298       next_arg++;
1299     }
1300
1301   if (attach
1302       && (*next_arg == NULL
1303           || (*next_arg)[0] == '\0'
1304           || (pid = strtoul (*next_arg, &arg_end, 0)) == 0
1305           || *arg_end != '\0'
1306           || next_arg[1] != NULL))
1307     bad_attach = 1;
1308
1309   if (bad_attach)
1310     {
1311       gdbserver_usage (stderr);
1312       exit (1);
1313     }
1314
1315   initialize_async_io ();
1316   initialize_low ();
1317
1318   own_buf = malloc (PBUFSIZ + 1);
1319   mem_buf = malloc (PBUFSIZ);
1320
1321   if (pid == 0 && *next_arg != NULL)
1322     {
1323       int i, n;
1324
1325       n = argc - (next_arg - argv);
1326       program_argv = malloc (sizeof (char *) * (n + 1));
1327       for (i = 0; i < n; i++)
1328         program_argv[i] = strdup (next_arg[i]);
1329       program_argv[i] = NULL;
1330
1331       /* Wait till we are at first instruction in program.  */
1332       signal = start_inferior (program_argv, &status);
1333
1334       /* We are now (hopefully) stopped at the first instruction of
1335          the target process.  This assumes that the target process was
1336          successfully created.  */
1337     }
1338   else if (pid != 0)
1339     {
1340       if (attach_inferior (pid, &status, &signal) == -1)
1341         error ("Attaching not supported on this target");
1342
1343       /* Otherwise succeeded.  */
1344     }
1345   else
1346     {
1347       status = 'W';
1348       signal = 0;
1349     }
1350
1351   /* Don't report shared library events on the initial connection,
1352      even if some libraries are preloaded.  Avoids the "stopped by
1353      shared library event" notice on gdb side.  */
1354   dlls_changed = 0;
1355
1356   if (setjmp (toplevel))
1357     {
1358       fprintf (stderr, "Killing inferior\n");
1359       kill_inferior ();
1360       exit (1);
1361     }
1362
1363   if (status == 'W' || status == 'X')
1364     was_running = 0;
1365   else
1366     was_running = 1;
1367
1368   if (!was_running && !multi_mode)
1369     {
1370       fprintf (stderr, "No program to debug.  GDBserver exiting.\n");
1371       exit (1);
1372     }
1373
1374   while (1)
1375     {
1376       remote_open (port);
1377
1378     restart:
1379       if (setjmp (toplevel) != 0)
1380         {
1381           /* An error occurred.  */
1382           if (response_needed)
1383             {
1384               write_enn (own_buf);
1385               putpkt (own_buf);
1386             }
1387         }
1388
1389       disable_async_io ();
1390       while (!exit_requested)
1391         {
1392           unsigned char sig;
1393           int packet_len;
1394           int new_packet_len = -1;
1395
1396           response_needed = 0;
1397           packet_len = getpkt (own_buf);
1398           if (packet_len <= 0)
1399             break;
1400           response_needed = 1;
1401
1402           i = 0;
1403           ch = own_buf[i++];
1404           switch (ch)
1405             {
1406             case 'q':
1407               handle_query (own_buf, packet_len, &new_packet_len);
1408               break;
1409             case 'Q':
1410               handle_general_set (own_buf);
1411               break;
1412             case 'D':
1413               require_running (own_buf);
1414               fprintf (stderr, "Detaching from inferior\n");
1415               if (detach_inferior () != 0)
1416                 write_enn (own_buf);
1417               else
1418                 {
1419                   write_ok (own_buf);
1420
1421                   if (extended_protocol)
1422                     {
1423                       /* Treat this like a normal program exit.  */
1424                       signal = 0;
1425                       status = 'W';
1426                     }
1427                   else
1428                     {
1429                       putpkt (own_buf);
1430                       remote_close ();
1431
1432                       /* If we are attached, then we can exit.  Otherwise, we
1433                          need to hang around doing nothing, until the child
1434                          is gone.  */
1435                       if (!attached)
1436                         join_inferior ();
1437
1438                       exit (0);
1439                     }
1440                 }
1441               break;
1442             case '!':
1443               extended_protocol = 1;
1444               write_ok (own_buf);
1445               break;
1446             case '?':
1447               prepare_resume_reply (own_buf, status, signal);
1448               break;
1449             case 'H':
1450               if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
1451                 {
1452                   unsigned long gdb_id, thread_id;
1453
1454                   require_running (own_buf);
1455                   gdb_id = strtoul (&own_buf[2], NULL, 16);
1456                   if (gdb_id == 0 || gdb_id == -1)
1457                     thread_id = gdb_id;
1458                   else
1459                     {
1460                       thread_id = gdb_id_to_thread_id (gdb_id);
1461                       if (thread_id == 0)
1462                         {
1463                           write_enn (own_buf);
1464                           break;
1465                         }
1466                     }
1467
1468                   if (own_buf[1] == 'g')
1469                     {
1470                       general_thread = thread_id;
1471                       set_desired_inferior (1);
1472                     }
1473                   else if (own_buf[1] == 'c')
1474                     cont_thread = thread_id;
1475                   else if (own_buf[1] == 's')
1476                     step_thread = thread_id;
1477
1478                   write_ok (own_buf);
1479                 }
1480               else
1481                 {
1482                   /* Silently ignore it so that gdb can extend the protocol
1483                      without compatibility headaches.  */
1484                   own_buf[0] = '\0';
1485                 }
1486               break;
1487             case 'g':
1488               require_running (own_buf);
1489               set_desired_inferior (1);
1490               registers_to_string (own_buf);
1491               break;
1492             case 'G':
1493               require_running (own_buf);
1494               set_desired_inferior (1);
1495               registers_from_string (&own_buf[1]);
1496               write_ok (own_buf);
1497               break;
1498             case 'm':
1499               require_running (own_buf);
1500               decode_m_packet (&own_buf[1], &mem_addr, &len);
1501               if (read_inferior_memory (mem_addr, mem_buf, len) == 0)
1502                 convert_int_to_ascii (mem_buf, own_buf, len);
1503               else
1504                 write_enn (own_buf);
1505               break;
1506             case 'M':
1507               require_running (own_buf);
1508               decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
1509               if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
1510                 write_ok (own_buf);
1511               else
1512                 write_enn (own_buf);
1513               break;
1514             case 'X':
1515               require_running (own_buf);
1516               if (decode_X_packet (&own_buf[1], packet_len - 1,
1517                                    &mem_addr, &len, mem_buf) < 0
1518                   || write_inferior_memory (mem_addr, mem_buf, len) != 0)
1519                 write_enn (own_buf);
1520               else
1521                 write_ok (own_buf);
1522               break;
1523             case 'C':
1524               require_running (own_buf);
1525               convert_ascii_to_int (own_buf + 1, &sig, 1);
1526               if (target_signal_to_host_p (sig))
1527                 signal = target_signal_to_host (sig);
1528               else
1529                 signal = 0;
1530               myresume (own_buf, 0, &signal, &status);
1531               break;
1532             case 'S':
1533               require_running (own_buf);
1534               convert_ascii_to_int (own_buf + 1, &sig, 1);
1535               if (target_signal_to_host_p (sig))
1536                 signal = target_signal_to_host (sig);
1537               else
1538                 signal = 0;
1539               myresume (own_buf, 1, &signal, &status);
1540               break;
1541             case 'c':
1542               require_running (own_buf);
1543               signal = 0;
1544               myresume (own_buf, 0, &signal, &status);
1545               break;
1546             case 's':
1547               require_running (own_buf);
1548               signal = 0;
1549               myresume (own_buf, 1, &signal, &status);
1550               break;
1551             case 'Z':
1552               {
1553                 char *lenptr;
1554                 char *dataptr;
1555                 CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
1556                 int len = strtol (lenptr + 1, &dataptr, 16);
1557                 char type = own_buf[1];
1558
1559                 if (the_target->insert_watchpoint == NULL
1560                     || (type < '2' || type > '4'))
1561                   {
1562                     /* No watchpoint support or not a watchpoint command;
1563                        unrecognized either way.  */
1564                     own_buf[0] = '\0';
1565                   }
1566                 else
1567                   {
1568                     int res;
1569
1570                     require_running (own_buf);
1571                     res = (*the_target->insert_watchpoint) (type, addr, len);
1572                     if (res == 0)
1573                       write_ok (own_buf);
1574                     else if (res == 1)
1575                       /* Unsupported.  */
1576                       own_buf[0] = '\0';
1577                     else
1578                       write_enn (own_buf);
1579                   }
1580                 break;
1581               }
1582             case 'z':
1583               {
1584                 char *lenptr;
1585                 char *dataptr;
1586                 CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
1587                 int len = strtol (lenptr + 1, &dataptr, 16);
1588                 char type = own_buf[1];
1589
1590                 if (the_target->remove_watchpoint == NULL
1591                     || (type < '2' || type > '4'))
1592                   {
1593                     /* No watchpoint support or not a watchpoint command;
1594                        unrecognized either way.  */
1595                     own_buf[0] = '\0';
1596                   }
1597                 else
1598                   {
1599                     int res;
1600
1601                     require_running (own_buf);
1602                     res = (*the_target->remove_watchpoint) (type, addr, len);
1603                     if (res == 0)
1604                       write_ok (own_buf);
1605                     else if (res == 1)
1606                       /* Unsupported.  */
1607                       own_buf[0] = '\0';
1608                     else
1609                       write_enn (own_buf);
1610                   }
1611                 break;
1612               }
1613             case 'k':
1614               response_needed = 0;
1615               if (!target_running ())
1616                 /* The packet we received doesn't make sense - but we
1617                    can't reply to it, either.  */
1618                 goto restart;
1619
1620               fprintf (stderr, "Killing inferior\n");
1621               kill_inferior ();
1622
1623               /* When using the extended protocol, we wait with no
1624                  program running.  The traditional protocol will exit
1625                  instead.  */
1626               if (extended_protocol)
1627                 {
1628                   status = 'X';
1629                   signal = TARGET_SIGNAL_KILL;
1630                   was_running = 0;
1631                   goto restart;
1632                 }
1633               else
1634                 {
1635                   exit (0);
1636                   break;
1637                 }
1638             case 'T':
1639               {
1640                 unsigned long gdb_id, thread_id;
1641
1642                 require_running (own_buf);
1643                 gdb_id = strtoul (&own_buf[1], NULL, 16);
1644                 thread_id = gdb_id_to_thread_id (gdb_id);
1645                 if (thread_id == 0)
1646                   {
1647                     write_enn (own_buf);
1648                     break;
1649                   }
1650
1651                 if (mythread_alive (thread_id))
1652                   write_ok (own_buf);
1653                 else
1654                   write_enn (own_buf);
1655               }
1656               break;
1657             case 'R':
1658               response_needed = 0;
1659
1660               /* Restarting the inferior is only supported in the
1661                  extended protocol.  */
1662               if (extended_protocol)
1663                 {
1664                   if (target_running ())
1665                     kill_inferior ();
1666                   fprintf (stderr, "GDBserver restarting\n");
1667
1668                   /* Wait till we are at 1st instruction in prog.  */
1669                   if (program_argv != NULL)
1670                     signal = start_inferior (program_argv, &status);
1671                   else
1672                     {
1673                       status = 'X';
1674                       signal = TARGET_SIGNAL_KILL;
1675                     }
1676                   goto restart;
1677                 }
1678               else
1679                 {
1680                   /* It is a request we don't understand.  Respond with an
1681                      empty packet so that gdb knows that we don't support this
1682                      request.  */
1683                   own_buf[0] = '\0';
1684                   break;
1685                 }
1686             case 'v':
1687               /* Extended (long) request.  */
1688               handle_v_requests (own_buf, &status, &signal,
1689                                  packet_len, &new_packet_len);
1690               break;
1691
1692             default:
1693               /* It is a request we don't understand.  Respond with an
1694                  empty packet so that gdb knows that we don't support this
1695                  request.  */
1696               own_buf[0] = '\0';
1697               break;
1698             }
1699
1700           if (new_packet_len != -1)
1701             putpkt_binary (own_buf, new_packet_len);
1702           else
1703             putpkt (own_buf);
1704
1705           response_needed = 0;
1706
1707           if (was_running && (status == 'W' || status == 'X'))
1708             {
1709               was_running = 0;
1710
1711               if (status == 'W')
1712                 fprintf (stderr,
1713                          "\nChild exited with status %d\n", signal);
1714               if (status == 'X')
1715                 fprintf (stderr, "\nChild terminated with signal = 0x%x (%s)\n",
1716                          target_signal_to_host (signal),
1717                          target_signal_to_name (signal));
1718
1719               if (extended_protocol)
1720                 goto restart;
1721               else
1722                 {
1723                   fprintf (stderr, "GDBserver exiting\n");
1724                   exit (0);
1725                 }
1726             }
1727
1728           if (status != 'W' && status != 'X')
1729             was_running = 1;
1730         }
1731
1732       /* If an exit was requested (using the "monitor exit" command),
1733          terminate now.  The only other way to get here is for
1734          getpkt to fail; close the connection and reopen it at the
1735          top of the loop.  */
1736
1737       if (exit_requested)
1738         {
1739           remote_close ();
1740           if (attached && target_running ())
1741             detach_inferior ();
1742           else if (target_running ())
1743             kill_inferior ();
1744           exit (0);
1745         }
1746       else
1747         {
1748           fprintf (stderr, "Remote side has terminated connection.  "
1749                            "GDBserver will reopen the connection.\n");
1750           remote_close ();
1751         }
1752     }
1753 }