gdb/gdbserver/remote-utils.c

   1 /* Remote utility routines for the remote server for GDB.
   2    Copyright (C) 1986, 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   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 3 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, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "server.h"
  22 #include "terminal.h"
  23 #include "target.h"
  24 #include <stdio.h>
  25 #include <string.h>
  26 #if HAVE_SYS_IOCTL_H
  27 #include <sys/ioctl.h>
  28 #endif
  29 #if HAVE_SYS_FILE_H
  30 #include <sys/file.h>
  31 #endif
  32 #if HAVE_NETINET_IN_H
  33 #include <netinet/in.h>
  34 #endif
  35 #if HAVE_SYS_SOCKET_H
  36 #include <sys/socket.h>
  37 #endif
  38 #if HAVE_NETDB_H
  39 #include <netdb.h>
  40 #endif
  41 #if HAVE_NETINET_TCP_H
  42 #include <netinet/tcp.h>
  43 #endif
  44 #if HAVE_SYS_IOCTL_H
  45 #include <sys/ioctl.h>
  46 #endif
  47 #if HAVE_SIGNAL_H
  48 #include <signal.h>
  49 #endif
  50 #if HAVE_FCNTL_H
  51 #include <fcntl.h>
  52 #endif
  53 #include <sys/time.h>
  54 #if HAVE_UNISTD_H
  55 #include <unistd.h>
  56 #endif
  57 #if HAVE_ARPA_INET_H
  58 #include <arpa/inet.h>
  59 #endif
  60 #include <sys/stat.h>
  61 #if HAVE_ERRNO_H
  62 #include <errno.h>
  63 #endif
  64
  65 #if USE_WIN32API
  66 #include <winsock.h>
  67 #endif
  68
  69 #if __QNX__
  70 #include <sys/iomgr.h>
  71 #endif /* __QNX__ */
  72
  73 #ifndef HAVE_SOCKLEN_T
  74 typedef int socklen_t;
  75 #endif
  76
  77 #if USE_WIN32API
  78 # define INVALID_DESCRIPTOR INVALID_SOCKET
  79 #else
  80 # define INVALID_DESCRIPTOR -1
  81 #endif
  82
  83 /* A cache entry for a successfully looked-up symbol.  */
  84 struct sym_cache
  85 {
  86   char *name;
  87   CORE_ADDR addr;
  88   struct sym_cache *next;
  89 };
  90
  91 int remote_debug = 0;
  92 struct ui_file *gdb_stdlog;
  93
  94 static int remote_desc = INVALID_DESCRIPTOR;
  95
  96 /* FIXME headerize? */
  97 extern int using_threads;
  98 extern int debug_threads;
  99
 100 /* If true, then GDB has requested noack mode.  */
 101 int noack_mode = 0;
 102 /* If true, then we tell GDB to use noack mode by default.  */
 103 int transport_is_reliable = 0;
 104
 105 #ifdef USE_WIN32API
 106 # define read(fd, buf, len) recv (fd, (char *) buf, len, 0)
 107 # define write(fd, buf, len) send (fd, (char *) buf, len, 0)
 108 #endif
 109
 110 /* Open a connection to a remote debugger.
 111    NAME is the filename used for communication.  */
 112
 113 void
 114 remote_open (char *name)
 115 {
 116 #if defined(F_SETFL) && defined (FASYNC)
 117   int save_fcntl_flags;
 118 #endif
 119   char *port_str;
 120
 121   port_str = strchr (name, ':');
 122   if (port_str == NULL)
 123     {
 124 #ifdef USE_WIN32API
 125       error ("Only <host>:<port> is supported on this platform.");
 126 #else
 127       struct stat statbuf;
 128
 129       if (stat (name, &statbuf) == 0
 130           && (S_ISCHR (statbuf.st_mode) || S_ISFIFO (statbuf.st_mode)))
 131         remote_desc = open (name, O_RDWR);
 132       else
 133         {
 134           errno = EINVAL;
 135           remote_desc = -1;
 136         }
 137
 138       if (remote_desc < 0)
 139         perror_with_name ("Could not open remote device");
 140
 141 #ifdef HAVE_TERMIOS
 142       {
 143         struct termios termios;
 144         tcgetattr (remote_desc, &termios);
 145
 146         termios.c_iflag = 0;
 147         termios.c_oflag = 0;
 148         termios.c_lflag = 0;
 149         termios.c_cflag &= ~(CSIZE | PARENB);
 150         termios.c_cflag |= CLOCAL | CS8;
 151         termios.c_cc[VMIN] = 1;
 152         termios.c_cc[VTIME] = 0;
 153
 154         tcsetattr (remote_desc, TCSANOW, &termios);
 155       }
 156 #endif
 157
 158 #ifdef HAVE_TERMIO
 159       {
 160         struct termio termio;
 161         ioctl (remote_desc, TCGETA, &termio);
 162
 163         termio.c_iflag = 0;
 164         termio.c_oflag = 0;
 165         termio.c_lflag = 0;
 166         termio.c_cflag &= ~(CSIZE | PARENB);
 167         termio.c_cflag |= CLOCAL | CS8;
 168         termio.c_cc[VMIN] = 1;
 169         termio.c_cc[VTIME] = 0;
 170
 171         ioctl (remote_desc, TCSETA, &termio);
 172       }
 173 #endif
 174
 175 #ifdef HAVE_SGTTY
 176       {
 177         struct sgttyb sg;
 178
 179         ioctl (remote_desc, TIOCGETP, &sg);
 180         sg.sg_flags = RAW;
 181         ioctl (remote_desc, TIOCSETP, &sg);
 182       }
 183 #endif
 184
 185       fprintf (stderr, "Remote debugging using %s\n", name);
 186 #endif /* USE_WIN32API */
 187
 188       transport_is_reliable = 0;
 189     }
 190   else
 191     {
 192 #ifdef USE_WIN32API
 193       static int winsock_initialized;
 194 #endif
 195       int port;
 196       struct sockaddr_in sockaddr;
 197       socklen_t tmp;
 198       int tmp_desc;
 199       char *port_end;
 200
 201       port = strtoul (port_str + 1, &port_end, 10);
 202       if (port_str[1] == '\0' || *port_end != '\0')
 203         fatal ("Bad port argument: %s", name);
 204
 205 #ifdef USE_WIN32API
 206       if (!winsock_initialized)
 207         {
 208           WSADATA wsad;
 209
 210           WSAStartup (MAKEWORD (1, 0), &wsad);
 211           winsock_initialized = 1;
 212         }
 213 #endif
 214
 215       tmp_desc = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
 216       if (tmp_desc < 0)
 217         perror_with_name ("Can't open socket");
 218
 219       /* Allow rapid reuse of this port. */
 220       tmp = 1;
 221       setsockopt (tmp_desc, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp,
 222                   sizeof (tmp));
 223
 224       sockaddr.sin_family = PF_INET;
 225       sockaddr.sin_port = htons (port);
 226       sockaddr.sin_addr.s_addr = INADDR_ANY;
 227
 228       if (bind (tmp_desc, (struct sockaddr *) &sockaddr, sizeof (sockaddr))
 229           || listen (tmp_desc, 1))
 230         perror_with_name ("Can't bind address");
 231
 232       /* If port is zero, a random port will be selected, and the
 233          fprintf below needs to know what port was selected.  */
 234       if (port == 0)
 235         {
 236           socklen_t len = sizeof (sockaddr);
 237           if (getsockname (tmp_desc, (struct sockaddr *) &sockaddr, &len) < 0
 238               || len < sizeof (sockaddr))
 239             perror_with_name ("Can't determine port");
 240           port = ntohs (sockaddr.sin_port);
 241         }
 242
 243       fprintf (stderr, "Listening on port %d\n", port);
 244       fflush (stderr);
 245
 246       tmp = sizeof (sockaddr);
 247       remote_desc = accept (tmp_desc, (struct sockaddr *) &sockaddr, &tmp);
 248       if (remote_desc == -1)
 249         perror_with_name ("Accept failed");
 250
 251       /* Enable TCP keep alive process. */
 252       tmp = 1;
 253       setsockopt (remote_desc, SOL_SOCKET, SO_KEEPALIVE,
 254                   (char *) &tmp, sizeof (tmp));
 255
 256       /* Tell TCP not to delay small packets.  This greatly speeds up
 257          interactive response. */
 258       tmp = 1;
 259       setsockopt (remote_desc, IPPROTO_TCP, TCP_NODELAY,
 260                   (char *) &tmp, sizeof (tmp));
 261
 262
 263 #ifndef USE_WIN32API
 264       close (tmp_desc);         /* No longer need this */
 265
 266       signal (SIGPIPE, SIG_IGN);        /* If we don't do this, then gdbserver simply
 267                                            exits when the remote side dies.  */
 268 #else
 269       closesocket (tmp_desc);   /* No longer need this */
 270 #endif
 271
 272       /* Convert IP address to string.  */
 273       fprintf (stderr, "Remote debugging from host %s\n",
 274                inet_ntoa (sockaddr.sin_addr));
 275
 276       transport_is_reliable = 1;
 277     }
 278
 279 #if defined(F_SETFL) && defined (FASYNC)
 280   save_fcntl_flags = fcntl (remote_desc, F_GETFL, 0);
 281   fcntl (remote_desc, F_SETFL, save_fcntl_flags | FASYNC);
 282 #if defined (F_SETOWN)
 283   fcntl (remote_desc, F_SETOWN, getpid ());
 284 #endif
 285 #endif
 286
 287   /* Register the event loop handler.  */
 288   add_file_handler (remote_desc, handle_serial_event, NULL);
 289 }
 290
 291 void
 292 remote_close (void)
 293 {
 294   delete_file_handler (remote_desc);
 295
 296 #ifdef USE_WIN32API
 297   closesocket (remote_desc);
 298 #else
 299   close (remote_desc);
 300 #endif
 301 }
 302
 303 /* Convert hex digit A to a number.  */
 304
 305 static int
 306 fromhex (int a)
 307 {
 308   if (a >= '0' && a <= '9')
 309     return a - '0';
 310   else if (a >= 'a' && a <= 'f')
 311     return a - 'a' + 10;
 312   else
 313     error ("Reply contains invalid hex digit");
 314   return 0;
 315 }
 316
 317 static const char hexchars[] = "0123456789abcdef";
 318
 319 static int
 320 ishex (int ch, int *val)
 321 {
 322   if ((ch >= 'a') && (ch <= 'f'))
 323     {
 324       *val = ch - 'a' + 10;
 325       return 1;
 326     }
 327   if ((ch >= 'A') && (ch <= 'F'))
 328     {
 329       *val = ch - 'A' + 10;
 330       return 1;
 331     }
 332   if ((ch >= '0') && (ch <= '9'))
 333     {
 334       *val = ch - '0';
 335       return 1;
 336     }
 337   return 0;
 338 }
 339
 340 int
 341 unhexify (char *bin, const char *hex, int count)
 342 {
 343   int i;
 344
 345   for (i = 0; i < count; i++)
 346     {
 347       if (hex[0] == 0 || hex[1] == 0)
 348         {
 349           /* Hex string is short, or of uneven length.
 350              Return the count that has been converted so far. */
 351           return i;
 352         }
 353       *bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]);
 354       hex += 2;
 355     }
 356   return i;
 357 }
 358
 359 void
 360 decode_address (CORE_ADDR *addrp, const char *start, int len)
 361 {
 362   CORE_ADDR addr;
 363   char ch;
 364   int i;
 365
 366   addr = 0;
 367   for (i = 0; i < len; i++)
 368     {
 369       ch = start[i];
 370       addr = addr << 4;
 371       addr = addr | (fromhex (ch) & 0x0f);
 372     }
 373   *addrp = addr;
 374 }
 375
 376 const char *
 377 decode_address_to_semicolon (CORE_ADDR *addrp, const char *start)
 378 {
 379   const char *end;
 380
 381   end = start;
 382   while (*end != '\0' && *end != ';')
 383     end++;
 384
 385   decode_address (addrp, start, end - start);
 386
 387   if (*end == ';')
 388     end++;
 389   return end;
 390 }
 391
 392 /* Convert number NIB to a hex digit.  */
 393
 394 static int
 395 tohex (int nib)
 396 {
 397   if (nib < 10)
 398     return '0' + nib;
 399   else
 400     return 'a' + nib - 10;
 401 }
 402
 403 int
 404 hexify (char *hex, const char *bin, int count)
 405 {
 406   int i;
 407
 408   /* May use a length, or a nul-terminated string as input. */
 409   if (count == 0)
 410     count = strlen (bin);
 411
 412   for (i = 0; i < count; i++)
 413     {
 414       *hex++ = tohex ((*bin >> 4) & 0xf);
 415       *hex++ = tohex (*bin++ & 0xf);
 416     }
 417   *hex = 0;
 418   return i;
 419 }
 420
 421 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
 422    binary data in OUT_BUF.  Set *OUT_LEN to the length of the data
 423    encoded in OUT_BUF, and return the number of bytes in OUT_BUF
 424    (which may be more than *OUT_LEN due to escape characters).  The
 425    total number of bytes in the output buffer will be at most
 426    OUT_MAXLEN.  */
 427
 428 int
 429 remote_escape_output (const gdb_byte *buffer, int len,
 430                       gdb_byte *out_buf, int *out_len,
 431                       int out_maxlen)
 432 {
 433   int input_index, output_index;
 434
 435   output_index = 0;
 436   for (input_index = 0; input_index < len; input_index++)
 437     {
 438       gdb_byte b = buffer[input_index];
 439
 440       if (b == '$' || b == '#' || b == '}' || b == '*')
 441         {
 442           /* These must be escaped.  */
 443           if (output_index + 2 > out_maxlen)
 444             break;
 445           out_buf[output_index++] = '}';
 446           out_buf[output_index++] = b ^ 0x20;
 447         }
 448       else
 449         {
 450           if (output_index + 1 > out_maxlen)
 451             break;
 452           out_buf[output_index++] = b;
 453         }
 454     }
 455
 456   *out_len = input_index;
 457   return output_index;
 458 }
 459
 460 /* Convert BUFFER, escaped data LEN bytes long, into binary data
 461    in OUT_BUF.  Return the number of bytes written to OUT_BUF.
 462    Raise an error if the total number of bytes exceeds OUT_MAXLEN.
 463
 464    This function reverses remote_escape_output.  It allows more
 465    escaped characters than that function does, in particular because
 466    '*' must be escaped to avoid the run-length encoding processing
 467    in reading packets.  */
 468
 469 static int
 470 remote_unescape_input (const gdb_byte *buffer, int len,
 471                        gdb_byte *out_buf, int out_maxlen)
 472 {
 473   int input_index, output_index;
 474   int escaped;
 475
 476   output_index = 0;
 477   escaped = 0;
 478   for (input_index = 0; input_index < len; input_index++)
 479     {
 480       gdb_byte b = buffer[input_index];
 481
 482       if (output_index + 1 > out_maxlen)
 483         error ("Received too much data from the target.");
 484
 485       if (escaped)
 486         {
 487           out_buf[output_index++] = b ^ 0x20;
 488           escaped = 0;
 489         }
 490       else if (b == '}')
 491         escaped = 1;
 492       else
 493         out_buf[output_index++] = b;
 494     }
 495
 496   if (escaped)
 497     error ("Unmatched escape character in target response.");
 498
 499   return output_index;
 500 }
 501
 502 /* Look for a sequence of characters which can be run-length encoded.
 503    If there are any, update *CSUM and *P.  Otherwise, output the
 504    single character.  Return the number of characters consumed.  */
 505
 506 static int
 507 try_rle (char *buf, int remaining, unsigned char *csum, char **p)
 508 {
 509   int n;
 510
 511   /* Always output the character.  */
 512   *csum += buf[0];
 513   *(*p)++ = buf[0];
 514
 515   /* Don't go past '~'.  */
 516   if (remaining > 97)
 517     remaining = 97;
 518
 519   for (n = 1; n < remaining; n++)
 520     if (buf[n] != buf[0])
 521       break;
 522
 523   /* N is the index of the first character not the same as buf[0].
 524      buf[0] is counted twice, so by decrementing N, we get the number
 525      of characters the RLE sequence will replace.  */
 526   n--;
 527
 528   if (n < 3)
 529     return 1;
 530
 531   /* Skip the frame characters.  The manual says to skip '+' and '-'
 532      also, but there's no reason to.  Unfortunately these two unusable
 533      characters double the encoded length of a four byte zero
 534      value.  */
 535   while (n + 29 == '$' || n + 29 == '#')
 536     n--;
 537
 538   *csum += '*';
 539   *(*p)++ = '*';
 540   *csum += n + 29;
 541   *(*p)++ = n + 29;
 542
 543   return n + 1;
 544 }
 545
 546 char *
 547 unpack_varlen_hex (char *buff,  /* packet to parse */
 548                    ULONGEST *result)
 549 {
 550   int nibble;
 551   ULONGEST retval = 0;
 552
 553   while (ishex (*buff, &nibble))
 554     {
 555       buff++;
 556       retval = retval << 4;
 557       retval |= nibble & 0x0f;
 558     }
 559   *result = retval;
 560   return buff;
 561 }
 562
 563 /* Write a PTID to BUF.  Returns BUF+CHARACTERS_WRITTEN.  */
 564
 565 char *
 566 write_ptid (char *buf, ptid_t ptid)
 567 {
 568   int pid, tid;
 569
 570   if (multi_process)
 571     {
 572       pid = ptid_get_pid (ptid);
 573       if (pid < 0)
 574         buf += sprintf (buf, "p-%x.", -pid);
 575       else
 576         buf += sprintf (buf, "p%x.", pid);
 577     }
 578   tid = ptid_get_lwp (ptid);
 579   if (tid < 0)
 580     buf += sprintf (buf, "-%x", -tid);
 581   else
 582     buf += sprintf (buf, "%x", tid);
 583
 584   return buf;
 585 }
 586
 587 ULONGEST
 588 hex_or_minus_one (char *buf, char **obuf)
 589 {
 590   ULONGEST ret;
 591
 592   if (strncmp (buf, "-1", 2) == 0)
 593     {
 594       ret = (ULONGEST) -1;
 595       buf += 2;
 596     }
 597   else
 598     buf = unpack_varlen_hex (buf, &ret);
 599
 600   if (obuf)
 601     *obuf = buf;
 602
 603   return ret;
 604 }
 605
 606 /* Extract a PTID from BUF.  If non-null, OBUF is set to the to one
 607    passed the last parsed char.  Returns null_ptid on error.  */
 608 ptid_t
 609 read_ptid (char *buf, char **obuf)
 610 {
 611   char *p = buf;
 612   char *pp;
 613   ULONGEST pid = 0, tid = 0;
 614
 615   if (*p == 'p')
 616     {
 617       /* Multi-process ptid.  */
 618       pp = unpack_varlen_hex (p + 1, &pid);
 619       if (*pp != '.')
 620         error ("invalid remote ptid: %s\n", p);
 621
 622       p = pp + 1;
 623
 624       tid = hex_or_minus_one (p, &pp);
 625
 626       if (obuf)
 627         *obuf = pp;
 628       return ptid_build (pid, tid, 0);
 629     }
 630
 631   /* No multi-process.  Just a tid.  */
 632   tid = hex_or_minus_one (p, &pp);
 633
 634   /* Since the stub is not sending a process id, then default to
 635      what's in the current inferior.  */
 636   pid = ptid_get_pid (((struct inferior_list_entry *) current_inferior)->id);
 637
 638   if (obuf)
 639     *obuf = pp;
 640   return ptid_build (pid, tid, 0);
 641 }
 642
 643 /* Send a packet to the remote machine, with error checking.
 644    The data of the packet is in BUF, and the length of the
 645    packet is in CNT.  Returns >= 0 on success, -1 otherwise.  */
 646
 647 static int
 648 putpkt_binary_1 (char *buf, int cnt, int is_notif)
 649 {
 650   int i;
 651   unsigned char csum = 0;
 652   char *buf2;
 653   char buf3[1];
 654   char *p;
 655
 656   buf2 = xmalloc (PBUFSIZ);
 657
 658   /* Copy the packet into buffer BUF2, encapsulating it
 659      and giving it a checksum.  */
 660
 661   p = buf2;
 662   if (is_notif)
 663     *p++ = '%';
 664   else
 665     *p++ = '$';
 666
 667   for (i = 0; i < cnt;)
 668     i += try_rle (buf + i, cnt - i, &csum, &p);
 669
 670   *p++ = '#';
 671   *p++ = tohex ((csum >> 4) & 0xf);
 672   *p++ = tohex (csum & 0xf);
 673
 674   *p = '\0';
 675
 676   /* Send it over and over until we get a positive ack.  */
 677
 678   do
 679     {
 680       int cc;
 681
 682       if (write (remote_desc, buf2, p - buf2) != p - buf2)
 683         {
 684           perror ("putpkt(write)");
 685           free (buf2);
 686           return -1;
 687         }
 688
 689       if (noack_mode || is_notif)
 690         {
 691           /* Don't expect an ack then.  */
 692           if (remote_debug)
 693             {
 694               if (is_notif)
 695                 fprintf (stderr, "putpkt (\"%s\"); [notif]\n", buf2);
 696               else
 697                 fprintf (stderr, "putpkt (\"%s\"); [noack mode]\n", buf2);
 698               fflush (stderr);
 699             }
 700           break;
 701         }
 702
 703       if (remote_debug)
 704         {
 705           fprintf (stderr, "putpkt (\"%s\"); [looking for ack]\n", buf2);
 706           fflush (stderr);
 707         }
 708       cc = read (remote_desc, buf3, 1);
 709       if (remote_debug)
 710         {
 711           fprintf (stderr, "[received '%c' (0x%x)]\n", buf3[0], buf3[0]);
 712           fflush (stderr);
 713         }
 714
 715       if (cc <= 0)
 716         {
 717           if (cc == 0)
 718             fprintf (stderr, "putpkt(read): Got EOF\n");
 719           else
 720             perror ("putpkt(read)");
 721
 722           free (buf2);
 723           return -1;
 724         }
 725
 726       /* Check for an input interrupt while we're here.  */
 727       if (buf3[0] == '\003' && current_inferior != NULL)
 728         (*the_target->request_interrupt) ();
 729     }
 730   while (buf3[0] != '+');
 731
 732   free (buf2);
 733   return 1;                     /* Success! */
 734 }
 735
 736 int
 737 putpkt_binary (char *buf, int cnt)
 738 {
 739   return putpkt_binary_1 (buf, cnt, 0);
 740 }
 741
 742 /* Send a packet to the remote machine, with error checking.  The data
 743    of the packet is in BUF, and the packet should be a NUL-terminated
 744    string.  Returns >= 0 on success, -1 otherwise.  */
 745
 746 int
 747 putpkt (char *buf)
 748 {
 749   return putpkt_binary (buf, strlen (buf));
 750 }
 751
 752 int
 753 putpkt_notif (char *buf)
 754 {
 755   return putpkt_binary_1 (buf, strlen (buf), 1);
 756 }
 757
 758 /* Come here when we get an input interrupt from the remote side.  This
 759    interrupt should only be active while we are waiting for the child to do
 760    something.  About the only thing that should come through is a ^C, which
 761    will cause us to request child interruption.  */
 762
 763 static void
 764 input_interrupt (int unused)
 765 {
 766   fd_set readset;
 767   struct timeval immediate = { 0, 0 };
 768
 769   /* Protect against spurious interrupts.  This has been observed to
 770      be a problem under NetBSD 1.4 and 1.5.  */
 771
 772   FD_ZERO (&readset);
 773   FD_SET (remote_desc, &readset);
 774   if (select (remote_desc + 1, &readset, 0, 0, &immediate) > 0)
 775     {
 776       int cc;
 777       char c = 0;
 778
 779       cc = read (remote_desc, &c, 1);
 780
 781       if (cc != 1 || c != '\003' || current_inferior == NULL)
 782         {
 783           fprintf (stderr, "input_interrupt, count = %d c = %d ('%c')\n",
 784                    cc, c, c);
 785           return;
 786         }
 787
 788       (*the_target->request_interrupt) ();
 789     }
 790 }
 791
 792 /* Check if the remote side sent us an interrupt request (^C).  */
 793 void
 794 check_remote_input_interrupt_request (void)
 795 {
 796   /* This function may be called before establishing communications,
 797      therefore we need to validate the remote descriptor.  */
 798
 799   if (remote_desc == INVALID_DESCRIPTOR)
 800     return;
 801
 802   input_interrupt (0);
 803 }
 804
 805 /* Asynchronous I/O support.  SIGIO must be enabled when waiting, in order to
 806    accept Control-C from the client, and must be disabled when talking to
 807    the client.  */
 808
 809 static void
 810 unblock_async_io (void)
 811 {
 812 #ifndef USE_WIN32API
 813   sigset_t sigio_set;
 814
 815   sigemptyset (&sigio_set);
 816   sigaddset (&sigio_set, SIGIO);
 817   sigprocmask (SIG_UNBLOCK, &sigio_set, NULL);
 818 #endif
 819 }
 820
 821 #ifdef __QNX__
 822 static void
 823 nto_comctrl (int enable)
 824 {
 825   struct sigevent event;
 826
 827   if (enable)
 828     {
 829       event.sigev_notify = SIGEV_SIGNAL_THREAD;
 830       event.sigev_signo = SIGIO;
 831       event.sigev_code = 0;
 832       event.sigev_value.sival_ptr = NULL;
 833       event.sigev_priority = -1;
 834       ionotify (remote_desc, _NOTIFY_ACTION_POLLARM, _NOTIFY_COND_INPUT,
 835                 &event);
 836     }
 837   else
 838     ionotify (remote_desc, _NOTIFY_ACTION_POLL, _NOTIFY_COND_INPUT, NULL);
 839 }
 840 #endif /* __QNX__ */
 841
 842
 843 /* Current state of asynchronous I/O.  */
 844 static int async_io_enabled;
 845
 846 /* Enable asynchronous I/O.  */
 847 void
 848 enable_async_io (void)
 849 {
 850   if (async_io_enabled)
 851     return;
 852
 853 #ifndef USE_WIN32API
 854   signal (SIGIO, input_interrupt);
 855 #endif
 856   async_io_enabled = 1;
 857 #ifdef __QNX__
 858   nto_comctrl (1);
 859 #endif /* __QNX__ */
 860 }
 861
 862 /* Disable asynchronous I/O.  */
 863 void
 864 disable_async_io (void)
 865 {
 866   if (!async_io_enabled)
 867     return;
 868
 869 #ifndef USE_WIN32API
 870   signal (SIGIO, SIG_IGN);
 871 #endif
 872   async_io_enabled = 0;
 873 #ifdef __QNX__
 874   nto_comctrl (0);
 875 #endif /* __QNX__ */
 876
 877 }
 878
 879 void
 880 initialize_async_io (void)
 881 {
 882   /* Make sure that async I/O starts disabled.  */
 883   async_io_enabled = 1;
 884   disable_async_io ();
 885
 886   /* Make sure the signal is unblocked.  */
 887   unblock_async_io ();
 888 }
 889
 890 /* Returns next char from remote GDB.  -1 if error.  */
 891
 892 static int
 893 readchar (void)
 894 {
 895   static unsigned char buf[BUFSIZ];
 896   static int bufcnt = 0;
 897   static unsigned char *bufp;
 898
 899   if (bufcnt-- > 0)
 900     return *bufp++;
 901
 902   bufcnt = read (remote_desc, buf, sizeof (buf));
 903
 904   if (bufcnt <= 0)
 905     {
 906       if (bufcnt == 0)
 907         fprintf (stderr, "readchar: Got EOF\n");
 908       else
 909         perror ("readchar");
 910
 911       return -1;
 912     }
 913
 914   bufp = buf;
 915   bufcnt--;
 916   return *bufp++;
 917 }
 918
 919 /* Read a packet from the remote machine, with error checking,
 920    and store it in BUF.  Returns length of packet, or negative if error. */
 921
 922 int
 923 getpkt (char *buf)
 924 {
 925   char *bp;
 926   unsigned char csum, c1, c2;
 927   int c;
 928
 929   while (1)
 930     {
 931       csum = 0;
 932
 933       while (1)
 934         {
 935           c = readchar ();
 936           if (c == '$')
 937             break;
 938           if (remote_debug)
 939             {
 940               fprintf (stderr, "[getpkt: discarding char '%c']\n", c);
 941               fflush (stderr);
 942             }
 943
 944           if (c < 0)
 945             return -1;
 946         }
 947
 948       bp = buf;
 949       while (1)
 950         {
 951           c = readchar ();
 952           if (c < 0)
 953             return -1;
 954           if (c == '#')
 955             break;
 956           *bp++ = c;
 957           csum += c;
 958         }
 959       *bp = 0;
 960
 961       c1 = fromhex (readchar ());
 962       c2 = fromhex (readchar ());
 963
 964       if (csum == (c1 << 4) + c2)
 965         break;
 966
 967       if (noack_mode)
 968         {
 969           fprintf (stderr, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s [no-ack-mode, Bad medium?]\n",
 970                    (c1 << 4) + c2, csum, buf);
 971           /* Not much we can do, GDB wasn't expecting an ack/nac.  */
 972           break;
 973         }
 974
 975       fprintf (stderr, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
 976                (c1 << 4) + c2, csum, buf);
 977       write (remote_desc, "-", 1);
 978     }
 979
 980   if (!noack_mode)
 981     {
 982       if (remote_debug)
 983         {
 984           fprintf (stderr, "getpkt (\"%s\");  [sending ack] \n", buf);
 985           fflush (stderr);
 986         }
 987
 988       write (remote_desc, "+", 1);
 989
 990       if (remote_debug)
 991         {
 992           fprintf (stderr, "[sent ack]\n");
 993           fflush (stderr);
 994         }
 995     }
 996   else
 997     {
 998       if (remote_debug)
 999         {
1000           fprintf (stderr, "getpkt (\"%s\");  [no ack sent] \n", buf);
1001           fflush (stderr);
1002         }
1003     }
1004
1005   return bp - buf;
1006 }
1007
1008 void
1009 write_ok (char *buf)
1010 {
1011   buf[0] = 'O';
1012   buf[1] = 'K';
1013   buf[2] = '\0';
1014 }
1015
1016 void
1017 write_enn (char *buf)
1018 {
1019   /* Some day, we should define the meanings of the error codes... */
1020   buf[0] = 'E';
1021   buf[1] = '0';
1022   buf[2] = '1';
1023   buf[3] = '\0';
1024 }
1025
1026 void
1027 convert_int_to_ascii (unsigned char *from, char *to, int n)
1028 {
1029   int nib;
1030   int ch;
1031   while (n--)
1032     {
1033       ch = *from++;
1034       nib = ((ch & 0xf0) >> 4) & 0x0f;
1035       *to++ = tohex (nib);
1036       nib = ch & 0x0f;
1037       *to++ = tohex (nib);
1038     }
1039   *to++ = 0;
1040 }
1041
1042
1043 void
1044 convert_ascii_to_int (char *from, unsigned char *to, int n)
1045 {
1046   int nib1, nib2;
1047   while (n--)
1048     {
1049       nib1 = fromhex (*from++);
1050       nib2 = fromhex (*from++);
1051       *to++ = (((nib1 & 0x0f) << 4) & 0xf0) | (nib2 & 0x0f);
1052     }
1053 }
1054
1055 static char *
1056 outreg (struct regcache *regcache, int regno, char *buf)
1057 {
1058   if ((regno >> 12) != 0)
1059     *buf++ = tohex ((regno >> 12) & 0xf);
1060   if ((regno >> 8) != 0)
1061     *buf++ = tohex ((regno >> 8) & 0xf);
1062   *buf++ = tohex ((regno >> 4) & 0xf);
1063   *buf++ = tohex (regno & 0xf);
1064   *buf++ = ':';
1065   collect_register_as_string (regcache, regno, buf);
1066   buf += 2 * register_size (regno);
1067   *buf++ = ';';
1068
1069   return buf;
1070 }
1071
1072 void
1073 new_thread_notify (int id)
1074 {
1075   char own_buf[256];
1076
1077   /* The `n' response is not yet part of the remote protocol.  Do nothing.  */
1078   if (1)
1079     return;
1080
1081   if (server_waiting == 0)
1082     return;
1083
1084   sprintf (own_buf, "n%x", id);
1085   disable_async_io ();
1086   putpkt (own_buf);
1087   enable_async_io ();
1088 }
1089
1090 void
1091 dead_thread_notify (int id)
1092 {
1093   char own_buf[256];
1094
1095   /* The `x' response is not yet part of the remote protocol.  Do nothing.  */
1096   if (1)
1097     return;
1098
1099   sprintf (own_buf, "x%x", id);
1100   disable_async_io ();
1101   putpkt (own_buf);
1102   enable_async_io ();
1103 }
1104
1105 void
1106 prepare_resume_reply (char *buf, ptid_t ptid,
1107                       struct target_waitstatus *status)
1108 {
1109   if (debug_threads)
1110     fprintf (stderr, "Writing resume reply for %s:%d\n\n",
1111              target_pid_to_str (ptid), status->kind);
1112
1113   switch (status->kind)
1114     {
1115     case TARGET_WAITKIND_STOPPED:
1116       {
1117         struct thread_info *saved_inferior;
1118         const char **regp;
1119         struct regcache *regcache;
1120
1121         sprintf (buf, "T%02x", status->value.sig);
1122         buf += strlen (buf);
1123
1124         regp = gdbserver_expedite_regs;
1125
1126         saved_inferior = current_inferior;
1127
1128         current_inferior = find_thread_ptid (ptid);
1129
1130         regcache = get_thread_regcache (current_inferior, 1);
1131
1132         if (the_target->stopped_by_watchpoint != NULL
1133             && (*the_target->stopped_by_watchpoint) ())
1134           {
1135             CORE_ADDR addr;
1136             int i;
1137
1138             strncpy (buf, "watch:", 6);
1139             buf += 6;
1140
1141             addr = (*the_target->stopped_data_address) ();
1142
1143             /* Convert each byte of the address into two hexadecimal
1144                chars.  Note that we take sizeof (void *) instead of
1145                sizeof (addr); this is to avoid sending a 64-bit
1146                address to a 32-bit GDB.  */
1147             for (i = sizeof (void *) * 2; i > 0; i--)
1148               *buf++ = tohex ((addr >> (i - 1) * 4) & 0xf);
1149             *buf++ = ';';
1150           }
1151
1152         while (*regp)
1153           {
1154             buf = outreg (regcache, find_regno (*regp), buf);
1155             regp ++;
1156           }
1157         *buf = '\0';
1158
1159         /* Formerly, if the debugger had not used any thread features
1160            we would not burden it with a thread status response.  This
1161            was for the benefit of GDB 4.13 and older.  However, in
1162            recent GDB versions the check (``if (cont_thread != 0)'')
1163            does not have the desired effect because of sillyness in
1164            the way that the remote protocol handles specifying a
1165            thread.  Since thread support relies on qSymbol support
1166            anyway, assume GDB can handle threads.  */
1167
1168         if (using_threads && !disable_packet_Tthread)
1169           {
1170             /* This if (1) ought to be unnecessary.  But remote_wait
1171                in GDB will claim this event belongs to inferior_ptid
1172                if we do not specify a thread, and there's no way for
1173                gdbserver to know what inferior_ptid is.  */
1174             if (1 || !ptid_equal (general_thread, ptid))
1175               {
1176                 int core = -1;
1177                 /* In non-stop, don't change the general thread behind
1178                    GDB's back.  */
1179                 if (!non_stop)
1180                   general_thread = ptid;
1181                 sprintf (buf, "thread:");
1182                 buf += strlen (buf);
1183                 buf = write_ptid (buf, ptid);
1184                 strcat (buf, ";");
1185                 buf += strlen (buf);
1186
1187                 if (the_target->core_of_thread)
1188                   core = (*the_target->core_of_thread) (ptid);
1189                 if (core != -1)
1190                   {
1191                     sprintf (buf, "core:");
1192                     buf += strlen (buf);
1193                     sprintf (buf, "%x", core);
1194                     strcat (buf, ";");
1195                     buf += strlen (buf);
1196                   }
1197               }
1198           }
1199
1200         if (dlls_changed)
1201           {
1202             strcpy (buf, "library:;");
1203             buf += strlen (buf);
1204             dlls_changed = 0;
1205           }
1206
1207         current_inferior = saved_inferior;
1208       }
1209       break;
1210     case TARGET_WAITKIND_EXITED:
1211       if (multi_process)
1212         sprintf (buf, "W%x;process:%x",
1213                  status->value.integer, ptid_get_pid (ptid));
1214       else
1215         sprintf (buf, "W%02x", status->value.integer);
1216       break;
1217     case TARGET_WAITKIND_SIGNALLED:
1218       if (multi_process)
1219         sprintf (buf, "X%x;process:%x",
1220                  status->value.sig, ptid_get_pid (ptid));
1221       else
1222         sprintf (buf, "X%02x", status->value.sig);
1223       break;
1224     default:
1225       error ("unhandled waitkind");
1226       break;
1227     }
1228 }
1229
1230 void
1231 decode_m_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr)
1232 {
1233   int i = 0, j = 0;
1234   char ch;
1235   *mem_addr_ptr = *len_ptr = 0;
1236
1237   while ((ch = from[i++]) != ',')
1238     {
1239       *mem_addr_ptr = *mem_addr_ptr << 4;
1240       *mem_addr_ptr |= fromhex (ch) & 0x0f;
1241     }
1242
1243   for (j = 0; j < 4; j++)
1244     {
1245       if ((ch = from[i++]) == 0)
1246         break;
1247       *len_ptr = *len_ptr << 4;
1248       *len_ptr |= fromhex (ch) & 0x0f;
1249     }
1250 }
1251
1252 void
1253 decode_M_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr,
1254                  unsigned char *to)
1255 {
1256   int i = 0;
1257   char ch;
1258   *mem_addr_ptr = *len_ptr = 0;
1259
1260   while ((ch = from[i++]) != ',')
1261     {
1262       *mem_addr_ptr = *mem_addr_ptr << 4;
1263       *mem_addr_ptr |= fromhex (ch) & 0x0f;
1264     }
1265
1266   while ((ch = from[i++]) != ':')
1267     {
1268       *len_ptr = *len_ptr << 4;
1269       *len_ptr |= fromhex (ch) & 0x0f;
1270     }
1271
1272   convert_ascii_to_int (&from[i++], to, *len_ptr);
1273 }
1274
1275 int
1276 decode_X_packet (char *from, int packet_len, CORE_ADDR *mem_addr_ptr,
1277                  unsigned int *len_ptr, unsigned char *to)
1278 {
1279   int i = 0;
1280   char ch;
1281   *mem_addr_ptr = *len_ptr = 0;
1282
1283   while ((ch = from[i++]) != ',')
1284     {
1285       *mem_addr_ptr = *mem_addr_ptr << 4;
1286       *mem_addr_ptr |= fromhex (ch) & 0x0f;
1287     }
1288
1289   while ((ch = from[i++]) != ':')
1290     {
1291       *len_ptr = *len_ptr << 4;
1292       *len_ptr |= fromhex (ch) & 0x0f;
1293     }
1294
1295   if (remote_unescape_input ((const gdb_byte *) &from[i], packet_len - i,
1296                              to, *len_ptr) != *len_ptr)
1297     return -1;
1298
1299   return 0;
1300 }
1301
1302 /* Decode a qXfer write request.  */
1303 int
1304 decode_xfer_write (char *buf, int packet_len, char **annex, CORE_ADDR *offset,
1305                    unsigned int *len, unsigned char *data)
1306 {
1307   char ch;
1308
1309   /* Extract and NUL-terminate the annex.  */
1310   *annex = buf;
1311   while (*buf && *buf != ':')
1312     buf++;
1313   if (*buf == '\0')
1314     return -1;
1315   *buf++ = 0;
1316
1317   /* Extract the offset.  */
1318   *offset = 0;
1319   while ((ch = *buf++) != ':')
1320     {
1321       *offset = *offset << 4;
1322       *offset |= fromhex (ch) & 0x0f;
1323     }
1324
1325   /* Get encoded data.  */
1326   packet_len -= buf - *annex;
1327   *len = remote_unescape_input ((const gdb_byte *) buf, packet_len,
1328                                 data, packet_len);
1329   return 0;
1330 }
1331
1332 /* Decode the parameters of a qSearch:memory packet.  */
1333
1334 int
1335 decode_search_memory_packet (const char *buf, int packet_len,
1336                              CORE_ADDR *start_addrp,
1337                              CORE_ADDR *search_space_lenp,
1338                              gdb_byte *pattern, unsigned int *pattern_lenp)
1339 {
1340   const char *p = buf;
1341
1342   p = decode_address_to_semicolon (start_addrp, p);
1343   p = decode_address_to_semicolon (search_space_lenp, p);
1344   packet_len -= p - buf;
1345   *pattern_lenp = remote_unescape_input ((const gdb_byte *) p, packet_len,
1346                                          pattern, packet_len);
1347   return 0;
1348 }
1349
1350 static void
1351 free_sym_cache (struct sym_cache *sym)
1352 {
1353   if (sym != NULL)
1354     {
1355       free (sym->name);
1356       free (sym);
1357     }
1358 }
1359
1360 void
1361 clear_symbol_cache (struct sym_cache **symcache_p)
1362 {
1363   struct sym_cache *sym, *next;
1364
1365   /* Check the cache first.  */
1366   for (sym = *symcache_p; sym; sym = next)
1367     {
1368       next = sym->next;
1369       free_sym_cache (sym);
1370     }
1371
1372   *symcache_p = NULL;
1373 }
1374
1375 /* Ask GDB for the address of NAME, and return it in ADDRP if found.
1376    Returns 1 if the symbol is found, 0 if it is not, -1 on error.  */
1377
1378 int
1379 look_up_one_symbol (const char *name, CORE_ADDR *addrp)
1380 {
1381   char own_buf[266], *p, *q;
1382   int len;
1383   struct sym_cache *sym;
1384   struct process_info *proc;
1385
1386   proc = current_process ();
1387
1388   /* Check the cache first.  */
1389   for (sym = proc->symbol_cache; sym; sym = sym->next)
1390     if (strcmp (name, sym->name) == 0)
1391       {
1392         *addrp = sym->addr;
1393         return 1;
1394       }
1395
1396   /* If we've passed the call to thread_db_look_up_symbols, then
1397      anything not in the cache must not exist; we're not interested
1398      in any libraries loaded after that point, only in symbols in
1399      libpthread.so.  It might not be an appropriate time to look
1400      up a symbol, e.g. while we're trying to fetch registers.  */
1401   if (proc->all_symbols_looked_up)
1402     return 0;
1403
1404   /* Send the request.  */
1405   strcpy (own_buf, "qSymbol:");
1406   hexify (own_buf + strlen ("qSymbol:"), name, strlen (name));
1407   if (putpkt (own_buf) < 0)
1408     return -1;
1409
1410   /* FIXME:  Eventually add buffer overflow checking (to getpkt?)  */
1411   len = getpkt (own_buf);
1412   if (len < 0)
1413     return -1;
1414
1415   /* We ought to handle pretty much any packet at this point while we
1416      wait for the qSymbol "response".  That requires re-entering the
1417      main loop.  For now, this is an adequate approximation; allow
1418      GDB to read from memory while it figures out the address of the
1419      symbol.  */
1420   while (own_buf[0] == 'm')
1421     {
1422       CORE_ADDR mem_addr;
1423       unsigned char *mem_buf;
1424       unsigned int mem_len;
1425
1426       decode_m_packet (&own_buf[1], &mem_addr, &mem_len);
1427       mem_buf = xmalloc (mem_len);
1428       if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0)
1429         convert_int_to_ascii (mem_buf, own_buf, mem_len);
1430       else
1431         write_enn (own_buf);
1432       free (mem_buf);
1433       if (putpkt (own_buf) < 0)
1434         return -1;
1435       len = getpkt (own_buf);
1436       if (len < 0)
1437         return -1;
1438     }
1439
1440   if (strncmp (own_buf, "qSymbol:", strlen ("qSymbol:")) != 0)
1441     {
1442       warning ("Malformed response to qSymbol, ignoring: %s\n", own_buf);
1443       return -1;
1444     }
1445
1446   p = own_buf + strlen ("qSymbol:");
1447   q = p;
1448   while (*q && *q != ':')
1449     q++;
1450
1451   /* Make sure we found a value for the symbol.  */
1452   if (p == q || *q == '\0')
1453     return 0;
1454
1455   decode_address (addrp, p, q - p);
1456
1457   /* Save the symbol in our cache.  */
1458   sym = xmalloc (sizeof (*sym));
1459   sym->name = xstrdup (name);
1460   sym->addr = *addrp;
1461   sym->next = proc->symbol_cache;
1462   proc->symbol_cache = sym;
1463
1464   return 1;
1465 }
1466
1467 void
1468 monitor_output (const char *msg)
1469 {
1470   char *buf = xmalloc (strlen (msg) * 2 + 2);
1471
1472   buf[0] = 'O';
1473   hexify (buf + 1, msg, 0);
1474
1475   putpkt (buf);
1476   free (buf);
1477 }
1478
1479 /* Return a malloc allocated string with special characters from TEXT
1480    replaced by entity references.  */
1481
1482 char *
1483 xml_escape_text (const char *text)
1484 {
1485   char *result;
1486   int i, special;
1487
1488   /* Compute the length of the result.  */
1489   for (i = 0, special = 0; text[i] != '\0'; i++)
1490     switch (text[i])
1491       {
1492       case '\'':
1493       case '\"':
1494         special += 5;
1495         break;
1496       case '&':
1497         special += 4;
1498         break;
1499       case '<':
1500       case '>':
1501         special += 3;
1502         break;
1503       default:
1504         break;
1505       }
1506
1507   /* Expand the result.  */
1508   result = xmalloc (i + special + 1);
1509   for (i = 0, special = 0; text[i] != '\0'; i++)
1510     switch (text[i])
1511       {
1512       case '\'':
1513         strcpy (result + i + special, "&apos;");
1514         special += 5;
1515         break;
1516       case '\"':
1517         strcpy (result + i + special, "&quot;");
1518         special += 5;
1519         break;
1520       case '&':
1521         strcpy (result + i + special, "&amp;");
1522         special += 4;
1523         break;
1524       case '<':
1525         strcpy (result + i + special, "&lt;");
1526         special += 3;
1527         break;
1528       case '>':
1529         strcpy (result + i + special, "&gt;");
1530         special += 3;
1531         break;
1532       default:
1533         result[i + special] = text[i];
1534         break;
1535       }
1536   result[i + special] = '\0';
1537
1538   return result;
1539 }
1540
1541 void
1542 buffer_grow (struct buffer *buffer, const char *data, size_t size)
1543 {
1544   char *new_buffer;
1545   size_t new_buffer_size;
1546
1547   if (size == 0)
1548     return;
1549
1550   new_buffer_size = buffer->buffer_size;
1551
1552   if (new_buffer_size == 0)
1553     new_buffer_size = 1;
1554
1555   while (buffer->used_size + size > new_buffer_size)
1556     new_buffer_size *= 2;
1557   new_buffer = realloc (buffer->buffer, new_buffer_size);
1558   if (!new_buffer)
1559     abort ();
1560   memcpy (new_buffer + buffer->used_size, data, size);
1561   buffer->buffer = new_buffer;
1562   buffer->buffer_size = new_buffer_size;
1563   buffer->used_size += size;
1564 }
1565
1566 void
1567 buffer_free (struct buffer *buffer)
1568 {
1569   if (!buffer)
1570     return;
1571
1572   free (buffer->buffer);
1573   buffer->buffer = NULL;
1574   buffer->buffer_size = 0;
1575   buffer->used_size = 0;
1576 }
1577
1578 void
1579 buffer_init (struct buffer *buffer)
1580 {
1581   memset (buffer, 0, sizeof (*buffer));
1582 }
1583
1584 char*
1585 buffer_finish (struct buffer *buffer)
1586 {
1587   char *ret = buffer->buffer;
1588   buffer->buffer = NULL;
1589   buffer->buffer_size = 0;
1590   buffer->used_size = 0;
1591   return ret;
1592 }
1593
1594 void
1595 buffer_xml_printf (struct buffer *buffer, const char *format, ...)
1596 {
1597   va_list ap;
1598   const char *f;
1599   const char *prev;
1600   int percent = 0;
1601
1602   va_start (ap, format);
1603
1604   prev = format;
1605   for (f = format; *f; f++)
1606     {
1607       if (percent)
1608        {
1609          switch (*f)
1610            {
1611            case 's':
1612              {
1613                char *p;
1614                char *a = va_arg (ap, char *);
1615                buffer_grow (buffer, prev, f - prev - 1);
1616                p = xml_escape_text (a);
1617                buffer_grow_str (buffer, p);
1618                free (p);
1619                prev = f + 1;
1620              }
1621              break;
1622            case 'd':
1623              {
1624                int i = va_arg (ap, int);
1625                char b[sizeof ("4294967295")];
1626
1627                buffer_grow (buffer, prev, f - prev - 1);
1628                sprintf (b, "%d", i);
1629                buffer_grow_str (buffer, b);
1630                prev = f + 1;
1631              }
1632            }
1633          percent = 0;
1634        }
1635       else if (*f == '%')
1636        percent = 1;
1637     }
1638
1639   buffer_grow_str (buffer, prev);
1640   va_end (ap);
1641 }