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, 2011 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 182 happen. */ 183 184 tmp = min (port_str - name, (int) sizeof hostname - 1); 185 strncpy (hostname, name, tmp); /* Don't want colon. */ 186 hostname[tmp] = '\000'; /* Tie off host name. */ 187 port = atoi (port_str + 1); 188 189 /* Default hostname is localhost. */ 190 if (!hostname[0]) 191 strcpy (hostname, "localhost"); 192 193 hostent = gethostbyname (hostname); 194 if (!hostent) 195 { 196 fprintf_unfiltered (gdb_stderr, "%s: unknown host\n", hostname); 197 errno = ENOENT; 198 return -1; 199 } 200 201 sockaddr.sin_family = PF_INET; 202 sockaddr.sin_port = htons (port); 203 memcpy (&sockaddr.sin_addr.s_addr, hostent->h_addr, 204 sizeof (struct in_addr)); 205 206 retry: 207 208 if (use_udp) 209 scb->fd = socket (PF_INET, SOCK_DGRAM, 0); 210 else 211 scb->fd = socket (PF_INET, SOCK_STREAM, 0); 212 213 if (scb->fd == -1) 214 return -1; 215 216 /* Set socket nonblocking. */ 217 ioarg = 1; 218 ioctl (scb->fd, FIONBIO, &ioarg); 219 220 /* Use Non-blocking connect. connect() will return 0 if connected 221 already. */ 222 n = connect (scb->fd, (struct sockaddr *) &sockaddr, sizeof (sockaddr)); 223 224 if (n < 0) 225 { 226 #ifdef USE_WIN32API 227 int err = WSAGetLastError(); 228 #else 229 int err = errno; 230 #endif 231 232 /* Maybe we're waiting for the remote target to become ready to 233 accept connections. */ 234 if (tcp_auto_retry 235 #ifdef USE_WIN32API 236 && err == WSAECONNREFUSED 237 #else 238 && err == ECONNREFUSED 239 #endif 240 && wait_for_connect (NULL, &polls) >= 0) 241 { 242 close (scb->fd); 243 goto retry; 244 } 245 246 if ( 247 #ifdef USE_WIN32API 248 /* Under Windows, calling "connect" with a non-blocking socket 249 results in WSAEWOULDBLOCK, not WSAEINPROGRESS. */ 250 err != WSAEWOULDBLOCK 251 #else 252 err != EINPROGRESS 253 #endif 254 ) 255 { 256 errno = err; 257 net_close (scb); 258 return -1; 259 } 260 261 /* Looks like we need to wait for the connect. */ 262 do 263 { 264 n = wait_for_connect (scb, &polls); 265 } 266 while (n == 0); 267 if (n < 0) 268 { 269 net_close (scb); 270 return -1; 271 } 272 } 273 274 /* Got something. Is it an error? */ 275 { 276 int res, err; 277 socklen_t len; 278 279 len = sizeof (err); 280 /* On Windows, the fourth parameter to getsockopt is a "char *"; 281 on UNIX systems it is generally "void *". The cast to "void *" 282 is OK everywhere, since in C "void *" can be implicitly 283 converted to any pointer type. */ 284 res = getsockopt (scb->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len); 285 if (res < 0 || err) 286 { 287 /* Maybe the target still isn't ready to accept the connection. */ 288 if (tcp_auto_retry 289 #ifdef USE_WIN32API 290 && err == WSAECONNREFUSED 291 #else 292 && err == ECONNREFUSED 293 #endif 294 && wait_for_connect (NULL, &polls) >= 0) 295 { 296 close (scb->fd); 297 goto retry; 298 } 299 if (err) 300 errno = err; 301 net_close (scb); 302 return -1; 303 } 304 } 305 306 /* Turn off nonblocking. */ 307 ioarg = 0; 308 ioctl (scb->fd, FIONBIO, &ioarg); 309 310 if (use_udp == 0) 311 { 312 /* Disable Nagle algorithm. Needed in some cases. */ 313 tmp = 1; 314 setsockopt (scb->fd, IPPROTO_TCP, TCP_NODELAY, 315 (char *)&tmp, sizeof (tmp)); 316 } 317 318 #ifdef SIGPIPE 319 /* If we don't do this, then GDB simply exits 320 when the remote side dies. */ 321 signal (SIGPIPE, SIG_IGN); 322 #endif 323 324 return 0; 325 } 326 327 void 328 net_close (struct serial *scb) 329 { 330 if (scb->fd == -1) 331 return; 332 333 close (scb->fd); 334 scb->fd = -1; 335 } 336 337 int 338 net_read_prim (struct serial *scb, size_t count) 339 { 340 return recv (scb->fd, scb->buf, count, 0); 341 } 342 343 int 344 net_write_prim (struct serial *scb, const void *buf, size_t count) 345 { 346 return send (scb->fd, buf, count, 0); 347 } 348 349 int 350 ser_tcp_send_break (struct serial *scb) 351 { 352 /* Send telnet IAC and BREAK characters. */ 353 return (serial_write (scb, "\377\363", 2)); 354 } 355 356 /* Support for "set tcp" and "show tcp" commands. */ 357 358 static void 359 set_tcp_cmd (char *args, int from_tty) 360 { 361 help_list (tcp_set_cmdlist, "set tcp ", -1, gdb_stdout); 362 } 363 364 static void 365 show_tcp_cmd (char *args, int from_tty) 366 { 367 help_list (tcp_show_cmdlist, "show tcp ", -1, gdb_stdout); 368 } 369 370 371 void 372 _initialize_ser_tcp (void) 373 { 374 #ifdef USE_WIN32API 375 /* Do nothing; the TCP serial operations will be initialized in 376 ser-mingw.c. */ 377 #else 378 struct serial_ops *ops; 379 380 ops = XMALLOC (struct serial_ops); 381 memset (ops, 0, sizeof (struct serial_ops)); 382 ops->name = "tcp"; 383 ops->next = 0; 384 ops->open = net_open; 385 ops->close = net_close; 386 ops->readchar = ser_base_readchar; 387 ops->write = ser_base_write; 388 ops->flush_output = ser_base_flush_output; 389 ops->flush_input = ser_base_flush_input; 390 ops->send_break = ser_tcp_send_break; 391 ops->go_raw = ser_base_raw; 392 ops->get_tty_state = ser_base_get_tty_state; 393 ops->copy_tty_state = ser_base_copy_tty_state; 394 ops->set_tty_state = ser_base_set_tty_state; 395 ops->print_tty_state = ser_base_print_tty_state; 396 ops->noflush_set_tty_state = ser_base_noflush_set_tty_state; 397 ops->setbaudrate = ser_base_setbaudrate; 398 ops->setstopbits = ser_base_setstopbits; 399 ops->drain_output = ser_base_drain_output; 400 ops->async = ser_base_async; 401 ops->read_prim = net_read_prim; 402 ops->write_prim = net_write_prim; 403 serial_add_interface (ops); 404 #endif /* USE_WIN32API */ 405 406 add_prefix_cmd ("tcp", class_maintenance, set_tcp_cmd, _("\ 407 TCP protocol specific variables\n\ 408 Configure variables specific to remote TCP connections"), 409 &tcp_set_cmdlist, "set tcp ", 410 0 /* allow-unknown */, &setlist); 411 add_prefix_cmd ("tcp", class_maintenance, show_tcp_cmd, _("\ 412 TCP protocol specific variables\n\ 413 Configure variables specific to remote TCP connections"), 414 &tcp_show_cmdlist, "show tcp ", 415 0 /* allow-unknown */, &showlist); 416 417 add_setshow_boolean_cmd ("auto-retry", class_obscure, 418 &tcp_auto_retry, _("\ 419 Set auto-retry on socket connect"), _("\ 420 Show auto-retry on socket connect"), 421 NULL, NULL, NULL, 422 &tcp_set_cmdlist, &tcp_show_cmdlist); 423 424 add_setshow_uinteger_cmd ("connect-timeout", class_obscure, 425 &tcp_retry_limit, _("\ 426 Set timeout limit for socket connection"), _("\ 427 Show timeout limit for socket connection"), 428 NULL, NULL, NULL, 429 &tcp_set_cmdlist, &tcp_show_cmdlist); 430 } 431