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, 2009 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       if (data == NULL)
 653         {
 654           write_enn (own_buf);
 655           return;
 656         }
 657       n = (*the_target->read_auxv) (ofs, data, len + 1);
 658       if (n < 0)
 659         write_enn (own_buf);
 660       else if (n > len)
 661         *new_packet_len_p = write_qxfer_response (own_buf, data, len, 1);
 662       else
 663         *new_packet_len_p = write_qxfer_response (own_buf, data, n, 0);
 664
 665       free (data);
 666
 667       return;
 668     }
 669
 670   if (strncmp ("qXfer:features:read:", own_buf, 20) == 0)
 671     {
 672       CORE_ADDR ofs;
 673       unsigned int len, total_len;
 674       const char *document;
 675       char *annex;
 676
 677       require_running (own_buf);
 678
 679       /* Grab the annex, offset, and length.  */
 680       if (decode_xfer_read (own_buf + 20, &annex, &ofs, &len) < 0)
 681         {
 682           strcpy (own_buf, "E00");
 683           return;
 684         }
 685
 686       /* Now grab the correct annex.  */
 687       document = get_features_xml (annex);
 688       if (document == NULL)
 689         {
 690           strcpy (own_buf, "E00");
 691           return;
 692         }
 693
 694       total_len = strlen (document);
 695       if (len > PBUFSIZ - 2)
 696         len = PBUFSIZ - 2;
 697
 698       if (ofs > total_len)
 699         write_enn (own_buf);
 700       else if (len < total_len - ofs)
 701         *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
 702                                                   len, 1);
 703       else
 704         *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
 705                                                   total_len - ofs, 0);
 706
 707       return;
 708     }
 709
 710   if (strncmp ("qXfer:libraries:read:", own_buf, 21) == 0)
 711     {
 712       CORE_ADDR ofs;
 713       unsigned int len, total_len;
 714       char *document, *p;
 715       struct inferior_list_entry *dll_ptr;
 716       char *annex;
 717
 718       require_running (own_buf);
 719
 720       /* Reject any annex; grab the offset and length.  */
 721       if (decode_xfer_read (own_buf + 21, &annex, &ofs, &len) < 0
 722           || annex[0] != '\0')
 723         {
 724           strcpy (own_buf, "E00");
 725           return;
 726         }
 727
 728       /* Over-estimate the necessary memory.  Assume that every character
 729          in the library name must be escaped.  */
 730       total_len = 64;
 731       for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
 732         total_len += 128 + 6 * strlen (((struct dll_info *) dll_ptr)->name);
 733
 734       document = malloc (total_len);
 735       if (document == NULL)
 736         {
 737           write_enn (own_buf);
 738           return;
 739         }
 740       strcpy (document, "<library-list>\n");
 741       p = document + strlen (document);
 742
 743       for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
 744         {
 745           struct dll_info *dll = (struct dll_info *) dll_ptr;
 746           char *name;
 747
 748           strcpy (p, "  <library name=\"");
 749           p = p + strlen (p);
 750           name = xml_escape_text (dll->name);
 751           strcpy (p, name);
 752           free (name);
 753           p = p + strlen (p);
 754           strcpy (p, "\"><segment address=\"");
 755           p = p + strlen (p);
 756           sprintf (p, "0x%lx", (long) dll->base_addr);
 757           p = p + strlen (p);
 758           strcpy (p, "\"/></library>\n");
 759           p = p + strlen (p);
 760         }
 761
 762       strcpy (p, "</library-list>\n");
 763
 764       total_len = strlen (document);
 765       if (len > PBUFSIZ - 2)
 766         len = PBUFSIZ - 2;
 767
 768       if (ofs > total_len)
 769         write_enn (own_buf);
 770       else if (len < total_len - ofs)
 771         *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
 772                                                   len, 1);
 773       else
 774         *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
 775                                                   total_len - ofs, 0);
 776
 777       free (document);
 778       return;
 779     }
 780
 781   if (the_target->qxfer_osdata != NULL
 782       && strncmp ("qXfer:osdata:read:", own_buf, 18) == 0)
 783     {
 784       char *annex;
 785       int n;
 786       unsigned int len;
 787       CORE_ADDR ofs;
 788       unsigned char *workbuf;
 789
 790       strcpy (own_buf, "E00");
 791       if (decode_xfer_read (own_buf + 18, &annex, &ofs, &len) < 0)
 792        return;
 793       if (len > PBUFSIZ - 2)
 794        len = PBUFSIZ - 2;
 795       workbuf = malloc (len + 1);
 796       if (!workbuf)
 797         return;
 798
 799       n = (*the_target->qxfer_osdata) (annex, workbuf, NULL, ofs, len + 1);
 800       if (n < 0)
 801        write_enn (own_buf);
 802       else if (n > len)
 803        *new_packet_len_p = write_qxfer_response
 804                              (own_buf, workbuf, len, 1);
 805       else
 806        *new_packet_len_p = write_qxfer_response
 807                              (own_buf, workbuf, n, 0);
 808
 809       free (workbuf);
 810       return;
 811     }
 812
 813   if (the_target->qxfer_siginfo != NULL
 814       && strncmp ("qXfer:siginfo:read:", own_buf, 19) == 0)
 815     {
 816       unsigned char *data;
 817       int n;
 818       CORE_ADDR ofs;
 819       unsigned int len;
 820       char *annex;
 821
 822       require_running (own_buf);
 823
 824       /* Reject any annex; grab the offset and length.  */
 825       if (decode_xfer_read (own_buf + 19, &annex, &ofs, &len) < 0
 826           || annex[0] != '\0')
 827         {
 828           strcpy (own_buf, "E00");
 829           return;
 830         }
 831
 832       /* Read one extra byte, as an indicator of whether there is
 833          more.  */
 834       if (len > PBUFSIZ - 2)
 835         len = PBUFSIZ - 2;
 836       data = malloc (len + 1);
 837       if (!data)
 838         return;
 839       n = (*the_target->qxfer_siginfo) (annex, data, NULL, ofs, len + 1);
 840       if (n < 0)
 841         write_enn (own_buf);
 842       else if (n > len)
 843         *new_packet_len_p = write_qxfer_response (own_buf, data, len, 1);
 844       else
 845         *new_packet_len_p = write_qxfer_response (own_buf, data, n, 0);
 846
 847       free (data);
 848       return;
 849     }
 850
 851   if (the_target->qxfer_siginfo != NULL
 852       && strncmp ("qXfer:siginfo:write:", own_buf, 20) == 0)
 853     {
 854       char *annex;
 855       int n;
 856       unsigned int len;
 857       CORE_ADDR ofs;
 858       unsigned char *data;
 859
 860       require_running (own_buf);
 861
 862       strcpy (own_buf, "E00");
 863       data = malloc (packet_len - 19);
 864       if (!data)
 865         return;
 866       if (decode_xfer_write (own_buf + 20, packet_len - 20, &annex,
 867                              &ofs, &len, data) < 0)
 868         {
 869           free (data);
 870           return;
 871         }
 872
 873       n = (*the_target->qxfer_siginfo)
 874         (annex, NULL, (unsigned const char *)data, ofs, len);
 875       if (n < 0)
 876         write_enn (own_buf);
 877       else
 878         sprintf (own_buf, "%x", n);
 879
 880       free (data);
 881       return;
 882     }
 883
 884   /* Protocol features query.  */
 885   if (strncmp ("qSupported", own_buf, 10) == 0
 886       && (own_buf[10] == ':' || own_buf[10] == '\0'))
 887     {
 888       sprintf (own_buf, "PacketSize=%x;QPassSignals+", PBUFSIZ - 1);
 889
 890       /* We do not have any hook to indicate whether the target backend
 891          supports qXfer:libraries:read, so always report it.  */
 892       strcat (own_buf, ";qXfer:libraries:read+");
 893
 894       if (the_target->read_auxv != NULL)
 895         strcat (own_buf, ";qXfer:auxv:read+");
 896
 897       if (the_target->qxfer_spu != NULL)
 898         strcat (own_buf, ";qXfer:spu:read+;qXfer:spu:write+");
 899
 900       if (the_target->qxfer_siginfo != NULL)
 901         strcat (own_buf, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
 902
 903       /* We always report qXfer:features:read, as targets may
 904          install XML files on a subsequent call to arch_setup.
 905          If we reported to GDB on startup that we don't support
 906          qXfer:feature:read at all, we will never be re-queried.  */
 907       strcat (own_buf, ";qXfer:features:read+");
 908
 909       if (transport_is_reliable)
 910         strcat (own_buf, ";QStartNoAckMode+");
 911
 912       if (the_target->qxfer_osdata != NULL)
 913         strcat (own_buf, ";qXfer:osdata:read+");
 914
 915       return;
 916     }
 917
 918   /* Thread-local storage support.  */
 919   if (the_target->get_tls_address != NULL
 920       && strncmp ("qGetTLSAddr:", own_buf, 12) == 0)
 921     {
 922       char *p = own_buf + 12;
 923       CORE_ADDR parts[3], address = 0;
 924       int i, err;
 925
 926       require_running (own_buf);
 927
 928       for (i = 0; i < 3; i++)
 929         {
 930           char *p2;
 931           int len;
 932
 933           if (p == NULL)
 934             break;
 935
 936           p2 = strchr (p, ',');
 937           if (p2)
 938             {
 939               len = p2 - p;
 940               p2++;
 941             }
 942           else
 943             {
 944               len = strlen (p);
 945               p2 = NULL;
 946             }
 947
 948           decode_address (&parts[i], p, len);
 949           p = p2;
 950         }
 951
 952       if (p != NULL || i < 3)
 953         err = 1;
 954       else
 955         {
 956           struct thread_info *thread = gdb_id_to_thread (parts[0]);
 957
 958           if (thread == NULL)
 959             err = 2;
 960           else
 961             err = the_target->get_tls_address (thread, parts[1], parts[2],
 962                                                &address);
 963         }
 964
 965       if (err == 0)
 966         {
 967           sprintf (own_buf, "%llx", address);
 968           return;
 969         }
 970       else if (err > 0)
 971         {
 972           write_enn (own_buf);
 973           return;
 974         }
 975
 976       /* Otherwise, pretend we do not understand this packet.  */
 977     }
 978
 979   /* Handle "monitor" commands.  */
 980   if (strncmp ("qRcmd,", own_buf, 6) == 0)
 981     {
 982       char *mon = malloc (PBUFSIZ);
 983       int len = strlen (own_buf + 6);
 984
 985       if (mon == NULL)
 986         {
 987           write_enn (own_buf);
 988           return;
 989         }
 990
 991       if ((len % 2) != 0 || unhexify (mon, own_buf + 6, len / 2) != len / 2)
 992         {
 993           write_enn (own_buf);
 994           free (mon);
 995           return;
 996         }
 997       mon[len / 2] = '\0';
 998
 999       write_ok (own_buf);
1000
1001       if (strcmp (mon, "set debug 1") == 0)
1002         {
1003           debug_threads = 1;
1004           monitor_output ("Debug output enabled.\n");
1005         }
1006       else if (strcmp (mon, "set debug 0") == 0)
1007         {
1008           debug_threads = 0;
1009           monitor_output ("Debug output disabled.\n");
1010         }
1011       else if (strcmp (mon, "set remote-debug 1") == 0)
1012         {
1013           remote_debug = 1;
1014           monitor_output ("Protocol debug output enabled.\n");
1015         }
1016       else if (strcmp (mon, "set remote-debug 0") == 0)
1017         {
1018           remote_debug = 0;
1019           monitor_output ("Protocol debug output disabled.\n");
1020         }
1021       else if (strcmp (mon, "help") == 0)
1022         monitor_show_help ();
1023       else if (strcmp (mon, "exit") == 0)
1024         exit_requested = 1;
1025       else
1026         {
1027           monitor_output ("Unknown monitor command.\n\n");
1028           monitor_show_help ();
1029           write_enn (own_buf);
1030         }
1031
1032       free (mon);
1033       return;
1034     }
1035
1036   if (strncmp ("qSearch:memory:", own_buf, sizeof ("qSearch:memory:") - 1) == 0)
1037     {
1038       require_running (own_buf);
1039       handle_search_memory (own_buf, packet_len);
1040       return;
1041     }
1042
1043   if (strcmp (own_buf, "qAttached") == 0)
1044     {
1045       require_running (own_buf);
1046       strcpy (own_buf, attached ? "1" : "0");
1047       return;
1048     }
1049
1050   /* Otherwise we didn't know what packet it was.  Say we didn't
1051      understand it.  */
1052   own_buf[0] = 0;
1053 }
1054
1055 /* Parse vCont packets.  */
1056 void
1057 handle_v_cont (char *own_buf, char *status, int *signal)
1058 {
1059   char *p, *q;
1060   int n = 0, i = 0;
1061   struct thread_resume *resume_info, default_action;
1062
1063   /* Count the number of semicolons in the packet.  There should be one
1064      for every action.  */
1065   p = &own_buf[5];
1066   while (p)
1067     {
1068       n++;
1069       p++;
1070       p = strchr (p, ';');
1071     }
1072   /* Allocate room for one extra action, for the default remain-stopped
1073      behavior; if no default action is in the list, we'll need the extra
1074      slot.  */
1075   resume_info = malloc ((n + 1) * sizeof (resume_info[0]));
1076   if (resume_info == NULL)
1077     goto err;
1078
1079   default_action.thread = -1;
1080   default_action.leave_stopped = 1;
1081   default_action.step = 0;
1082   default_action.sig = 0;
1083
1084   p = &own_buf[5];
1085   i = 0;
1086   while (*p)
1087     {
1088       p++;
1089
1090       resume_info[i].leave_stopped = 0;
1091
1092       if (p[0] == 's' || p[0] == 'S')
1093         resume_info[i].step = 1;
1094       else if (p[0] == 'c' || p[0] == 'C')
1095         resume_info[i].step = 0;
1096       else
1097         goto err;
1098
1099       if (p[0] == 'S' || p[0] == 'C')
1100         {
1101           int sig;
1102           sig = strtol (p + 1, &q, 16);
1103           if (p == q)
1104             goto err;
1105           p = q;
1106
1107           if (!target_signal_to_host_p (sig))
1108             goto err;
1109           resume_info[i].sig = target_signal_to_host (sig);
1110         }
1111       else
1112         {
1113           resume_info[i].sig = 0;
1114           p = p + 1;
1115         }
1116
1117       if (p[0] == 0)
1118         {
1119           resume_info[i].thread = -1;
1120           default_action = resume_info[i];
1121
1122           /* Note: we don't increment i here, we'll overwrite this entry
1123              the next time through.  */
1124         }
1125       else if (p[0] == ':')
1126         {
1127           unsigned int gdb_id = strtoul (p + 1, &q, 16);
1128           unsigned long thread_id;
1129
1130           if (p == q)
1131             goto err;
1132           p = q;
1133           if (p[0] != ';' && p[0] != 0)
1134             goto err;
1135
1136           thread_id = gdb_id_to_thread_id (gdb_id);
1137           if (thread_id)
1138             resume_info[i].thread = thread_id;
1139           else
1140             goto err;
1141
1142           i++;
1143         }
1144     }
1145
1146   resume_info[i] = default_action;
1147
1148   /* Still used in occasional places in the backend.  */
1149   if (n == 1 && resume_info[0].thread != -1)
1150     cont_thread = resume_info[0].thread;
1151   else
1152     cont_thread = -1;
1153   set_desired_inferior (0);
1154
1155   enable_async_io ();
1156   (*the_target->resume) (resume_info);
1157
1158   free (resume_info);
1159
1160   *signal = mywait (status, 1);
1161   prepare_resume_reply (own_buf, *status, *signal);
1162   disable_async_io ();
1163   return;
1164
1165 err:
1166   write_enn (own_buf);
1167   free (resume_info);
1168   return;
1169 }
1170
1171 /* Attach to a new program.  Return 1 if successful, 0 if failure.  */
1172 int
1173 handle_v_attach (char *own_buf, char *status, int *signal)
1174 {
1175   int pid;
1176
1177   pid = strtol (own_buf + 8, NULL, 16);
1178   if (pid != 0 && attach_inferior (pid, status, signal) == 0)
1179     {
1180       /* Don't report shared library events after attaching, even if
1181          some libraries are preloaded.  GDB will always poll the
1182          library list.  Avoids the "stopped by shared library event"
1183          notice on the GDB side.  */
1184       dlls_changed = 0;
1185       prepare_resume_reply (own_buf, *status, *signal);
1186       return 1;
1187     }
1188   else
1189     {
1190       write_enn (own_buf);
1191       return 0;
1192     }
1193 }
1194
1195 /* Run a new program.  Return 1 if successful, 0 if failure.  */
1196 static int
1197 handle_v_run (char *own_buf, char *status, int *signal)
1198 {
1199   char *p, *next_p, **new_argv;
1200   int i, new_argc;
1201
1202   new_argc = 0;
1203   for (p = own_buf + strlen ("vRun;"); p && *p; p = strchr (p, ';'))
1204     {
1205       p++;
1206       new_argc++;
1207     }
1208
1209   new_argv = calloc (new_argc + 2, sizeof (char *));
1210   if (new_argv == NULL)
1211     {
1212       write_enn (own_buf);
1213       return 0;
1214     }
1215
1216   i = 0;
1217   for (p = own_buf + strlen ("vRun;"); *p; p = next_p)
1218     {
1219       next_p = strchr (p, ';');
1220       if (next_p == NULL)
1221         next_p = p + strlen (p);
1222
1223       if (i == 0 && p == next_p)
1224         new_argv[i] = NULL;
1225       else
1226         {
1227           /* FIXME: Fail request if out of memory instead of dying.  */
1228           new_argv[i] = xmalloc (1 + (next_p - p) / 2);
1229           unhexify (new_argv[i], p, (next_p - p) / 2);
1230           new_argv[i][(next_p - p) / 2] = '\0';
1231         }
1232
1233       if (*next_p)
1234         next_p++;
1235       i++;
1236     }
1237   new_argv[i] = NULL;
1238
1239   if (new_argv[0] == NULL)
1240     {
1241       /* GDB didn't specify a program to run.  Use the program from the
1242          last run with the new argument list.  */
1243
1244       if (program_argv == NULL)
1245         {
1246           /* FIXME: new_argv memory leak */
1247           write_enn (own_buf);
1248           return 0;
1249         }
1250
1251       new_argv[0] = strdup (program_argv[0]);
1252       if (new_argv[0] == NULL)
1253         {
1254           /* FIXME: new_argv memory leak */
1255           write_enn (own_buf);
1256           return 0;
1257         }
1258     }
1259
1260   /* Free the old argv and install the new one.  */
1261   freeargv (program_argv);
1262   program_argv = new_argv;
1263
1264   *signal = start_inferior (program_argv, status);
1265   if (*status == 'T')
1266     {
1267       prepare_resume_reply (own_buf, *status, *signal);
1268       return 1;
1269     }
1270   else
1271     {
1272       write_enn (own_buf);
1273       return 0;
1274     }
1275 }
1276
1277 /* Handle all of the extended 'v' packets.  */
1278 void
1279 handle_v_requests (char *own_buf, char *status, int *signal,
1280                    int packet_len, int *new_packet_len)
1281 {
1282   if (!disable_packet_vCont)
1283     {
1284       if (strncmp (own_buf, "vCont;", 6) == 0)
1285         {
1286           require_running (own_buf);
1287           handle_v_cont (own_buf, status, signal);
1288           return;
1289         }
1290
1291       if (strncmp (own_buf, "vCont?", 6) == 0)
1292         {
1293           strcpy (own_buf, "vCont;c;C;s;S");
1294           return;
1295         }
1296     }
1297
1298   if (strncmp (own_buf, "vFile:", 6) == 0
1299       && handle_vFile (own_buf, packet_len, new_packet_len))
1300     return;
1301
1302   if (strncmp (own_buf, "vAttach;", 8) == 0)
1303     {
1304       if (target_running ())
1305         {
1306           fprintf (stderr, "Already debugging a process\n");
1307           write_enn (own_buf);
1308           return;
1309         }
1310       handle_v_attach (own_buf, status, signal);
1311       return;
1312     }
1313
1314   if (strncmp (own_buf, "vRun;", 5) == 0)
1315     {
1316       if (target_running ())
1317         {
1318           fprintf (stderr, "Already debugging a process\n");
1319           write_enn (own_buf);
1320           return;
1321         }
1322       handle_v_run (own_buf, status, signal);
1323       return;
1324     }
1325
1326   /* Otherwise we didn't know what packet it was.  Say we didn't
1327      understand it.  */
1328   own_buf[0] = 0;
1329   return;
1330 }
1331
1332 void
1333 myresume (char *own_buf, int step, int *signalp, char *statusp)
1334 {
1335   struct thread_resume resume_info[2];
1336   int n = 0;
1337   int sig = *signalp;
1338
1339   set_desired_inferior (0);
1340
1341   if (step || sig || (cont_thread != 0 && cont_thread != -1))
1342     {
1343       resume_info[0].thread
1344         = ((struct inferior_list_entry *) current_inferior)->id;
1345       resume_info[0].step = step;
1346       resume_info[0].sig = sig;
1347       resume_info[0].leave_stopped = 0;
1348       n++;
1349     }
1350   resume_info[n].thread = -1;
1351   resume_info[n].step = 0;
1352   resume_info[n].sig = 0;
1353   resume_info[n].leave_stopped = (cont_thread != 0 && cont_thread != -1);
1354
1355   enable_async_io ();
1356   (*the_target->resume) (resume_info);
1357   *signalp = mywait (statusp, 1);
1358   prepare_resume_reply (own_buf, *statusp, *signalp);
1359   disable_async_io ();
1360 }
1361
1362 static void
1363 gdbserver_version (void)
1364 {
1365   printf ("GNU gdbserver %s%s\n"
1366           "Copyright (C) 2009 Free Software Foundation, Inc.\n"
1367           "gdbserver is free software, covered by the GNU General Public License.\n"
1368           "This gdbserver was configured as \"%s\"\n",
1369           PKGVERSION, version, host_name);
1370 }
1371
1372 static void
1373 gdbserver_usage (FILE *stream)
1374 {
1375   fprintf (stream, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
1376            "\tgdbserver [OPTIONS] --attach COMM PID\n"
1377            "\tgdbserver [OPTIONS] --multi COMM\n"
1378            "\n"
1379            "COMM may either be a tty device (for serial debugging), or \n"
1380            "HOST:PORT to listen for a TCP connection.\n"
1381            "\n"
1382            "Options:\n"
1383            "  --debug               Enable general debugging output.\n"
1384            "  --remote-debug        Enable remote protocol debugging output.\n"
1385            "  --version             Display version information and exit.\n"
1386            "  --wrapper WRAPPER --  Run WRAPPER to start new programs.\n");
1387   if (REPORT_BUGS_TO[0] && stream == stdout)
1388     fprintf (stream, "Report bugs to \"%s\".\n", REPORT_BUGS_TO);
1389 }
1390
1391 static void
1392 gdbserver_show_disableable (FILE *stream)
1393 {
1394   fprintf (stream, "Disableable packets:\n"
1395            "  vCont       \tAll vCont packets\n"
1396            "  qC          \tQuerying the current thread\n"
1397            "  qfThreadInfo\tThread listing\n"
1398            "  Tthread     \tPassing the thread specifier in the T stop reply packet\n"
1399            "  threads     \tAll of the above\n");
1400 }
1401
1402
1403 #undef require_running
1404 #define require_running(BUF)                    \
1405   if (!target_running ())                       \
1406     {                                           \
1407       write_enn (BUF);                          \
1408       break;                                    \
1409     }
1410
1411 int
1412 main (int argc, char *argv[])
1413 {
1414   char ch, status, *own_buf;
1415   unsigned char *mem_buf;
1416   int i = 0;
1417   int signal;
1418   unsigned int len;
1419   CORE_ADDR mem_addr;
1420   int bad_attach;
1421   int pid;
1422   char *arg_end, *port;
1423   char **next_arg = &argv[1];
1424   int multi_mode = 0;
1425   int attach = 0;
1426   int was_running;
1427
1428   while (*next_arg != NULL && **next_arg == '-')
1429     {
1430       if (strcmp (*next_arg, "--version") == 0)
1431         {
1432           gdbserver_version ();
1433           exit (0);
1434         }
1435       else if (strcmp (*next_arg, "--help") == 0)
1436         {
1437           gdbserver_usage (stdout);
1438           exit (0);
1439         }
1440       else if (strcmp (*next_arg, "--attach") == 0)
1441         attach = 1;
1442       else if (strcmp (*next_arg, "--multi") == 0)
1443         multi_mode = 1;
1444       else if (strcmp (*next_arg, "--wrapper") == 0)
1445         {
1446           next_arg++;
1447
1448           wrapper_argv = next_arg;
1449           while (*next_arg != NULL && strcmp (*next_arg, "--") != 0)
1450             next_arg++;
1451
1452           if (next_arg == wrapper_argv || *next_arg == NULL)
1453             {
1454               gdbserver_usage (stderr);
1455               exit (1);
1456             }
1457
1458           /* Consume the "--".  */
1459           *next_arg = NULL;
1460         }
1461       else if (strcmp (*next_arg, "--debug") == 0)
1462         debug_threads = 1;
1463       else if (strcmp (*next_arg, "--remote-debug") == 0)
1464         remote_debug = 1;
1465       else if (strcmp (*next_arg, "--disable-packet") == 0)
1466         {
1467           gdbserver_show_disableable (stdout);
1468           exit (0);
1469         }
1470       else if (strncmp (*next_arg,
1471                         "--disable-packet=",
1472                         sizeof ("--disable-packet=") - 1) == 0)
1473         {
1474           char *packets, *tok;
1475
1476           packets = *next_arg += sizeof ("--disable-packet=") - 1;
1477           for (tok = strtok (packets, ",");
1478                tok != NULL;
1479                tok = strtok (NULL, ","))
1480             {
1481               if (strcmp ("vCont", tok) == 0)
1482                 disable_packet_vCont = 1;
1483               else if (strcmp ("Tthread", tok) == 0)
1484                 disable_packet_Tthread = 1;
1485               else if (strcmp ("qC", tok) == 0)
1486                 disable_packet_qC = 1;
1487               else if (strcmp ("qfThreadInfo", tok) == 0)
1488                 disable_packet_qfThreadInfo = 1;
1489               else if (strcmp ("threads", tok) == 0)
1490                 {
1491                   disable_packet_vCont = 1;
1492                   disable_packet_Tthread = 1;
1493                   disable_packet_qC = 1;
1494                   disable_packet_qfThreadInfo = 1;
1495                 }
1496               else
1497                 {
1498                   fprintf (stderr, "Don't know how to disable \"%s\".\n\n",
1499                            tok);
1500                   gdbserver_show_disableable (stderr);
1501                   exit (1);
1502                 }
1503             }
1504         }
1505       else
1506         {
1507           fprintf (stderr, "Unknown argument: %s\n", *next_arg);
1508           exit (1);
1509         }
1510
1511       next_arg++;
1512       continue;
1513     }
1514
1515   if (setjmp (toplevel))
1516     {
1517       fprintf (stderr, "Exiting\n");
1518       exit (1);
1519     }
1520
1521   port = *next_arg;
1522   next_arg++;
1523   if (port == NULL || (!attach && !multi_mode && *next_arg == NULL))
1524     {
1525       gdbserver_usage (stderr);
1526       exit (1);
1527     }
1528
1529   bad_attach = 0;
1530   pid = 0;
1531
1532   /* --attach used to come after PORT, so allow it there for
1533        compatibility.  */
1534   if (*next_arg != NULL && strcmp (*next_arg, "--attach") == 0)
1535     {
1536       attach = 1;
1537       next_arg++;
1538     }
1539
1540   if (attach
1541       && (*next_arg == NULL
1542           || (*next_arg)[0] == '\0'
1543           || (pid = strtoul (*next_arg, &arg_end, 0)) == 0
1544           || *arg_end != '\0'
1545           || next_arg[1] != NULL))
1546     bad_attach = 1;
1547
1548   if (bad_attach)
1549     {
1550       gdbserver_usage (stderr);
1551       exit (1);
1552     }
1553
1554   initialize_async_io ();
1555   initialize_low ();
1556
1557   own_buf = xmalloc (PBUFSIZ + 1);
1558   mem_buf = xmalloc (PBUFSIZ);
1559
1560   if (pid == 0 && *next_arg != NULL)
1561     {
1562       int i, n;
1563
1564       n = argc - (next_arg - argv);
1565       program_argv = xmalloc (sizeof (char *) * (n + 1));
1566       for (i = 0; i < n; i++)
1567         program_argv[i] = xstrdup (next_arg[i]);
1568       program_argv[i] = NULL;
1569
1570       /* Wait till we are at first instruction in program.  */
1571       signal = start_inferior (program_argv, &status);
1572
1573       /* We are now (hopefully) stopped at the first instruction of
1574          the target process.  This assumes that the target process was
1575          successfully created.  */
1576     }
1577   else if (pid != 0)
1578     {
1579       if (attach_inferior (pid, &status, &signal) == -1)
1580         error ("Attaching not supported on this target");
1581
1582       /* Otherwise succeeded.  */
1583     }
1584   else
1585     {
1586       status = 'W';
1587       signal = 0;
1588     }
1589
1590   /* Don't report shared library events on the initial connection,
1591      even if some libraries are preloaded.  Avoids the "stopped by
1592      shared library event" notice on gdb side.  */
1593   dlls_changed = 0;
1594
1595   if (setjmp (toplevel))
1596     {
1597       fprintf (stderr, "Killing inferior\n");
1598       kill_inferior ();
1599       exit (1);
1600     }
1601
1602   if (status == 'W' || status == 'X')
1603     was_running = 0;
1604   else
1605     was_running = 1;
1606
1607   if (!was_running && !multi_mode)
1608     {
1609       fprintf (stderr, "No program to debug.  GDBserver exiting.\n");
1610       exit (1);
1611     }
1612
1613   while (1)
1614     {
1615       noack_mode = 0;
1616       remote_open (port);
1617
1618     restart:
1619       if (setjmp (toplevel) != 0)
1620         {
1621           /* An error occurred.  */
1622           if (response_needed)
1623             {
1624               write_enn (own_buf);
1625               putpkt (own_buf);
1626             }
1627         }
1628
1629       disable_async_io ();
1630       while (!exit_requested)
1631         {
1632           unsigned char sig;
1633           int packet_len;
1634           int new_packet_len = -1;
1635
1636           response_needed = 0;
1637           packet_len = getpkt (own_buf);
1638           if (packet_len <= 0)
1639             break;
1640           response_needed = 1;
1641
1642           i = 0;
1643           ch = own_buf[i++];
1644           switch (ch)
1645             {
1646             case 'q':
1647               handle_query (own_buf, packet_len, &new_packet_len);
1648               break;
1649             case 'Q':
1650               handle_general_set (own_buf);
1651               break;
1652             case 'D':
1653               require_running (own_buf);
1654               fprintf (stderr, "Detaching from inferior\n");
1655               if (detach_inferior () != 0)
1656                 write_enn (own_buf);
1657               else
1658                 {
1659                   write_ok (own_buf);
1660
1661                   if (extended_protocol)
1662                     {
1663                       /* Treat this like a normal program exit.  */
1664                       signal = 0;
1665                       status = 'W';
1666                     }
1667                   else
1668                     {
1669                       putpkt (own_buf);
1670                       remote_close ();
1671
1672                       /* If we are attached, then we can exit.  Otherwise, we
1673                          need to hang around doing nothing, until the child
1674                          is gone.  */
1675                       if (!attached)
1676                         join_inferior ();
1677
1678                       exit (0);
1679                     }
1680                 }
1681               break;
1682             case '!':
1683               extended_protocol = 1;
1684               write_ok (own_buf);
1685               break;
1686             case '?':
1687               prepare_resume_reply (own_buf, status, signal);
1688               break;
1689             case 'H':
1690               if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
1691                 {
1692                   unsigned long gdb_id, thread_id;
1693
1694                   require_running (own_buf);
1695                   gdb_id = strtoul (&own_buf[2], NULL, 16);
1696                   if (gdb_id == 0 || gdb_id == -1)
1697                     thread_id = gdb_id;
1698                   else
1699                     {
1700                       thread_id = gdb_id_to_thread_id (gdb_id);
1701                       if (thread_id == 0)
1702                         {
1703                           write_enn (own_buf);
1704                           break;
1705                         }
1706                     }
1707
1708                   if (own_buf[1] == 'g')
1709                     {
1710                       general_thread = thread_id;
1711                       set_desired_inferior (1);
1712                     }
1713                   else if (own_buf[1] == 'c')
1714                     cont_thread = thread_id;
1715                   else if (own_buf[1] == 's')
1716                     step_thread = thread_id;
1717
1718                   write_ok (own_buf);
1719                 }
1720               else
1721                 {
1722                   /* Silently ignore it so that gdb can extend the protocol
1723                      without compatibility headaches.  */
1724                   own_buf[0] = '\0';
1725                 }
1726               break;
1727             case 'g':
1728               require_running (own_buf);
1729               set_desired_inferior (1);
1730               registers_to_string (own_buf);
1731               break;
1732             case 'G':
1733               require_running (own_buf);
1734               set_desired_inferior (1);
1735               registers_from_string (&own_buf[1]);
1736               write_ok (own_buf);
1737               break;
1738             case 'm':
1739               require_running (own_buf);
1740               decode_m_packet (&own_buf[1], &mem_addr, &len);
1741               if (read_inferior_memory (mem_addr, mem_buf, len) == 0)
1742                 convert_int_to_ascii (mem_buf, own_buf, len);
1743               else
1744                 write_enn (own_buf);
1745               break;
1746             case 'M':
1747               require_running (own_buf);
1748               decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
1749               if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
1750                 write_ok (own_buf);
1751               else
1752                 write_enn (own_buf);
1753               break;
1754             case 'X':
1755               require_running (own_buf);
1756               if (decode_X_packet (&own_buf[1], packet_len - 1,
1757                                    &mem_addr, &len, mem_buf) < 0
1758                   || write_inferior_memory (mem_addr, mem_buf, len) != 0)
1759                 write_enn (own_buf);
1760               else
1761                 write_ok (own_buf);
1762               break;
1763             case 'C':
1764               require_running (own_buf);
1765               convert_ascii_to_int (own_buf + 1, &sig, 1);
1766               if (target_signal_to_host_p (sig))
1767                 signal = target_signal_to_host (sig);
1768               else
1769                 signal = 0;
1770               myresume (own_buf, 0, &signal, &status);
1771               break;
1772             case 'S':
1773               require_running (own_buf);
1774               convert_ascii_to_int (own_buf + 1, &sig, 1);
1775               if (target_signal_to_host_p (sig))
1776                 signal = target_signal_to_host (sig);
1777               else
1778                 signal = 0;
1779               myresume (own_buf, 1, &signal, &status);
1780               break;
1781             case 'c':
1782               require_running (own_buf);
1783               signal = 0;
1784               myresume (own_buf, 0, &signal, &status);
1785               break;
1786             case 's':
1787               require_running (own_buf);
1788               signal = 0;
1789               myresume (own_buf, 1, &signal, &status);
1790               break;
1791             case 'Z':
1792               {
1793                 char *lenptr;
1794                 char *dataptr;
1795                 CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
1796                 int len = strtol (lenptr + 1, &dataptr, 16);
1797                 char type = own_buf[1];
1798
1799                 if (the_target->insert_watchpoint == NULL
1800                     || (type < '2' || type > '4'))
1801                   {
1802                     /* No watchpoint support or not a watchpoint command;
1803                        unrecognized either way.  */
1804                     own_buf[0] = '\0';
1805                   }
1806                 else
1807                   {
1808                     int res;
1809
1810                     require_running (own_buf);
1811                     res = (*the_target->insert_watchpoint) (type, addr, len);
1812                     if (res == 0)
1813                       write_ok (own_buf);
1814                     else if (res == 1)
1815                       /* Unsupported.  */
1816                       own_buf[0] = '\0';
1817                     else
1818                       write_enn (own_buf);
1819                   }
1820                 break;
1821               }
1822             case 'z':
1823               {
1824                 char *lenptr;
1825                 char *dataptr;
1826                 CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
1827                 int len = strtol (lenptr + 1, &dataptr, 16);
1828                 char type = own_buf[1];
1829
1830                 if (the_target->remove_watchpoint == NULL
1831                     || (type < '2' || type > '4'))
1832                   {
1833                     /* No watchpoint support or not a watchpoint command;
1834                        unrecognized either way.  */
1835                     own_buf[0] = '\0';
1836                   }
1837                 else
1838                   {
1839                     int res;
1840
1841                     require_running (own_buf);
1842                     res = (*the_target->remove_watchpoint) (type, addr, len);
1843                     if (res == 0)
1844                       write_ok (own_buf);
1845                     else if (res == 1)
1846                       /* Unsupported.  */
1847                       own_buf[0] = '\0';
1848                     else
1849                       write_enn (own_buf);
1850                   }
1851                 break;
1852               }
1853             case 'k':
1854               response_needed = 0;
1855               if (!target_running ())
1856                 /* The packet we received doesn't make sense - but we
1857                    can't reply to it, either.  */
1858                 goto restart;
1859
1860               fprintf (stderr, "Killing inferior\n");
1861               kill_inferior ();
1862
1863               /* When using the extended protocol, we wait with no
1864                  program running.  The traditional protocol will exit
1865                  instead.  */
1866               if (extended_protocol)
1867                 {
1868                   status = 'X';
1869                   signal = TARGET_SIGNAL_KILL;
1870                   was_running = 0;
1871                   goto restart;
1872                 }
1873               else
1874                 {
1875                   exit (0);
1876                   break;
1877                 }
1878             case 'T':
1879               {
1880                 unsigned long gdb_id, thread_id;
1881
1882                 require_running (own_buf);
1883                 gdb_id = strtoul (&own_buf[1], NULL, 16);
1884                 thread_id = gdb_id_to_thread_id (gdb_id);
1885                 if (thread_id == 0)
1886                   {
1887                     write_enn (own_buf);
1888                     break;
1889                   }
1890
1891                 if (mythread_alive (thread_id))
1892                   write_ok (own_buf);
1893                 else
1894                   write_enn (own_buf);
1895               }
1896               break;
1897             case 'R':
1898               response_needed = 0;
1899
1900               /* Restarting the inferior is only supported in the
1901                  extended protocol.  */
1902               if (extended_protocol)
1903                 {
1904                   if (target_running ())
1905                     kill_inferior ();
1906                   fprintf (stderr, "GDBserver restarting\n");
1907
1908                   /* Wait till we are at 1st instruction in prog.  */
1909                   if (program_argv != NULL)
1910                     signal = start_inferior (program_argv, &status);
1911                   else
1912                     {
1913                       status = 'X';
1914                       signal = TARGET_SIGNAL_KILL;
1915                     }
1916                   goto restart;
1917                 }
1918               else
1919                 {
1920                   /* It is a request we don't understand.  Respond with an
1921                      empty packet so that gdb knows that we don't support this
1922                      request.  */
1923                   own_buf[0] = '\0';
1924                   break;
1925                 }
1926             case 'v':
1927               /* Extended (long) request.  */
1928               handle_v_requests (own_buf, &status, &signal,
1929                                  packet_len, &new_packet_len);
1930               break;
1931
1932             default:
1933               /* It is a request we don't understand.  Respond with an
1934                  empty packet so that gdb knows that we don't support this
1935                  request.  */
1936               own_buf[0] = '\0';
1937               break;
1938             }
1939
1940           if (new_packet_len != -1)
1941             putpkt_binary (own_buf, new_packet_len);
1942           else
1943             putpkt (own_buf);
1944
1945           response_needed = 0;
1946
1947           if (was_running && (status == 'W' || status == 'X'))
1948             {
1949               was_running = 0;
1950
1951               if (status == 'W')
1952                 fprintf (stderr,
1953                          "\nChild exited with status %d\n", signal);
1954               if (status == 'X')
1955                 fprintf (stderr, "\nChild terminated with signal = 0x%x (%s)\n",
1956                          target_signal_to_host (signal),
1957                          target_signal_to_name (signal));
1958
1959               if (extended_protocol)
1960                 goto restart;
1961               else
1962                 {
1963                   fprintf (stderr, "GDBserver exiting\n");
1964                   exit (0);
1965                 }
1966             }
1967
1968           if (status != 'W' && status != 'X')
1969             was_running = 1;
1970         }
1971
1972       /* If an exit was requested (using the "monitor exit" command),
1973          terminate now.  The only other way to get here is for
1974          getpkt to fail; close the connection and reopen it at the
1975          top of the loop.  */
1976
1977       if (exit_requested)
1978         {
1979           remote_close ();
1980           if (attached && target_running ())
1981             detach_inferior ();
1982           else if (target_running ())
1983             kill_inferior ();
1984           exit (0);
1985         }
1986       else
1987         {
1988           fprintf (stderr, "Remote side has terminated connection.  "
1989                            "GDBserver will reopen the connection.\n");
1990           remote_close ();
1991         }
1992     }
1993 }