GDB (xrefs)
/tmp/gdb-7.10/gdb/ser-tcp.c
Go to the documentation of this file.
1 /* Serial interface for raw TCP connections on Un*x like systems.
2 
3  Copyright (C) 1992-2015 Free Software Foundation, Inc.
4 
5  This file is part of GDB.
6 
7  This program is free software; you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation; either version 3 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 #include "defs.h"
21 #include "serial.h"
22 #include "ser-base.h"
23 #include "ser-tcp.h"
24 #include "gdbcmd.h"
25 #include "cli/cli-decode.h"
26 #include "cli/cli-setshow.h"
27 #include "filestuff.h"
28 
29 #include <sys/types.h>
30 
31 #ifdef HAVE_SYS_FILIO_H
32 #include <sys/filio.h> /* For FIONBIO. */
33 #endif
34 #ifdef HAVE_SYS_IOCTL_H
35 #include <sys/ioctl.h> /* For FIONBIO. */
36 #endif
37 
38 #include <sys/time.h>
39 
40 #ifdef USE_WIN32API
41 #include <winsock2.h>
42 #ifndef ETIMEDOUT
43 #define ETIMEDOUT WSAETIMEDOUT
44 #endif
45 #define close(fd) closesocket (fd)
46 #define ioctl ioctlsocket
47 #else
48 #include <netinet/in.h>
49 #include <arpa/inet.h>
50 #include <netdb.h>
51 #include <sys/socket.h>
52 #include <netinet/tcp.h>
53 #endif
54 
55 #include <signal.h>
56 #include "gdb_select.h"
57 
58 #ifndef HAVE_SOCKLEN_T
59 typedef int socklen_t;
60 #endif
61 
62 void _initialize_ser_tcp (void);
63 
64 /* For "set tcp" and "show tcp". */
65 
68 
69 /* Whether to auto-retry refused connections. */
70 
71 static int tcp_auto_retry = 1;
72 
73 /* Timeout period for connections, in seconds. */
74 
75 static unsigned int tcp_retry_limit = 15;
76 
77 /* How many times per second to poll deprecated_ui_loop_hook. */
78 
79 #define POLL_INTERVAL 5
80 
81 /* Helper function to wait a while. If SCB is non-null, wait on its
82  file descriptor. Otherwise just wait on a timeout, updating *POLLS.
83  Returns -1 on timeout or interrupt, otherwise the value of select. */
84 
85 static int
86 wait_for_connect (struct serial *scb, unsigned int *polls)
87 {
88  struct timeval t;
89  int n;
90 
91  /* While we wait for the connect to complete,
92  poll the UI so it can update or the user can
93  interrupt. */
95  {
96  errno = EINTR;
97  return -1;
98  }
99 
100  /* Check for timeout. */
101  if (*polls > tcp_retry_limit * POLL_INTERVAL)
102  {
103  errno = ETIMEDOUT;
104  return -1;
105  }
106 
107  /* Back off to polling once per second after the first POLL_INTERVAL
108  polls. */
109  if (*polls < POLL_INTERVAL)
110  {
111  t.tv_sec = 0;
112  t.tv_usec = 1000000 / POLL_INTERVAL;
113  }
114  else
115  {
116  t.tv_sec = 1;
117  t.tv_usec = 0;
118  }
119 
120  if (scb)
121  {
122  fd_set rset, wset, eset;
123 
124  FD_ZERO (&rset);
125  FD_SET (scb->fd, &rset);
126  wset = rset;
127  eset = rset;
128 
129  /* POSIX systems return connection success or failure by signalling
130  wset. Windows systems return success in wset and failure in
131  eset.
132 
133  We must call select here, rather than gdb_select, because
134  the serial structure has not yet been initialized - the
135  MinGW select wrapper will not know that this FD refers
136  to a socket. */
137  n = select (scb->fd + 1, &rset, &wset, &eset, &t);
138  }
139  else
140  /* Use gdb_select here, since we have no file descriptors, and on
141  Windows, plain select doesn't work in that case. */
142  n = gdb_select (0, NULL, NULL, NULL, &t);
143 
144  /* If we didn't time out, only count it as one poll. */
145  if (n > 0 || *polls < POLL_INTERVAL)
146  (*polls)++;
147  else
148  (*polls) += POLL_INTERVAL;
149 
150  return n;
151 }
152 
153 /* Open a tcp socket. */
154 
155 int
156 net_open (struct serial *scb, const char *name)
157 {
158  char *port_str, hostname[100];
159  int n, port, tmp;
160  int use_udp;
161  struct hostent *hostent;
162  struct sockaddr_in sockaddr;
163 #ifdef USE_WIN32API
164  u_long ioarg;
165 #else
166  int ioarg;
167 #endif
168  unsigned int polls = 0;
169 
170  use_udp = 0;
171  if (startswith (name, "udp:"))
172  {
173  use_udp = 1;
174  name = name + 4;
175  }
176  else if (startswith (name, "tcp:"))
177  name = name + 4;
178 
179  port_str = strchr (name, ':');
180 
181  if (!port_str)
182  error (_("net_open: No colon in host name!")); /* Shouldn't ever
183  happen. */
184 
185  tmp = min (port_str - name, (int) sizeof hostname - 1);
186  strncpy (hostname, name, tmp); /* Don't want colon. */
187  hostname[tmp] = '\000'; /* Tie off host name. */
188  port = atoi (port_str + 1);
189 
190  /* Default hostname is localhost. */
191  if (!hostname[0])
192  strcpy (hostname, "localhost");
193 
194  hostent = gethostbyname (hostname);
195  if (!hostent)
196  {
197  fprintf_unfiltered (gdb_stderr, "%s: unknown host\n", hostname);
198  errno = ENOENT;
199  return -1;
200  }
201 
202  sockaddr.sin_family = PF_INET;
203  sockaddr.sin_port = htons (port);
204  memcpy (&sockaddr.sin_addr.s_addr, hostent->h_addr,
205  sizeof (struct in_addr));
206 
207  retry:
208 
209  if (use_udp)
210  scb->fd = gdb_socket_cloexec (PF_INET, SOCK_DGRAM, 0);
211  else
212  scb->fd = gdb_socket_cloexec (PF_INET, SOCK_STREAM, 0);
213 
214  if (scb->fd == -1)
215  return -1;
216 
217  /* Set socket nonblocking. */
218  ioarg = 1;
219  ioctl (scb->fd, FIONBIO, &ioarg);
220 
221  /* Use Non-blocking connect. connect() will return 0 if connected
222  already. */
223  n = connect (scb->fd, (struct sockaddr *) &sockaddr, sizeof (sockaddr));
224 
225  if (n < 0)
226  {
227 #ifdef USE_WIN32API
228  int err = WSAGetLastError();
229 #else
230  int err = errno;
231 #endif
232 
233  /* Maybe we're waiting for the remote target to become ready to
234  accept connections. */
235  if (tcp_auto_retry
236 #ifdef USE_WIN32API
237  && err == WSAECONNREFUSED
238 #else
239  && err == ECONNREFUSED
240 #endif
241  && wait_for_connect (NULL, &polls) >= 0)
242  {
243  close (scb->fd);
244  goto retry;
245  }
246 
247  if (
248 #ifdef USE_WIN32API
249  /* Under Windows, calling "connect" with a non-blocking socket
250  results in WSAEWOULDBLOCK, not WSAEINPROGRESS. */
251  err != WSAEWOULDBLOCK
252 #else
253  err != EINPROGRESS
254 #endif
255  )
256  {
257  errno = err;
258  net_close (scb);
259  return -1;
260  }
261 
262  /* Looks like we need to wait for the connect. */
263  do
264  {
265  n = wait_for_connect (scb, &polls);
266  }
267  while (n == 0);
268  if (n < 0)
269  {
270  net_close (scb);
271  return -1;
272  }
273  }
274 
275  /* Got something. Is it an error? */
276  {
277  int res, err;
278  socklen_t len;
279 
280  len = sizeof (err);
281  /* On Windows, the fourth parameter to getsockopt is a "char *";
282  on UNIX systems it is generally "void *". The cast to "void *"
283  is OK everywhere, since in C "void *" can be implicitly
284  converted to any pointer type. */
285  res = getsockopt (scb->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len);
286  if (res < 0 || err)
287  {
288  /* Maybe the target still isn't ready to accept the connection. */
289  if (tcp_auto_retry
290 #ifdef USE_WIN32API
291  && err == WSAECONNREFUSED
292 #else
293  && err == ECONNREFUSED
294 #endif
295  && wait_for_connect (NULL, &polls) >= 0)
296  {
297  close (scb->fd);
298  goto retry;
299  }
300  if (err)
301  errno = err;
302  net_close (scb);
303  return -1;
304  }
305  }
306 
307  /* Turn off nonblocking. */
308  ioarg = 0;
309  ioctl (scb->fd, FIONBIO, &ioarg);
310 
311  if (use_udp == 0)
312  {
313  /* Disable Nagle algorithm. Needed in some cases. */
314  tmp = 1;
315  setsockopt (scb->fd, IPPROTO_TCP, TCP_NODELAY,
316  (char *)&tmp, sizeof (tmp));
317  }
318 
319 #ifdef SIGPIPE
320  /* If we don't do this, then GDB simply exits
321  when the remote side dies. */
322  signal (SIGPIPE, SIG_IGN);
323 #endif
324 
325  return 0;
326 }
327 
328 void
329 net_close (struct serial *scb)
330 {
331  if (scb->fd == -1)
332  return;
333 
334  close (scb->fd);
335  scb->fd = -1;
336 }
337 
338 int
339 net_read_prim (struct serial *scb, size_t count)
340 {
341  /* Need to cast to silence -Wpointer-sign on MinGW, as Winsock's
342  'recv' takes 'char *' as second argument, while 'scb->buf' is
343  'unsigned char *'. */
344  return recv (scb->fd, (void *) scb->buf, count, 0);
345 }
346 
347 int
348 net_write_prim (struct serial *scb, const void *buf, size_t count)
349 {
350  return send (scb->fd, buf, count, 0);
351 }
352 
353 int
355 {
356  /* Send telnet IAC and BREAK characters. */
357  return (serial_write (scb, "\377\363", 2));
358 }
359 
360 /* Support for "set tcp" and "show tcp" commands. */
361 
362 static void
363 set_tcp_cmd (char *args, int from_tty)
364 {
365  help_list (tcp_set_cmdlist, "set tcp ", all_commands, gdb_stdout);
366 }
367 
368 static void
369 show_tcp_cmd (char *args, int from_tty)
370 {
371  help_list (tcp_show_cmdlist, "show tcp ", all_commands, gdb_stdout);
372 }
373 
374 #ifndef USE_WIN32API
375 
376 /* The TCP ops. */
377 
378 static const struct serial_ops tcp_ops =
379 {
380  "tcp",
381  net_open,
382  net_close,
383  NULL,
389  ser_base_raw,
402 };
403 
404 #endif /* USE_WIN32API */
405 
406 void
408 {
409 #ifdef USE_WIN32API
410  /* Do nothing; the TCP serial operations will be initialized in
411  ser-mingw.c. */
412 #else
413  serial_add_interface (&tcp_ops);
414 #endif /* USE_WIN32API */
415 
417 TCP protocol specific variables\n\
418 Configure variables specific to remote TCP connections"),
419  &tcp_set_cmdlist, "set tcp ",
420  0 /* allow-unknown */, &setlist);
422 TCP protocol specific variables\n\
423 Configure variables specific to remote TCP connections"),
424  &tcp_show_cmdlist, "show tcp ",
425  0 /* allow-unknown */, &showlist);
426 
427  add_setshow_boolean_cmd ("auto-retry", class_obscure,
428  &tcp_auto_retry, _("\
429 Set auto-retry on socket connect"), _("\
430 Show auto-retry on socket connect"),
431  NULL, NULL, NULL,
432  &tcp_set_cmdlist, &tcp_show_cmdlist);
433 
434  add_setshow_uinteger_cmd ("connect-timeout", class_obscure,
435  &tcp_retry_limit, _("\
436 Set timeout limit in seconds for socket connection"), _("\
437 Show timeout limit in seconds for socket connection"), _("\
438 If set to \"unlimited\", GDB will keep attempting to establish a\n\
439 connection forever, unless interrupted with Ctrl-c.\n\
440 The default is 15 seconds."),
441  NULL, NULL,
442  &tcp_set_cmdlist, &tcp_show_cmdlist);
443 }
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:338
int ser_base_set_tty_state(struct serial *scb, serial_ttystate ttystate)
Definition: ser-base.c:510
int ser_base_flush_output(struct serial *scb)
Definition: ser-base.c:459
struct ui_file * gdb_stdout
Definition: main.c:71
int net_write_prim(struct serial *scb, const void *buf, size_t count)
Definition: ser-tcp.c:348
static int tcp_auto_retry
Definition: ser-tcp.c:71
int serial_write(struct serial *scb, const void *buf, size_t count)
Definition: serial.c:403
int ser_base_setbaudrate(struct serial *scb, int rate)
Definition: ser-base.c:533
#define _(String)
Definition: gdb_locale.h:40
int gdb_socket_cloexec(int domain, int style, int protocol)
Definition: filestuff.c:367
int ser_base_setstopbits(struct serial *scb, int num)
Definition: ser-base.c:539
static unsigned int tcp_retry_limit
Definition: ser-tcp.c:75
void ser_base_raw(struct serial *scb)
Definition: ser-base.c:490
void ser_base_async(struct serial *scb, int async_p)
Definition: ser-base.c:555
struct cmd_list_element * setlist
Definition: cli-cmds.c:135
const char *const name
Definition: aarch64-tdep.c:68
int net_read_prim(struct serial *scb, size_t count)
Definition: ser-tcp.c:339
unsigned long u_long
Definition: ser-go32.c:130
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t err
Definition: gnu-nat.c:1816
void add_setshow_uinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:694
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
struct cmd_list_element * showlist
Definition: cli-cmds.c:143
int ser_base_noflush_set_tty_state(struct serial *scb, serial_ttystate new_ttystate, serial_ttystate old_ttystate)
Definition: ser-base.c:516
static void set_tcp_cmd(char *args, int from_tty)
Definition: ser-tcp.c:363
#define min(a, b)
Definition: defs.h:106
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:75
Definition: serial.h:227
int gdb_select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
Definition: mingw-hdep.c:59
static struct cmd_list_element * tcp_show_cmdlist
Definition: ser-tcp.c:67
void _initialize_ser_tcp(void)
Definition: ser-tcp.c:407
int ser_base_drain_output(struct serial *scb)
Definition: ser-base.c:484
unsigned char buf[BUFSIZ]
Definition: serial.h:245
static struct cmd_list_element * tcp_set_cmdlist
Definition: ser-tcp.c:66
static int wait_for_connect(struct serial *scb, unsigned int *polls)
Definition: ser-tcp.c:86
static void show_tcp_cmd(char *args, int from_tty)
Definition: ser-tcp.c:369
void ser_base_print_tty_state(struct serial *scb, serial_ttystate ttystate, struct ui_file *stream)
Definition: ser-base.c:524
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
Definition: cli-decode.c:1023
int ser_base_setparity(struct serial *scb, int parity)
Definition: ser-base.c:547
void serial_add_interface(const struct serial_ops *optable)
Definition: serial.c:162
struct ui_file * gdb_stderr
Definition: main.c:72
int ser_base_flush_input(struct serial *scb)
Definition: ser-base.c:465
int ser_base_readchar(struct serial *scb, int timeout)
Definition: ser-base.c:435
#define POLL_INTERVAL
Definition: ser-tcp.c:79
int fd
Definition: serial.h:233
int ser_base_write(struct serial *scb, const void *buf, size_t count)
Definition: ser-base.c:441
void net_close(struct serial *scb)
Definition: ser-tcp.c:329
int ser_tcp_send_break(struct serial *scb)
Definition: ser-tcp.c:354
serial_ttystate ser_base_copy_tty_state(struct serial *scb, serial_ttystate ttystate)
Definition: ser-base.c:503
void error(const char *fmt,...)
Definition: errors.c:38
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:541
int(* deprecated_ui_loop_hook)(int signo)
Definition: top.c:180
serial_ttystate ser_base_get_tty_state(struct serial *scb)
Definition: ser-base.c:496
const ULONGEST const LONGEST len
Definition: target.h:309
int net_open(struct serial *scb, const char *name)
Definition: ser-tcp.c:156