1 /* Serial interface for raw TCP connections on Un*x like systems 2 Copyright 1992, 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, Boston, MA 02111-1307, USA. */ 19 20 #include "defs.h" 21 #include "serial.h" 22 #include <sys/types.h> 23 #include <sys/time.h> 24 #include <netinet/in.h> 25 #include <arpa/inet.h> 26 #include <netdb.h> 27 #include <sys/socket.h> 28 29 #ifndef __CYGWIN32__ 30 #include <netinet/tcp.h> 31 #endif 32 33 #include "signals.h" 34 #include "gdb_string.h" 35 36 struct tcp_ttystate 37 { 38 int bogus; 39 }; 40 41 static int tcp_open PARAMS ((serial_t scb, const char *name)); 42 static void tcp_raw PARAMS ((serial_t scb)); 43 static int wait_for PARAMS ((serial_t scb, int timeout)); 44 static int tcp_readchar PARAMS ((serial_t scb, int timeout)); 45 static int tcp_setbaudrate PARAMS ((serial_t scb, int rate)); 46 static int tcp_setstopbits PARAMS ((serial_t scb, int num)); 47 static int tcp_write PARAMS ((serial_t scb, const char *str, int len)); 48 /* FIXME: static void tcp_restore PARAMS ((serial_t scb)); */ 49 static void tcp_close PARAMS ((serial_t scb)); 50 static serial_ttystate tcp_get_tty_state PARAMS ((serial_t scb)); 51 static int tcp_set_tty_state PARAMS ((serial_t scb, serial_ttystate state)); 52 static int tcp_return_0 PARAMS ((serial_t)); 53 static int tcp_noflush_set_tty_state PARAMS ((serial_t, serial_ttystate, 54 serial_ttystate)); 55 static void tcp_print_tty_state PARAMS ((serial_t, serial_ttystate)); 56 57 /* Open up a raw tcp socket */ 58 59 static int 60 tcp_open(scb, name) 61 serial_t scb; 62 const char *name; 63 { 64 char *port_str; 65 int port; 66 struct hostent *hostent; 67 struct sockaddr_in sockaddr; 68 int tmp; 69 char hostname[100]; 70 struct protoent *protoent; 71 int i; 72 73 port_str = strchr (name, ':'); 74 75 if (!port_str) 76 error ("tcp_open: No colon in host name!"); /* Shouldn't ever happen */ 77 78 tmp = min (port_str - name, (int) sizeof hostname - 1); 79 strncpy (hostname, name, tmp); /* Don't want colon */ 80 hostname[tmp] = '\000'; /* Tie off host name */ 81 port = atoi (port_str + 1); 82 83 hostent = gethostbyname (hostname); 84 85 if (!hostent) 86 { 87 fprintf_unfiltered (gdb_stderr, "%s: unknown host\n", hostname); 88 errno = ENOENT; 89 return -1; 90 } 91 92 for (i = 1; i <= 15; i++) 93 { 94 scb->fd = socket (PF_INET, SOCK_STREAM, 0); 95 if (scb->fd < 0) 96 return -1; 97 98 /* Allow rapid reuse of this port. */ 99 tmp = 1; 100 setsockopt (scb->fd, SOL_SOCKET, SO_REUSEADDR, (char *)&tmp, sizeof(tmp)); 101 102 /* Enable TCP keep alive process. */ 103 tmp = 1; 104 setsockopt (scb->fd, SOL_SOCKET, SO_KEEPALIVE, (char *)&tmp, sizeof(tmp)); 105 106 sockaddr.sin_family = PF_INET; 107 sockaddr.sin_port = htons(port); 108 memcpy (&sockaddr.sin_addr.s_addr, hostent->h_addr, 109 sizeof (struct in_addr)); 110 111 if (!connect (scb->fd, (struct sockaddr *) &sockaddr, sizeof(sockaddr))) 112 break; 113 114 close (scb->fd); 115 scb->fd = -1; 116 117 /* We retry for ECONNREFUSED because that is often a temporary condition, which 118 happens when the server is being restarted. */ 119 120 if (errno != ECONNREFUSED) 121 return -1; 122 123 sleep (1); 124 } 125 126 protoent = getprotobyname ("tcp"); 127 if (!protoent) 128 return -1; 129 130 tmp = 1; 131 if (setsockopt (scb->fd, protoent->p_proto, TCP_NODELAY, 132 (char *)&tmp, sizeof(tmp))) 133 return -1; 134 135 signal(SIGPIPE, SIG_IGN); /* If we don't do this, then GDB simply exits 136 when the remote side dies. */ 137 138 return 0; 139 } 140 141 static serial_ttystate 142 tcp_get_tty_state(scb) 143 serial_t scb; 144 { 145 struct tcp_ttystate *state; 146 147 state = (struct tcp_ttystate *)xmalloc(sizeof *state); 148 149 return (serial_ttystate)state; 150 } 151 152 static int 153 tcp_set_tty_state(scb, ttystate) 154 serial_t scb; 155 serial_ttystate ttystate; 156 { 157 struct tcp_ttystate *state; 158 159 state = (struct tcp_ttystate *)ttystate; 160 161 return 0; 162 } 163 164 static int 165 tcp_return_0 (scb) 166 serial_t scb; 167 { 168 return 0; 169 } 170 171 static void 172 tcp_raw(scb) 173 serial_t scb; 174 { 175 return; /* Always in raw mode */ 176 } 177 178 /* Wait for input on scb, with timeout seconds. Returns 0 on success, 179 otherwise SERIAL_TIMEOUT or SERIAL_ERROR. 180 181 For termio{s}, we actually just setup VTIME if necessary, and let the 182 timeout occur in the read() in tcp_read(). 183 */ 184 185 static int 186 wait_for(scb, timeout) 187 serial_t scb; 188 int timeout; 189 { 190 int numfds; 191 struct timeval tv; 192 fd_set readfds, exceptfds; 193 194 FD_ZERO (&readfds); 195 FD_ZERO (&exceptfds); 196 197 tv.tv_sec = timeout; 198 tv.tv_usec = 0; 199 200 FD_SET(scb->fd, &readfds); 201 FD_SET(scb->fd, &exceptfds); 202 203 while (1) 204 { 205 if (timeout >= 0) 206 numfds = select(scb->fd+1, &readfds, 0, &exceptfds, &tv); 207 else 208 numfds = select(scb->fd+1, &readfds, 0, &exceptfds, 0); 209 210 if (numfds <= 0) 211 if (numfds == 0) 212 return SERIAL_TIMEOUT; 213 else if (errno == EINTR) 214 continue; 215 else 216 return SERIAL_ERROR; /* Got an error from select or poll */ 217 218 return 0; 219 } 220 } 221 222 /* Read a character with user-specified timeout. TIMEOUT is number of seconds 223 to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns 224 char if successful. Returns -2 if timeout expired, EOF if line dropped 225 dead, or -3 for any other error (see errno in that case). */ 226 227 static int 228 tcp_readchar(scb, timeout) 229 serial_t scb; 230 int timeout; 231 { 232 int status; 233 234 if (scb->bufcnt-- > 0) 235 return *scb->bufp++; 236 237 status = wait_for(scb, timeout); 238 239 if (status < 0) 240 return status; 241 242 while (1) 243 { 244 scb->bufcnt = read(scb->fd, scb->buf, BUFSIZ); 245 if (scb->bufcnt != -1 || errno != EINTR) 246 break; 247 } 248 249 if (scb->bufcnt <= 0) 250 if (scb->bufcnt == 0) 251 return SERIAL_TIMEOUT; /* 0 chars means timeout [may need to 252 distinguish between EOF & timeouts 253 someday] */ 254 else 255 return SERIAL_ERROR; /* Got an error from read */ 256 257 scb->bufcnt--; 258 scb->bufp = scb->buf; 259 return *scb->bufp++; 260 } 261 262 static int 263 tcp_noflush_set_tty_state (scb, new_ttystate, old_ttystate) 264 serial_t scb; 265 serial_ttystate new_ttystate; 266 serial_ttystate old_ttystate; 267 { 268 return 0; 269 } 270 271 static void 272 tcp_print_tty_state (scb, ttystate) 273 serial_t scb; 274 serial_ttystate ttystate; 275 { 276 /* Nothing to print. */ 277 return; 278 } 279 280 static int 281 tcp_setbaudrate(scb, rate) 282 serial_t scb; 283 int rate; 284 { 285 return 0; /* Never fails! */ 286 } 287 288 static int 289 tcp_setstopbits(scb, num) 290 serial_t scb; 291 int num; 292 { 293 return 0; /* Never fails! */ 294 } 295 296 static int 297 tcp_write(scb, str, len) 298 serial_t scb; 299 const char *str; 300 int len; 301 { 302 int cc; 303 304 while (len > 0) 305 { 306 cc = write(scb->fd, str, len); 307 308 if (cc < 0) 309 return 1; 310 len -= cc; 311 str += cc; 312 } 313 return 0; 314 } 315 316 static void 317 tcp_close(scb) 318 serial_t scb; 319 { 320 if (scb->fd < 0) 321 return; 322 323 close(scb->fd); 324 scb->fd = -1; 325 } 326 327 static struct serial_ops tcp_ops = 328 { 329 "tcp", 330 0, 331 tcp_open, 332 tcp_close, 333 tcp_readchar, 334 tcp_write, 335 tcp_return_0, /* flush output */ 336 tcp_return_0, /* flush input */ 337 tcp_return_0, /* send break */ 338 tcp_raw, 339 tcp_get_tty_state, 340 tcp_set_tty_state, 341 tcp_print_tty_state, 342 tcp_noflush_set_tty_state, 343 tcp_setbaudrate, 344 tcp_setstopbits, 345 }; 346 347 void 348 _initialize_ser_tcp () 349 { 350 serial_add_interface (&tcp_ops); 351 } 352