URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [gdb/] [gdbserver/] [remote-utils.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/* Remote utility routines for the remote server for GDB.
   Copyright 1986, 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
   2002
   Free Software Foundation, Inc.
 
   This file is part of GDB.
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */
 
#include "server.h"
#include "terminal.h"
#include <stdio.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/file.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/tcp.h>
#include <sys/ioctl.h>
#include <signal.h>
#include <fcntl.h>
#include <sys/time.h>
#include <unistd.h>
#include <arpa/inet.h>
 
int remote_debug = 0;
struct ui_file *gdb_stdlog;
 
static int remote_desc;
 
/* FIXME headerize? */
extern int using_threads;
extern int debug_threads;
 
extern int signal_pid;
 
/* Open a connection to a remote debugger.
   NAME is the filename used for communication.  */
 
void
remote_open (char *name)
{
  int save_fcntl_flags;
 
  if (!strchr (name, ':'))
    {
      remote_desc = open (name, O_RDWR);
      if (remote_desc < 0)
        perror_with_name ("Could not open remote device");
 
#ifdef HAVE_TERMIOS
      {
        struct termios termios;
        tcgetattr (remote_desc, &termios);
 
        termios.c_iflag = 0;
        termios.c_oflag = 0;
        termios.c_lflag = 0;
        termios.c_cflag &= ~(CSIZE | PARENB);
        termios.c_cflag |= CLOCAL | CS8;
        termios.c_cc[VMIN] = 1;
        termios.c_cc[VTIME] = 0;
 
        tcsetattr (remote_desc, TCSANOW, &termios);
      }
#endif
 
#ifdef HAVE_TERMIO
      {
        struct termio termio;
        ioctl (remote_desc, TCGETA, &termio);
 
        termio.c_iflag = 0;
        termio.c_oflag = 0;
        termio.c_lflag = 0;
        termio.c_cflag &= ~(CSIZE | PARENB);
        termio.c_cflag |= CLOCAL | CS8;
        termio.c_cc[VMIN] = 1;
        termio.c_cc[VTIME] = 0;
 
        ioctl (remote_desc, TCSETA, &termio);
      }
#endif
 
#ifdef HAVE_SGTTY
      {
        struct sgttyb sg;
 
        ioctl (remote_desc, TIOCGETP, &sg);
        sg.sg_flags = RAW;
        ioctl (remote_desc, TIOCSETP, &sg);
      }
#endif
 
      fprintf (stderr, "Remote debugging using %s\n", name);
    }
  else
    {
      char *port_str;
      int port;
      struct sockaddr_in sockaddr;
      int tmp;
      int tmp_desc;
 
      port_str = strchr (name, ':');
 
      port = atoi (port_str + 1);
 
      tmp_desc = socket (PF_INET, SOCK_STREAM, 0);
      if (tmp_desc < 0)
        perror_with_name ("Can't open socket");
 
      /* Allow rapid reuse of this port. */
      tmp = 1;
      setsockopt (tmp_desc, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp,
                  sizeof (tmp));
 
      sockaddr.sin_family = PF_INET;
      sockaddr.sin_port = htons (port);
      sockaddr.sin_addr.s_addr = INADDR_ANY;
 
      if (bind (tmp_desc, (struct sockaddr *) &sockaddr, sizeof (sockaddr))
          || listen (tmp_desc, 1))
        perror_with_name ("Can't bind address");
 
      tmp = sizeof (sockaddr);
      remote_desc = accept (tmp_desc, (struct sockaddr *) &sockaddr, &tmp);
      if (remote_desc == -1)
        perror_with_name ("Accept failed");
 
      /* Enable TCP keep alive process. */
      tmp = 1;
      setsockopt (tmp_desc, SOL_SOCKET, SO_KEEPALIVE, (char *) &tmp, sizeof (tmp));
 
      /* Tell TCP not to delay small packets.  This greatly speeds up
         interactive response. */
      tmp = 1;
      setsockopt (remote_desc, IPPROTO_TCP, TCP_NODELAY,
                  (char *) &tmp, sizeof (tmp));
 
      close (tmp_desc);         /* No longer need this */
 
      signal (SIGPIPE, SIG_IGN);        /* If we don't do this, then gdbserver simply
                                           exits when the remote side dies.  */
 
      /* Convert IP address to string.  */
      fprintf (stderr, "Remote debugging from host %s\n",
         inet_ntoa (sockaddr.sin_addr));
    }
 
#if defined(F_SETFL) && defined (FASYNC)
  save_fcntl_flags = fcntl (remote_desc, F_GETFL, 0);
  fcntl (remote_desc, F_SETFL, save_fcntl_flags | FASYNC);
#if defined (F_SETOWN)
  fcntl (remote_desc, F_SETOWN, getpid ());
#endif
#endif
  disable_async_io ();
}
 
void
remote_close (void)
{
  close (remote_desc);
}
 
/* Convert hex digit A to a number.  */
 
static int
fromhex (int a)
{
  if (a >= '0' && a <= '9')
    return a - '0';
  else if (a >= 'a' && a <= 'f')
    return a - 'a' + 10;
  else
    error ("Reply contains invalid hex digit");
  return 0;
}
 
int
unhexify (char *bin, const char *hex, int count)
{
  int i;
 
  for (i = 0; i < count; i++)
    {
      if (hex[0] == 0 || hex[1] == 0)
        {
          /* Hex string is short, or of uneven length.
             Return the count that has been converted so far. */
          return i;
        }
      *bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]);
      hex += 2;
    }
  return i;
}
 
