X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fser-tcp.c;h=83a84fc7ac319d2a5b8c222a6219dc3a54e33d46;hb=c5aa993b1f4add48fbdc6cc3117059f616e49875;hp=6ff79aa3d4a670dc67b539e3be046ea3bad646c4;hpb=c2e247c4ff760324df53fe50a9ef9168fd5e9452;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/ser-tcp.c b/gdb/ser-tcp.c index 6ff79aa3d4..83a84fc7ac 100644 --- a/gdb/ser-tcp.c +++ b/gdb/ser-tcp.c @@ -1,21 +1,22 @@ /* Serial interface for raw TCP connections on Un*x like systems - Copyright 1992, 1993 Free Software Foundation, Inc. + Copyright 1992, 1993, 1998 Free Software Foundation, Inc. -This file is part of GDB. + 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 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. + 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., 675 Mass Ave, Cambridge, MA 02139, USA. */ + 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 "defs.h" #include "serial.h" @@ -25,29 +26,46 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include #include +#ifdef HAVE_UNISTD_H +#include +#endif + +#ifndef __CYGWIN32__ #include +#endif + #include "signals.h" +#include "gdb_string.h" + +extern int (*ui_loop_hook) PARAMS ((int)); struct tcp_ttystate -{ - int bogus; -}; + { + 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_setstopbits PARAMS ((serial_t scb, int num)); static int tcp_write PARAMS ((serial_t scb, const char *str, int len)); -static void tcp_restore PARAMS ((serial_t scb)); +/* FIXME: 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)); +static int tcp_return_0 PARAMS ((serial_t)); +static int tcp_noflush_set_tty_state PARAMS ((serial_t, serial_ttystate, + serial_ttystate)); +static void tcp_print_tty_state PARAMS ((serial_t, serial_ttystate)); + +void _initialize_ser_tcp PARAMS ((void)); /* Open up a raw tcp socket */ static int -tcp_open(scb, name) +tcp_open (scb, name) serial_t scb; const char *name; { @@ -58,14 +76,15 @@ tcp_open(scb, name) int tmp; char hostname[100]; struct protoent *protoent; + int i; port_str = strchr (name, ':'); if (!port_str) - error ("tcp_open: No colon in host name!"); /* Shouldn't ever happen */ + error ("tcp_open: No colon in host name!"); /* Shouldn't ever happen */ - tmp = min (port_str - name, sizeof hostname - 1); - strncpy (hostname, name, tmp); /* Don't want colon */ + 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); @@ -73,33 +92,43 @@ tcp_open(scb, name) if (!hostent) { - fprintf (stderr, "%s: unknown host\n", hostname); + fprintf_unfiltered (gdb_stderr, "%s: unknown host\n", hostname); errno = ENOENT; return -1; } - scb->fd = socket (PF_INET, SOCK_STREAM, 0); - if (scb->fd < 0) - return -1; + for (i = 1; i <= 15; i++) + { + scb->fd = socket (PF_INET, SOCK_STREAM, 0); + if (scb->fd < 0) + return -1; - /* Allow rapid reuse of this port. */ - tmp = 1; - setsockopt (scb->fd, SOL_SOCKET, SO_REUSEADDR, (char *)&tmp, sizeof(tmp)); + /* Allow rapid reuse of this port. */ + tmp = 1; + setsockopt (scb->fd, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp, sizeof (tmp)); - /* Enable TCP keep alive process. */ - tmp = 1; - setsockopt (scb->fd, SOL_SOCKET, SO_KEEPALIVE, (char *)&tmp, sizeof(tmp)); + /* Enable TCP keep alive process. */ + tmp = 1; + setsockopt (scb->fd, SOL_SOCKET, SO_KEEPALIVE, (char *) &tmp, sizeof (tmp)); - sockaddr.sin_family = PF_INET; - sockaddr.sin_port = htons(port); - memcpy (&sockaddr.sin_addr.s_addr, hostent->h_addr, - sizeof (struct in_addr)); + sockaddr.sin_family = PF_INET; + sockaddr.sin_port = htons (port); + memcpy (&sockaddr.sin_addr.s_addr, hostent->h_addr, + sizeof (struct in_addr)); - if (connect (scb->fd, &sockaddr, sizeof(sockaddr))) - { - close(scb->fd); + if (!connect (scb->fd, (struct sockaddr *) &sockaddr, sizeof (sockaddr))) + break; + + close (scb->fd); scb->fd = -1; - return -1; + +/* We retry for ECONNREFUSED because that is often a temporary condition, which + happens when the server is being restarted. */ + + if (errno != ECONNREFUSED) + return -1; + + sleep (1); } protoent = getprotobyname ("tcp"); @@ -108,49 +137,47 @@ tcp_open(scb, name) tmp = 1; if (setsockopt (scb->fd, protoent->p_proto, TCP_NODELAY, - (char *)&tmp, sizeof(tmp))) + (char *) &tmp, sizeof (tmp))) return -1; - signal(SIGPIPE, SIG_IGN); /* If we don't do this, then GDB simply exits + 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) +tcp_get_tty_state (scb) serial_t scb; { struct tcp_ttystate *state; - state = (struct tcp_ttystate *)xmalloc(sizeof *state); + state = (struct tcp_ttystate *) xmalloc (sizeof *state); - return (serial_ttystate)state; + return (serial_ttystate) state; } static int -tcp_set_tty_state(scb, ttystate) +tcp_set_tty_state (scb, ttystate) serial_t scb; serial_ttystate ttystate; { struct tcp_ttystate *state; - state = (struct tcp_ttystate *)ttystate; + state = (struct tcp_ttystate *) ttystate; return 0; } static int -tcp_flush_output (scb) +tcp_return_0 (scb) serial_t scb; { - /* This is only used by utils.c on stdout, so it doesn't need to work - for tcp. */ return 0; } static void -tcp_raw(scb) +tcp_raw (scb) serial_t scb; { return; /* Always in raw mode */ @@ -164,7 +191,7 @@ tcp_raw(scb) */ static int -wait_for(scb, timeout) +wait_for (scb, timeout) serial_t scb; int timeout; { @@ -178,23 +205,25 @@ wait_for(scb, timeout) tv.tv_sec = timeout; tv.tv_usec = 0; - FD_SET(scb->fd, &readfds); - FD_SET(scb->fd, &exceptfds); + FD_SET (scb->fd, &readfds); + FD_SET (scb->fd, &exceptfds); while (1) { if (timeout >= 0) - numfds = select(scb->fd+1, &readfds, 0, &exceptfds, &tv); + numfds = select (scb->fd + 1, &readfds, 0, &exceptfds, &tv); else - numfds = select(scb->fd+1, &readfds, 0, &exceptfds, 0); + 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 */ + { + if (numfds == 0) + return SERIAL_TIMEOUT; + else if (errno == EINTR) + continue; + else + return SERIAL_ERROR; /* Got an error from select or poll */ + } return 0; } @@ -206,29 +235,79 @@ wait_for(scb, timeout) dead, or -3 for any other error (see errno in that case). */ static int -tcp_readchar(scb, timeout) +tcp_readchar (scb, timeout) serial_t scb; int timeout; { int status; + int delta; if (scb->bufcnt-- > 0) return *scb->bufp++; - status = wait_for(scb, timeout); + /* We have to be able to keep the GUI alive here, so we break the original + timeout into steps of 1 second, running the "keep the GUI alive" hook + each time through the loop. + + Also, timeout = 0 means to poll, so we just set the delta to 0, so we + will only go through the loop once. */ + + delta = (timeout == 0 ? 0 : 1); + while (1) + { + + /* N.B. The UI may destroy our world (for instance by calling + remote_stop,) in which case we want to get out of here as + quickly as possible. It is not safe to touch scb, since + someone else might have freed it. The ui_loop_hook signals that + we should exit by returning 1. */ + + if (ui_loop_hook) + { + if (ui_loop_hook (0)) + return SERIAL_TIMEOUT; + } + + status = wait_for (scb, delta); + timeout -= delta; + + /* If we got a character or an error back from wait_for, then we can + break from the loop before the timeout is completed. */ + + if (status != SERIAL_TIMEOUT) + { + break; + } + + /* If we have exhausted the original timeout, then generate + a SERIAL_TIMEOUT, and pass it out of the loop. */ + + else if (timeout == 0) + { + status == SERIAL_TIMEOUT; + break; + } + } if (status < 0) return status; - scb->bufcnt = read(scb->fd, scb->buf, BUFSIZ); + while (1) + { + scb->bufcnt = read (scb->fd, scb->buf, BUFSIZ); + if (scb->bufcnt != -1 || errno != EINTR) + break; + } if (scb->bufcnt <= 0) - if (scb->bufcnt == 0) - return SERIAL_TIMEOUT; /* 0 chars means timeout [may need to + { + 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 */ + else + return SERIAL_ERROR; /* Got an error from read */ + } scb->bufcnt--; scb->bufp = scb->buf; @@ -254,7 +333,7 @@ tcp_print_tty_state (scb, ttystate) } static int -tcp_setbaudrate(scb, rate) +tcp_setbaudrate (scb, rate) serial_t scb; int rate; { @@ -262,16 +341,15 @@ tcp_setbaudrate(scb, rate) } static int -tcp_set_process_group (scb, ttystate, group) +tcp_setstopbits (scb, num) serial_t scb; - serial_ttystate ttystate; - int group; + int num; { - return 0; + return 0; /* Never fails! */ } static int -tcp_write(scb, str, len) +tcp_write (scb, str, len) serial_t scb; const char *str; int len; @@ -280,7 +358,7 @@ tcp_write(scb, str, len) while (len > 0) { - cc = write(scb->fd, str, len); + cc = write (scb->fd, str, len); if (cc < 0) return 1; @@ -291,13 +369,13 @@ tcp_write(scb, str, len) } static void -tcp_close(scb) +tcp_close (scb) serial_t scb; { if (scb->fd < 0) return; - close(scb->fd); + close (scb->fd); scb->fd = -1; } @@ -309,14 +387,17 @@ static struct serial_ops tcp_ops = tcp_close, tcp_readchar, tcp_write, - tcp_flush_output, + 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 + tcp_setstopbits, + tcp_return_0, /* wait for output to drain */ }; void