tools/gdb/remote.c

   1 /*
   2  * taken from gdb/remote.c
   3  *
   4  * I am only interested in the write to memory stuff - everything else
   5  * has been ripped out
   6  *
   7  * all the copyright notices etc have been left in
   8  */
   9
  10 /* enough so that it will compile */
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <errno.h>
  15
  16 /*nicked from gcc..*/
  17
  18 #ifndef alloca
  19 #ifdef __GNUC__
  20 #define alloca __builtin_alloca
  21 #else /* not GNU C.  */
  22 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
  23 #include <alloca.h>
  24 #else /* not sparc */
  25 #if defined (MSDOS) && !defined (__TURBOC__)
  26 #include <malloc.h>
  27 #else /* not MSDOS, or __TURBOC__ */
  28 #if defined(_AIX)
  29 #include <malloc.h>
  30  #pragma alloca
  31 #else /* not MSDOS, __TURBOC__, or _AIX */
  32 #ifdef __hpux
  33 #endif /* __hpux */
  34 #endif /* not _AIX */
  35 #endif /* not MSDOS, or __TURBOC__ */
  36 #endif /* not sparc.  */
  37 #endif /* not GNU C.  */
  38 #ifdef __cplusplus
  39 extern "C" {
  40 #endif
  41     void* alloca(size_t);
  42 #ifdef __cplusplus
  43 }
  44 #endif
  45 #endif /* alloca not defined.  */
  46
  47
  48 #include "serial.h"
  49 #include "error.h"
  50 #include "remote.h"
  51 #define REGISTER_BYTES 0
  52 #define fprintf_unfiltered fprintf
  53 #define fprintf_filtered fprintf
  54 #define fputs_unfiltered fputs
  55 #define fputs_filtered fputs
  56 #define fputc_unfiltered fputc
  57 #define fputc_filtered fputc
  58 #define printf_unfiltered printf
  59 #define printf_filtered printf
  60 #define puts_unfiltered puts
  61 #define puts_filtered puts
  62 #define putchar_unfiltered putchar
  63 #define putchar_filtered putchar
  64 #define fputstr_unfiltered(a,b,c) fputs((a), (c))
  65 #define gdb_stdlog stderr
  66 #define SERIAL_READCHAR(fd,timo)        serialreadchar((fd), (timo))
  67 #define SERIAL_WRITE(fd, addr, len)     serialwrite((fd), (addr), (len))
  68 #define error Error
  69 #define perror_with_name Perror
  70 #define gdb_flush fflush
  71 #define max(a,b) (((a)>(b))?(a):(b))
  72 #define min(a,b) (((a)<(b))?(a):(b))
  73 #define target_mourn_inferior() {}
  74 #define ULONGEST unsigned long
  75 #define CORE_ADDR unsigned long
  76
  77 static int putpkt (char *);
  78 static int putpkt_binary(char *, int);
  79 static void getpkt (char *, int);
  80
  81 static int remote_debug = 0, remote_register_buf_size = 0, watchdog = 0;
  82
  83 int remote_desc = -1, remote_timeout = 10;
  84
  85 static void
  86 fputstrn_unfiltered(char *s, int n, int x, FILE *fp)
  87 {
  88     while (n-- > 0)
  89         fputc(*s++, fp);
  90 }
  91
  92 void
  93 remote_reset(void)
  94 {
  95     SERIAL_WRITE(remote_desc, "+", 1);
  96 }
  97
  98 void
  99 remote_continue(void)
 100 {
 101     putpkt("c");
 102 }
 103
 104 /* Remote target communications for serial-line targets in custom GDB protocol
 105    Copyright 1988, 91, 92, 93, 94, 95, 96, 97, 98, 1999
 106    Free Software Foundation, Inc.
 107
 108    This file is part of GDB.
 109
 110    This program is free software; you can redistribute it and/or modify
 111    it under the terms of the GNU General Public License as published by
 112    the Free Software Foundation; either version 2 of the License, or
 113    (at your option) any later version.
 114
 115    This program is distributed in the hope that it will be useful,
 116    but WITHOUT ANY WARRANTY; without even the implied warranty of
 117    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 118    GNU General Public License for more details.
 119
 120    You should have received a copy of the GNU General Public License
 121    along with this program; if not, write to the Free Software
 122    Foundation, Inc., 59 Temple Place - Suite 330,
 123    Boston, MA 02111-1307, USA.  */
 124 /* *INDENT-OFF* */
 125 /* Remote communication protocol.
 126
 127    A debug packet whose contents are <data>
 128    is encapsulated for transmission in the form:
 129
 130         $ <data> # CSUM1 CSUM2
 131
 132         <data> must be ASCII alphanumeric and cannot include characters
 133         '$' or '#'.  If <data> starts with two characters followed by
 134         ':', then the existing stubs interpret this as a sequence number.
 135
 136         CSUM1 and CSUM2 are ascii hex representation of an 8-bit
 137         checksum of <data>, the most significant nibble is sent first.
 138         the hex digits 0-9,a-f are used.
 139
 140    Receiver responds with:
 141
 142         +       - if CSUM is correct and ready for next packet
 143         -       - if CSUM is incorrect
 144
 145    <data> is as follows:
 146    Most values are encoded in ascii hex digits.  Signal numbers are according
 147    to the numbering in target.h.
 148
 149         Request         Packet
 150
 151         set thread      Hct...          Set thread for subsequent operations.
 152                                         c = 'c' for thread used in step and
 153                                         continue; t... can be -1 for all
 154                                         threads.
 155                                         c = 'g' for thread used in other
 156                                         operations.  If zero, pick a thread,
 157                                         any thread.
 158         reply           OK              for success
 159                         ENN             for an error.
 160
 161         read registers  g
 162         reply           XX....X         Each byte of register data
 163                                         is described by two hex digits.
 164                                         Registers are in the internal order
 165                                         for GDB, and the bytes in a register
 166                                         are in the same order the machine uses.
 167                         or ENN          for an error.
 168
 169         write regs      GXX..XX         Each byte of register data
 170                                         is described by two hex digits.
 171         reply           OK              for success
 172                         ENN             for an error
 173
 174         write reg       Pn...=r...      Write register n... with value r...,
 175                                         which contains two hex digits for each
 176                                         byte in the register (target byte
 177                                         order).
 178         reply           OK              for success
 179                         ENN             for an error
 180         (not supported by all stubs).
 181
 182         read mem        mAA..AA,LLLL    AA..AA is address, LLLL is length.
 183         reply           XX..XX          XX..XX is mem contents
 184                                         Can be fewer bytes than requested
 185                                         if able to read only part of the data.
 186                         or ENN          NN is errno
 187
 188         write mem       MAA..AA,LLLL:XX..XX
 189                                         AA..AA is address,
 190                                         LLLL is number of bytes,
 191                                         XX..XX is data
 192         reply           OK              for success
 193                         ENN             for an error (this includes the case
 194                                         where only part of the data was
 195                                         written).
 196
 197         write mem       XAA..AA,LLLL:XX..XX
 198          (binary)                       AA..AA is address,
 199                                         LLLL is number of bytes,
 200                                         XX..XX is binary data
 201         reply           OK              for success
 202                         ENN             for an error
 203
 204         continue        cAA..AA         AA..AA is address to resume
 205                                         If AA..AA is omitted,
 206                                         resume at same address.
 207
 208         step            sAA..AA         AA..AA is address to resume
 209                                         If AA..AA is omitted,
 210                                         resume at same address.
 211
 212         continue with   Csig;AA..AA     Continue with signal sig (hex signal
 213         signal                          number).  If ;AA..AA is omitted,
 214                                         resume at same address.
 215
 216         step with       Ssig;AA..AA     Like 'C' but step not continue.
 217         signal
 218
 219         last signal     ?               Reply the current reason for stopping.
 220                                         This is the same reply as is generated
 221                                         for step or cont : SAA where AA is the
 222                                         signal number.
 223
 224         detach          D               Reply OK.
 225
 226         There is no immediate reply to step or cont.
 227         The reply comes when the machine stops.
 228         It is           SAA             AA is the signal number.
 229
 230         or...           TAAn...:r...;n...:r...;n...:r...;
 231                                         AA = signal number
 232                                         n... = register number (hex)
 233                                           r... = register contents
 234                                         n... = `thread'
 235                                           r... = thread process ID.  This is
 236                                                  a hex integer.
 237                                         n... = other string not starting
 238                                             with valid hex digit.
 239                                           gdb should ignore this n,r pair
 240                                           and go on to the next.  This way
 241                                           we can extend the protocol.
 242         or...           WAA             The process exited, and AA is
 243                                         the exit status.  This is only
 244                                         applicable for certains sorts of
 245                                         targets.
 246         or...           XAA             The process terminated with signal
 247                                         AA.
 248         or (obsolete)   NAA;tttttttt;dddddddd;bbbbbbbb
 249                                         AA = signal number
 250                                         tttttttt = address of symbol "_start"
 251                                         dddddddd = base of data section
 252                                         bbbbbbbb = base of bss  section.
 253                                         Note: only used by Cisco Systems
 254                                         targets.  The difference between this
 255                                         reply and the "qOffsets" query is that
 256                                         the 'N' packet may arrive spontaneously
 257                                         whereas the 'qOffsets' is a query
 258                                         initiated by the host debugger.
 259         or...           OXX..XX XX..XX  is hex encoding of ASCII data. This
 260                                         can happen at any time while the
 261                                         program is running and the debugger
 262                                         should continue to wait for
 263                                         'W', 'T', etc.
 264
 265         thread alive    TXX             Find out if the thread XX is alive.
 266         reply           OK              thread is still alive
 267                         ENN             thread is dead
 268
 269         remote restart  RXX             Restart the remote server
 270
 271         extended ops    !               Use the extended remote protocol.
 272                                         Sticky -- only needs to be set once.
 273
 274         kill request    k
 275
 276         toggle debug    d               toggle debug flag (see 386 & 68k stubs)
 277         reset           r               reset -- see sparc stub.
 278         reserved        <other>         On other requests, the stub should
 279                                         ignore the request and send an empty
 280                                         response ($#<checksum>).  This way
 281                                         we can extend the protocol and GDB
 282                                         can tell whether the stub it is
 283                                         talking to uses the old or the new.
 284         search          tAA:PP,MM       Search backwards starting at address
 285                                         AA for a match with pattern PP and
 286                                         mask MM.  PP and MM are 4 bytes.
 287                                         Not supported by all stubs.
 288
 289         general query   qXXXX           Request info about XXXX.
 290         general set     QXXXX=yyyy      Set value of XXXX to yyyy.
 291         query sect offs qOffsets        Get section offsets.  Reply is
 292                                         Text=xxx;Data=yyy;Bss=zzz
 293
 294         Responses can be run-length encoded to save space.  A '*' means that
 295         the next character is an ASCII encoding giving a repeat count which
 296         stands for that many repititions of the character preceding the '*'.
 297         The encoding is n+29, yielding a printable character where n >=3
 298         (which is where rle starts to win).  Don't use an n > 126.
 299
 300         So
 301         "0* " means the same as "0000".  */
 302 /* *INDENT-ON* */
 303
 304 /* This variable (available to the user via "set remotebinarydownload")
 305    dictates whether downloads are sent in binary (via the 'X' packet).
 306    We assume that the stub can, and attempt to do it. This will be cleared if
 307    the stub does not understand it. This switch is still needed, though
 308    in cases when the packet is supported in the stub, but the connection
 309    does not allow it (i.e., 7-bit serial connection only). */
 310 static int remote_binary_download = 1;
 311
 312 /* Have we already checked whether binary downloads work? */
 313 static int remote_binary_checked;
 314
 315 /* Maximum number of bytes to read/write at once.  The value here
 316    is chosen to fill up a packet (the headers account for the 32).  */
 317 #define MAXBUFBYTES(N) (((N)-32)/2)
 318
 319 /* Having this larger than 400 causes us to be incompatible with m68k-stub.c
 320    and i386-stub.c.  Normally, no one would notice because it only matters
 321    for writing large chunks of memory (e.g. in downloads).  Also, this needs
 322    to be more than 400 if required to hold the registers (see below, where
 323    we round it up based on REGISTER_BYTES).  */
 324 /* Round up PBUFSIZ to hold all the registers, at least.  */
 325 #define PBUFSIZ ((REGISTER_BYTES > MAXBUFBYTES (400)) \
 326                  ? (REGISTER_BYTES * 2 + 32) \
 327                  : 400)
 328
 329
 330 /* This variable sets the number of bytes to be written to the target
 331    in a single packet.  Normally PBUFSIZ is satisfactory, but some
 332    targets need smaller values (perhaps because the receiving end
 333    is slow).  */
 334
 335 static int remote_write_size = 0x7fffffff;
 336
 337 /* This variable sets the number of bits in an address that are to be
 338    sent in a memory ("M" or "m") packet.  Normally, after stripping
 339    leading zeros, the entire address would be sent. This variable
 340    restricts the address to REMOTE_ADDRESS_SIZE bits.  HISTORY: The
 341    initial implementation of remote.c restricted the address sent in
 342    memory packets to ``host::sizeof long'' bytes - (typically 32
 343    bits).  Consequently, for 64 bit targets, the upper 32 bits of an
 344    address was never sent.  Since fixing this bug may cause a break in
 345    some remote targets this variable is principly provided to
 346    facilitate backward compatibility. */
 347
 348 static int remote_address_size;
 349
 350 /* Convert hex digit A to a number.  */
 351
 352 static int
 353 fromhex (int a)
 354 {
 355   if (a >= '0' && a <= '9')
 356     return a - '0';
 357   else if (a >= 'a' && a <= 'f')
 358     return a - 'a' + 10;
 359   else if (a >= 'A' && a <= 'F')
 360     return a - 'A' + 10;
 361   else {
 362     error ("Reply contains invalid hex digit %d", a);
 363     return -1;
 364   }
 365 }
 366
 367 /* Convert number NIB to a hex digit.  */
 368
 369 static int
 370 tohex (int nib)
 371 {
 372   if (nib < 10)
 373     return '0' + nib;
 374   else
 375     return 'a' + nib - 10;
 376 }
 377
 378 /* Return the number of hex digits in num.  */
 379
 380 static int
 381 hexnumlen (ULONGEST num)
 382 {
 383   int i;
 384
 385   for (i = 0; num != 0; i++)
 386     num >>= 4;
 387
 388   return max (i, 1);
 389 }
 390
 391 /* Set BUF to the hex digits representing NUM.  */
 392
 393 static int
 394 hexnumstr (char *buf, ULONGEST num)
 395 {
 396   int i;
 397   int len = hexnumlen (num);
 398
 399   buf[len] = '\0';
 400
 401   for (i = len - 1; i >= 0; i--)
 402     {
 403       buf[i] = "0123456789abcdef"[(num & 0xf)];
 404       num >>= 4;
 405     }
 406
 407   return len;
 408 }
 409
 410 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
 411
 412 static CORE_ADDR
 413 remote_address_masked (CORE_ADDR addr)
 414 {
 415   if (remote_address_size > 0
 416       && remote_address_size < (sizeof (ULONGEST) * 8))
 417     {
 418       /* Only create a mask when that mask can safely be constructed
 419          in a ULONGEST variable. */
 420       ULONGEST mask = 1;
 421       mask = (mask << remote_address_size) - 1;
 422       addr &= mask;
 423     }
 424   return addr;
 425 }
 426
 427 /* Determine whether the remote target supports binary downloading.
 428    This is accomplished by sending a no-op memory write of zero length
 429    to the target at the specified address. It does not suffice to send
 430    the whole packet, since many stubs strip the eighth bit and subsequently
 431    compute a wrong checksum, which causes real havoc with remote_write_bytes.
 432
 433    NOTE: This can still lose if the serial line is not eight-bit clean. In
 434    cases like this, the user should clear "remotebinarydownload". */
 435 static void
 436 check_binary_download (CORE_ADDR addr)
 437 {
 438   if (remote_binary_download && !remote_binary_checked)
 439     {
 440       char *buf = alloca (PBUFSIZ);
 441       char *p;
 442       remote_binary_checked = 1;
 443
 444       p = buf;
 445       *p++ = 'X';
 446       p += hexnumstr (p, (ULONGEST) addr);
 447       *p++ = ',';
 448       p += hexnumstr (p, (ULONGEST) 0);
 449       *p++ = ':';
 450       *p = '\0';
 451
 452       putpkt_binary (buf, (int) (p - buf));
 453       getpkt (buf, 0);
 454
 455       if (buf[0] == '\0')
 456         remote_binary_download = 0;
 457     }
 458
 459   if (remote_debug)
 460     {
 461       if (remote_binary_download)
 462         fprintf_unfiltered (gdb_stdlog,
 463                             "binary downloading suppported by target\n");
 464       else
 465         fprintf_unfiltered (gdb_stdlog,
 466                             "binary downloading NOT suppported by target\n");
 467     }
 468 }
 469
 470 /* Write memory data directly to the remote machine.
 471    This does not inform the data cache; the data cache uses this.
 472    MEMADDR is the address in the remote memory space.
 473    MYADDR is the address of the buffer in our space.
 474    LEN is the number of bytes.
 475
 476    Returns number of bytes transferred, or 0 for error.  */
 477
 478 int
 479 remote_write_bytes (memaddr, myaddr, len)
 480      CORE_ADDR memaddr;
 481      char *myaddr;
 482      int len;
 483 {
 484   unsigned char *buf = alloca (PBUFSIZ);
 485   int max_buf_size;             /* Max size of packet output buffer */
 486   int origlen;
 487   extern int verbose;
 488
 489   /* Verify that the target can support a binary download */
 490   check_binary_download (memaddr);
 491
 492   /* Chop the transfer down if necessary */
 493
 494   max_buf_size = min (remote_write_size, PBUFSIZ);
 495   if (remote_register_buf_size != 0)
 496     max_buf_size = min (max_buf_size, remote_register_buf_size);
 497
 498   /* Subtract header overhead from max payload size -  $M<memaddr>,<len>:#nn */
 499   max_buf_size -= 2 + hexnumlen (memaddr + len - 1) + 1 + hexnumlen (len) + 4;
 500
 501   origlen = len;
 502   while (len > 0)
 503     {
 504       unsigned char *p, *plen;
 505       int todo;
 506       int i;
 507
 508       /* construct "M"<memaddr>","<len>":" */
 509       /* sprintf (buf, "M%lx,%x:", (unsigned long) memaddr, todo); */
 510       memaddr = remote_address_masked (memaddr);
 511       p = buf;
 512       if (remote_binary_download)
 513         {
 514           *p++ = 'X';
 515           todo = min (len, max_buf_size);
 516         }
 517       else
 518         {
 519           *p++ = 'M';
 520           todo = min (len, max_buf_size / 2);   /* num bytes that will fit */
 521         }
 522
 523       p += hexnumstr ((char *)p, (ULONGEST) memaddr);
 524       *p++ = ',';
 525
 526       plen = p;                 /* remember where len field goes */
 527       p += hexnumstr ((char *)p, (ULONGEST) todo);
 528       *p++ = ':';
 529       *p = '\0';
 530
 531       /* We send target system values byte by byte, in increasing byte
 532          addresses, each byte encoded as two hex characters (or one
 533          binary character).  */
 534       if (remote_binary_download)
 535         {
 536           int escaped = 0;
 537           for (i = 0;
 538                (i < todo) && (i + escaped) < (max_buf_size - 2);
 539                i++)
 540             {
 541               switch (myaddr[i] & 0xff)
 542                 {
 543                 case '$':
 544                 case '#':
 545                 case 0x7d:
 546                   /* These must be escaped */
 547                   escaped++;
 548                   *p++ = 0x7d;
 549                   *p++ = (myaddr[i] & 0xff) ^ 0x20;
 550                   break;
 551                 default:
 552                   *p++ = myaddr[i] & 0xff;
 553                   break;
 554                 }
 555             }
 556
 557           if (i < todo)
 558             {
 559               /* Escape chars have filled up the buffer prematurely,
 560                  and we have actually sent fewer bytes than planned.
 561                  Fix-up the length field of the packet.  */
 562
 563               /* FIXME: will fail if new len is a shorter string than
 564                  old len.  */
 565
 566               plen += hexnumstr ((char *)plen, (ULONGEST) i);
 567               *plen++ = ':';
 568             }
 569         }
 570       else
 571         {
 572           for (i = 0; i < todo; i++)
 573             {
 574               *p++ = tohex ((myaddr[i] >> 4) & 0xf);
 575               *p++ = tohex (myaddr[i] & 0xf);
 576             }
 577           *p = '\0';
 578         }
 579
 580       putpkt_binary ((char *)buf, (int) (p - buf));
 581       getpkt ((char *)buf, 0);
 582
 583       if (buf[0] == 'E')
 584         {
 585           /* There is no correspondance between what the remote protocol uses
 586              for errors and errno codes.  We would like a cleaner way of
 587              representing errors (big enough to include errno codes, bfd_error
 588              codes, and others).  But for now just return EIO.  */
 589           errno = EIO;
 590           return 0;
 591         }
 592
 593       /* Increment by i, not by todo, in case escape chars
 594          caused us to send fewer bytes than we'd planned.  */
 595       myaddr += i;
 596       memaddr += i;
 597       len -= i;
 598
 599       if (verbose)
 600         putc('.', stderr);
 601     }
 602   return origlen;
 603 }
 604
 605 /* Stuff for dealing with the packets which are part of this protocol.
 606    See comment at top of file for details.  */
 607
 608 /* Read a single character from the remote end, masking it down to 7 bits. */
 609
 610 static int
 611 readchar (int timeout)
 612 {
 613   int ch;
 614
 615   ch = SERIAL_READCHAR (remote_desc, timeout);
 616
 617   switch (ch)
 618     {
 619     case SERIAL_EOF:
 620       error ("Remote connection closed");
 621     case SERIAL_ERROR:
 622       perror_with_name ("Remote communication error");
 623     case SERIAL_TIMEOUT:
 624       return ch;
 625     default:
 626       return ch & 0x7f;
 627     }
 628 }
 629
 630 static int
 631 putpkt (buf)
 632      char *buf;
 633 {
 634   return putpkt_binary (buf, strlen (buf));
 635 }
 636
 637 /* Send a packet to the remote machine, with error checking.  The data
 638    of the packet is in BUF.  The string in BUF can be at most  PBUFSIZ - 5
 639    to account for the $, # and checksum, and for a possible /0 if we are
 640    debugging (remote_debug) and want to print the sent packet as a string */
 641
 642 static int
 643 putpkt_binary (buf, cnt)
 644      char *buf;
 645      int cnt;
 646 {
 647   int i;
 648   unsigned char csum = 0;
 649   char *buf2 = alloca (PBUFSIZ);
 650   char *junkbuf = alloca (PBUFSIZ);
 651
 652   int ch;
 653   int tcount = 0;
 654   char *p;
 655
 656   /* Copy the packet into buffer BUF2, encapsulating it
 657      and giving it a checksum.  */
 658
 659   if (cnt > BUFSIZ - 5)         /* Prosanity check */
 660     abort ();
 661
 662   p = buf2;
 663   *p++ = '$';
 664
 665   for (i = 0; i < cnt; i++)
 666     {
 667       csum += buf[i];
 668       *p++ = buf[i];
 669     }
 670   *p++ = '#';
 671   *p++ = tohex ((csum >> 4) & 0xf);
 672   *p++ = tohex (csum & 0xf);
 673
 674   /* Send it over and over until we get a positive ack.  */
 675
 676   while (1)
 677     {
 678       int started_error_output = 0;
 679
 680       if (remote_debug)
 681         {
 682           *p = '\0';
 683           fprintf_unfiltered (gdb_stdlog, "Sending packet: ");
 684           fputstrn_unfiltered (buf2, p - buf2, 0, gdb_stdlog);
 685           fprintf_unfiltered (gdb_stdlog, "...");
 686           gdb_flush (gdb_stdlog);
 687         }
 688       if (SERIAL_WRITE (remote_desc, buf2, p - buf2))
 689         perror_with_name ("putpkt: write failed");
 690
 691       /* read until either a timeout occurs (-2) or '+' is read */
 692       while (1)
 693         {
 694           ch = readchar (remote_timeout);
 695
 696           if (remote_debug)
 697             {
 698               switch (ch)
 699                 {
 700                 case '+':
 701                 case SERIAL_TIMEOUT:
 702                 case '$':
 703                   if (started_error_output)
 704                     {
 705                       putchar_unfiltered ('\n');
 706                       started_error_output = 0;
 707                     }
 708                 }
 709             }
 710
 711           switch (ch)
 712             {
 713             case '+':
 714               if (remote_debug)
 715                 fprintf_unfiltered (gdb_stdlog, "Ack\n");
 716               return 1;
 717             case SERIAL_TIMEOUT:
 718               tcount++;
 719               if (tcount > 3)
 720                 return 0;
 721               break;            /* Retransmit buffer */
 722             case '$':
 723               {
 724                 /* It's probably an old response, and we're out of sync.
 725                    Just gobble up the packet and ignore it.  */
 726                 getpkt (junkbuf, 0);
 727                 continue;       /* Now, go look for + */
 728               }
 729             default:
 730               if (remote_debug)
 731                 {
 732                   if (!started_error_output)
 733                     {
 734                       started_error_output = 1;
 735                       fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
 736                     }
 737                   fputc_unfiltered (ch & 0177, gdb_stdlog);
 738                 }
 739               continue;
 740             }
 741           break;                /* Here to retransmit */
 742         }
 743
 744 #if 0
 745       /* This is wrong.  If doing a long backtrace, the user should be
 746          able to get out next time we call QUIT, without anything as
 747          violent as interrupt_query.  If we want to provide a way out of
 748          here without getting to the next QUIT, it should be based on
 749          hitting ^C twice as in remote_wait.  */
 750       if (quit_flag)
 751         {
 752           quit_flag = 0;
 753           interrupt_query ();
 754         }
 755 #endif
 756     }
 757 }
 758
 759 /* Come here after finding the start of the frame.  Collect the rest
 760    into BUF, verifying the checksum, length, and handling run-length
 761    compression.  Returns 0 on any error, 1 on success.  */
 762
 763 static int
 764 read_frame (char *buf)
 765 {
 766   unsigned char csum;
 767   char *bp;
 768   int c;
 769
 770   csum = 0;
 771   bp = buf;
 772
 773   while (1)
 774     {
 775       c = readchar (remote_timeout);
 776
 777       switch (c)
 778         {
 779         case SERIAL_TIMEOUT:
 780           if (remote_debug)
 781             fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog);
 782           return 0;
 783         case '$':
 784           if (remote_debug)
 785             fputs_filtered ("Saw new packet start in middle of old one\n",
 786                             gdb_stdlog);
 787           return 0;             /* Start a new packet, count retries */
 788         case '#':
 789           {
 790             unsigned char pktcsum;
 791
 792             *bp = '\000';
 793
 794             pktcsum = fromhex (readchar (remote_timeout)) << 4;
 795             pktcsum |= fromhex (readchar (remote_timeout));
 796
 797             if (csum == pktcsum)
 798               {
 799                 return 1;
 800               }
 801
 802             if (remote_debug)
 803               {
 804                 fprintf_filtered (gdb_stdlog,
 805                               "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
 806                                   pktcsum, csum);
 807                 fputs_filtered (buf, gdb_stdlog);
 808                 fputs_filtered ("\n", gdb_stdlog);
 809               }
 810             return 0;
 811           }
 812         case '*':               /* Run length encoding */
 813           csum += c;
 814           c = readchar (remote_timeout);
 815           csum += c;
 816           c = c - ' ' + 3;      /* Compute repeat count */
 817
 818           if (c > 0 && c < 255 && bp + c - 1 < buf + PBUFSIZ - 1)
 819             {
 820               memset (bp, *(bp - 1), c);
 821               bp += c;
 822               continue;
 823             }
 824
 825           *bp = '\0';
 826           printf_filtered ("Repeat count %d too large for buffer: ", c);
 827           puts_filtered (buf);
 828           puts_filtered ("\n");
 829           return 0;
 830         default:
 831           if (bp < buf + PBUFSIZ - 1)
 832             {
 833               *bp++ = c;
 834               csum += c;
 835               continue;
 836             }
 837
 838           *bp = '\0';
 839           puts_filtered ("Remote packet too long: ");
 840           puts_filtered (buf);
 841           puts_filtered ("\n");
 842
 843           return 0;
 844         }
 845     }
 846 }
 847
 848 /* Read a packet from the remote machine, with error checking, and
 849    store it in BUF.  BUF is expected to be of size PBUFSIZ.  If
 850    FOREVER, wait forever rather than timing out; this is used while
 851    the target is executing user code.  */
 852
 853 static void
 854 getpkt (buf, forever)
 855      char *buf;
 856      int forever;
 857 {
 858   int c;
 859   int tries;
 860   int timeout;
 861   int val;
 862
 863   strcpy (buf, "timeout");
 864
 865   if (forever)
 866     {
 867       timeout = watchdog > 0 ? watchdog : -1;
 868     }
 869
 870   else
 871     timeout = remote_timeout;
 872
 873 #define MAX_TRIES 3
 874
 875   for (tries = 1; tries <= MAX_TRIES; tries++)
 876     {
 877       /* This can loop forever if the remote side sends us characters
 878          continuously, but if it pauses, we'll get a zero from readchar
 879          because of timeout.  Then we'll count that as a retry.  */
 880
 881       /* Note that we will only wait forever prior to the start of a packet.
 882          After that, we expect characters to arrive at a brisk pace.  They
 883          should show up within remote_timeout intervals.  */
 884
 885       do
 886         {
 887           c = readchar (timeout);
 888
 889           if (c == SERIAL_TIMEOUT)
 890             {
 891               if (forever)      /* Watchdog went off.  Kill the target. */
 892                 {
 893                   target_mourn_inferior ();
 894                   error ("Watchdog has expired.  Target detached.\n");
 895                 }
 896               if (remote_debug)
 897                 fputs_filtered ("Timed out.\n", gdb_stdlog);
 898               goto retry;
 899             }
 900         }
 901       while (c != '$');
 902
 903       /* We've found the start of a packet, now collect the data.  */
 904
 905       val = read_frame (buf);
 906
 907       if (val == 1)
 908         {
 909           if (remote_debug)
 910             {
 911               fprintf_unfiltered (gdb_stdlog, "Packet received: ");
 912               fputstr_unfiltered (buf, 0, gdb_stdlog);
 913               fprintf_unfiltered (gdb_stdlog, "\n");
 914             }
 915           SERIAL_WRITE (remote_desc, "+", 1);
 916           return;
 917         }
 918
 919       /* Try the whole thing again.  */
 920     retry:
 921       SERIAL_WRITE (remote_desc, "-", 1);
 922     }
 923
 924   /* We have tried hard enough, and just can't receive the packet.  Give up. */
 925
 926   printf_unfiltered ("Ignoring packet error, continuing...\n");
 927   SERIAL_WRITE (remote_desc, "+", 1);
 928 }