static void
decode_address (CORE_ADDR *addrp, const char *start, int len)
{
  CORE_ADDR addr;
  char ch;
  int i;
 
  addr = 0;
  for (i = 0; i < len; i++)
    {
      ch = start[i];
      addr = addr << 4;
      addr = addr | (fromhex (ch) & 0x0f);
    }
  *addrp = addr;
}
 
/* Convert number NIB to a hex digit.  */
 
static int
tohex (int nib)
{
  if (nib < 10)
    return '0' + nib;
  else
    return 'a' + nib - 10;
}
 
int
hexify (char *hex, const char *bin, int count)
{
  int i;
 
  /* May use a length, or a nul-terminated string as input. */
  if (count == 0)
    count = strlen (bin);
 
  for (i = 0; i < count; i++)
    {
      *hex++ = tohex ((*bin >> 4) & 0xf);
      *hex++ = tohex (*bin++ & 0xf);
    }
  *hex = 0;
  return i;
}
 
/* Send a packet to the remote machine, with error checking.
   The data of the packet is in BUF.  Returns >= 0 on success, -1 otherwise. */
 
int
putpkt (char *buf)
{
  int i;
  unsigned char csum = 0;
  char *buf2;
  char buf3[1];
  int cnt = strlen (buf);
  char *p;
 
  buf2 = malloc (PBUFSIZ);
 
  /* Copy the packet into buffer BUF2, encapsulating it
     and giving it a checksum.  */
 
  p = buf2;
  *p++ = '$';
 
  for (i = 0; i < cnt; i++)
    {
      csum += buf[i];
      *p++ = buf[i];
    }
  *p++ = '#';
  *p++ = tohex ((csum >> 4) & 0xf);
  *p++ = tohex (csum & 0xf);
 
  *p = '\0';
 
  /* Send it over and over until we get a positive ack.  */
 
  do
    {
      int cc;
 
      if (write (remote_desc, buf2, p - buf2) != p - buf2)
        {
          perror ("putpkt(write)");
          return -1;
        }
 
      if (remote_debug)
        {
          fprintf (stderr, "putpkt (\"%s\"); [looking for ack]\n", buf2);
          fflush (stderr);
        }
      cc = read (remote_desc, buf3, 1);
      if (remote_debug)
        {
          fprintf (stderr, "[received '%c' (0x%x)]\n", buf3[0], buf3[0]);
          fflush (stderr);
        }
 
      if (cc <= 0)
        {
          if (cc == 0)
            fprintf (stderr, "putpkt(read): Got EOF\n");
          else
            perror ("putpkt(read)");
 
          free (buf2);
          return -1;
        }
 
      /* Check for an input interrupt while we're here.  */
      if (buf3[0] == '\003')
        kill (signal_pid, SIGINT);
    }
  while (buf3[0] != '+');
 
  free (buf2);
  return 1;                     /* Success! */
}
 
