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, 2003, 2004
   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       fprintf (stderr, "Listening on port %d\n", port);
 139
 140       tmp = sizeof (sockaddr);
 141       remote_desc = accept (tmp_desc, (struct sockaddr *) &sockaddr, &tmp);
 142       if (remote_desc == -1)
 143         perror_with_name ("Accept failed");
 144
 145       /* Enable TCP keep alive process. */
 146       tmp = 1;
 147       setsockopt (tmp_desc, SOL_SOCKET, SO_KEEPALIVE, (char *) &tmp, sizeof (tmp));
 148
 149       /* Tell TCP not to delay small packets.  This greatly speeds up
 150          interactive response. */
 151       tmp = 1;
 152       setsockopt (remote_desc, IPPROTO_TCP, TCP_NODELAY,
 153                   (char *) &tmp, sizeof (tmp));
 154
 155       close (tmp_desc);         /* No longer need this */
 156
 157       signal (SIGPIPE, SIG_IGN);        /* If we don't do this, then gdbserver simply
 158                                            exits when the remote side dies.  */
 159
 160       /* Convert IP address to string.  */
 161       fprintf (stderr, "Remote debugging from host %s\n",
 162          inet_ntoa (sockaddr.sin_addr));
 163     }
 164
 165 #if defined(F_SETFL) && defined (FASYNC)
 166   save_fcntl_flags = fcntl (remote_desc, F_GETFL, 0);
 167   fcntl (remote_desc, F_SETFL, save_fcntl_flags | FASYNC);
 168 #if defined (F_SETOWN)
 169   fcntl (remote_desc, F_SETOWN, getpid ());
 170 #endif
 171 #endif
 172   disable_async_io ();
 173 }
 174
 175 void
 176 remote_close (void)
 177 {
 178   close (remote_desc);
 179 }
 180
 181 /* Convert hex digit A to a number.  */
 182
 183 static int
 184 fromhex (int a)
 185 {
 186   if (a >= '0' && a <= '9')
 187     return a - '0';
 188   else if (a >= 'a' && a <= 'f')
 189     return a - 'a' + 10;
 190   else
 191     error ("Reply contains invalid hex digit");
 192   return 0;
 193 }
 194
 195 int
 196 unhexify (char *bin, const char *hex, int count)
 197 {
 198   int i;
 199
 200   for (i = 0; i < count; i++)
 201     {
 202       if (hex[0] == 0 || hex[1] == 0)
 203         {
 204           /* Hex string is short, or of uneven length.
 205              Return the count that has been converted so far. */
 206           return i;
 207         }
 208       *bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]);
 209       hex += 2;
 210     }
 211   return i;
 212 }
 213
 214 static void
 215 decode_address (CORE_ADDR *addrp, const char *start, int len)
 216 {
 217   CORE_ADDR addr;
 218   char ch;
 219   int i;
 220
 221   addr = 0;
 222   for (i = 0; i < len; i++)
 223     {
 224       ch = start[i];
 225       addr = addr << 4;
 226       addr = addr | (fromhex (ch) & 0x0f);
 227     }
 228   *addrp = addr;
 229 }
 230
 231 /* Convert number NIB to a hex digit.  */
 232
 233 static int
 234 tohex (int nib)
 235 {
 236   if (nib < 10)
 237     return '0' + nib;
 238   else
 239     return 'a' + nib - 10;
 240 }
 241
 242 int
 243 hexify (char *hex, const char *bin, int count)
 244 {
 245   int i;
 246
 247   /* May use a length, or a nul-terminated string as input. */
 248   if (count == 0)
 249     count = strlen (bin);
 250
 251   for (i = 0; i < count; i++)
 252     {
 253       *hex++ = tohex ((*bin >> 4) & 0xf);
 254       *hex++ = tohex (*bin++ & 0xf);
 255     }
 256   *hex = 0;
 257   return i;
 258 }
 259
 260 /* Send a packet to the remote machine, with error checking.
 261    The data of the packet is in BUF.  Returns >= 0 on success, -1 otherwise. */
 262
 263 int
 264 putpkt (char *buf)
 265 {
 266   int i;
 267   unsigned char csum = 0;
 268   char *buf2;
 269   char buf3[1];
 270   int cnt = strlen (buf);
 271   char *p;
 272
 273   buf2 = malloc (PBUFSIZ);
 274
 275   /* Copy the packet into buffer BUF2, encapsulating it
 276      and giving it a checksum.  */
 277
 278   p = buf2;
 279   *p++ = '$';
 280
 281   for (i = 0; i < cnt; i++)
 282     {
 283       csum += buf[i];
 284       *p++ = buf[i];
 285     }
 286   *p++ = '#';
 287   *p++ = tohex ((csum >> 4) & 0xf);
 288   *p++ = tohex (csum & 0xf);
 289
 290   *p = '\0';
 291
 292   /* Send it over and over until we get a positive ack.  */
 293
 294   do
 295     {
 296       int cc;
 297
 298       if (write (remote_desc, buf2, p - buf2) != p - buf2)
 299         {
 300           perror ("putpkt(write)");
 301           return -1;
 302         }
 303
 304       if (remote_debug)
 305         {
 306           fprintf (stderr, "putpkt (\"%s\"); [looking for ack]\n", buf2);
 307           fflush (stderr);
 308         }
 309       cc = read (remote_desc, buf3, 1);
 310       if (remote_debug)
 311         {
 312           fprintf (stderr, "[received '%c' (0x%x)]\n", buf3[0], buf3[0]);
 313           fflush (stderr);
 314         }
 315
 316       if (cc <= 0)
 317         {
 318           if (cc == 0)
 319             fprintf (stderr, "putpkt(read): Got EOF\n");
 320           else
 321             perror ("putpkt(read)");
 322
 323           free (buf2);
 324           return -1;
 325         }
 326
 327       /* Check for an input interrupt while we're here.  */
 328       if (buf3[0] == '\003')
 329         (*the_target->send_signal) (SIGINT);
 330     }
 331   while (buf3[0] != '+');
 332
 333   free (buf2);
 334   return 1;                     /* Success! */
 335 }
 336
 337 /* Come here when we get an input interrupt from the remote side.  This
 338    interrupt should only be active while we are waiting for the child to do
 339    something.  About the only thing that should come through is a ^C, which
 340    will cause us to send a SIGINT to the child.  */
 341
 342 static void
 343 input_interrupt (int unused)
 344 {
 345   fd_set readset;
 346   struct timeval immediate = { 0, 0 };
 347
 348   /* Protect against spurious interrupts.  This has been observed to
 349      be a problem under NetBSD 1.4 and 1.5.  */
 350
 351   FD_ZERO (&readset);
 352   FD_SET (remote_desc, &readset);
 353   if (select (remote_desc + 1, &readset, 0, 0, &immediate) > 0)
 354     {
 355       int cc;
 356       char c;
 357
 358       cc = read (remote_desc, &c, 1);
 359
 360       if (cc != 1 || c != '\003')
 361         {
 362           fprintf (stderr, "input_interrupt, cc = %d c = %d\n", cc, c);
 363           return;
 364         }
 365
 366       (*the_target->send_signal) (SIGINT);
 367     }
 368 }
 369
 370 void
 371 block_async_io (void)
 372 {
 373   sigset_t sigio_set;
 374   sigemptyset (&sigio_set);
 375   sigaddset (&sigio_set, SIGIO);
 376   sigprocmask (SIG_BLOCK, &sigio_set, NULL);
 377 }
 378
 379 void
 380 unblock_async_io (void)
 381 {
 382   sigset_t sigio_set;
 383   sigemptyset (&sigio_set);
 384   sigaddset (&sigio_set, SIGIO);
 385   sigprocmask (SIG_UNBLOCK, &sigio_set, NULL);
 386 }
 387
 388 void
 389 enable_async_io (void)
 390 {
 391   signal (SIGIO, input_interrupt);
 392 }
 393
 394 void
 395 disable_async_io (void)
 396 {
 397   signal (SIGIO, SIG_IGN);
 398 }
 399
 400 /* Returns next char from remote GDB.  -1 if error.  */
 401
 402 static int
 403 readchar (void)
 404 {
 405   static char buf[BUFSIZ];
 406   static int bufcnt = 0;
 407   static char *bufp;
 408
 409   if (bufcnt-- > 0)
 410     return *bufp++ & 0x7f;
 411
 412   bufcnt = read (remote_desc, buf, sizeof (buf));
 413
 414   if (bufcnt <= 0)
 415     {
 416       if (bufcnt == 0)
 417         fprintf (stderr, "readchar: Got EOF\n");
 418       else
 419         perror ("readchar");
 420
 421       return -1;
 422     }
 423
 424   bufp = buf;
 425   bufcnt--;
 426   return *bufp++ & 0x7f;
 427 }
 428
 429 /* Read a packet from the remote machine, with error checking,
 430    and store it in BUF.  Returns length of packet, or negative if error. */
 431
 432 int
 433 getpkt (char *buf)
 434 {
 435   char *bp;
 436   unsigned char csum, c1, c2;
 437   int c;
 438
 439   while (1)
 440     {
 441       csum = 0;
 442
 443       while (1)
 444         {
 445           c = readchar ();
 446           if (c == '$')
 447             break;
 448           if (remote_debug)
 449             {
 450               fprintf (stderr, "[getpkt: discarding char '%c']\n", c);
 451               fflush (stderr);
 452             }
 453
 454           if (c < 0)
 455             return -1;
 456         }
 457
 458       bp = buf;
 459       while (1)
 460         {
 461           c = readchar ();
 462           if (c < 0)
 463             return -1;
 464           if (c == '#')
 465             break;
 466           *bp++ = c;
 467           csum += c;
 468         }
 469       *bp = 0;
 470
 471       c1 = fromhex (readchar ());
 472       c2 = fromhex (readchar ());
 473
 474       if (csum == (c1 << 4) + c2)
 475         break;
 476
 477       fprintf (stderr, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
 478                (c1 << 4) + c2, csum, buf);
 479       write (remote_desc, "-", 1);
 480     }
 481
 482   if (remote_debug)
 483     {
 484       fprintf (stderr, "getpkt (\"%s\");  [sending ack] \n", buf);
 485       fflush (stderr);
 486     }
 487
 488   write (remote_desc, "+", 1);
 489
 490   if (remote_debug)
 491     {
 492       fprintf (stderr, "[sent ack]\n");
 493       fflush (stderr);
 494     }
 495
 496   return bp - buf;
 497 }
 498
 499 void
 500 write_ok (char *buf)
 501 {
 502   buf[0] = 'O';
 503   buf[1] = 'K';
 504   buf[2] = '\0';
 505 }
 506
 507 void
 508 write_enn (char *buf)
 509 {
 510   /* Some day, we should define the meanings of the error codes... */
 511   buf[0] = 'E';
 512   buf[1] = '0';
 513   buf[2] = '1';
 514   buf[3] = '\0';
 515 }
 516
 517 void
 518 convert_int_to_ascii (char *from, char *to, int n)
 519 {
 520   int nib;
 521   char ch;
 522   while (n--)
 523     {
 524       ch = *from++;
 525       nib = ((ch & 0xf0) >> 4) & 0x0f;
 526       *to++ = tohex (nib);
 527       nib = ch & 0x0f;
 528       *to++ = tohex (nib);
 529     }
 530   *to++ = 0;
 531 }
 532
 533
 534 void
 535 convert_ascii_to_int (char *from, char *to, int n)
 536 {
 537   int nib1, nib2;
 538   while (n--)
 539     {
 540       nib1 = fromhex (*from++);
 541       nib2 = fromhex (*from++);
 542       *to++ = (((nib1 & 0x0f) << 4) & 0xf0) | (nib2 & 0x0f);
 543     }
 544 }
 545
 546 static char *
 547 outreg (int regno, char *buf)
 548 {
 549   if ((regno >> 12) != 0)
 550     *buf++ = tohex ((regno >> 12) & 0xf);
 551   if ((regno >> 8) != 0)
 552     *buf++ = tohex ((regno >> 8) & 0xf);
 553   *buf++ = tohex ((regno >> 4) & 0xf);
 554   *buf++ = tohex (regno & 0xf);
 555   *buf++ = ':';
 556   collect_register_as_string (regno, buf);
 557   buf += 2 * register_size (regno);
 558   *buf++ = ';';
 559
 560   return buf;
 561 }
 562
 563 void
 564 new_thread_notify (int id)
 565 {
 566   char own_buf[256];
 567
 568   /* The `n' response is not yet part of the remote protocol.  Do nothing.  */
 569   if (1)
 570     return;
 571
 572   if (server_waiting == 0)
 573     return;
 574
 575   sprintf (own_buf, "n%x", id);
 576   disable_async_io ();
 577   putpkt (own_buf);
 578   enable_async_io ();
 579 }
 580
 581 void
 582 dead_thread_notify (int id)
 583 {
 584   char own_buf[256];
 585
 586   /* The `x' response is not yet part of the remote protocol.  Do nothing.  */
 587   if (1)
 588     return;
 589
 590   sprintf (own_buf, "x%x", id);
 591   disable_async_io ();
 592   putpkt (own_buf);
 593   enable_async_io ();
 594 }
 595
 596 void
 597 prepare_resume_reply (char *buf, char status, unsigned char signo)
 598 {
 599   int nib, sig;
 600
 601   *buf++ = status;
 602
 603   sig = (int)target_signal_from_host (signo);
 604
 605   nib = ((sig & 0xf0) >> 4);
 606   *buf++ = tohex (nib);
 607   nib = sig & 0x0f;
 608   *buf++ = tohex (nib);
 609
 610   if (status == 'T')
 611     {
 612       const char **regp = gdbserver_expedite_regs;
 613       while (*regp)
 614         {
 615           buf = outreg (find_regno (*regp), buf);
 616           regp ++;
 617         }
 618
 619       /* Formerly, if the debugger had not used any thread features we would not
 620          burden it with a thread status response.  This was for the benefit of
 621          GDB 4.13 and older.  However, in recent GDB versions the check
 622          (``if (cont_thread != 0)'') does not have the desired effect because of
 623          sillyness in the way that the remote protocol handles specifying a thread.
 624          Since thread support relies on qSymbol support anyway, assume GDB can handle
 625          threads.  */
 626
 627       if (using_threads)
 628         {
 629           /* FIXME right place to set this? */
 630           thread_from_wait = ((struct inferior_list_entry *)current_inferior)->id;
 631           if (debug_threads)
 632             fprintf (stderr, "Writing resume reply for %d\n\n", thread_from_wait);
 633           /* This if (1) ought to be unnecessary.  But remote_wait in GDB
 634              will claim this event belongs to inferior_ptid if we do not
 635              specify a thread, and there's no way for gdbserver to know
 636              what inferior_ptid is.  */
 637           if (1 || old_thread_from_wait != thread_from_wait)
 638             {
 639               general_thread = thread_from_wait;
 640               sprintf (buf, "thread:%x;", thread_from_wait);
 641               buf += strlen (buf);
 642               old_thread_from_wait = thread_from_wait;
 643             }
 644         }
 645     }
 646   /* For W and X, we're done.  */
 647   *buf++ = 0;
 648 }
 649
 650 void
 651 decode_m_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr)
 652 {
 653   int i = 0, j = 0;
 654   char ch;
 655   *mem_addr_ptr = *len_ptr = 0;
 656
 657   while ((ch = from[i++]) != ',')
 658     {
 659       *mem_addr_ptr = *mem_addr_ptr << 4;
 660       *mem_addr_ptr |= fromhex (ch) & 0x0f;
 661     }
 662
 663   for (j = 0; j < 4; j++)
 664     {
 665       if ((ch = from[i++]) == 0)
 666         break;
 667       *len_ptr = *len_ptr << 4;
 668       *len_ptr |= fromhex (ch) & 0x0f;
 669     }
 670 }
 671
 672 void
 673 decode_M_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr,
 674                  char *to)
 675 {
 676   int i = 0;
 677   char ch;
 678   *mem_addr_ptr = *len_ptr = 0;
 679
 680   while ((ch = from[i++]) != ',')
 681     {
 682       *mem_addr_ptr = *mem_addr_ptr << 4;
 683       *mem_addr_ptr |= fromhex (ch) & 0x0f;
 684     }
 685
 686   while ((ch = from[i++]) != ':')
 687     {
 688       *len_ptr = *len_ptr << 4;
 689       *len_ptr |= fromhex (ch) & 0x0f;
 690     }
 691
 692   convert_ascii_to_int (&from[i++], to, *len_ptr);
 693 }
 694
 695 int
 696 look_up_one_symbol (const char *name, CORE_ADDR *addrp)
 697 {
 698   char own_buf[266], *p, *q;
 699   int len;
 700
 701   /* Send the request.  */
 702   strcpy (own_buf, "qSymbol:");
 703   hexify (own_buf + strlen ("qSymbol:"), name, strlen (name));
 704   if (putpkt (own_buf) < 0)
 705     return -1;
 706
 707   /* FIXME:  Eventually add buffer overflow checking (to getpkt?)  */
 708   len = getpkt (own_buf);
 709   if (len < 0)
 710     return -1;
 711
 712   if (strncmp (own_buf, "qSymbol:", strlen ("qSymbol:")) != 0)
 713     {
 714       /* Malformed response.  */
 715       if (remote_debug)
 716         {
 717           fprintf (stderr, "Malformed response to qSymbol, ignoring.\n");
 718           fflush (stderr);
 719         }
 720
 721       return -1;
 722     }
 723
 724   p = own_buf + strlen ("qSymbol:");
 725   q = p;
 726   while (*q && *q != ':')
 727     q++;
 728
 729   /* Make sure we found a value for the symbol.  */
 730   if (p == q || *q == '\0')
 731     return 0;
 732
 733   decode_address (addrp, p, q - p);
 734   return 1;
 735 }
 736