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 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "server.h"
  21
  22 #if HAVE_UNISTD_H
  23 #include <unistd.h>
  24 #endif
  25 #if HAVE_SIGNAL_H
  26 #include <signal.h>
  27 #endif
  28 #if HAVE_SYS_WAIT_H
  29 #include <sys/wait.h>
  30 #endif
  31
  32 unsigned long cont_thread;
  33 unsigned long general_thread;
  34 unsigned long step_thread;
  35 unsigned long thread_from_wait;
  36 unsigned long old_thread_from_wait;
  37 int extended_protocol;
  38 int server_waiting;
  39
  40 /* Enable miscellaneous debugging output.  The name is historical - it
  41    was originally used to debug LinuxThreads support.  */
  42 int debug_threads;
  43
  44 int pass_signals[TARGET_SIGNAL_LAST];
  45
  46 jmp_buf toplevel;
  47
  48 /* The PID of the originally created or attached inferior.  Used to
  49    send signals to the process when GDB sends us an asynchronous interrupt
  50    (user hitting Control-C in the client), and to wait for the child to exit
  51    when no longer debugging it.  */
  52
  53 unsigned long signal_pid;
  54
  55 #ifdef SIGTTOU
  56 /* A file descriptor for the controlling terminal.  */
  57 int terminal_fd;
  58
  59 /* TERMINAL_FD's original foreground group.  */
  60 pid_t old_foreground_pgrp;
  61
  62 /* Hand back terminal ownership to the original foreground group.  */
  63
  64 static void
  65 restore_old_foreground_pgrp (void)
  66 {
  67   tcsetpgrp (terminal_fd, old_foreground_pgrp);
  68 }
  69 #endif
  70
  71 static int
  72 start_inferior (char *argv[], char *statusptr)
  73 {
  74 #ifdef SIGTTOU
  75   signal (SIGTTOU, SIG_DFL);
  76   signal (SIGTTIN, SIG_DFL);
  77 #endif
  78
  79   signal_pid = create_inferior (argv[0], argv);
  80
  81   /* FIXME: we don't actually know at this point that the create
  82      actually succeeded.  We won't know that until we wait.  */
  83   fprintf (stderr, "Process %s created; pid = %ld\n", argv[0],
  84            signal_pid);
  85   fflush (stderr);
  86
  87 #ifdef SIGTTOU
  88   signal (SIGTTOU, SIG_IGN);
  89   signal (SIGTTIN, SIG_IGN);
  90   terminal_fd = fileno (stderr);
  91   old_foreground_pgrp = tcgetpgrp (terminal_fd);
  92   tcsetpgrp (terminal_fd, signal_pid);
  93   atexit (restore_old_foreground_pgrp);
  94 #endif
  95
  96   /* Wait till we are at 1st instruction in program, return signal
  97      number (assuming success).  */
  98   return mywait (statusptr, 0);
  99 }
 100
 101 static int
 102 attach_inferior (int pid, char *statusptr, int *sigptr)
 103 {
 104   /* myattach should return -1 if attaching is unsupported,
 105      0 if it succeeded, and call error() otherwise.  */
 106
 107   if (myattach (pid) != 0)
 108     return -1;
 109
 110   fprintf (stderr, "Attached; pid = %d\n", pid);
 111   fflush (stderr);
 112
 113   /* FIXME - It may be that we should get the SIGNAL_PID from the
 114      attach function, so that it can be the main thread instead of
 115      whichever we were told to attach to.  */
 116   signal_pid = pid;
 117
 118   *sigptr = mywait (statusptr, 0);
 119
 120   /* GDB knows to ignore the first SIGSTOP after attaching to a running
 121      process using the "attach" command, but this is different; it's
 122      just using "target remote".  Pretend it's just starting up.  */
 123   if (*statusptr == 'T' && *sigptr == TARGET_SIGNAL_STOP)
 124     *sigptr = TARGET_SIGNAL_TRAP;
 125
 126   return 0;
 127 }
 128
 129 extern int remote_debug;
 130
 131 /* Decode a qXfer read request.  Return 0 if everything looks OK,
 132    or -1 otherwise.  */
 133
 134 static int
 135 decode_xfer_read (char *buf, char **annex, CORE_ADDR *ofs, unsigned int *len)
 136 {
 137   /* Extract and NUL-terminate the annex.  */
 138   *annex = buf;
 139   while (*buf && *buf != ':')
 140     buf++;
 141   if (*buf == '\0')
 142     return -1;
 143   *buf++ = 0;
 144
 145   /* After the read marker and annex, qXfer looks like a
 146      traditional 'm' packet.  */
 147   decode_m_packet (buf, ofs, len);
 148
 149   return 0;
 150 }
 151
 152 /* Write the response to a successful qXfer read.  Returns the
 153    length of the (binary) data stored in BUF, corresponding
 154    to as much of DATA/LEN as we could fit.  IS_MORE controls
 155    the first character of the response.  */
 156 static int
 157 write_qxfer_response (char *buf, const void *data, int len, int is_more)
 158 {
 159   int out_len;
 160
 161   if (is_more)
 162     buf[0] = 'm';
 163   else
 164     buf[0] = 'l';
 165
 166   return remote_escape_output (data, len, (unsigned char *) buf + 1, &out_len,
 167                                PBUFSIZ - 2) + 1;
 168 }
 169
 170 /* Handle all of the extended 'Q' packets.  */
 171 void
 172 handle_general_set (char *own_buf)
 173 {
 174   if (strncmp ("QPassSignals:", own_buf, strlen ("QPassSignals:")) == 0)
 175     {
 176       int numsigs = (int) TARGET_SIGNAL_LAST, i;
 177       const char *p = own_buf + strlen ("QPassSignals:");
 178       CORE_ADDR cursig;
 179
 180       p = decode_address_to_semicolon (&cursig, p);
 181       for (i = 0; i < numsigs; i++)
 182         {
 183           if (i == cursig)
 184             {
 185               pass_signals[i] = 1;
 186               if (*p == '\0')
 187                 /* Keep looping, to clear the remaining signals.  */
 188                 cursig = -1;
 189               else
 190                 p = decode_address_to_semicolon (&cursig, p);
 191             }
 192           else
 193             pass_signals[i] = 0;
 194         }
 195       strcpy (own_buf, "OK");
 196       return;
 197     }
 198
 199   /* Otherwise we didn't know what packet it was.  Say we didn't
 200      understand it.  */
 201   own_buf[0] = 0;
 202 }
 203
 204 static const char *
 205 get_features_xml (const char *annex)
 206 {
 207   static int features_supported = -1;
 208   static char *document;
 209
 210 #ifdef USE_XML
 211   extern const char *const xml_builtin[][2];
 212   int i;
 213
 214   /* Look for the annex.  */
 215   for (i = 0; xml_builtin[i][0] != NULL; i++)
 216     if (strcmp (annex, xml_builtin[i][0]) == 0)
 217       break;
 218
 219   if (xml_builtin[i][0] != NULL)
 220     return xml_builtin[i][1];
 221 #endif
 222
 223   if (strcmp (annex, "target.xml") != 0)
 224     return NULL;
 225
 226   if (features_supported == -1)
 227     {
 228       const char *arch = NULL;
 229       if (the_target->arch_string != NULL)
 230         arch = (*the_target->arch_string) ();
 231
 232       if (arch == NULL)
 233         features_supported = 0;
 234       else
 235         {
 236           features_supported = 1;
 237           document = malloc (64 + strlen (arch));
 238           snprintf (document, 64 + strlen (arch),
 239                     "<target><architecture>%s</architecture></target>",
 240                     arch);
 241         }
 242     }
 243
 244   return document;
 245 }
 246
 247 void
 248 monitor_show_help (void)
 249 {
 250   monitor_output ("The following monitor commands are supported:\n");
 251   monitor_output ("  set debug <0|1>\n");
 252   monitor_output ("    Enable general debugging messages\n");
 253   monitor_output ("  set remote-debug <0|1>\n");
 254   monitor_output ("    Enable remote protocol debugging messages\n");
 255 }
 256
 257 /* Handle all of the extended 'q' packets.  */
 258 void
 259 handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
 260 {
 261   static struct inferior_list_entry *thread_ptr;
 262
 263   /* Reply the current thread id.  */
 264   if (strcmp ("qC", own_buf) == 0)
 265     {
 266       thread_ptr = all_threads.head;
 267       sprintf (own_buf, "QC%x",
 268         thread_to_gdb_id ((struct thread_info *)thread_ptr));
 269       return;
 270     }
 271
 272   if (strcmp ("qSymbol::", own_buf) == 0)
 273     {
 274       if (the_target->look_up_symbols != NULL)
 275         (*the_target->look_up_symbols) ();
 276
 277       strcpy (own_buf, "OK");
 278       return;
 279     }
 280
 281   if (strcmp ("qfThreadInfo", own_buf) == 0)
 282     {
 283       thread_ptr = all_threads.head;
 284       sprintf (own_buf, "m%x", thread_to_gdb_id ((struct thread_info *)thread_ptr));
 285       thread_ptr = thread_ptr->next;
 286       return;
 287     }
 288
 289   if (strcmp ("qsThreadInfo", own_buf) == 0)
 290     {
 291       if (thread_ptr != NULL)
 292         {
 293           sprintf (own_buf, "m%x", thread_to_gdb_id ((struct thread_info *)thread_ptr));
 294           thread_ptr = thread_ptr->next;
 295           return;
 296         }
 297       else
 298         {
 299           sprintf (own_buf, "l");
 300           return;
 301         }
 302     }
 303
 304   if (the_target->read_offsets != NULL
 305       && strcmp ("qOffsets", own_buf) == 0)
 306     {
 307       CORE_ADDR text, data;
 308
 309       if (the_target->read_offsets (&text, &data))
 310         sprintf (own_buf, "Text=%lX;Data=%lX;Bss=%lX",
 311                  (long)text, (long)data, (long)data);
 312       else
 313         write_enn (own_buf);
 314
 315       return;
 316     }
 317
 318   if (the_target->qxfer_spu != NULL
 319       && strncmp ("qXfer:spu:read:", own_buf, 15) == 0)
 320     {
 321       char *annex;
 322       int n;
 323       unsigned int len;
 324       CORE_ADDR ofs;
 325       unsigned char *spu_buf;
 326
 327       strcpy (own_buf, "E00");
 328       if (decode_xfer_read (own_buf + 15, &annex, &ofs, &len) < 0)
 329           return;
 330       if (len > PBUFSIZ - 2)
 331         len = PBUFSIZ - 2;
 332       spu_buf = malloc (len + 1);
 333       if (!spu_buf)
 334         return;
 335
 336       n = (*the_target->qxfer_spu) (annex, spu_buf, NULL, ofs, len + 1);
 337       if (n < 0)
 338         write_enn (own_buf);
 339       else if (n > len)
 340         *new_packet_len_p = write_qxfer_response
 341                               (own_buf, spu_buf, len, 1);
 342       else
 343         *new_packet_len_p = write_qxfer_response
 344                               (own_buf, spu_buf, n, 0);
 345
 346       free (spu_buf);
 347       return;
 348     }
 349
 350   if (the_target->qxfer_spu != NULL
 351       && strncmp ("qXfer:spu:write:", own_buf, 16) == 0)
 352     {
 353       char *annex;
 354       int n;
 355       unsigned int len;
 356       CORE_ADDR ofs;
 357       unsigned char *spu_buf;
 358
 359       strcpy (own_buf, "E00");
 360       spu_buf = malloc (packet_len - 15);
 361       if (!spu_buf)
 362         return;
 363       if (decode_xfer_write (own_buf + 16, packet_len - 16, &annex,
 364                              &ofs, &len, spu_buf) < 0)
 365         {
 366           free (spu_buf);
 367           return;
 368         }
 369
 370       n = (*the_target->qxfer_spu)
 371         (annex, NULL, (unsigned const char *)spu_buf, ofs, len);
 372       if (n < 0)
 373         write_enn (own_buf);
 374       else
 375         sprintf (own_buf, "%x", n);
 376
 377       free (spu_buf);
 378       return;
 379     }
 380
 381   if (the_target->read_auxv != NULL
 382       && strncmp ("qXfer:auxv:read:", own_buf, 16) == 0)
 383     {
 384       unsigned char *data;
 385       int n;
 386       CORE_ADDR ofs;
 387       unsigned int len;
 388       char *annex;
 389
 390       /* Reject any annex; grab the offset and length.  */
 391       if (decode_xfer_read (own_buf + 16, &annex, &ofs, &len) < 0
 392           || annex[0] != '\0')
 393         {
 394           strcpy (own_buf, "E00");
 395           return;
 396         }
 397
 398       /* Read one extra byte, as an indicator of whether there is
 399          more.  */
 400       if (len > PBUFSIZ - 2)
 401         len = PBUFSIZ - 2;
 402       data = malloc (len + 1);
 403       n = (*the_target->read_auxv) (ofs, data, len + 1);
 404       if (n < 0)
 405         write_enn (own_buf);
 406       else if (n > len)
 407         *new_packet_len_p = write_qxfer_response (own_buf, data, len, 1);
 408       else
 409         *new_packet_len_p = write_qxfer_response (own_buf, data, n, 0);
 410
 411       free (data);
 412
 413       return;
 414     }
 415
 416   if (strncmp ("qXfer:features:read:", own_buf, 20) == 0)
 417     {
 418       CORE_ADDR ofs;
 419       unsigned int len, total_len;
 420       const char *document;
 421       char *annex;
 422
 423       /* Check for support.  */
 424       document = get_features_xml ("target.xml");
 425       if (document == NULL)
 426         {
 427           own_buf[0] = '\0';
 428           return;
 429         }
 430
 431       /* Grab the annex, offset, and length.  */
 432       if (decode_xfer_read (own_buf + 20, &annex, &ofs, &len) < 0)
 433         {
 434           strcpy (own_buf, "E00");
 435           return;
 436         }
 437
 438       /* Now grab the correct annex.  */
 439       document = get_features_xml (annex);
 440       if (document == NULL)
 441         {
 442           strcpy (own_buf, "E00");
 443           return;
 444         }
 445
 446       total_len = strlen (document);
 447       if (len > PBUFSIZ - 2)
 448         len = PBUFSIZ - 2;
 449
 450       if (ofs > total_len)
 451         write_enn (own_buf);
 452       else if (len < total_len - ofs)
 453         *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
 454                                                   len, 1);
 455       else
 456         *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
 457                                                   total_len - ofs, 0);
 458
 459       return;
 460     }
 461
 462   if (strncmp ("qXfer:libraries:read:", own_buf, 21) == 0)
 463     {
 464       CORE_ADDR ofs;
 465       unsigned int len, total_len;
 466       char *document, *p;
 467       struct inferior_list_entry *dll_ptr;
 468       char *annex;
 469
 470       /* Reject any annex; grab the offset and length.  */
 471       if (decode_xfer_read (own_buf + 21, &annex, &ofs, &len) < 0
 472           || annex[0] != '\0')
 473         {
 474           strcpy (own_buf, "E00");
 475           return;
 476         }
 477
 478       /* Over-estimate the necessary memory.  Assume that every character
 479          in the library name must be escaped.  */
 480       total_len = 64;
 481       for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
 482         total_len += 128 + 6 * strlen (((struct dll_info *) dll_ptr)->name);
 483
 484       document = malloc (total_len);
 485       strcpy (document, "<library-list>\n");
 486       p = document + strlen (document);
 487
 488       for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
 489         {
 490           struct dll_info *dll = (struct dll_info *) dll_ptr;
 491           char *name;
 492
 493           strcpy (p, "  <library name=\"");
 494           p = p + strlen (p);
 495           name = xml_escape_text (dll->name);
 496           strcpy (p, name);
 497           free (name);
 498           p = p + strlen (p);
 499           strcpy (p, "\"><segment address=\"");
 500           p = p + strlen (p);
 501           sprintf (p, "0x%lx", (long) dll->base_addr);
 502           p = p + strlen (p);
 503           strcpy (p, "\"/></library>\n");
 504           p = p + strlen (p);
 505         }
 506
 507       strcpy (p, "</library-list>\n");
 508
 509       total_len = strlen (document);
 510       if (len > PBUFSIZ - 2)
 511         len = PBUFSIZ - 2;
 512
 513       if (ofs > total_len)
 514         write_enn (own_buf);
 515       else if (len < total_len - ofs)
 516         *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
 517                                                   len, 1);
 518       else
 519         *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
 520                                                   total_len - ofs, 0);
 521
 522       free (document);
 523       return;
 524     }
 525
 526   /* Protocol features query.  */
 527   if (strncmp ("qSupported", own_buf, 10) == 0
 528       && (own_buf[10] == ':' || own_buf[10] == '\0'))
 529     {
 530       sprintf (own_buf, "PacketSize=%x;QPassSignals+", PBUFSIZ - 1);
 531
 532       /* We do not have any hook to indicate whether the target backend
 533          supports qXfer:libraries:read, so always report it.  */
 534       strcat (own_buf, ";qXfer:libraries:read+");
 535
 536       if (the_target->read_auxv != NULL)
 537         strcat (own_buf, ";qXfer:auxv:read+");
 538
 539       if (the_target->qxfer_spu != NULL)
 540         strcat (own_buf, ";qXfer:spu:read+;qXfer:spu:write+");
 541
 542       if (get_features_xml ("target.xml") != NULL)
 543         strcat (own_buf, ";qXfer:features:read+");
 544
 545       return;
 546     }
 547
 548   /* Thread-local storage support.  */
 549   if (the_target->get_tls_address != NULL
 550       && strncmp ("qGetTLSAddr:", own_buf, 12) == 0)
 551     {
 552       char *p = own_buf + 12;
 553       CORE_ADDR parts[3], address = 0;
 554       int i, err;
 555
 556       for (i = 0; i < 3; i++)
 557         {
 558           char *p2;
 559           int len;
 560
 561           if (p == NULL)
 562             break;
 563
 564           p2 = strchr (p, ',');
 565           if (p2)
 566             {
 567               len = p2 - p;
 568               p2++;
 569             }
 570           else
 571             {
 572               len = strlen (p);
 573               p2 = NULL;
 574             }
 575
 576           decode_address (&parts[i], p, len);
 577           p = p2;
 578         }
 579
 580       if (p != NULL || i < 3)
 581         err = 1;
 582       else
 583         {
 584           struct thread_info *thread = gdb_id_to_thread (parts[0]);
 585
 586           if (thread == NULL)
 587             err = 2;
 588           else
 589             err = the_target->get_tls_address (thread, parts[1], parts[2],
 590                                                &address);
 591         }
 592
 593       if (err == 0)
 594         {
 595           sprintf (own_buf, "%llx", address);
 596           return;
 597         }
 598       else if (err > 0)
 599         {
 600           write_enn (own_buf);
 601           return;
 602         }
 603
 604       /* Otherwise, pretend we do not understand this packet.  */
 605     }
 606
 607   /* Handle "monitor" commands.  */
 608   if (strncmp ("qRcmd,", own_buf, 6) == 0)
 609     {
 610       char *mon = malloc (PBUFSIZ);
 611       int len = strlen (own_buf + 6);
 612
 613       if ((len % 1) != 0 || unhexify (mon, own_buf + 6, len / 2) != len / 2)
 614         {
 615           write_enn (own_buf);
 616           free (mon);
 617           return;
 618         }
 619       mon[len / 2] = '\0';
 620
 621       write_ok (own_buf);
 622
 623       if (strcmp (mon, "set debug 1") == 0)
 624         {
 625           debug_threads = 1;
 626           monitor_output ("Debug output enabled.\n");
 627         }
 628       else if (strcmp (mon, "set debug 0") == 0)
 629         {
 630           debug_threads = 0;
 631           monitor_output ("Debug output disabled.\n");
 632         }
 633       else if (strcmp (mon, "set remote-debug 1") == 0)
 634         {
 635           remote_debug = 1;
 636           monitor_output ("Protocol debug output enabled.\n");
 637         }
 638       else if (strcmp (mon, "set remote-debug 0") == 0)
 639         {
 640           remote_debug = 0;
 641           monitor_output ("Protocol debug output disabled.\n");
 642         }
 643       else if (strcmp (mon, "help") == 0)
 644         monitor_show_help ();
 645       else
 646         {
 647           monitor_output ("Unknown monitor command.\n\n");
 648           monitor_show_help ();
 649           write_enn (own_buf);
 650         }
 651
 652       free (mon);
 653       return;
 654     }
 655
 656   /* Otherwise we didn't know what packet it was.  Say we didn't
 657      understand it.  */
 658   own_buf[0] = 0;
 659 }
 660
 661 /* Parse vCont packets.  */
 662 void
 663 handle_v_cont (char *own_buf, char *status, int *signal)
 664 {
 665   char *p, *q;
 666   int n = 0, i = 0;
 667   struct thread_resume *resume_info, default_action;
 668
 669   /* Count the number of semicolons in the packet.  There should be one
 670      for every action.  */
 671   p = &own_buf[5];
 672   while (p)
 673     {
 674       n++;
 675       p++;
 676       p = strchr (p, ';');
 677     }
 678   /* Allocate room for one extra action, for the default remain-stopped
 679      behavior; if no default action is in the list, we'll need the extra
 680      slot.  */
 681   resume_info = malloc ((n + 1) * sizeof (resume_info[0]));
 682
 683   default_action.thread = -1;
 684   default_action.leave_stopped = 1;
 685   default_action.step = 0;
 686   default_action.sig = 0;
 687
 688   p = &own_buf[5];
 689   i = 0;
 690   while (*p)
 691     {
 692       p++;
 693
 694       resume_info[i].leave_stopped = 0;
 695
 696       if (p[0] == 's' || p[0] == 'S')
 697         resume_info[i].step = 1;
 698       else if (p[0] == 'c' || p[0] == 'C')
 699         resume_info[i].step = 0;
 700       else
 701         goto err;
 702
 703       if (p[0] == 'S' || p[0] == 'C')
 704         {
 705           int sig;
 706           sig = strtol (p + 1, &q, 16);
 707           if (p == q)
 708             goto err;
 709           p = q;
 710
 711           if (!target_signal_to_host_p (sig))
 712             goto err;
 713           resume_info[i].sig = target_signal_to_host (sig);
 714         }
 715       else
 716         {
 717           resume_info[i].sig = 0;
 718           p = p + 1;
 719         }
 720
 721       if (p[0] == 0)
 722         {
 723           resume_info[i].thread = -1;
 724           default_action = resume_info[i];
 725
 726           /* Note: we don't increment i here, we'll overwrite this entry
 727              the next time through.  */
 728         }
 729       else if (p[0] == ':')
 730         {
 731           unsigned int gdb_id = strtoul (p + 1, &q, 16);
 732           unsigned long thread_id;
 733
 734           if (p == q)
 735             goto err;
 736           p = q;
 737           if (p[0] != ';' && p[0] != 0)
 738             goto err;
 739
 740           thread_id = gdb_id_to_thread_id (gdb_id);
 741           if (thread_id)
 742             resume_info[i].thread = thread_id;
 743           else
 744             goto err;
 745
 746           i++;
 747         }
 748     }
 749
 750   resume_info[i] = default_action;
 751
 752   /* Still used in occasional places in the backend.  */
 753   if (n == 1 && resume_info[0].thread != -1)
 754     cont_thread = resume_info[0].thread;
 755   else
 756     cont_thread = -1;
 757   set_desired_inferior (0);
 758
 759   (*the_target->resume) (resume_info);
 760
 761   free (resume_info);
 762
 763   *signal = mywait (status, 1);
 764   prepare_resume_reply (own_buf, *status, *signal);
 765   return;
 766
 767 err:
 768   write_enn (own_buf);
 769   free (resume_info);
 770   return;
 771 }
 772
 773 /* Handle all of the extended 'v' packets.  */
 774 void
 775 handle_v_requests (char *own_buf, char *status, int *signal,
 776                    int packet_len, int *new_packet_len)
 777 {
 778   if (strncmp (own_buf, "vCont;", 6) == 0)
 779     {
 780       handle_v_cont (own_buf, status, signal);
 781       return;
 782     }
 783
 784   if (strncmp (own_buf, "vCont?", 6) == 0)
 785     {
 786       strcpy (own_buf, "vCont;c;C;s;S");
 787       return;
 788     }
 789
 790   if (strncmp (own_buf, "vFile:", 6) == 0
 791       && handle_vFile (own_buf, packet_len, new_packet_len))
 792     return;
 793
 794   /* Otherwise we didn't know what packet it was.  Say we didn't
 795      understand it.  */
 796   own_buf[0] = 0;
 797   return;
 798 }
 799
 800 void
 801 myresume (int step, int sig)
 802 {
 803   struct thread_resume resume_info[2];
 804   int n = 0;
 805
 806   if (step || sig || (cont_thread != 0 && cont_thread != -1))
 807     {
 808       resume_info[0].thread
 809         = ((struct inferior_list_entry *) current_inferior)->id;
 810       resume_info[0].step = step;
 811       resume_info[0].sig = sig;
 812       resume_info[0].leave_stopped = 0;
 813       n++;
 814     }
 815   resume_info[n].thread = -1;
 816   resume_info[n].step = 0;
 817   resume_info[n].sig = 0;
 818   resume_info[n].leave_stopped = (cont_thread != 0 && cont_thread != -1);
 819
 820   (*the_target->resume) (resume_info);
 821 }
 822
 823 static int attached;
 824
 825 static void
 826 gdbserver_version (void)
 827 {
 828   printf ("GNU gdbserver %s\n"
 829           "Copyright (C) 2007 Free Software Foundation, Inc.\n"
 830           "gdbserver is free software, covered by the GNU General Public License.\n"
 831           "This gdbserver was configured as \"%s\"\n",
 832           version, host_name);
 833 }
 834
 835 static void
 836 gdbserver_usage (void)
 837 {
 838   printf ("Usage:\tgdbserver COMM PROG [ARGS ...]\n"
 839           "\tgdbserver COMM --attach PID\n"
 840           "\n"
 841           "COMM may either be a tty device (for serial debugging), or \n"
 842           "HOST:PORT to listen for a TCP connection.\n");
 843 }
 844
 845 int
 846 main (int argc, char *argv[])
 847 {
 848   char ch, status, *own_buf;
 849   unsigned char *mem_buf;
 850   int i = 0;
 851   int signal;
 852   unsigned int len;
 853   CORE_ADDR mem_addr;
 854   int bad_attach;
 855   int pid;
 856   char *arg_end;
 857
 858   if (argc >= 2 && strcmp (argv[1], "--version") == 0)
 859     {
 860       gdbserver_version ();
 861       exit (0);
 862     }
 863
 864   if (argc >= 2 && strcmp (argv[1], "--help") == 0)
 865     {
 866       gdbserver_usage ();
 867       exit (0);
 868     }
 869
 870   if (setjmp (toplevel))
 871     {
 872       fprintf (stderr, "Exiting\n");
 873       exit (1);
 874     }
 875
 876   bad_attach = 0;
 877   pid = 0;
 878   attached = 0;
 879   if (argc >= 3 && strcmp (argv[2], "--attach") == 0)
 880     {
 881       if (argc == 4
 882           && argv[3][0] != '\0'
 883           && (pid = strtoul (argv[3], &arg_end, 10)) != 0
 884           && *arg_end == '\0')
 885         {
 886           ;
 887         }
 888       else
 889         bad_attach = 1;
 890     }
 891
 892   if (argc < 3 || bad_attach)
 893     {
 894       gdbserver_usage ();
 895       exit (1);
 896     }
 897
 898   initialize_low ();
 899
 900   own_buf = malloc (PBUFSIZ + 1);
 901   mem_buf = malloc (PBUFSIZ);
 902
 903   if (pid == 0)
 904     {
 905       /* Wait till we are at first instruction in program.  */
 906       signal = start_inferior (&argv[2], &status);
 907
 908       /* We are now (hopefully) stopped at the first instruction of
 909          the target process.  This assumes that the target process was
 910          successfully created.  */
 911
 912       /* Don't report shared library events on the initial connection,
 913          even if some libraries are preloaded.  */
 914       dlls_changed = 0;
 915     }
 916   else
 917     {
 918       switch (attach_inferior (pid, &status, &signal))
 919         {
 920         case -1:
 921           error ("Attaching not supported on this target");
 922           break;
 923         default:
 924           attached = 1;
 925           break;
 926         }
 927     }
 928
 929   if (setjmp (toplevel))
 930     {
 931       fprintf (stderr, "Killing inferior\n");
 932       kill_inferior ();
 933       exit (1);
 934     }
 935
 936   if (status == 'W' || status == 'X')
 937     {
 938       fprintf (stderr, "No inferior, GDBserver exiting.\n");
 939       exit (1);
 940     }
 941
 942   while (1)
 943     {
 944       remote_open (argv[1]);
 945
 946     restart:
 947       setjmp (toplevel);
 948       while (1)
 949         {
 950           unsigned char sig;
 951           int packet_len;
 952           int new_packet_len = -1;
 953
 954           packet_len = getpkt (own_buf);
 955           if (packet_len <= 0)
 956             break;
 957
 958           i = 0;
 959           ch = own_buf[i++];
 960           switch (ch)
 961             {
 962             case 'q':
 963               handle_query (own_buf, packet_len, &new_packet_len);
 964               break;
 965             case 'Q':
 966               handle_general_set (own_buf);
 967               break;
 968             case 'D':
 969               fprintf (stderr, "Detaching from inferior\n");
 970               if (detach_inferior () != 0)
 971                 {
 972                   write_enn (own_buf);
 973                   putpkt (own_buf);
 974                 }
 975               else
 976                 {
 977                   write_ok (own_buf);
 978                   putpkt (own_buf);
 979                   remote_close ();
 980
 981                   /* If we are attached, then we can exit.  Otherwise, we
 982                      need to hang around doing nothing, until the child
 983                      is gone.  */
 984                   if (!attached)
 985                     join_inferior ();
 986
 987                   exit (0);
 988                 }
 989             case '!':
 990               if (attached == 0)
 991                 {
 992                   extended_protocol = 1;
 993                   prepare_resume_reply (own_buf, status, signal);
 994                 }
 995               else
 996                 {
 997                   /* We can not use the extended protocol if we are
 998                      attached, because we can not restart the running
 999                      program.  So return unrecognized.  */
1000                   own_buf[0] = '\0';
1001                 }
1002               break;
1003             case '?':
1004               prepare_resume_reply (own_buf, status, signal);
1005               break;
1006             case 'H':
1007               if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
1008                 {
1009                   unsigned long gdb_id, thread_id;
1010
1011                   gdb_id = strtoul (&own_buf[2], NULL, 16);
1012                   thread_id = gdb_id_to_thread_id (gdb_id);
1013                   if (thread_id == 0)
1014                     {
1015                       write_enn (own_buf);
1016                       break;
1017                     }
1018
1019                   if (own_buf[1] == 'g')
1020                     {
1021                       general_thread = thread_id;
1022                       set_desired_inferior (1);
1023                     }
1024                   else if (own_buf[1] == 'c')
1025                     cont_thread = thread_id;
1026                   else if (own_buf[1] == 's')
1027                     step_thread = thread_id;
1028
1029                   write_ok (own_buf);
1030                 }
1031               else
1032                 {
1033                   /* Silently ignore it so that gdb can extend the protocol
1034                      without compatibility headaches.  */
1035                   own_buf[0] = '\0';
1036                 }
1037               break;
1038             case 'g':
1039               set_desired_inferior (1);
1040               registers_to_string (own_buf);
1041               break;
1042             case 'G':
1043               set_desired_inferior (1);
1044               registers_from_string (&own_buf[1]);
1045               write_ok (own_buf);
1046               break;
1047             case 'm':
1048               decode_m_packet (&own_buf[1], &mem_addr, &len);
1049               if (read_inferior_memory (mem_addr, mem_buf, len) == 0)
1050                 convert_int_to_ascii (mem_buf, own_buf, len);
1051               else
1052                 write_enn (own_buf);
1053               break;
1054             case 'M':
1055               decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
1056               if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
1057                 write_ok (own_buf);
1058               else
1059                 write_enn (own_buf);
1060               break;
1061             case 'X':
1062               if (decode_X_packet (&own_buf[1], packet_len - 1,
1063                                    &mem_addr, &len, mem_buf) < 0
1064                   || write_inferior_memory (mem_addr, mem_buf, len) != 0)
1065                 write_enn (own_buf);
1066               else
1067                 write_ok (own_buf);
1068               break;
1069             case 'C':
1070               convert_ascii_to_int (own_buf + 1, &sig, 1);
1071               if (target_signal_to_host_p (sig))
1072                 signal = target_signal_to_host (sig);
1073               else
1074                 signal = 0;
1075               set_desired_inferior (0);
1076               myresume (0, signal);
1077               signal = mywait (&status, 1);
1078               prepare_resume_reply (own_buf, status, signal);
1079               break;
1080             case 'S':
1081               convert_ascii_to_int (own_buf + 1, &sig, 1);
1082               if (target_signal_to_host_p (sig))
1083                 signal = target_signal_to_host (sig);
1084               else
1085                 signal = 0;
1086               set_desired_inferior (0);
1087               myresume (1, signal);
1088               signal = mywait (&status, 1);
1089               prepare_resume_reply (own_buf, status, signal);
1090               break;
1091             case 'c':
1092               set_desired_inferior (0);
1093               myresume (0, 0);
1094               signal = mywait (&status, 1);
1095               prepare_resume_reply (own_buf, status, signal);
1096               break;
1097             case 's':
1098               set_desired_inferior (0);
1099               myresume (1, 0);
1100               signal = mywait (&status, 1);
1101               prepare_resume_reply (own_buf, status, signal);
1102               break;
1103             case 'Z':
1104               {
1105                 char *lenptr;
1106                 char *dataptr;
1107                 CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
1108                 int len = strtol (lenptr + 1, &dataptr, 16);
1109                 char type = own_buf[1];
1110
1111                 if (the_target->insert_watchpoint == NULL
1112                     || (type < '2' || type > '4'))
1113                   {
1114                     /* No watchpoint support or not a watchpoint command;
1115                        unrecognized either way.  */
1116                     own_buf[0] = '\0';
1117                   }
1118                 else
1119                   {
1120                     int res;
1121
1122                     res = (*the_target->insert_watchpoint) (type, addr, len);
1123                     if (res == 0)
1124                       write_ok (own_buf);
1125                     else if (res == 1)
1126                       /* Unsupported.  */
1127                       own_buf[0] = '\0';
1128                     else
1129                       write_enn (own_buf);
1130                   }
1131                 break;
1132               }
1133             case 'z':
1134               {
1135                 char *lenptr;
1136                 char *dataptr;
1137                 CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
1138                 int len = strtol (lenptr + 1, &dataptr, 16);
1139                 char type = own_buf[1];
1140
1141                 if (the_target->remove_watchpoint == NULL
1142                     || (type < '2' || type > '4'))
1143                   {
1144                     /* No watchpoint support or not a watchpoint command;
1145                        unrecognized either way.  */
1146                     own_buf[0] = '\0';
1147                   }
1148                 else
1149                   {
1150                     int res;
1151
1152                     res = (*the_target->remove_watchpoint) (type, addr, len);
1153                     if (res == 0)
1154                       write_ok (own_buf);
1155                     else if (res == 1)
1156                       /* Unsupported.  */
1157                       own_buf[0] = '\0';
1158                     else
1159                       write_enn (own_buf);
1160                   }
1161                 break;
1162               }
1163             case 'k':
1164               fprintf (stderr, "Killing inferior\n");
1165               kill_inferior ();
1166               /* When using the extended protocol, we start up a new
1167                  debugging session.   The traditional protocol will
1168                  exit instead.  */
1169               if (extended_protocol)
1170                 {
1171                   write_ok (own_buf);
1172                   fprintf (stderr, "GDBserver restarting\n");
1173
1174                   /* Wait till we are at 1st instruction in prog.  */
1175                   signal = start_inferior (&argv[2], &status);
1176                   goto restart;
1177                   break;
1178                 }
1179               else
1180                 {
1181                   exit (0);
1182                   break;
1183                 }
1184             case 'T':
1185               {
1186                 unsigned long gdb_id, thread_id;
1187
1188                 gdb_id = strtoul (&own_buf[1], NULL, 16);
1189                 thread_id = gdb_id_to_thread_id (gdb_id);
1190                 if (thread_id == 0)
1191                   {
1192                     write_enn (own_buf);
1193                     break;
1194                   }
1195
1196                 if (mythread_alive (thread_id))
1197                   write_ok (own_buf);
1198                 else
1199                   write_enn (own_buf);
1200               }
1201               break;
1202             case 'R':
1203               /* Restarting the inferior is only supported in the
1204                  extended protocol.  */
1205               if (extended_protocol)
1206                 {
1207                   kill_inferior ();
1208                   write_ok (own_buf);
1209                   fprintf (stderr, "GDBserver restarting\n");
1210
1211                   /* Wait till we are at 1st instruction in prog.  */
1212                   signal = start_inferior (&argv[2], &status);
1213                   goto restart;
1214                   break;
1215                 }
1216               else
1217                 {
1218                   /* It is a request we don't understand.  Respond with an
1219                      empty packet so that gdb knows that we don't support this
1220                      request.  */
1221                   own_buf[0] = '\0';
1222                   break;
1223                 }
1224             case 'v':
1225               /* Extended (long) request.  */
1226               handle_v_requests (own_buf, &status, &signal,
1227                                  packet_len, &new_packet_len);
1228               break;
1229
1230             default:
1231               /* It is a request we don't understand.  Respond with an
1232                  empty packet so that gdb knows that we don't support this
1233                  request.  */
1234               own_buf[0] = '\0';
1235               break;
1236             }
1237
1238           if (new_packet_len != -1)
1239             putpkt_binary (own_buf, new_packet_len);
1240           else
1241             putpkt (own_buf);
1242
1243           if (status == 'W')
1244             fprintf (stderr,
1245                      "\nChild exited with status %d\n", signal);
1246           if (status == 'X')
1247             fprintf (stderr, "\nChild terminated with signal = 0x%x (%s)\n",
1248                      target_signal_to_host (signal),
1249                      target_signal_to_name (signal));
1250           if (status == 'W' || status == 'X')
1251             {
1252               if (extended_protocol)
1253                 {
1254                   fprintf (stderr, "Killing inferior\n");
1255                   kill_inferior ();
1256                   write_ok (own_buf);
1257                   fprintf (stderr, "GDBserver restarting\n");
1258
1259                   /* Wait till we are at 1st instruction in prog.  */
1260                   signal = start_inferior (&argv[2], &status);
1261                   goto restart;
1262                   break;
1263                 }
1264               else
1265                 {
1266                   fprintf (stderr, "GDBserver exiting\n");
1267                   exit (0);
1268                 }
1269             }
1270         }
1271
1272       /* We come here when getpkt fails.
1273
1274          For the extended remote protocol we exit (and this is the only
1275          way we gracefully exit!).
1276
1277          For the traditional remote protocol close the connection,
1278          and re-open it at the top of the loop.  */
1279       if (extended_protocol)
1280         {
1281           remote_close ();
1282           exit (0);
1283         }
1284       else
1285         {
1286           fprintf (stderr, "Remote side has terminated connection.  "
1287                            "GDBserver will reopen the connection.\n");
1288           remote_close ();
1289         }
1290     }
1291 }