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, 0)) != 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   else
 913     {
 914       switch (attach_inferior (pid, &status, &signal))
 915         {
 916         case -1:
 917           error ("Attaching not supported on this target");
 918           break;
 919         default:
 920           attached = 1;
 921           break;
 922         }
 923     }
 924
 925   /* Don't report shared library events on the initial connection,
 926      even if some libraries are preloaded.  Avoids the "stopped by
 927      shared library event" notice on gdb side.  */
 928   dlls_changed = 0;
 929
 930   if (setjmp (toplevel))
 931     {
 932       fprintf (stderr, "Killing inferior\n");
 933       kill_inferior ();
 934       exit (1);
 935     }
 936
 937   if (status == 'W' || status == 'X')
 938     {
 939       fprintf (stderr, "No inferior, GDBserver exiting.\n");
 940       exit (1);
 941     }
 942
 943   while (1)
 944     {
 945       remote_open (argv[1]);
 946
 947     restart:
 948       setjmp (toplevel);
 949       while (1)
 950         {
 951           unsigned char sig;
 952           int packet_len;
 953           int new_packet_len = -1;
 954
 955           packet_len = getpkt (own_buf);
 956           if (packet_len <= 0)
 957             break;
 958
 959           i = 0;
 960           ch = own_buf[i++];
 961           switch (ch)
 962             {
 963             case 'q':
 964               handle_query (own_buf, packet_len, &new_packet_len);
 965               break;
 966             case 'Q':
 967               handle_general_set (own_buf);
 968               break;
 969             case 'D':
 970               fprintf (stderr, "Detaching from inferior\n");
 971               if (detach_inferior () != 0)
 972                 {
 973                   write_enn (own_buf);
 974                   putpkt (own_buf);
 975                 }
 976               else
 977                 {
 978                   write_ok (own_buf);
 979                   putpkt (own_buf);
 980                   remote_close ();
 981
 982                   /* If we are attached, then we can exit.  Otherwise, we
 983                      need to hang around doing nothing, until the child
 984                      is gone.  */
 985                   if (!attached)
 986                     join_inferior ();
 987
 988                   exit (0);
 989                 }
 990             case '!':
 991               if (attached == 0)
 992                 {
 993                   extended_protocol = 1;
 994                   prepare_resume_reply (own_buf, status, signal);
 995                 }
 996               else
 997                 {
 998                   /* We can not use the extended protocol if we are
 999                      attached, because we can not restart the running
1000                      program.  So return unrecognized.  */
1001                   own_buf[0] = '\0';
1002                 }
1003               break;
1004             case '?':
1005               prepare_resume_reply (own_buf, status, signal);
1006               break;
1007             case 'H':
1008               if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
1009                 {
1010                   unsigned long gdb_id, thread_id;
1011
1012                   gdb_id = strtoul (&own_buf[2], NULL, 16);
1013                   thread_id = gdb_id_to_thread_id (gdb_id);
1014                   if (thread_id == 0)
1015                     {
1016                       write_enn (own_buf);
1017                       break;
1018                     }
1019
1020                   if (own_buf[1] == 'g')
1021                     {
1022                       general_thread = thread_id;
1023                       set_desired_inferior (1);
1024                     }
1025                   else if (own_buf[1] == 'c')
1026                     cont_thread = thread_id;
1027                   else if (own_buf[1] == 's')
1028                     step_thread = thread_id;
1029
1030                   write_ok (own_buf);
1031                 }
1032               else
1033                 {
1034                   /* Silently ignore it so that gdb can extend the protocol
1035                      without compatibility headaches.  */
1036                   own_buf[0] = '\0';
1037                 }
1038               break;
1039             case 'g':
1040               set_desired_inferior (1);
1041               registers_to_string (own_buf);
1042               break;
1043             case 'G':
1044               set_desired_inferior (1);
1045               registers_from_string (&own_buf[1]);
1046               write_ok (own_buf);
1047               break;
1048             case 'm':
1049               decode_m_packet (&own_buf[1], &mem_addr, &len);
1050               if (read_inferior_memory (mem_addr, mem_buf, len) == 0)
1051                 convert_int_to_ascii (mem_buf, own_buf, len);
1052               else
1053                 write_enn (own_buf);
1054               break;
1055             case 'M':
1056               decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
1057               if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
1058                 write_ok (own_buf);
1059               else
1060                 write_enn (own_buf);
1061               break;
1062             case 'X':
1063               if (decode_X_packet (&own_buf[1], packet_len - 1,
1064                                    &mem_addr, &len, mem_buf) < 0
1065                   || write_inferior_memory (mem_addr, mem_buf, len) != 0)
1066                 write_enn (own_buf);
1067               else
1068                 write_ok (own_buf);
1069               break;
1070             case 'C':
1071               convert_ascii_to_int (own_buf + 1, &sig, 1);
1072               if (target_signal_to_host_p (sig))
1073                 signal = target_signal_to_host (sig);
1074               else
1075                 signal = 0;
1076               set_desired_inferior (0);
1077               myresume (0, signal);
1078               signal = mywait (&status, 1);
1079               prepare_resume_reply (own_buf, status, signal);
1080               break;
1081             case 'S':
1082               convert_ascii_to_int (own_buf + 1, &sig, 1);
1083               if (target_signal_to_host_p (sig))
1084                 signal = target_signal_to_host (sig);
1085               else
1086                 signal = 0;
1087               set_desired_inferior (0);
1088               myresume (1, signal);
1089               signal = mywait (&status, 1);
1090               prepare_resume_reply (own_buf, status, signal);
1091               break;
1092             case 'c':
1093               set_desired_inferior (0);
1094               myresume (0, 0);
1095               signal = mywait (&status, 1);
1096               prepare_resume_reply (own_buf, status, signal);
1097               break;
1098             case 's':
1099               set_desired_inferior (0);
1100               myresume (1, 0);
1101               signal = mywait (&status, 1);
1102               prepare_resume_reply (own_buf, status, signal);
1103               break;
1104             case 'Z':
1105               {
1106                 char *lenptr;
1107                 char *dataptr;
1108                 CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
1109                 int len = strtol (lenptr + 1, &dataptr, 16);
1110                 char type = own_buf[1];
1111
1112                 if (the_target->insert_watchpoint == NULL
1113                     || (type < '2' || type > '4'))
1114                   {
1115                     /* No watchpoint support or not a watchpoint command;
1116                        unrecognized either way.  */
1117                     own_buf[0] = '\0';
1118                   }
1119                 else
1120                   {
1121                     int res;
1122
1123                     res = (*the_target->insert_watchpoint) (type, addr, len);
1124                     if (res == 0)
1125                       write_ok (own_buf);
1126                     else if (res == 1)
1127                       /* Unsupported.  */
1128                       own_buf[0] = '\0';
1129                     else
1130                       write_enn (own_buf);
1131                   }
1132                 break;
1133               }
1134             case 'z':
1135               {
1136                 char *lenptr;
1137                 char *dataptr;
1138                 CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
1139                 int len = strtol (lenptr + 1, &dataptr, 16);
1140                 char type = own_buf[1];
1141
1142                 if (the_target->remove_watchpoint == NULL
1143                     || (type < '2' || type > '4'))
1144                   {
1145                     /* No watchpoint support or not a watchpoint command;
1146                        unrecognized either way.  */
1147                     own_buf[0] = '\0';
1148                   }
1149                 else
1150                   {
1151                     int res;
1152
1153                     res = (*the_target->remove_watchpoint) (type, addr, len);
1154                     if (res == 0)
1155                       write_ok (own_buf);
1156                     else if (res == 1)
1157                       /* Unsupported.  */
1158                       own_buf[0] = '\0';
1159                     else
1160                       write_enn (own_buf);
1161                   }
1162                 break;
1163               }
1164             case 'k':
1165               fprintf (stderr, "Killing inferior\n");
1166               kill_inferior ();
1167               /* When using the extended protocol, we start up a new
1168                  debugging session.   The traditional protocol will
1169                  exit instead.  */
1170               if (extended_protocol)
1171                 {
1172                   write_ok (own_buf);
1173                   fprintf (stderr, "GDBserver restarting\n");
1174
1175                   /* Wait till we are at 1st instruction in prog.  */
1176                   signal = start_inferior (&argv[2], &status);
1177                   goto restart;
1178                   break;
1179                 }
1180               else
1181                 {
1182                   exit (0);
1183                   break;
1184                 }
1185             case 'T':
1186               {
1187                 unsigned long gdb_id, thread_id;
1188
1189                 gdb_id = strtoul (&own_buf[1], NULL, 16);
1190                 thread_id = gdb_id_to_thread_id (gdb_id);
1191                 if (thread_id == 0)
1192                   {
1193                     write_enn (own_buf);
1194                     break;
1195                   }
1196
1197                 if (mythread_alive (thread_id))
1198                   write_ok (own_buf);
1199                 else
1200                   write_enn (own_buf);
1201               }
1202               break;
1203             case 'R':
1204               /* Restarting the inferior is only supported in the
1205                  extended protocol.  */
1206               if (extended_protocol)
1207                 {
1208                   kill_inferior ();
1209                   write_ok (own_buf);
1210                   fprintf (stderr, "GDBserver restarting\n");
1211
1212                   /* Wait till we are at 1st instruction in prog.  */
1213                   signal = start_inferior (&argv[2], &status);
1214                   goto restart;
1215                   break;
1216                 }
1217               else
1218                 {
1219                   /* It is a request we don't understand.  Respond with an
1220                      empty packet so that gdb knows that we don't support this
1221                      request.  */
1222                   own_buf[0] = '\0';
1223                   break;
1224                 }
1225             case 'v':
1226               /* Extended (long) request.  */
1227               handle_v_requests (own_buf, &status, &signal,
1228                                  packet_len, &new_packet_len);
1229               break;
1230
1231             default:
1232               /* It is a request we don't understand.  Respond with an
1233                  empty packet so that gdb knows that we don't support this
1234                  request.  */
1235               own_buf[0] = '\0';
1236               break;
1237             }
1238
1239           if (new_packet_len != -1)
1240             putpkt_binary (own_buf, new_packet_len);
1241           else
1242             putpkt (own_buf);
1243
1244           if (status == 'W')
1245             fprintf (stderr,
1246                      "\nChild exited with status %d\n", signal);
1247           if (status == 'X')
1248             fprintf (stderr, "\nChild terminated with signal = 0x%x (%s)\n",
1249                      target_signal_to_host (signal),
1250                      target_signal_to_name (signal));
1251           if (status == 'W' || status == 'X')
1252             {
1253               if (extended_protocol)
1254                 {
1255                   fprintf (stderr, "Killing inferior\n");
1256                   kill_inferior ();
1257                   write_ok (own_buf);
1258                   fprintf (stderr, "GDBserver restarting\n");
1259
1260                   /* Wait till we are at 1st instruction in prog.  */
1261                   signal = start_inferior (&argv[2], &status);
1262                   goto restart;
1263                   break;
1264                 }
1265               else
1266                 {
1267                   fprintf (stderr, "GDBserver exiting\n");
1268                   exit (0);
1269                 }
1270             }
1271         }
1272
1273       /* We come here when getpkt fails.
1274
1275          For the extended remote protocol we exit (and this is the only
1276          way we gracefully exit!).
1277
1278          For the traditional remote protocol close the connection,
1279          and re-open it at the top of the loop.  */
1280       if (extended_protocol)
1281         {
1282           remote_close ();
1283           exit (0);
1284         }
1285       else
1286         {
1287           fprintf (stderr, "Remote side has terminated connection.  "
1288                            "GDBserver will reopen the connection.\n");
1289           remote_close ();
1290         }
1291     }
1292 }