OSDN Git Service

614466d12d42968e59639401c11067e208ae4070
[pf3gnuchains/pf3gnuchains4x.git] / gdb / gdbserver / remote-utils.c
1 /* Remote utility routines for the remote server for GDB.
2    Copyright (C) 1986, 1989, 1993 Free Software Foundation, Inc.
3
4    This file is part of GDB.
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 59 Temple Place - Suite 330,
19    Boston, MA 02111-1307, USA.  */
20
21 #include "server.h"
22 #include "terminal.h"
23 #include <stdio.h>
24 #include <string.h>
25 #include <sys/ioctl.h>
26 #include <sys/file.h>
27 #include <netinet/in.h>
28 #include <sys/socket.h>
29 #include <netdb.h>
30 #include <netinet/tcp.h>
31 #include <sys/ioctl.h>
32 #include <signal.h>
33 #include <fcntl.h>
34
35 int remote_debug = 0;
36 struct ui_file *gdb_stdlog;
37
38 static int remote_desc;
39
40 /* Open a connection to a remote debugger.
41    NAME is the filename used for communication.  */
42
43 void
44 remote_open (char *name)
45 {
46   int save_fcntl_flags;
47
48   if (!strchr (name, ':'))
49     {
50       remote_desc = open (name, O_RDWR);
51       if (remote_desc < 0)
52         perror_with_name ("Could not open remote device");
53
54 #ifdef HAVE_TERMIOS
55       {
56         struct termios termios;
57         tcgetattr (remote_desc, &termios);
58
59         termios.c_iflag = 0;
60         termios.c_oflag = 0;
61         termios.c_lflag = 0;
62         termios.c_cflag &= ~(CSIZE | PARENB);
63         termios.c_cflag |= CLOCAL | CS8;
64         termios.c_cc[VMIN] = 0;
65         termios.c_cc[VTIME] = 0;
66
67         tcsetattr (remote_desc, TCSANOW, &termios);
68       }
69 #endif
70
71 #ifdef HAVE_TERMIO
72       {
73         struct termio termio;
74         ioctl (remote_desc, TCGETA, &termio);
75
76         termio.c_iflag = 0;
77         termio.c_oflag = 0;
78         termio.c_lflag = 0;
79         termio.c_cflag &= ~(CSIZE | PARENB);
80         termio.c_cflag |= CLOCAL | CS8;
81         termio.c_cc[VMIN] = 0;
82         termio.c_cc[VTIME] = 0;
83
84         ioctl (remote_desc, TCSETA, &termio);
85       }
86 #endif
87
88 #ifdef HAVE_SGTTY
89       {
90         struct sgttyb sg;
91
92         ioctl (remote_desc, TIOCGETP, &sg);
93         sg.sg_flags = RAW;
94         ioctl (remote_desc, TIOCSETP, &sg);
95       }
96 #endif
97
98
99     }
100   else
101     {
102       char *port_str;
103       int port;
104       struct sockaddr_in sockaddr;
105       int tmp;
106       struct protoent *protoent;
107       int tmp_desc;
108
109       port_str = strchr (name, ':');
110
111       port = atoi (port_str + 1);
112
113       tmp_desc = socket (PF_INET, SOCK_STREAM, 0);
114       if (tmp_desc < 0)
115         perror_with_name ("Can't open socket");
116
117       /* Allow rapid reuse of this port. */
118       tmp = 1;
119       setsockopt (tmp_desc, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp,
120                   sizeof (tmp));
121
122       sockaddr.sin_family = PF_INET;
123       sockaddr.sin_port = htons (port);
124       sockaddr.sin_addr.s_addr = INADDR_ANY;
125
126       if (bind (tmp_desc, (struct sockaddr *) &sockaddr, sizeof (sockaddr))
127           || listen (tmp_desc, 1))
128         perror_with_name ("Can't bind address");
129
130       tmp = sizeof (sockaddr);
131       remote_desc = accept (tmp_desc, (struct sockaddr *) &sockaddr, &tmp);
132       if (remote_desc == -1)
133         perror_with_name ("Accept failed");
134
135       protoent = getprotobyname ("tcp");
136       if (!protoent)
137         perror_with_name ("getprotobyname");
138
139       /* Enable TCP keep alive process. */
140       tmp = 1;
141       setsockopt (tmp_desc, SOL_SOCKET, SO_KEEPALIVE, (char *) &tmp, sizeof (tmp));
142
143       /* Tell TCP not to delay small packets.  This greatly speeds up
144          interactive response. */
145       tmp = 1;
146       setsockopt (remote_desc, protoent->p_proto, TCP_NODELAY,
147                   (char *) &tmp, sizeof (tmp));
148
149       close (tmp_desc);         /* No longer need this */
150
151       signal (SIGPIPE, SIG_IGN);        /* If we don't do this, then gdbserver simply
152                                            exits when the remote side dies.  */
153     }
154
155 #if defined(F_SETFL) && defined (FASYNC)
156   save_fcntl_flags = fcntl (remote_desc, F_GETFL, 0);
157   fcntl (remote_desc, F_SETFL, save_fcntl_flags | FASYNC);
158   disable_async_io ();
159 #endif /* FASYNC */
160   fprintf (stderr, "Remote debugging using %s\n", name);
161 }
162
163 void
164 remote_close (void)
165 {
166   close (remote_desc);
167 }
168
169 /* Convert hex digit A to a number.  */
170
171 static int
172 fromhex (int a)
173 {
174   if (a >= '0' && a <= '9')
175     return a - '0';
176   else if (a >= 'a' && a <= 'f')
177     return a - 'a' + 10;
178   else
179     error ("Reply contains invalid hex digit");
180 }
181
182 /* Convert number NIB to a hex digit.  */
183
184 static int
185 tohex (int nib)
186 {
187   if (nib < 10)
188     return '0' + nib;
189   else
190     return 'a' + nib - 10;
191 }
192
193 /* Send a packet to the remote machine, with error checking.
194    The data of the packet is in BUF.  Returns >= 0 on success, -1 otherwise. */
195
196 int
197 putpkt (char *buf)
198 {
199   int i;
200   unsigned char csum = 0;
201   char buf2[PBUFSIZ];
202   char buf3[1];
203   int cnt = strlen (buf);
204   char *p;
205
206   /* Copy the packet into buffer BUF2, encapsulating it
207      and giving it a checksum.  */
208
209   p = buf2;
210   *p++ = '$';
211
212   for (i = 0; i < cnt; i++)
213     {
214       csum += buf[i];
215       *p++ = buf[i];
216     }
217   *p++ = '#';
218   *p++ = tohex ((csum >> 4) & 0xf);
219   *p++ = tohex (csum & 0xf);
220
221   *p = '\0';
222
223   /* Send it over and over until we get a positive ack.  */
224
225   do
226     {
227       int cc;
228
229       if (write (remote_desc, buf2, p - buf2) != p - buf2)
230         {
231           perror ("putpkt(write)");
232           return -1;
233         }
234
235       if (remote_debug)
236         printf ("putpkt (\"%s\"); [looking for ack]\n", buf2);
237       cc = read (remote_desc, buf3, 1);
238       if (remote_debug)
239         printf ("[received '%c' (0x%x)]\n", buf3[0], buf3[0]);
240       if (cc <= 0)
241         {
242           if (cc == 0)
243             fprintf (stderr, "putpkt(read): Got EOF\n");
244           else
245             perror ("putpkt(read)");
246
247           return -1;
248         }
249     }
250   while (buf3[0] != '+');
251
252   return 1;                     /* Success! */
253 }
254
255 /* Come here when we get an input interrupt from the remote side.  This
256    interrupt should only be active while we are waiting for the child to do
257    something.  About the only thing that should come through is a ^C, which
258    will cause us to send a SIGINT to the child.  */
259
260 static void
261 input_interrupt (void)
262 {
263   int cc;
264   char c;
265
266   cc = read (remote_desc, &c, 1);
267
268   if (cc != 1 || c != '\003')
269     {
270       fprintf (stderr, "input_interrupt, cc = %d c = %d\n", cc, c);
271       return;
272     }
273
274   kill (inferior_pid, SIGINT);
275 }
276
277 void
278 enable_async_io (void)
279 {
280   signal (SIGIO, input_interrupt);
281 }
282
283 void
284 disable_async_io (void)
285 {
286   signal (SIGIO, SIG_IGN);
287 }
288
289 /* Returns next char from remote GDB.  -1 if error.  */
290
291 static int
292 readchar (void)
293 {
294   static char buf[BUFSIZ];
295   static int bufcnt = 0;
296   static char *bufp;
297
298   if (bufcnt-- > 0)
299     return *bufp++ & 0x7f;
300
301   bufcnt = read (remote_desc, buf, sizeof (buf));
302
303   if (bufcnt <= 0)
304     {
305       if (bufcnt == 0)
306         fprintf (stderr, "readchar: Got EOF\n");
307       else
308         perror ("readchar");
309
310       return -1;
311     }
312
313   bufp = buf;
314   bufcnt--;
315   return *bufp++ & 0x7f;
316 }
317
318 /* Read a packet from the remote machine, with error checking,
319    and store it in BUF.  Returns length of packet, or negative if error. */
320
321 int
322 getpkt (char *buf)
323 {
324   char *bp;
325   unsigned char csum, c1, c2;
326   int c;
327
328   while (1)
329     {
330       csum = 0;
331
332       while (1)
333         {
334           c = readchar ();
335           if (c == '$')
336             break;
337           if (remote_debug)
338             printf ("[getpkt: discarding char '%c']\n", c);
339           if (c < 0)
340             return -1;
341         }
342
343       bp = buf;
344       while (1)
345         {
346           c = readchar ();
347           if (c < 0)
348             return -1;
349           if (c == '#')
350             break;
351           *bp++ = c;
352           csum += c;
353         }
354       *bp = 0;
355
356       c1 = fromhex (readchar ());
357       c2 = fromhex (readchar ());
358
359       if (csum == (c1 << 4) + c2)
360         break;
361
362       fprintf (stderr, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
363                (c1 << 4) + c2, csum, buf);
364       write (remote_desc, "-", 1);
365     }
366
367   if (remote_debug)
368     printf ("getpkt (\"%s\");  [sending ack] \n", buf);
369
370   write (remote_desc, "+", 1);
371
372   if (remote_debug)
373     printf ("[sent ack]\n");
374   return bp - buf;
375 }
376
377 void
378 write_ok (char *buf)
379 {
380   buf[0] = 'O';
381   buf[1] = 'K';
382   buf[2] = '\0';
383 }
384
385 void
386 write_enn (char *buf)
387 {
388   buf[0] = 'E';
389   buf[1] = 'N';
390   buf[2] = 'N';
391   buf[3] = '\0';
392 }
393
394 void
395 convert_int_to_ascii (char *from, char *to, int n)
396 {
397   int nib;
398   char ch;
399   while (n--)
400     {
401       ch = *from++;
402       nib = ((ch & 0xf0) >> 4) & 0x0f;
403       *to++ = tohex (nib);
404       nib = ch & 0x0f;
405       *to++ = tohex (nib);
406     }
407   *to++ = 0;
408 }
409
410
411 void
412 convert_ascii_to_int (char *from, char *to, int n)
413 {
414   int nib1, nib2;
415   while (n--)
416     {
417       nib1 = fromhex (*from++);
418       nib2 = fromhex (*from++);
419       *to++ = (((nib1 & 0x0f) << 4) & 0xf0) | (nib2 & 0x0f);
420     }
421 }
422
423 static char *
424 outreg (int regno, char *buf)
425 {
426   int regsize = REGISTER_RAW_SIZE (regno);
427
428   if ((regno >> 12) != 0)
429     *buf++ = tohex ((regno >> 12) & 0xf);
430   if ((regno >> 8) != 0)
431     *buf++ = tohex ((regno >> 8) & 0xf);
432   *buf++ = tohex ((regno >> 4) & 0xf);
433   *buf++ = tohex (regno & 0xf);
434   *buf++ = ':';
435   convert_int_to_ascii (&registers[REGISTER_BYTE (regno)], buf, regsize);
436   buf += 2 * regsize;
437   *buf++ = ';';
438
439   return buf;
440 }
441
442 void
443 prepare_resume_reply (char *buf, char status, unsigned char signo)
444 {
445   int nib;
446
447   *buf++ = status;
448
449   /* FIXME!  Should be converting this signal number (numbered
450      according to the signal numbering of the system we are running on)
451      to the signal numbers used by the gdb protocol (see enum target_signal
452      in gdb/target.h).  */
453   nib = ((signo & 0xf0) >> 4);
454   *buf++ = tohex (nib);
455   nib = signo & 0x0f;
456   *buf++ = tohex (nib);
457
458   if (status == 'T')
459     {
460 #ifdef GDBSERVER_RESUME_REGS
461       static int gdbserver_resume_regs[] = GDBSERVER_RESUME_REGS ;
462       int i;
463       for (i = 0; 
464            i < sizeof (gdbserver_resume_regs) 
465                 / sizeof (gdbserver_resume_regs[0]);
466            i++)
467         {
468           int regnum = gdbserver_resume_regs[i];
469           buf = outreg (regnum, buf);
470         }
471 #else /* !defined(GDBSERVER_RESUME_REGS) */
472       buf = outreg (PC_REGNUM, buf);
473       buf = outreg (FP_REGNUM, buf);
474       buf = outreg (SP_REGNUM, buf);
475       if (NPC_REGNUM >= 0)
476         buf = outreg (NPC_REGNUM, buf);
477 #ifdef O7_REGNUM
478       buf = outreg (O7_REGNUM, buf);
479 #endif
480 #endif /* GDBSERVER_RESUME_REGS */
481
482       /* If the debugger hasn't used any thread features, don't burden it with
483          threads.  If we didn't check this, GDB 4.13 and older would choke.  */
484       if (cont_thread != 0)
485         {
486           if (old_thread_from_wait != thread_from_wait)
487             {
488               sprintf (buf, "thread:%x;", thread_from_wait);
489               buf += strlen (buf);
490               old_thread_from_wait = thread_from_wait;
491             }
492         }
493     }
494   /* For W and X, we're done.  */
495   *buf++ = 0;
496 }
497
498 void
499 decode_m_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr)
500 {
501   int i = 0, j = 0;
502   char ch;
503   *mem_addr_ptr = *len_ptr = 0;
504
505   while ((ch = from[i++]) != ',')
506     {
507       *mem_addr_ptr = *mem_addr_ptr << 4;
508       *mem_addr_ptr |= fromhex (ch) & 0x0f;
509     }
510
511   for (j = 0; j < 4; j++)
512     {
513       if ((ch = from[i++]) == 0)
514         break;
515       *len_ptr = *len_ptr << 4;
516       *len_ptr |= fromhex (ch) & 0x0f;
517     }
518 }
519
520 void
521 decode_M_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr,
522                  char *to)
523 {
524   int i = 0;
525   char ch;
526   *mem_addr_ptr = *len_ptr = 0;
527
528   while ((ch = from[i++]) != ',')
529     {
530       *mem_addr_ptr = *mem_addr_ptr << 4;
531       *mem_addr_ptr |= fromhex (ch) & 0x0f;
532     }
533
534   while ((ch = from[i++]) != ':')
535     {
536       *len_ptr = *len_ptr << 4;
537       *len_ptr |= fromhex (ch) & 0x0f;
538     }
539
540   convert_ascii_to_int (&from[i++], to, *len_ptr);
541 }