/* Come here when we get an input interrupt from the remote side.  This
   interrupt should only be active while we are waiting for the child to do
   something.  About the only thing that should come through is a ^C, which
   will cause us to send a SIGINT to the child.  */
 
static void
input_interrupt (int unused)
{
  fd_set readset;
  struct timeval immediate = { 0, 0 };
 
  /* Protect against spurious interrupts.  This has been observed to
     be a problem under NetBSD 1.4 and 1.5.  */
 
  FD_ZERO (&readset);
  FD_SET (remote_desc, &readset);
  if (select (remote_desc + 1, &readset, 0, 0, &immediate) > 0)
    {
      int cc;
      char c;
 
      cc = read (remote_desc, &c, 1);
 
      if (cc != 1 || c != '\003')
        {
          fprintf (stderr, "input_interrupt, cc = %d c = %d\n", cc, c);
          return;
        }
 
      kill (signal_pid, SIGINT);
    }
}
 
void
enable_async_io (void)
{
  signal (SIGIO, input_interrupt);
}
 
void
disable_async_io (void)
{
  signal (SIGIO, SIG_IGN);
}
 
/* Returns next char from remote GDB.  -1 if error.  */
 
static int
readchar (void)
{
  static char buf[BUFSIZ];
  static int bufcnt = 0;
  static char *bufp;
 
  if (bufcnt-- > 0)
    return *bufp++ & 0x7f;
 
  bufcnt = read (remote_desc, buf, sizeof (buf));
 
  if (bufcnt <= 0)
    {
      if (bufcnt == 0)
        fprintf (stderr, "readchar: Got EOF\n");
      else
        perror ("readchar");
 
      return -1;
    }
 
  bufp = buf;
  bufcnt--;
  return *bufp++ & 0x7f;
}
 
/* Read a packet from the remote machine, with error checking,
   and store it in BUF.  Returns length of packet, or negative if error. */
 
int
getpkt (char *buf)
{
  char *bp;
  unsigned char csum, c1, c2;
  int c;
 
  while (1)
    {
      csum = 0;
 
      while (1)
        {
          c = readchar ();
          if (c == '$')
            break;
          if (remote_debug)
            {
              fprintf (stderr, "[getpkt: discarding char '%c']\n", c);
              fflush (stderr);
            }
 
          if (c < 0)
            return -1;
        }
 
      bp = buf;
      while (1)
        {
          c = readchar ();
          if (c < 0)
            return -1;
          if (c == '#')
            break;
          *bp++ = c;
          csum += c;
        }
      *bp = 0;
 
      c1 = fromhex (readchar ());
      c2 = fromhex (readchar ());
 
      if (csum == (c1 << 4) + c2)
        break;
 
      fprintf (stderr, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
               (c1 << 4) + c2, csum, buf);
      write (remote_desc, "-", 1);
    }
 
  if (remote_debug)
    {
      fprintf (stderr, "getpkt (\"%s\");  [sending ack] \n", buf);
      fflush (stderr);
    }
 
  write (remote_desc, "+", 1);
 
  if (remote_debug)
    {
      fprintf (stderr, "[sent ack]\n");
      fflush (stderr);
    }
 
  return bp - buf;
}
 
void
write_ok (char *buf)
{
  buf[0] = 'O';
  buf[1] = 'K';
  buf[2] = '\0';
}
 
void
write_enn (char *buf)
{
  buf[0] = 'E';
  buf[1] = 'N';
  buf[2] = 'N';
  buf[3] = '\0';
}
 
void
convert_int_to_ascii (char *from, char *to, int n)
{
  int nib;
  char ch;
  while (n--)
    {
      ch = *from++;
      nib = ((ch & 0xf0) >> 4) & 0x0f;
      *to++ = tohex (nib);
      nib = ch & 0x0f;
      *to++ = tohex (nib);
    }
  *to++ = 0;
}
 
 
void
convert_ascii_to_int (char *from, char *to, int n)
{
  int nib1, nib2;
  while (n--)
    {
      nib1 = fromhex (*from++);
      nib2 = fromhex (*from++);
      *to++ = (((nib1 & 0x0f) << 4) & 0xf0) | (nib2 & 0x0f);
    }
}
 
