gdb/gdbserver/remote-utils.c

   1 /* Remote utility routines for the remote server for GDB.
   2    Copyright 1986, 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
   3    2002
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "server.h"
  24 #include "terminal.h"
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <sys/ioctl.h>
  28 #include <sys/file.h>
  29 #include <netinet/in.h>
  30 #include <sys/socket.h>
  31 #include <netdb.h>
  32 #include <netinet/tcp.h>
  33 #include <sys/ioctl.h>
  34 #include <signal.h>
  35 #include <fcntl.h>
  36 #include <sys/time.h>
  37 #include <unistd.h>
  38 #include <arpa/inet.h>
  39
  40 int remote_debug = 0;
  41 struct ui_file *gdb_stdlog;
  42
  43 static int remote_desc;
  44
  45 /* FIXME headerize? */
  46 extern int using_threads;
  47 extern int debug_threads;
  48
  49 /* Open a connection to a remote debugger.
  50    NAME is the filename used for communication.  */
  51
  52 void
  53 remote_open (char *name)
  54 {
  55   int save_fcntl_flags;
  56
  57   if (!strchr (name, ':'))
  58     {
  59       remote_desc = open (name, O_RDWR);
  60       if (remote_desc < 0)
  61         perror_with_name ("Could not open remote device");
  62
  63 #ifdef HAVE_TERMIOS
  64       {
  65         struct termios termios;
  66         tcgetattr (remote_desc, &termios);
  67
  68         termios.c_iflag = 0;
  69         termios.c_oflag = 0;
  70         termios.c_lflag = 0;
  71         termios.c_cflag &= ~(CSIZE | PARENB);
  72         termios.c_cflag |= CLOCAL | CS8;
  73         termios.c_cc[VMIN] = 1;
  74         termios.c_cc[VTIME] = 0;
  75
  76         tcsetattr (remote_desc, TCSANOW, &termios);
  77       }
  78 #endif
  79
  80 #ifdef HAVE_TERMIO
  81       {
  82         struct termio termio;
  83         ioctl (remote_desc, TCGETA, &termio);
  84
  85         termio.c_iflag = 0;
  86         termio.c_oflag = 0;
  87         termio.c_lflag = 0;
  88         termio.c_cflag &= ~(CSIZE | PARENB);
  89         termio.c_cflag |= CLOCAL | CS8;
  90         termio.c_cc[VMIN] = 1;
  91         termio.c_cc[VTIME] = 0;
  92
  93         ioctl (remote_desc, TCSETA, &termio);
  94       }
  95 #endif
  96
  97 #ifdef HAVE_SGTTY
  98       {
  99         struct sgttyb sg;
 100
 101         ioctl (remote_desc, TIOCGETP, &sg);
 102         sg.sg_flags = RAW;
 103         ioctl (remote_desc, TIOCSETP, &sg);
 104       }
 105 #endif
 106
 107       fprintf (stderr, "Remote debugging using %s\n", name);
 108     }
 109   else
 110     {
 111       char *port_str;
 112       int port;
 113       struct sockaddr_in sockaddr;
 114       int tmp;
 115       int tmp_desc;
 116
 117       port_str = strchr (name, ':');
 118
 119       port = atoi (port_str + 1);
 120
 121       tmp_desc = socket (PF_INET, SOCK_STREAM, 0);
 122       if (tmp_desc < 0)
 123         perror_with_name ("Can't open socket");
 124
 125       /* Allow rapid reuse of this port. */
 126       tmp = 1;
 127       setsockopt (tmp_desc, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp,
 128                   sizeof (tmp));
 129
 130       sockaddr.sin_family = PF_INET;
 131       sockaddr.sin_port = htons (port);
 132       sockaddr.sin_addr.s_addr = INADDR_ANY;
 133
 134       if (bind (tmp_desc, (struct sockaddr *) &sockaddr, sizeof (sockaddr))
 135           || listen (tmp_desc, 1))
 136         perror_with_name ("Can't bind address");
 137
 138       tmp = sizeof (sockaddr);
 139       remote_desc = accept (tmp_desc, (struct sockaddr *) &sockaddr, &tmp);
 140       if (remote_desc == -1)
 141         perror_with_name ("Accept failed");
 142
 143       /* Enable TCP keep alive process. */
 144       tmp = 1;
 145       setsockopt (tmp_desc, SOL_SOCKET, SO_KEEPALIVE, (char *) &tmp, sizeof (tmp));
 146
 147       /* Tell TCP not to delay small packets.  This greatly speeds up
 148          interactive response. */
 149       tmp = 1;
 150       setsockopt (remote_desc, IPPROTO_TCP, TCP_NODELAY,
 151                   (char *) &tmp, sizeof (tmp));
 152
 153       close (tmp_desc);         /* No longer need this */
 154
 155       signal (SIGPIPE, SIG_IGN);        /* If we don't do this, then gdbserver simply
 156                                            exits when the remote side dies.  */
 157
 158       /* Convert IP address to string.  */
 159       fprintf (stderr, "Remote debugging from host %s\n",
 160          inet_ntoa (sockaddr.sin_addr));
 161     }
 162
 163 #if defined(F_SETFL) && defined (FASYNC)
 164   save_fcntl_flags = fcntl (remote_desc, F_GETFL, 0);
 165   fcntl (remote_desc, F_SETFL, save_fcntl_flags | FASYNC);
 166 #if defined (F_SETOWN)
 167   fcntl (remote_desc, F_SETOWN, getpid ());
 168 #endif
 169 #endif
 170   disable_async_io ();
 171 }
 172
 173 void
 174 remote_close (void)
 175 {
 176   close (remote_desc);
 177 }
 178
 179 /* Convert hex digit A to a number.  */
 180
 181 static int
 182 fromhex (int a)
 183 {
 184   if (a >= '0' && a <= '9')
 185     return a - '0';
 186   else if (a >= 'a' && a <= 'f')
 187     return a - 'a' + 10;
 188   else
 189     error ("Reply contains invalid hex digit");
 190   return 0;
 191 }
 192
 193 int
 194 unhexify (char *bin, const char *hex, int count)
 195 {
 196   int i;
 197
 198   for (i = 0; i < count; i++)
 199     {
 200       if (hex[0] == 0 || hex[1] == 0)
 201         {
 202           /* Hex string is short, or of uneven length.
 203              Return the count that has been converted so far. */
 204           return i;
 205         }
 206       *bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]);
 207       hex += 2;
 208     }
 209   return i;
 210 }
 211
 212 static void
 213 decode_address (CORE_ADDR *addrp, const char *start, int len)
 214 {
 215   CORE_ADDR addr;
 216   char ch;
 217   int i;
 218
 219   addr = 0;
 220   for (i = 0; i < len; i++)
 221     {
 222       ch = start[i];
 223       addr = addr << 4;
 224       addr = addr | (fromhex (ch) & 0x0f);
 225     }
 226   *addrp = addr;
 227 }
 228
 229 /* Convert number NIB to a hex digit.  */
 230
 231 static int
 232 tohex (int nib)
 233 {
 234   if (nib < 10)
 235     return '0' + nib;
 236   else
 237     return 'a' + nib - 10;
 238 }
 239
 240 int
 241 hexify (char *hex, const char *bin, int count)
 242 {
 243   int i;
 244
 245   /* May use a length, or a nul-terminated string as input. */
 246   if (count == 0)
 247     count = strlen (bin);
 248
 249   for (i = 0; i < count; i++)
 250     {
 251       *hex++ = tohex ((*bin >> 4) & 0xf);
 252       *hex++ = tohex (*bin++ & 0xf);
 253     }
 254   *hex = 0;
 255   return i;
 256 }
 257
 258 /* Send a packet to the remote machine, with error checking.
 259    The data of the packet is in BUF.  Returns >= 0 on success, -1 otherwise. */
 260
 261 int
 262 putpkt (char *buf)
 263 {
 264   int i;
 265   unsigned char csum = 0;
 266   char *buf2;
 267   char buf3[1];
 268   int cnt = strlen (buf);
 269   char *p;
 270
 271   buf2 = malloc (PBUFSIZ);
 272
 273   /* Copy the packet into buffer BUF2, encapsulating it
 274      and giving it a checksum.  */
 275
 276   p = buf2;
 277   *p++ = '$';
 278
 279   for (i = 0; i < cnt; i++)
 280     {
 281       csum += buf[i];
 282       *p++ = buf[i];
 283     }
 284   *p++ = '#';
 285   *p++ = tohex ((csum >> 4) & 0xf);
 286   *p++ = tohex (csum & 0xf);
 287
 288   *p = '\0';
 289
 290   /* Send it over and over until we get a positive ack.  */
 291
 292   do
 293     {
 294       int cc;
 295
 296       if (write (remote_desc, buf2, p - buf2) != p - buf2)
 297         {
 298           perror ("putpkt(write)");
 299           return -1;
 300         }
 301
 302       if (remote_debug)
 303         {
 304           fprintf (stderr, "putpkt (\"%s\"); [looking for ack]\n", buf2);
 305           fflush (stderr);
 306         }
 307       cc = read (remote_desc, buf3, 1);
 308       if (remote_debug)
 309         {
 310           fprintf (stderr, "[received '%c' (0x%x)]\n", buf3[0], buf3[0]);
 311           fflush (stderr);
 312         }
 313
 314       if (cc <= 0)
 315         {
 316           if (cc == 0)
 317             fprintf (stderr, "putpkt(read): Got EOF\n");
 318           else
 319             perror ("putpkt(read)");
 320
 321           free (buf2);
 322           return -1;
 323         }
 324
 325       /* Check for an input interrupt while we're here.  */
 326       if (buf3[0] == '\003')
 327         kill ((*the_target->signal_pid) (), SIGINT);
 328     }
 329   while (buf3[0] != '+');
 330
 331   free (buf2);
 332   return 1;                     /* Success! */
 333 }
 334
 335 /* Come here when we get an input interrupt from the remote side.  This
 336    interrupt should only be active while we are waiting for the child to do
 337    something.  About the only thing that should come through is a ^C, which
 338    will cause us to send a SIGINT to the child.  */
 339
 340 static void
 341 input_interrupt (int unused)
 342 {
 343   fd_set readset;
 344   struct timeval immediate = { 0, 0 };
 345
 346   /* Protect against spurious interrupts.  This has been observed to
 347      be a problem under NetBSD 1.4 and 1.5.  */
 348
 349   FD_ZERO (&readset);
 350   FD_SET (remote_desc, &readset);
 351   if (select (remote_desc + 1, &readset, 0, 0, &immediate) > 0)
 352     {
 353       int cc;
 354       char c;
 355
 356       cc = read (remote_desc, &c, 1);
 357
 358       if (cc != 1 || c != '\003')
 359         {
 360           fprintf (stderr, "input_interrupt, cc = %d c = %d\n", cc, c);
 361           return;
 362         }
 363
 364       kill ((*the_target->signal_pid) (), SIGINT);
 365     }
 366 }
 367
 368 void
 369 enable_async_io (void)
 370 {
 371   signal (SIGIO, input_interrupt);
 372 }
 373
 374 void
 375 disable_async_io (void)
 376 {
 377   signal (SIGIO, SIG_IGN);
 378 }
 379
 380 /* Returns next char from remote GDB.  -1 if error.  */
 381
 382 static int
 383 readchar (void)
 384 {
 385   static char buf[BUFSIZ];
 386   static int bufcnt = 0;
 387   static char *bufp;
 388
 389   if (bufcnt-- > 0)
 390     return *bufp++ & 0x7f;
 391
 392   bufcnt = read (remote_desc, buf, sizeof (buf));
 393
 394   if (bufcnt <= 0)
 395     {
 396       if (bufcnt == 0)
 397         fprintf (stderr, "readchar: Got EOF\n");
 398       else
 399         perror ("readchar");
 400
 401       return -1;
 402     }
 403
 404   bufp = buf;
 405   bufcnt--;
 406   return *bufp++ & 0x7f;
 407 }
 408
 409 /* Read a packet from the remote machine, with error checking,
 410    and store it in BUF.  Returns length of packet, or negative if error. */
 411
 412 int
 413 getpkt (char *buf)
 414 {
 415   char *bp;
 416   unsigned char csum, c1, c2;
 417   int c;
 418
 419   while (1)
 420     {
 421       csum = 0;
 422
 423       while (1)
 424         {
 425           c = readchar ();
 426           if (c == '$')
 427             break;
 428           if (remote_debug)
 429             {
 430               fprintf (stderr, "[getpkt: discarding char '%c']\n", c);
 431               fflush (stderr);
 432             }
 433
 434           if (c < 0)
 435             return -1;
 436         }
 437
 438       bp = buf;
 439       while (1)
 440         {
 441           c = readchar ();
 442           if (c < 0)
 443             return -1;
 444           if (c == '#')
 445             break;
 446           *bp++ = c;
 447           csum += c;
 448         }
 449       *bp = 0;
 450
 451       c1 = fromhex (readchar ());
 452       c2 = fromhex (readchar ());
 453
 454       if (csum == (c1 << 4) + c2)
 455         break;
 456
 457       fprintf (stderr, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
 458                (c1 << 4) + c2, csum, buf);
 459       write (remote_desc, "-", 1);
 460     }
 461
 462   if (remote_debug)
 463     {
 464       fprintf (stderr, "getpkt (\"%s\");  [sending ack] \n", buf);
 465       fflush (stderr);
 466     }
 467
 468   write (remote_desc, "+", 1);
 469
 470   if (remote_debug)
 471     {
 472       fprintf (stderr, "[sent ack]\n");
 473       fflush (stderr);
 474     }
 475
 476   return bp - buf;
 477 }
 478
 479 void
 480 write_ok (char *buf)
 481 {
 482   buf[0] = 'O';
 483   buf[1] = 'K';
 484   buf[2] = '\0';
 485 }
 486
 487 void
 488 write_enn (char *buf)
 489 {
 490   buf[0] = 'E';
 491   buf[1] = 'N';
 492   buf[2] = 'N';
 493   buf[3] = '\0';
 494 }
 495
 496 void
 497 convert_int_to_ascii (char *from, char *to, int n)
 498 {
 499   int nib;
 500   char ch;
 501   while (n--)
 502     {
 503       ch = *from++;
 504       nib = ((ch & 0xf0) >> 4) & 0x0f;
 505       *to++ = tohex (nib);
 506       nib = ch & 0x0f;
 507       *to++ = tohex (nib);
 508     }
 509   *to++ = 0;
 510 }
 511
 512
 513 void
 514 convert_ascii_to_int (char *from, char *to, int n)
 515 {
 516   int nib1, nib2;
 517   while (n--)
 518     {
 519       nib1 = fromhex (*from++);
 520       nib2 = fromhex (*from++);
 521       *to++ = (((nib1 & 0x0f) << 4) & 0xf0) | (nib2 & 0x0f);
 522     }
 523 }
 524
 525 static char *
 526 outreg (int regno, char *buf)
 527 {
 528   if ((regno >> 12) != 0)
 529     *buf++ = tohex ((regno >> 12) & 0xf);
 530   if ((regno >> 8) != 0)
 531     *buf++ = tohex ((regno >> 8) & 0xf);
 532   *buf++ = tohex ((regno >> 4) & 0xf);
 533   *buf++ = tohex (regno & 0xf);
 534   *buf++ = ':';
 535   collect_register_as_string (regno, buf);
 536   buf += 2 * register_size (regno);
 537   *buf++ = ';';
 538
 539   return buf;
 540 }
 541
 542 void
 543 new_thread_notify (int id)
 544 {
 545   char own_buf[256];
 546
 547   /* The `n' response is not yet part of the remote protocol.  Do nothing.  */
 548   if (1)
 549     return;
 550
 551   if (server_waiting == 0)
 552     return;
 553
 554   sprintf (own_buf, "n%x", id);
 555   disable_async_io ();
 556   putpkt (own_buf);
 557   enable_async_io ();
 558 }
 559
 560 void
 561 dead_thread_notify (int id)
 562 {
 563   char own_buf[256];
 564
 565   /* The `x' response is not yet part of the remote protocol.  Do nothing.  */
 566   if (1)
 567     return;
 568
 569   sprintf (own_buf, "x%x", id);
 570   disable_async_io ();
 571   putpkt (own_buf);
 572   enable_async_io ();
 573 }
 574
 575 void
 576 prepare_resume_reply (char *buf, char status, unsigned char signo)
 577 {
 578   int nib, sig;
 579
 580   *buf++ = status;
 581
 582   sig = (int)target_signal_from_host (signo);
 583
 584   nib = ((sig & 0xf0) >> 4);
 585   *buf++ = tohex (nib);
 586   nib = sig & 0x0f;
 587   *buf++ = tohex (nib);
 588
 589   if (status == 'T')
 590     {
 591       const char **regp = gdbserver_expedite_regs;
 592       while (*regp)
 593         {
 594           buf = outreg (find_regno (*regp), buf);
 595           regp ++;
 596         }
 597
 598       /* Formerly, if the debugger had not used any thread features we would not
 599          burden it with a thread status response.  This was for the benefit of
 600          GDB 4.13 and older.  However, in recent GDB versions the check
 601          (``if (cont_thread != 0)'') does not have the desired effect because of
 602          sillyness in the way that the remote protocol handles specifying a thread.
 603          Since thread support relies on qSymbol support anyway, assume GDB can handle
 604          threads.  */
 605
 606       if (using_threads)
 607         {
 608           /* FIXME right place to set this? */
 609           thread_from_wait = ((struct inferior_list_entry *)current_inferior)->id;
 610           if (debug_threads)
 611             fprintf (stderr, "Writing resume reply for %d\n\n", thread_from_wait);
 612           if (old_thread_from_wait != thread_from_wait)
 613             {
 614               general_thread = thread_from_wait;
 615               sprintf (buf, "thread:%x;", thread_from_wait);
 616               buf += strlen (buf);
 617               old_thread_from_wait = thread_from_wait;
 618             }
 619         }
 620     }
 621   /* For W and X, we're done.  */
 622   *buf++ = 0;
 623 }
 624
 625 void
 626 decode_m_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr)
 627 {
 628   int i = 0, j = 0;
 629   char ch;
 630   *mem_addr_ptr = *len_ptr = 0;
 631
 632   while ((ch = from[i++]) != ',')
 633     {
 634       *mem_addr_ptr = *mem_addr_ptr << 4;
 635       *mem_addr_ptr |= fromhex (ch) & 0x0f;
 636     }
 637
 638   for (j = 0; j < 4; j++)
 639     {
 640       if ((ch = from[i++]) == 0)
 641         break;
 642       *len_ptr = *len_ptr << 4;
 643       *len_ptr |= fromhex (ch) & 0x0f;
 644     }
 645 }
 646
 647 void
 648 decode_M_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr,
 649                  char *to)
 650 {
 651   int i = 0;
 652   char ch;
 653   *mem_addr_ptr = *len_ptr = 0;
 654
 655   while ((ch = from[i++]) != ',')
 656     {
 657       *mem_addr_ptr = *mem_addr_ptr << 4;
 658       *mem_addr_ptr |= fromhex (ch) & 0x0f;
 659     }
 660
 661   while ((ch = from[i++]) != ':')
 662     {
 663       *len_ptr = *len_ptr << 4;
 664       *len_ptr |= fromhex (ch) & 0x0f;
 665     }
 666
 667   convert_ascii_to_int (&from[i++], to, *len_ptr);
 668 }
 669
 670 int
 671 look_up_one_symbol (const char *name, CORE_ADDR *addrp)
 672 {
 673   char own_buf[266], *p, *q;
 674   int len;
 675
 676   /* Send the request.  */
 677   strcpy (own_buf, "qSymbol:");
 678   hexify (own_buf + strlen ("qSymbol:"), name, strlen (name));
 679   if (putpkt (own_buf) < 0)
 680     return -1;
 681
 682   /* FIXME:  Eventually add buffer overflow checking (to getpkt?)  */
 683   len = getpkt (own_buf);
 684   if (len < 0)
 685     return -1;
 686
 687   if (strncmp (own_buf, "qSymbol:", strlen ("qSymbol:")) != 0)
 688     {
 689       /* Malformed response.  */
 690       if (remote_debug)
 691         {
 692           fprintf (stderr, "Malformed response to qSymbol, ignoring.\n");
 693           fflush (stderr);
 694         }
 695
 696       return -1;
 697     }
 698
 699   p = own_buf + strlen ("qSymbol:");
 700   q = p;
 701   while (*q && *q != ':')
 702     q++;
 703
 704   /* Make sure we found a value for the symbol.  */
 705   if (p == q || *q == '\0')
 706     return 0;
 707
 708   decode_address (addrp, p, q - p);
 709   return 1;
 710 }
 711