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