static char *
outreg (int regno, char *buf)
{
  if ((regno >> 12) != 0)
    *buf++ = tohex ((regno >> 12) & 0xf);
  if ((regno >> 8) != 0)
    *buf++ = tohex ((regno >> 8) & 0xf);
  *buf++ = tohex ((regno >> 4) & 0xf);
  *buf++ = tohex (regno & 0xf);
  *buf++ = ':';
  collect_register_as_string (regno, buf);
  buf += 2 * register_size (regno);
  *buf++ = ';';
 
  return buf;
}
 
void
new_thread_notify (int id)
{
  char own_buf[256];
 
  /* The `n' response is not yet part of the remote protocol.  Do nothing.  */
  if (1)
    return;
 
  if (server_waiting == 0)
    return;
 
  sprintf (own_buf, "n%x", id);
  disable_async_io ();
  putpkt (own_buf);
  enable_async_io ();
}
 
void
dead_thread_notify (int id)
{
  char own_buf[256];
 
  /* The `x' response is not yet part of the remote protocol.  Do nothing.  */
  if (1)
    return;
 
  sprintf (own_buf, "x%x", id);
  disable_async_io ();
  putpkt (own_buf);
  enable_async_io ();
}
 
void
prepare_resume_reply (char *buf, char status, unsigned char signo)
{
  int nib, sig;
 
  *buf++ = status;
 
  sig = (int)target_signal_from_host (signo);
 
  nib = ((sig & 0xf0) >> 4);
  *buf++ = tohex (nib);
  nib = sig & 0x0f;
  *buf++ = tohex (nib);
 
  if (status == 'T')
    {
      const char **regp = gdbserver_expedite_regs;
      while (*regp)
        {
          buf = outreg (find_regno (*regp), buf);
          regp ++;
        }
 
      /* Formerly, if the debugger had not used any thread features we would not
         burden it with a thread status response.  This was for the benefit of
         GDB 4.13 and older.  However, in recent GDB versions the check
         (``if (cont_thread != 0)'') does not have the desired effect because of
         sillyness in the way that the remote protocol handles specifying a thread.
         Since thread support relies on qSymbol support anyway, assume GDB can handle
         threads.  */
 
      if (using_threads)
        {
          /* FIXME right place to set this? */
          thread_from_wait = ((struct inferior_list_entry *)current_inferior)->id;
          if (debug_threads)
            fprintf (stderr, "Writing resume reply for %d\n\n", thread_from_wait);
          if (old_thread_from_wait != thread_from_wait)
            {
              general_thread = thread_from_wait;
              sprintf (buf, "thread:%x;", thread_from_wait);
              buf += strlen (buf);
              old_thread_from_wait = thread_from_wait;
            }
        }
    }
  /* For W and X, we're done.  */
  *buf++ = 0;
}
 
void
decode_m_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr)
{
  int i = 0, j = 0;
  char ch;
  *mem_addr_ptr = *len_ptr = 0;
 
  while ((ch = from[i++]) != ',')
    {
      *mem_addr_ptr = *mem_addr_ptr << 4;
      *mem_addr_ptr |= fromhex (ch) & 0x0f;
    }
 
  for (j = 0; j < 4; j++)
    {
      if ((ch = from[i++]) == 0)
        break;
      *len_ptr = *len_ptr << 4;
      *len_ptr |= fromhex (ch) & 0x0f;
    }
}
 
void
decode_M_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr,
                 char *to)
{
  int i = 0;
  char ch;
  *mem_addr_ptr = *len_ptr = 0;
 
  while ((ch = from[i++]) != ',')
    {
      *mem_addr_ptr = *mem_addr_ptr << 4;
      *mem_addr_ptr |= fromhex (ch) & 0x0f;
    }
 
  while ((ch = from[i++]) != ':')
    {
      *len_ptr = *len_ptr << 4;
      *len_ptr |= fromhex (ch) & 0x0f;
    }
 
  convert_ascii_to_int (&from[i++], to, *len_ptr);
}
 
