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