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