int
look_up_one_symbol (const char *name, CORE_ADDR *addrp)
{
  char own_buf[266], *p, *q;
  int len;
 
  /* Send the request.  */
  strcpy (own_buf, "qSymbol:");
  hexify (own_buf + strlen ("qSymbol:"), name, strlen (name));
  if (putpkt (own_buf) < 0)
    return -1;
 
  /* FIXME:  Eventually add buffer overflow checking (to getpkt?)  */
  len = getpkt (own_buf);
  if (len < 0)
    return -1;
 
  if (strncmp (own_buf, "qSymbol:", strlen ("qSymbol:")) != 0)
    {
      /* Malformed response.  */
      if (remote_debug)
        {
          fprintf (stderr, "Malformed response to qSymbol, ignoring.\n");
          fflush (stderr);
        }
 
      return -1;
    }
 
  p = own_buf + strlen ("qSymbol:");
  q = p;
  while (*q && *q != ':')
    q++;
 
  /* Make sure we found a value for the symbol.  */
  if (p == q || *q == '\0')
    return 0;
 
  decode_address (addrp, p, q - p);
  return 1;
}
 

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [gdb/] [gdbserver/] [remote-utils.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1181	sfurman	`/* Remote utility routines for the remote server for GDB.`
2			`Copyright 1986, 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,`
3			`2002`
4			`Free Software Foundation, Inc.`
5
6			`This file is part of GDB.`
7
8			`This program is free software; you can redistribute it and/or modify`
9			`it under the terms of the GNU General Public License as published by`
10			`the Free Software Foundation; either version 2 of the License, or`
11			`(at your option) any later version.`
12
13			`This program is distributed in the hope that it will be useful,`
14			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
15			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
16			`GNU General Public License for more details.`
17
18			`You should have received a copy of the GNU General Public License`
19			`along with this program; if not, write to the Free Software`
20			`Foundation, Inc., 59 Temple Place - Suite 330,`
21			`Boston, MA 02111-1307, USA. */`
22
23			`#include "server.h"`
24			`#include "terminal.h"`
25			`#include <stdio.h>`
26			`#include <string.h>`
27			`#include <sys/ioctl.h>`
28			`#include <sys/file.h>`
29			`#include <netinet/in.h>`
30			`#include <sys/socket.h>`
31			`#include <netdb.h>`
32			`#include <netinet/tcp.h>`
33			`#include <sys/ioctl.h>`
34			`#include <signal.h>`
35			`#include <fcntl.h>`
36			`#include <sys/time.h>`
37			`#include <unistd.h>`
38			`#include <arpa/inet.h>`
39
40			`int remote_debug = 0;`
41			`struct ui_file *gdb_stdlog;`
42
43			`static int remote_desc;`
44
45			`/* FIXME headerize? */`
46			`extern int using_threads;`
47			`extern int debug_threads;`
48
49			`extern int signal_pid;`
50
51			`/* Open a connection to a remote debugger.`
52			`NAME is the filename used for communication. */`
53
54			`void`
55			`remote_open (char *name)`
56			`{`
57			`int save_fcntl_flags;`
58
59			`if (!strchr (name, ':'))`
60			`{`
61			`remote_desc = open (name, O_RDWR);`
62			`if (remote_desc < 0)`
63			`perror_with_name ("Could not open remote device");`
64
65			`#ifdef HAVE_TERMIOS`
66			`{`
67			`struct termios termios;`
68			`tcgetattr (remote_desc, &termios);`
69
70			`termios.c_iflag = 0;`
71			`termios.c_oflag = 0;`
72			`termios.c_lflag = 0;`
73			`termios.c_cflag &= ~(CSIZE \| PARENB);`
74			`termios.c_cflag \|= CLOCAL \| CS8;`
75			`termios.c_cc[VMIN] = 1;`
76			`termios.c_cc[VTIME] = 0;`
77
78			`tcsetattr (remote_desc, TCSANOW, &termios);`
79			`}`
80			`#endif`
81
82			`#ifdef HAVE_TERMIO`
83			`{`
84			`struct termio termio;`
85			`ioctl (remote_desc, TCGETA, &termio);`
86
87			`termio.c_iflag = 0;`
88			`termio.c_oflag = 0;`
89			`termio.c_lflag = 0;`
90			`termio.c_cflag &= ~(CSIZE \| PARENB);`
91			`termio.c_cflag \|= CLOCAL \| CS8;`
92			`termio.c_cc[VMIN] = 1;`
93			`termio.c_cc[VTIME] = 0;`
94
95			`ioctl (remote_desc, TCSETA, &termio);`
96			`}`
97			`#endif`
98
99			`#ifdef HAVE_SGTTY`
100			`{`
101			`struct sgttyb sg;`
102
103			`ioctl (remote_desc, TIOCGETP, &sg);`
104			`sg.sg_flags = RAW;`
105			`ioctl (remote_desc, TIOCSETP, &sg);`
106			`}`
107			`#endif`
108
109			`fprintf (stderr, "Remote debugging using %s\n", name);`
110			`}`
111			`else`
112			`{`
113			`char *port_str;`
114			`int port;`
115			`struct sockaddr_in sockaddr;`
116			`int tmp;`
117			`int tmp_desc;`
118
119			`port_str = strchr (name, ':');`
120
121			`port = atoi (port_str + 1);`
122
123			`tmp_desc = socket (PF_INET, SOCK_STREAM, 0);`
124			`if (tmp_desc < 0)`
125			`perror_with_name ("Can't open socket");`
126
127			`/* Allow rapid reuse of this port. */`
128			`tmp = 1;`
129			`setsockopt (tmp_desc, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp,`
130			`sizeof (tmp));`
131
132			`sockaddr.sin_family = PF_INET;`
133			`sockaddr.sin_port = htons (port);`
134			`sockaddr.sin_addr.s_addr = INADDR_ANY;`
135
136			`if (bind (tmp_desc, (struct sockaddr *) &sockaddr, sizeof (sockaddr))`
137			`\|\| listen (tmp_desc, 1))`
138			`perror_with_name ("Can't bind address");`
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			`kill (signal_pid, 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			`kill (signal_pid, SIGINT);`
367			`}`
368			`}`
369
370			`void`
371			`enable_async_io (void)`
372			`{`
373			`signal (SIGIO, input_interrupt);`
374			`}`
375
376			`void`
377			`disable_async_io (void)`
378			`{`
379			`signal (SIGIO, SIG_IGN);`
380			`}`
381
382			`/* Returns next char from remote GDB. -1 if error. */`
383
384			`static int`
385			`readchar (void)`
386			`{`
387			`static char buf[BUFSIZ];`
388			`static int bufcnt = 0;`
389			`static char *bufp;`
390
391			`if (bufcnt-- > 0)`
392			`return *bufp++ & 0x7f;`
393
394			`bufcnt = read (remote_desc, buf, sizeof (buf));`
395
396			`if (bufcnt <= 0)`
397			`{`
398			`if (bufcnt == 0)`
399			`fprintf (stderr, "readchar: Got EOF\n");`
400			`else`
401			`perror ("readchar");`
402
403			`return -1;`
404			`}`
405
406			`bufp = buf;`
407			`bufcnt--;`
408			`return *bufp++ & 0x7f;`
409			`}`
410
411			`/* Read a packet from the remote machine, with error checking,`
412			`and store it in BUF. Returns length of packet, or negative if error. */`
413
414			`int`
415			`getpkt (char *buf)`
416			`{`
417			`char *bp;`
418			`unsigned char csum, c1, c2;`
419			`int c;`
420
421			`while (1)`
422			`{`
423			`csum = 0;`
424
425			`while (1)`
426			`{`
427			`c = readchar ();`
428			`if (c == '$')`
429			`break;`
430			`if (remote_debug)`
431			`{`
432			`fprintf (stderr, "[getpkt: discarding char '%c']\n", c);`
433			`fflush (stderr);`
434			`}`
435
436			`if (c < 0)`
437			`return -1;`
438			`}`
439
440			`bp = buf;`
441			`while (1)`
442			`{`
443			`c = readchar ();`
444			`if (c < 0)`
445			`return -1;`
446			`if (c == '#')`
447			`break;`
448			`*bp++ = c;`
449			`csum += c;`
450			`}`
451			`*bp = 0;`
452
453			`c1 = fromhex (readchar ());`
454			`c2 = fromhex (readchar ());`
455
456			`if (csum == (c1 << 4) + c2)`
457			`break;`
458
459			`fprintf (stderr, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",`
460			`(c1 << 4) + c2, csum, buf);`
461			`write (remote_desc, "-", 1);`
462			`}`
463
464			`if (remote_debug)`
465			`{`
466			`fprintf (stderr, "getpkt (\"%s\"); [sending ack] \n", buf);`
467			`fflush (stderr);`
468			`}`
469
470			`write (remote_desc, "+", 1);`
471
472			`if (remote_debug)`
473			`{`
474			`fprintf (stderr, "[sent ack]\n");`
475			`fflush (stderr);`
476			`}`
477
478			`return bp - buf;`
479			`}`
480
481			`void`
482			`write_ok (char *buf)`
483			`{`
484			`buf[0] = 'O';`
485			`buf[1] = 'K';`
486			`buf[2] = '\0';`
487			`}`
488
489			`void`
490			`write_enn (char *buf)`
491			`{`
492			`buf[0] = 'E';`
493			`buf[1] = 'N';`
494			`buf[2] = 'N';`
495			`buf[3] = '\0';`
496			`}`
497
498			`void`
499			`convert_int_to_ascii (char from, char to, int n)`
500			`{`
501			`int nib;`
502			`char ch;`
503			`while (n--)`
504			`{`
505			`ch = *from++;`
506			`nib = ((ch & 0xf0) >> 4) & 0x0f;`
507			`*to++ = tohex (nib);`
508			`nib = ch & 0x0f;`
509			`*to++ = tohex (nib);`
510			`}`
511			`*to++ = 0;`
512			`}`
513
514
515			`void`
516			`convert_ascii_to_int (char from, char to, int n)`
517			`{`
518			`int nib1, nib2;`
519			`while (n--)`
520			`{`
521			`nib1 = fromhex (*from++);`
522			`nib2 = fromhex (*from++);`
523			`*to++ = (((nib1 & 0x0f) << 4) & 0xf0) \| (nib2 & 0x0f);`
524			`}`
525			`}`
526
527			`static char *`
528			`outreg (int regno, char *buf)`
529			`{`
530			`if ((regno >> 12) != 0)`
531			`*buf++ = tohex ((regno >> 12) & 0xf);`
532			`if ((regno >> 8) != 0)`
533			`*buf++ = tohex ((regno >> 8) & 0xf);`
534			`*buf++ = tohex ((regno >> 4) & 0xf);`
535			`*buf++ = tohex (regno & 0xf);`
536			`*buf++ = ':';`
537			`collect_register_as_string (regno, buf);`
538			`buf += 2 * register_size (regno);`
539			`*buf++ = ';';`
540
541			`return buf;`
542			`}`
543
544			`void`
545			`new_thread_notify (int id)`
546			`{`
547			`char own_buf[256];`
548
549			/* The `n' response is not yet part of the remote protocol. Do nothing. */
550			`if (1)`
551			`return;`
552
553			`if (server_waiting == 0)`
554			`return;`
555
556			`sprintf (own_buf, "n%x", id);`
557			`disable_async_io ();`
558			`putpkt (own_buf);`
559			`enable_async_io ();`
560			`}`
561
562			`void`
563			`dead_thread_notify (int id)`
564			`{`
565			`char own_buf[256];`
566
567			/* The `x' response is not yet part of the remote protocol. Do nothing. */
568			`if (1)`
569			`return;`
570
571			`sprintf (own_buf, "x%x", id);`
572			`disable_async_io ();`
573			`putpkt (own_buf);`
574			`enable_async_io ();`
575			`}`
576
577			`void`
578			`prepare_resume_reply (char *buf, char status, unsigned char signo)`
579			`{`
580			`int nib, sig;`
581
582			`*buf++ = status;`
583
584			`sig = (int)target_signal_from_host (signo);`
585
586			`nib = ((sig & 0xf0) >> 4);`
587			`*buf++ = tohex (nib);`
588			`nib = sig & 0x0f;`
589			`*buf++ = tohex (nib);`
590
591			`if (status == 'T')`
592			`{`
593			`const char **regp = gdbserver_expedite_regs;`
594			`while (*regp)`
595			`{`
596			`buf = outreg (find_regno (*regp), buf);`
597			`regp ++;`
598			`}`
599
600			`/* Formerly, if the debugger had not used any thread features we would not`
601			`burden it with a thread status response. This was for the benefit of`
602			`GDB 4.13 and older. However, in recent GDB versions the check`
603			(``if (cont_thread != 0)'') does not have the desired effect because of
604			`sillyness in the way that the remote protocol handles specifying a thread.`
605			`Since thread support relies on qSymbol support anyway, assume GDB can handle`
606			`threads. */`
607
608			`if (using_threads)`
609			`{`
610			`/* FIXME right place to set this? */`
611			`thread_from_wait = ((struct inferior_list_entry *)current_inferior)->id;`
612			`if (debug_threads)`
613			`fprintf (stderr, "Writing resume reply for %d\n\n", thread_from_wait);`
614			`if (old_thread_from_wait != thread_from_wait)`
615			`{`
616			`general_thread = thread_from_wait;`
617			`sprintf (buf, "thread:%x;", thread_from_wait);`
618			`buf += strlen (buf);`
619			`old_thread_from_wait = thread_from_wait;`
620			`}`
621			`}`
622			`}`
623			`/* For W and X, we're done. */`
624			`*buf++ = 0;`
625			`}`
626
627			`void`
628			`decode_m_packet (char from, CORE_ADDR mem_addr_ptr, unsigned int *len_ptr)`
629			`{`
630			`int i = 0, j = 0;`
631			`char ch;`
632			`mem_addr_ptr = len_ptr = 0;`
633
634			`while ((ch = from[i++]) != ',')`
635			`{`
636			`mem_addr_ptr = mem_addr_ptr << 4;`
637			`*mem_addr_ptr \|= fromhex (ch) & 0x0f;`
638			`}`
639
640			`for (j = 0; j < 4; j++)`
641			`{`
642			`if ((ch = from[i++]) == 0)`
643			`break;`
644			`len_ptr = len_ptr << 4;`
645			`*len_ptr \|= fromhex (ch) & 0x0f;`
646			`}`
647			`}`
648
649			`void`
650			`decode_M_packet (char from, CORE_ADDR mem_addr_ptr, unsigned int *len_ptr,`
651			`char *to)`
652			`{`
653			`int i = 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			`while ((ch = from[i++]) != ':')`
664			`{`
665			`len_ptr = len_ptr << 4;`
666			`*len_ptr \|= fromhex (ch) & 0x0f;`
667			`}`
668
669			`convert_ascii_to_int (&from[i++], to, *len_ptr);`
670			`}`
671
672			`int`
673			`look_up_one_symbol (const char name, CORE_ADDR addrp)`
674			`{`
675			`char own_buf[266], p, q;`
676			`int len;`
677
678			`/* Send the request. */`
679			`strcpy (own_buf, "qSymbol:");`
680			`hexify (own_buf + strlen ("qSymbol:"), name, strlen (name));`
681			`if (putpkt (own_buf) < 0)`
682			`return -1;`
683
684			`/* FIXME: Eventually add buffer overflow checking (to getpkt?) */`
685			`len = getpkt (own_buf);`
686			`if (len < 0)`
687			`return -1;`
688
689			`if (strncmp (own_buf, "qSymbol:", strlen ("qSymbol:")) != 0)`
690			`{`
691			`/* Malformed response. */`
692			`if (remote_debug)`
693			`{`
694			`fprintf (stderr, "Malformed response to qSymbol, ignoring.\n");`
695			`fflush (stderr);`
696			`}`
697
698			`return -1;`
699			`}`
700
701			`p = own_buf + strlen ("qSymbol:");`
702			`q = p;`
703			`while (q && q != ':')`
704			`q++;`
705
706			`/* Make sure we found a value for the symbol. */`
707			`if (p == q \|\| *q == '\0')`
708			`return 0;`
709
710			`decode_address (addrp, p, q - p);`
711			`return 1;`
712			`}`
713