X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fser-tcp.c;h=f40bfce42bf5205e1ace3fe0262d96ffba0bec41;hb=aef525cb15cdf95759c015cf237d6337407aa47a;hp=f492bc13ccd7987181ddc2ddb199659ddff11c6a;hpb=704deef2c0830b00aca6614989cf7944b38ebeba;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/ser-tcp.c b/gdb/ser-tcp.c index f492bc13cc..f40bfce42b 100644 --- a/gdb/ser-tcp.c +++ b/gdb/ser-tcp.c @@ -1,326 +1,438 @@ -/* Serial interface for raw TCP connections on Un*x like systems - Copyright 1992, 1993 Free Software Foundation, Inc. +/* Serial interface for raw TCP connections on Un*x like systems. -This file is part of GDB. + Copyright (C) 1992-2013 Free Software Foundation, Inc. -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 file is part of GDB. -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. + 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 3 of the License, or + (at your option) any later version. -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., 675 Mass Ave, Cambridge, MA 02139, USA. */ + 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, see . */ #include "defs.h" #include "serial.h" +#include "ser-base.h" +#include "ser-tcp.h" +#include "gdbcmd.h" +#include "cli/cli-decode.h" +#include "cli/cli-setshow.h" +#include "filestuff.h" + #include + +#ifdef HAVE_SYS_FILIO_H +#include /* For FIONBIO. */ +#endif +#ifdef HAVE_SYS_IOCTL_H +#include /* For FIONBIO. */ +#endif + #include + +#ifdef USE_WIN32API +#include +#ifndef ETIMEDOUT +#define ETIMEDOUT WSAETIMEDOUT +#endif +#define close(fd) closesocket (fd) +#define ioctl ioctlsocket +#else #include #include #include #include #include -#include "signals.h" +#endif -struct tcp_ttystate -{ - int bogus; -}; - -static int tcp_open PARAMS ((serial_t scb, const char *name)); -static void tcp_raw PARAMS ((serial_t scb)); -static int wait_for PARAMS ((serial_t scb, int timeout)); -static int tcp_readchar PARAMS ((serial_t scb, int timeout)); -static int tcp_setbaudrate PARAMS ((serial_t scb, int rate)); -static int tcp_write PARAMS ((serial_t scb, const char *str, int len)); -static void tcp_restore PARAMS ((serial_t scb)); -static void tcp_close PARAMS ((serial_t scb)); -static serial_ttystate tcp_get_tty_state PARAMS ((serial_t scb)); -static int tcp_set_tty_state PARAMS ((serial_t scb, serial_ttystate state)); - -/* Open up a raw tcp socket */ +#include +#include "gdb_string.h" +#include "gdb_select.h" -static int -tcp_open(scb, name) - serial_t scb; - const char *name; -{ - char *port_str; - int port; - struct hostent *hostent; - struct sockaddr_in sockaddr; - int tmp; - char hostname[100]; - struct protoent *protoent; +#ifndef HAVE_SOCKLEN_T +typedef int socklen_t; +#endif - port_str = strchr (name, ':'); +void _initialize_ser_tcp (void); - if (!port_str) - error ("tcp_open: No colon in host name!"); /* Shouldn't ever happen */ +/* For "set tcp" and "show tcp". */ - tmp = min (port_str - name, sizeof hostname - 1); - strncpy (hostname, name, tmp); /* Don't want colon */ - hostname[tmp] = '\000'; /* Tie off host name */ - port = atoi (port_str + 1); +static struct cmd_list_element *tcp_set_cmdlist; +static struct cmd_list_element *tcp_show_cmdlist; - hostent = gethostbyname (hostname); +/* Whether to auto-retry refused connections. */ - if (!hostent) - { - fprintf (stderr, "%s: unknown host\n", hostname); - errno = ENOENT; - return -1; - } +static int tcp_auto_retry = 1; - scb->fd = socket (PF_INET, SOCK_STREAM, 0); - if (scb->fd < 0) - return -1; +/* Timeout period for connections, in seconds. */ - /* Allow rapid reuse of this port. */ - tmp = 1; - setsockopt (scb->fd, SOL_SOCKET, SO_REUSEADDR, (char *)&tmp, sizeof(tmp)); +static unsigned int tcp_retry_limit = 15; - /* Enable TCP keep alive process. */ - tmp = 1; - setsockopt (scb->fd, SOL_SOCKET, SO_KEEPALIVE, (char *)&tmp, sizeof(tmp)); +/* How many times per second to poll deprecated_ui_loop_hook. */ - sockaddr.sin_family = PF_INET; - sockaddr.sin_port = htons(port); - memcpy (&sockaddr.sin_addr.s_addr, hostent->h_addr, - sizeof (struct in_addr)); +#define POLL_INTERVAL 5 - if (connect (scb->fd, &sockaddr, sizeof(sockaddr))) - { - close(scb->fd); - scb->fd = -1; - return -1; - } - - protoent = getprotobyname ("tcp"); - if (!protoent) - return -1; - - tmp = 1; - if (setsockopt (scb->fd, protoent->p_proto, TCP_NODELAY, - (char *)&tmp, sizeof(tmp))) - return -1; - - signal(SIGPIPE, SIG_IGN); /* If we don't do this, then GDB simply exits - when the remote side dies. */ - - return 0; -} - -static serial_ttystate -tcp_get_tty_state(scb) - serial_t scb; -{ - struct tcp_ttystate *state; - - state = (struct tcp_ttystate *)xmalloc(sizeof *state); - - return (serial_ttystate)state; -} +/* Helper function to wait a while. If SCB is non-null, wait on its + file descriptor. Otherwise just wait on a timeout, updating *POLLS. + Returns -1 on timeout or interrupt, otherwise the value of select. */ static int -tcp_set_tty_state(scb, ttystate) - serial_t scb; - serial_ttystate ttystate; +wait_for_connect (struct serial *scb, unsigned int *polls) { - struct tcp_ttystate *state; + struct timeval t; + int n; - state = (struct tcp_ttystate *)ttystate; + /* While we wait for the connect to complete, + poll the UI so it can update or the user can + interrupt. */ + if (deprecated_ui_loop_hook && deprecated_ui_loop_hook (0)) + { + errno = EINTR; + return -1; + } - return 0; -} + /* Check for timeout. */ + if (*polls > tcp_retry_limit * POLL_INTERVAL) + { + errno = ETIMEDOUT; + return -1; + } -static int -tcp_return_0 (scb) - serial_t scb; -{ - return 0; -} + /* Back off to polling once per second after the first POLL_INTERVAL + polls. */ + if (*polls < POLL_INTERVAL) + { + t.tv_sec = 0; + t.tv_usec = 1000000 / POLL_INTERVAL; + } + else + { + t.tv_sec = 1; + t.tv_usec = 0; + } -static void -tcp_raw(scb) - serial_t scb; -{ - return; /* Always in raw mode */ + if (scb) + { + fd_set rset, wset, eset; + + FD_ZERO (&rset); + FD_SET (scb->fd, &rset); + wset = rset; + eset = rset; + + /* POSIX systems return connection success or failure by signalling + wset. Windows systems return success in wset and failure in + eset. + + We must call select here, rather than gdb_select, because + the serial structure has not yet been initialized - the + MinGW select wrapper will not know that this FD refers + to a socket. */ + n = select (scb->fd + 1, &rset, &wset, &eset, &t); + } + else + /* Use gdb_select here, since we have no file descriptors, and on + Windows, plain select doesn't work in that case. */ + n = gdb_select (0, NULL, NULL, NULL, &t); + + /* If we didn't time out, only count it as one poll. */ + if (n > 0 || *polls < POLL_INTERVAL) + (*polls)++; + else + (*polls) += POLL_INTERVAL; + + return n; } -/* Wait for input on scb, with timeout seconds. Returns 0 on success, - otherwise SERIAL_TIMEOUT or SERIAL_ERROR. - - For termio{s}, we actually just setup VTIME if necessary, and let the - timeout occur in the read() in tcp_read(). - */ +/* Open a tcp socket. */ -static int -wait_for(scb, timeout) - serial_t scb; - int timeout; +int +net_open (struct serial *scb, const char *name) { - int numfds; - struct timeval tv; - fd_set readfds, exceptfds; + char *port_str, hostname[100]; + int n, port, tmp; + int use_udp; + struct hostent *hostent; + struct sockaddr_in sockaddr; +#ifdef USE_WIN32API + u_long ioarg; +#else + int ioarg; +#endif + unsigned int polls = 0; + + use_udp = 0; + if (strncmp (name, "udp:", 4) == 0) + { + use_udp = 1; + name = name + 4; + } + else if (strncmp (name, "tcp:", 4) == 0) + name = name + 4; - FD_ZERO (&readfds); - FD_ZERO (&exceptfds); + port_str = strchr (name, ':'); - tv.tv_sec = timeout; - tv.tv_usec = 0; + if (!port_str) + error (_("net_open: No colon in host name!")); /* Shouldn't ever + happen. */ - FD_SET(scb->fd, &readfds); - FD_SET(scb->fd, &exceptfds); + tmp = min (port_str - name, (int) sizeof hostname - 1); + strncpy (hostname, name, tmp); /* Don't want colon. */ + hostname[tmp] = '\000'; /* Tie off host name. */ + port = atoi (port_str + 1); + + /* Default hostname is localhost. */ + if (!hostname[0]) + strcpy (hostname, "localhost"); - while (1) + hostent = gethostbyname (hostname); + if (!hostent) { - if (timeout >= 0) - numfds = select(scb->fd+1, &readfds, 0, &exceptfds, &tv); - else - numfds = select(scb->fd+1, &readfds, 0, &exceptfds, 0); - - if (numfds <= 0) - if (numfds == 0) - return SERIAL_TIMEOUT; - else if (errno == EINTR) - continue; - else - return SERIAL_ERROR; /* Got an error from select or poll */ - - return 0; + fprintf_unfiltered (gdb_stderr, "%s: unknown host\n", hostname); + errno = ENOENT; + return -1; } -} -/* Read a character with user-specified timeout. TIMEOUT is number of seconds - to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns - char if successful. Returns -2 if timeout expired, EOF if line dropped - dead, or -3 for any other error (see errno in that case). */ + sockaddr.sin_family = PF_INET; + sockaddr.sin_port = htons (port); + memcpy (&sockaddr.sin_addr.s_addr, hostent->h_addr, + sizeof (struct in_addr)); -static int -tcp_readchar(scb, timeout) - serial_t scb; - int timeout; -{ - int status; + retry: - if (scb->bufcnt-- > 0) - return *scb->bufp++; + if (use_udp) + scb->fd = gdb_socket_cloexec (PF_INET, SOCK_DGRAM, 0); + else + scb->fd = gdb_socket_cloexec (PF_INET, SOCK_STREAM, 0); - status = wait_for(scb, timeout); + if (scb->fd == -1) + return -1; + + /* Set socket nonblocking. */ + ioarg = 1; + ioctl (scb->fd, FIONBIO, &ioarg); - if (status < 0) - return status; + /* Use Non-blocking connect. connect() will return 0 if connected + already. */ + n = connect (scb->fd, (struct sockaddr *) &sockaddr, sizeof (sockaddr)); - scb->bufcnt = read(scb->fd, scb->buf, BUFSIZ); + if (n < 0) + { +#ifdef USE_WIN32API + int err = WSAGetLastError(); +#else + int err = errno; +#endif + + /* Maybe we're waiting for the remote target to become ready to + accept connections. */ + if (tcp_auto_retry +#ifdef USE_WIN32API + && err == WSAECONNREFUSED +#else + && err == ECONNREFUSED +#endif + && wait_for_connect (NULL, &polls) >= 0) + { + close (scb->fd); + goto retry; + } + + if ( +#ifdef USE_WIN32API + /* Under Windows, calling "connect" with a non-blocking socket + results in WSAEWOULDBLOCK, not WSAEINPROGRESS. */ + err != WSAEWOULDBLOCK +#else + err != EINPROGRESS +#endif + ) + { + errno = err; + net_close (scb); + return -1; + } + + /* Looks like we need to wait for the connect. */ + do + { + n = wait_for_connect (scb, &polls); + } + while (n == 0); + if (n < 0) + { + net_close (scb); + return -1; + } + } - if (scb->bufcnt <= 0) - if (scb->bufcnt == 0) - return SERIAL_TIMEOUT; /* 0 chars means timeout [may need to - distinguish between EOF & timeouts - someday] */ - else - return SERIAL_ERROR; /* Got an error from read */ + /* Got something. Is it an error? */ + { + int res, err; + socklen_t len; + + len = sizeof (err); + /* On Windows, the fourth parameter to getsockopt is a "char *"; + on UNIX systems it is generally "void *". The cast to "void *" + is OK everywhere, since in C "void *" can be implicitly + converted to any pointer type. */ + res = getsockopt (scb->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len); + if (res < 0 || err) + { + /* Maybe the target still isn't ready to accept the connection. */ + if (tcp_auto_retry +#ifdef USE_WIN32API + && err == WSAECONNREFUSED +#else + && err == ECONNREFUSED +#endif + && wait_for_connect (NULL, &polls) >= 0) + { + close (scb->fd); + goto retry; + } + if (err) + errno = err; + net_close (scb); + return -1; + } + } + + /* Turn off nonblocking. */ + ioarg = 0; + ioctl (scb->fd, FIONBIO, &ioarg); + + if (use_udp == 0) + { + /* Disable Nagle algorithm. Needed in some cases. */ + tmp = 1; + setsockopt (scb->fd, IPPROTO_TCP, TCP_NODELAY, + (char *)&tmp, sizeof (tmp)); + } - scb->bufcnt--; - scb->bufp = scb->buf; - return *scb->bufp++; -} +#ifdef SIGPIPE + /* If we don't do this, then GDB simply exits + when the remote side dies. */ + signal (SIGPIPE, SIG_IGN); +#endif -static int -tcp_noflush_set_tty_state (scb, new_ttystate, old_ttystate) - serial_t scb; - serial_ttystate new_ttystate; - serial_ttystate old_ttystate; -{ return 0; } -static void -tcp_print_tty_state (scb, ttystate) - serial_t scb; - serial_ttystate ttystate; +void +net_close (struct serial *scb) { - /* Nothing to print. */ - return; + if (scb->fd == -1) + return; + + close (scb->fd); + scb->fd = -1; } -static int -tcp_setbaudrate(scb, rate) - serial_t scb; - int rate; +int +net_read_prim (struct serial *scb, size_t count) { - return 0; /* Never fails! */ + /* Need to cast to silence -Wpointer-sign on MinGW, as Winsock's + 'recv' takes 'char *' as second argument, while 'scb->buf' is + 'unsigned char *'. */ + return recv (scb->fd, (void *) scb->buf, count, 0); } -static int -tcp_set_process_group (scb, ttystate, group) - serial_t scb; - serial_ttystate ttystate; - int group; +int +net_write_prim (struct serial *scb, const void *buf, size_t count) { - return 0; + return send (scb->fd, buf, count, 0); } -static int -tcp_write(scb, str, len) - serial_t scb; - const char *str; - int len; +int +ser_tcp_send_break (struct serial *scb) { - int cc; + /* Send telnet IAC and BREAK characters. */ + return (serial_write (scb, "\377\363", 2)); +} - while (len > 0) - { - cc = write(scb->fd, str, len); +/* Support for "set tcp" and "show tcp" commands. */ - if (cc < 0) - return 1; - len -= cc; - str += cc; - } - return 0; +static void +set_tcp_cmd (char *args, int from_tty) +{ + help_list (tcp_set_cmdlist, "set tcp ", -1, gdb_stdout); } static void -tcp_close(scb) - serial_t scb; +show_tcp_cmd (char *args, int from_tty) { - if (scb->fd < 0) - return; - - close(scb->fd); - scb->fd = -1; + help_list (tcp_show_cmdlist, "show tcp ", -1, gdb_stdout); } -static struct serial_ops tcp_ops = -{ - "tcp", - 0, - tcp_open, - tcp_close, - tcp_readchar, - tcp_write, - tcp_return_0, /* flush output */ - tcp_return_0, /* flush input */ - tcp_return_0, /* send break */ - tcp_raw, - tcp_get_tty_state, - tcp_set_tty_state, - tcp_print_tty_state, - tcp_noflush_set_tty_state, - tcp_setbaudrate, - tcp_set_process_group -}; void -_initialize_ser_tcp () +_initialize_ser_tcp (void) { - serial_add_interface (&tcp_ops); +#ifdef USE_WIN32API + /* Do nothing; the TCP serial operations will be initialized in + ser-mingw.c. */ +#else + struct serial_ops *ops; + + ops = XMALLOC (struct serial_ops); + memset (ops, 0, sizeof (struct serial_ops)); + ops->name = "tcp"; + ops->next = 0; + ops->open = net_open; + ops->close = net_close; + ops->readchar = ser_base_readchar; + ops->write = ser_base_write; + ops->flush_output = ser_base_flush_output; + ops->flush_input = ser_base_flush_input; + ops->send_break = ser_tcp_send_break; + ops->go_raw = ser_base_raw; + ops->get_tty_state = ser_base_get_tty_state; + ops->copy_tty_state = ser_base_copy_tty_state; + ops->set_tty_state = ser_base_set_tty_state; + ops->print_tty_state = ser_base_print_tty_state; + ops->noflush_set_tty_state = ser_base_noflush_set_tty_state; + ops->setbaudrate = ser_base_setbaudrate; + ops->setstopbits = ser_base_setstopbits; + ops->drain_output = ser_base_drain_output; + ops->async = ser_base_async; + ops->read_prim = net_read_prim; + ops->write_prim = net_write_prim; + serial_add_interface (ops); +#endif /* USE_WIN32API */ + + add_prefix_cmd ("tcp", class_maintenance, set_tcp_cmd, _("\ +TCP protocol specific variables\n\ +Configure variables specific to remote TCP connections"), + &tcp_set_cmdlist, "set tcp ", + 0 /* allow-unknown */, &setlist); + add_prefix_cmd ("tcp", class_maintenance, show_tcp_cmd, _("\ +TCP protocol specific variables\n\ +Configure variables specific to remote TCP connections"), + &tcp_show_cmdlist, "show tcp ", + 0 /* allow-unknown */, &showlist); + + add_setshow_boolean_cmd ("auto-retry", class_obscure, + &tcp_auto_retry, _("\ +Set auto-retry on socket connect"), _("\ +Show auto-retry on socket connect"), + NULL, NULL, NULL, + &tcp_set_cmdlist, &tcp_show_cmdlist); + + add_setshow_uinteger_cmd ("connect-timeout", class_obscure, + &tcp_retry_limit, _("\ +Set timeout limit in seconds for socket connection"), _("\ +Show timeout limit in seconds for socket connection"), _("\ +If set to \"unlimited\", GDB will keep attempting to establish a\n\ +connection forever, unless interrupted with Ctrl-c.\n\ +The default is 15 seconds."), + NULL, NULL, + &tcp_set_cmdlist, &tcp_show_cmdlist); }