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