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