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 {
 777   if (strncmp (own_buf, "vCont;", 6) == 0)
 778     {
 779       handle_v_cont (own_buf, status, signal);
 780       return;
 781     }
 782
 783   if (strncmp (own_buf, "vCont?", 6) == 0)
 784     {
 785       strcpy (own_buf, "vCont;c;C;s;S");
 786       return;
 787     }
 788
 789   /* Otherwise we didn't know what packet it was.  Say we didn't
 790      understand it.  */
 791   own_buf[0] = 0;
 792   return;
 793 }
 794
 795 void
 796 myresume (int step, int sig)
 797 {
 798   struct thread_resume resume_info[2];
 799   int n = 0;
 800
 801   if (step || sig || (cont_thread != 0 && cont_thread != -1))
 802     {
 803       resume_info[0].thread
 804         = ((struct inferior_list_entry *) current_inferior)->id;
 805       resume_info[0].step = step;
 806       resume_info[0].sig = sig;
 807       resume_info[0].leave_stopped = 0;
 808       n++;
 809     }
 810   resume_info[n].thread = -1;
 811   resume_info[n].step = 0;
 812   resume_info[n].sig = 0;
 813   resume_info[n].leave_stopped = (cont_thread != 0 && cont_thread != -1);
 814
 815   (*the_target->resume) (resume_info);
 816 }
 817
 818 static int attached;
 819
 820 static void
 821 gdbserver_version (void)
 822 {
 823   printf ("GNU gdbserver %s\n"
 824           "Copyright (C) 2007 Free Software Foundation, Inc.\n"
 825           "gdbserver is free software, covered by the GNU General Public License.\n"
 826           "This gdbserver was configured as \"%s\"\n",
 827           version, host_name);
 828 }
 829
 830 static void
 831 gdbserver_usage (void)
 832 {
 833   printf ("Usage:\tgdbserver COMM PROG [ARGS ...]\n"
 834           "\tgdbserver COMM --attach PID\n"
 835           "\n"
 836           "COMM may either be a tty device (for serial debugging), or \n"
 837           "HOST:PORT to listen for a TCP connection.\n");
 838 }
 839
 840 int
 841 main (int argc, char *argv[])
 842 {
 843   char ch, status, *own_buf;
 844   unsigned char *mem_buf;
 845   int i = 0;
 846   int signal;
 847   unsigned int len;
 848   CORE_ADDR mem_addr;
 849   int bad_attach;
 850   int pid;
 851   char *arg_end;
 852
 853   if (argc >= 2 && strcmp (argv[1], "--version") == 0)
 854     {
 855       gdbserver_version ();
 856       exit (0);
 857     }
 858
 859   if (argc >= 2 && strcmp (argv[1], "--help") == 0)
 860     {
 861       gdbserver_usage ();
 862       exit (0);
 863     }
 864
 865   if (setjmp (toplevel))
 866     {
 867       fprintf (stderr, "Exiting\n");
 868       exit (1);
 869     }
 870
 871   bad_attach = 0;
 872   pid = 0;
 873   attached = 0;
 874   if (argc >= 3 && strcmp (argv[2], "--attach") == 0)
 875     {
 876       if (argc == 4
 877           && argv[3][0] != '\0'
 878           && (pid = strtoul (argv[3], &arg_end, 10)) != 0
 879           && *arg_end == '\0')
 880         {
 881           ;
 882         }
 883       else
 884         bad_attach = 1;
 885     }
 886
 887   if (argc < 3 || bad_attach)
 888     {
 889       gdbserver_usage ();
 890       exit (1);
 891     }
 892
 893   initialize_low ();
 894
 895   own_buf = malloc (PBUFSIZ + 1);
 896   mem_buf = malloc (PBUFSIZ);
 897
 898   if (pid == 0)
 899     {
 900       /* Wait till we are at first instruction in program.  */
 901       signal = start_inferior (&argv[2], &status);
 902
 903       /* We are now (hopefully) stopped at the first instruction of
 904          the target process.  This assumes that the target process was
 905          successfully created.  */
 906
 907       /* Don't report shared library events on the initial connection,
 908          even if some libraries are preloaded.  */
 909       dlls_changed = 0;
 910     }
 911   else
 912     {
 913       switch (attach_inferior (pid, &status, &signal))
 914         {
 915         case -1:
 916           error ("Attaching not supported on this target");
 917           break;
 918         default:
 919           attached = 1;
 920           break;
 921         }
 922     }
 923
 924   if (setjmp (toplevel))
 925     {
 926       fprintf (stderr, "Killing inferior\n");
 927       kill_inferior ();
 928       exit (1);
 929     }
 930
 931   if (status == 'W' || status == 'X')
 932     {
 933       fprintf (stderr, "No inferior, GDBserver exiting.\n");
 934       exit (1);
 935     }
 936
 937   while (1)
 938     {
 939       remote_open (argv[1]);
 940
 941     restart:
 942       setjmp (toplevel);
 943       while (1)
 944         {
 945           unsigned char sig;
 946           int packet_len;
 947           int new_packet_len = -1;
 948
 949           packet_len = getpkt (own_buf);
 950           if (packet_len <= 0)
 951             break;
 952
 953           i = 0;
 954           ch = own_buf[i++];
 955           switch (ch)
 956             {
 957             case 'q':
 958               handle_query (own_buf, packet_len, &new_packet_len);
 959               break;
 960             case 'Q':
 961               handle_general_set (own_buf);
 962               break;
 963             case 'D':
 964               fprintf (stderr, "Detaching from inferior\n");
 965               if (detach_inferior () != 0)
 966                 {
 967                   write_enn (own_buf);
 968                   putpkt (own_buf);
 969                 }
 970               else
 971                 {
 972                   write_ok (own_buf);
 973                   putpkt (own_buf);
 974                   remote_close ();
 975
 976                   /* If we are attached, then we can exit.  Otherwise, we
 977                      need to hang around doing nothing, until the child
 978                      is gone.  */
 979                   if (!attached)
 980                     join_inferior ();
 981
 982                   exit (0);
 983                 }
 984             case '!':
 985               if (attached == 0)
 986                 {
 987                   extended_protocol = 1;
 988                   prepare_resume_reply (own_buf, status, signal);
 989                 }
 990               else
 991                 {
 992                   /* We can not use the extended protocol if we are
 993                      attached, because we can not restart the running
 994                      program.  So return unrecognized.  */
 995                   own_buf[0] = '\0';
 996                 }
 997               break;
 998             case '?':
 999               prepare_resume_reply (own_buf, status, signal);
1000               break;
1001             case 'H':
1002               if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
1003                 {
1004                   unsigned long gdb_id, thread_id;
1005
1006                   gdb_id = strtoul (&own_buf[2], NULL, 16);
1007                   thread_id = gdb_id_to_thread_id (gdb_id);
1008                   if (thread_id == 0)
1009                     {
1010                       write_enn (own_buf);
1011                       break;
1012                     }
1013
1014                   if (own_buf[1] == 'g')
1015                     {
1016                       general_thread = thread_id;
1017                       set_desired_inferior (1);
1018                     }
1019                   else if (own_buf[1] == 'c')
1020                     cont_thread = thread_id;
1021                   else if (own_buf[1] == 's')
1022                     step_thread = thread_id;
1023
1024                   write_ok (own_buf);
1025                 }
1026               else
1027                 {
1028                   /* Silently ignore it so that gdb can extend the protocol
1029                      without compatibility headaches.  */
1030                   own_buf[0] = '\0';
1031                 }
1032               break;
1033             case 'g':
1034               set_desired_inferior (1);
1035               registers_to_string (own_buf);
1036               break;
1037             case 'G':
1038               set_desired_inferior (1);
1039               registers_from_string (&own_buf[1]);
1040               write_ok (own_buf);
1041               break;
1042             case 'm':
1043               decode_m_packet (&own_buf[1], &mem_addr, &len);
1044               if (read_inferior_memory (mem_addr, mem_buf, len) == 0)
1045                 convert_int_to_ascii (mem_buf, own_buf, len);
1046               else
1047                 write_enn (own_buf);
1048               break;
1049             case 'M':
1050               decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
1051               if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
1052                 write_ok (own_buf);
1053               else
1054                 write_enn (own_buf);
1055               break;
1056             case 'X':
1057               if (decode_X_packet (&own_buf[1], packet_len - 1,
1058                                    &mem_addr, &len, mem_buf) < 0
1059                   || write_inferior_memory (mem_addr, mem_buf, len) != 0)
1060                 write_enn (own_buf);
1061               else
1062                 write_ok (own_buf);
1063               break;
1064             case 'C':
1065               convert_ascii_to_int (own_buf + 1, &sig, 1);
1066               if (target_signal_to_host_p (sig))
1067                 signal = target_signal_to_host (sig);
1068               else
1069                 signal = 0;
1070               set_desired_inferior (0);
1071               myresume (0, signal);
1072               signal = mywait (&status, 1);
1073               prepare_resume_reply (own_buf, status, signal);
1074               break;
1075             case 'S':
1076               convert_ascii_to_int (own_buf + 1, &sig, 1);
1077               if (target_signal_to_host_p (sig))
1078                 signal = target_signal_to_host (sig);
1079               else
1080                 signal = 0;
1081               set_desired_inferior (0);
1082               myresume (1, signal);
1083               signal = mywait (&status, 1);
1084               prepare_resume_reply (own_buf, status, signal);
1085               break;
1086             case 'c':
1087               set_desired_inferior (0);
1088               myresume (0, 0);
1089               signal = mywait (&status, 1);
1090               prepare_resume_reply (own_buf, status, signal);
1091               break;
1092             case 's':
1093               set_desired_inferior (0);
1094               myresume (1, 0);
1095               signal = mywait (&status, 1);
1096               prepare_resume_reply (own_buf, status, signal);
1097               break;
1098             case 'Z':
1099               {
1100                 char *lenptr;
1101                 char *dataptr;
1102                 CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
1103                 int len = strtol (lenptr + 1, &dataptr, 16);
1104                 char type = own_buf[1];
1105
1106                 if (the_target->insert_watchpoint == NULL
1107                     || (type < '2' || type > '4'))
1108                   {
1109                     /* No watchpoint support or not a watchpoint command;
1110                        unrecognized either way.  */
1111                     own_buf[0] = '\0';
1112                   }
1113                 else
1114                   {
1115                     int res;
1116
1117                     res = (*the_target->insert_watchpoint) (type, addr, len);
1118                     if (res == 0)
1119                       write_ok (own_buf);
1120                     else if (res == 1)
1121                       /* Unsupported.  */
1122                       own_buf[0] = '\0';
1123                     else
1124                       write_enn (own_buf);
1125                   }
1126                 break;
1127               }
1128             case 'z':
1129               {
1130                 char *lenptr;
1131                 char *dataptr;
1132                 CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
1133                 int len = strtol (lenptr + 1, &dataptr, 16);
1134                 char type = own_buf[1];
1135
1136                 if (the_target->remove_watchpoint == NULL
1137                     || (type < '2' || type > '4'))
1138                   {
1139                     /* No watchpoint support or not a watchpoint command;
1140                        unrecognized either way.  */
1141                     own_buf[0] = '\0';
1142                   }
1143                 else
1144                   {
1145                     int res;
1146
1147                     res = (*the_target->remove_watchpoint) (type, addr, len);
1148                     if (res == 0)
1149                       write_ok (own_buf);
1150                     else if (res == 1)
1151                       /* Unsupported.  */
1152                       own_buf[0] = '\0';
1153                     else
1154                       write_enn (own_buf);
1155                   }
1156                 break;
1157               }
1158             case 'k':
1159               fprintf (stderr, "Killing inferior\n");
1160               kill_inferior ();
1161               /* When using the extended protocol, we start up a new
1162                  debugging session.   The traditional protocol will
1163                  exit instead.  */
1164               if (extended_protocol)
1165                 {
1166                   write_ok (own_buf);
1167                   fprintf (stderr, "GDBserver restarting\n");
1168
1169                   /* Wait till we are at 1st instruction in prog.  */
1170                   signal = start_inferior (&argv[2], &status);
1171                   goto restart;
1172                   break;
1173                 }
1174               else
1175                 {
1176                   exit (0);
1177                   break;
1178                 }
1179             case 'T':
1180               {
1181                 unsigned long gdb_id, thread_id;
1182
1183                 gdb_id = strtoul (&own_buf[1], NULL, 16);
1184                 thread_id = gdb_id_to_thread_id (gdb_id);
1185                 if (thread_id == 0)
1186                   {
1187                     write_enn (own_buf);
1188                     break;
1189                   }
1190
1191                 if (mythread_alive (thread_id))
1192                   write_ok (own_buf);
1193                 else
1194                   write_enn (own_buf);
1195               }
1196               break;
1197             case 'R':
1198               /* Restarting the inferior is only supported in the
1199                  extended protocol.  */
1200               if (extended_protocol)
1201                 {
1202                   kill_inferior ();
1203                   write_ok (own_buf);
1204                   fprintf (stderr, "GDBserver restarting\n");
1205
1206                   /* Wait till we are at 1st instruction in prog.  */
1207                   signal = start_inferior (&argv[2], &status);
1208                   goto restart;
1209                   break;
1210                 }
1211               else
1212                 {
1213                   /* It is a request we don't understand.  Respond with an
1214                      empty packet so that gdb knows that we don't support this
1215                      request.  */
1216                   own_buf[0] = '\0';
1217                   break;
1218                 }
1219             case 'v':
1220               /* Extended (long) request.  */
1221               handle_v_requests (own_buf, &status, &signal);
1222               break;
1223             default:
1224               /* It is a request we don't understand.  Respond with an
1225                  empty packet so that gdb knows that we don't support this
1226                  request.  */
1227               own_buf[0] = '\0';
1228               break;
1229             }
1230
1231           if (new_packet_len != -1)
1232             putpkt_binary (own_buf, new_packet_len);
1233           else
1234             putpkt (own_buf);
1235
1236           if (status == 'W')
1237             fprintf (stderr,
1238                      "\nChild exited with status %d\n", signal);
1239           if (status == 'X')
1240             fprintf (stderr, "\nChild terminated with signal = 0x%x (%s)\n",
1241                      target_signal_to_host (signal),
1242                      target_signal_to_name (signal));
1243           if (status == 'W' || status == 'X')
1244             {
1245               if (extended_protocol)
1246                 {
1247                   fprintf (stderr, "Killing inferior\n");
1248                   kill_inferior ();
1249                   write_ok (own_buf);
1250                   fprintf (stderr, "GDBserver restarting\n");
1251
1252                   /* Wait till we are at 1st instruction in prog.  */
1253                   signal = start_inferior (&argv[2], &status);
1254                   goto restart;
1255                   break;
1256                 }
1257               else
1258                 {
1259                   fprintf (stderr, "GDBserver exiting\n");
1260                   exit (0);
1261                 }
1262             }
1263         }
1264
1265       /* We come here when getpkt fails.
1266
1267          For the extended remote protocol we exit (and this is the only
1268          way we gracefully exit!).
1269
1270          For the traditional remote protocol close the connection,
1271          and re-open it at the top of the loop.  */
1272       if (extended_protocol)
1273         {
1274           remote_close ();
1275           exit (0);
1276         }
1277       else
1278         {
1279           fprintf (stderr, "Remote side has terminated connection.  "
1280                            "GDBserver will reopen the connection.\n");
1281           remote_close ();
1282         }
1283     }
1284 }