gdb/gdbserver/server.c

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