[thirdparty/binutils-gdb.git] / gdb / ser-tcp.c

/* Serial interface for raw TCP connections on Un*x like systems.

   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2001, 2005, 2006,
   2007, 2008, 2009, 2010 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "serial.h"
#include "ser-base.h"
#include "ser-tcp.h"
#include "gdbcmd.h"
#include "cli/cli-decode.h"
#include "cli/cli-setshow.h"

#include <sys/types.h>

#ifdef HAVE_SYS_FILIO_H
#include <sys/filio.h>  /* For FIONBIO. */
#endif
#ifdef HAVE_SYS_IOCTL_H
#include <sys/ioctl.h>  /* For FIONBIO. */
#endif

#include <sys/time.h>

#ifdef USE_WIN32API
#include <winsock2.h>
#define ETIMEDOUT WSAETIMEDOUT
#define close(fd) closesocket (fd)
#define ioctl ioctlsocket
#else
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/socket.h>
#include <netinet/tcp.h>
#endif

#include <signal.h>
#include "gdb_string.h"
#include "gdb_select.h"

#ifndef HAVE_SOCKLEN_T
typedef int socklen_t;
#endif

void _initialize_ser_tcp (void);

/* For "set tcp" and "show tcp".  */

static struct cmd_list_element *tcp_set_cmdlist;
static struct cmd_list_element *tcp_show_cmdlist;

/* Whether to auto-retry refused connections.  */

static int tcp_auto_retry = 1;

/* Timeout period for connections, in seconds.  */

static int tcp_retry_limit = 15;

/* how many times per second to poll deprecated_ui_loop_hook */

#define POLL_INTERVAL 5

/* Helper function to wait a while.  If SCB is non-null, wait on its
   file descriptor.  Otherwise just wait on a timeout, updating *POLLS.
   Returns -1 on timeout or interrupt, otherwise the value of select.  */

static int
wait_for_connect (struct serial *scb, int *polls)
{
  struct timeval t;
  int n;

  /* While we wait for the connect to complete, 
     poll the UI so it can update or the user can 
     interrupt.  */
  if (deprecated_ui_loop_hook && deprecated_ui_loop_hook (0))
    {
      errno = EINTR;
      return -1;
    }

  /* Check for timeout.  */
  if (*polls > tcp_retry_limit * POLL_INTERVAL)
    {
      errno = ETIMEDOUT;
      return -1;
    }

  /* Back off to polling once per second after the first POLL_INTERVAL
     polls.  */
  if (*polls < POLL_INTERVAL)
    {
      t.tv_sec = 0;
      t.tv_usec = 1000000 / POLL_INTERVAL;
    }
  else
    {
      t.tv_sec = 1;
      t.tv_usec = 0;
    }

  if (scb)
    {
      fd_set rset, wset, eset;

      FD_ZERO (&rset);
      FD_SET (scb->fd, &rset);
      wset = rset;
      eset = rset;
	  
      /* POSIX systems return connection success or failure by signalling
	 wset.  Windows systems return success in wset and failure in
	 eset.
     
	 We must call select here, rather than gdb_select, because
	 the serial structure has not yet been initialized - the
	 MinGW select wrapper will not know that this FD refers
	 to a socket.  */
      n = select (scb->fd + 1, &rset, &wset, &eset, &t);
    }
  else
    /* Use gdb_select here, since we have no file descriptors, and on
       Windows, plain select doesn't work in that case.  */
    n = gdb_select (0, NULL, NULL, NULL, &t);

  /* If we didn't time out, only count it as one poll.  */
  if (n > 0 || *polls < POLL_INTERVAL)
    (*polls)++;
  else
    (*polls) += POLL_INTERVAL;

  return n;
}

/* Open a tcp socket */

int
net_open (struct serial *scb, const char *name)
{
  char *port_str, hostname[100];
  int n, port, tmp;
  int use_udp;
  struct hostent *hostent;
  struct sockaddr_in sockaddr;
#ifdef USE_WIN32API
  u_long ioarg;
#else
  int ioarg;
#endif
  int polls = 0;

  use_udp = 0;
  if (strncmp (name, "udp:", 4) == 0)
    {
      use_udp = 1;
      name = name + 4;
    }
  else if (strncmp (name, "tcp:", 4) == 0)
    name = name + 4;

  port_str = strchr (name, ':');

  if (!port_str)
    error (_("net_open: No colon in host name!"));	   /* Shouldn't ever happen */

  tmp = min (port_str - name, (int) sizeof hostname - 1);
  strncpy (hostname, name, tmp);	/* Don't want colon */
  hostname[tmp] = '\000';	/* Tie off host name */
  port = atoi (port_str + 1);

  /* default hostname is localhost */
  if (!hostname[0])
    strcpy (hostname, "localhost");

  hostent = gethostbyname (hostname);
  if (!hostent)
    {
      fprintf_unfiltered (gdb_stderr, "%s: unknown host\n", hostname);
      errno = ENOENT;
      return -1;
    }

  sockaddr.sin_family = PF_INET;
  sockaddr.sin_port = htons (port);
  memcpy (&sockaddr.sin_addr.s_addr, hostent->h_addr,
	  sizeof (struct in_addr));

 retry:

  if (use_udp)
    scb->fd = socket (PF_INET, SOCK_DGRAM, 0);
  else
    scb->fd = socket (PF_INET, SOCK_STREAM, 0);

  if (scb->fd == -1)
    return -1;
  
  /* set socket nonblocking */
  ioarg = 1;
  ioctl (scb->fd, FIONBIO, &ioarg);

  /* Use Non-blocking connect.  connect() will return 0 if connected already. */
  n = connect (scb->fd, (struct sockaddr *) &sockaddr, sizeof (sockaddr));

  if (n < 0)
    {
#ifdef USE_WIN32API
      int err = WSAGetLastError();
#else
      int err = errno;
#endif

      /* Maybe we're waiting for the remote target to become ready to
	 accept connections.  */
      if (tcp_auto_retry
#ifdef USE_WIN32API
	  && err == WSAECONNREFUSED
#else
	  && err == ECONNREFUSED
#endif
	  && wait_for_connect (NULL, &polls) >= 0)
	{
	  close (scb->fd);
	  goto retry;
	}

      if (
#ifdef USE_WIN32API
	  /* Under Windows, calling "connect" with a non-blocking socket
	     results in WSAEWOULDBLOCK, not WSAEINPROGRESS.  */
	  err != WSAEWOULDBLOCK
#else
	  err != EINPROGRESS
#endif
	  )
	{
	  errno = err;
	  net_close (scb);
	  return -1;
	}

      /* looks like we need to wait for the connect */
      do 
	{
	  n = wait_for_connect (scb, &polls);
	} 
      while (n == 0);
      if (n < 0)
	{
	  net_close (scb);
	  return -1;
	}
    }

  /* Got something.  Is it an error? */
  {
    int res, err;
    socklen_t len;

    len = sizeof (err);
    /* On Windows, the fourth parameter to getsockopt is a "char *";
       on UNIX systems it is generally "void *".  The cast to "void *"
       is OK everywhere, since in C "void *" can be implicitly
       converted to any pointer type.  */
    res = getsockopt (scb->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len);
    if (res < 0 || err)
      {
	/* Maybe the target still isn't ready to accept the connection.  */
	if (tcp_auto_retry
#ifdef USE_WIN32API
	    && err == WSAECONNREFUSED
#else
	    && err == ECONNREFUSED
#endif
	    && wait_for_connect (NULL, &polls) >= 0)
	  {
	    close (scb->fd);
	    goto retry;
	  }
	if (err)
	  errno = err;
	net_close (scb);
	return -1;
      }
  } 

  /* turn off nonblocking */
  ioarg = 0;
  ioctl (scb->fd, FIONBIO, &ioarg);

  if (use_udp == 0)
    {
      /* Disable Nagle algorithm. Needed in some cases. */
      tmp = 1;
      setsockopt (scb->fd, IPPROTO_TCP, TCP_NODELAY,
		  (char *)&tmp, sizeof (tmp));
    }

#ifdef SIGPIPE
  /* If we don't do this, then GDB simply exits
     when the remote side dies.  */
  signal (SIGPIPE, SIG_IGN);
#endif

  return 0;
}

void
net_close (struct serial *scb)
{
  if (scb->fd == -1)
    return;

  close (scb->fd);
  scb->fd = -1;
}

int
net_read_prim (struct serial *scb, size_t count)
{
  return recv (scb->fd, scb->buf, count, 0);
}

int
net_write_prim (struct serial *scb, const void *buf, size_t count)
{
  return send (scb->fd, buf, count, 0);
}

int
ser_tcp_send_break (struct serial *scb)
{
  /* Send telnet IAC and BREAK characters. */
  return (serial_write (scb, "\377\363", 2));
}

/* Support for "set tcp" and "show tcp" commands.  */

static void
set_tcp_cmd (char *args, int from_tty)
{
  help_list (tcp_set_cmdlist, "set tcp ", -1, gdb_stdout);
}

static void
show_tcp_cmd (char *args, int from_tty)
{
  help_list (tcp_show_cmdlist, "show tcp ", -1, gdb_stdout);
}


void
_initialize_ser_tcp (void)
{
#ifdef USE_WIN32API
  /* Do nothing; the TCP serial operations will be initialized in
     ser-mingw.c.  */
#else
  struct serial_ops *ops;

  ops = XMALLOC (struct serial_ops);
  memset (ops, 0, sizeof (struct serial_ops));
  ops->name = "tcp";
  ops->next = 0;
  ops->open = net_open;
  ops->close = net_close;
  ops->readchar = ser_base_readchar;
  ops->write = ser_base_write;
  ops->flush_output = ser_base_flush_output;
  ops->flush_input = ser_base_flush_input;
  ops->send_break = ser_tcp_send_break;
  ops->go_raw = ser_base_raw;
  ops->get_tty_state = ser_base_get_tty_state;
  ops->set_tty_state = ser_base_set_tty_state;
  ops->print_tty_state = ser_base_print_tty_state;
  ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
  ops->setbaudrate = ser_base_setbaudrate;
  ops->setstopbits = ser_base_setstopbits;
  ops->drain_output = ser_base_drain_output;
  ops->async = ser_base_async;
  ops->read_prim = net_read_prim;
  ops->write_prim = net_write_prim;
  serial_add_interface (ops);
#endif /* USE_WIN32API */

  add_prefix_cmd ("tcp", class_maintenance, set_tcp_cmd, _("\
TCP protocol specific variables\n\
Configure variables specific to remote TCP connections"),
		  &tcp_set_cmdlist, "set tcp ",
		  0 /* allow-unknown */, &setlist);
  add_prefix_cmd ("tcp", class_maintenance, show_tcp_cmd, _("\
TCP protocol specific variables\n\
Configure variables specific to remote TCP connections"),
		  &tcp_show_cmdlist, "show tcp ",
		  0 /* allow-unknown */, &showlist);

  add_setshow_boolean_cmd ("auto-retry", class_obscure,
			   &tcp_auto_retry, _("\
Set auto-retry on socket connect"), _("\
Show auto-retry on socket connect"), 
			   NULL, NULL, NULL,
			   &tcp_set_cmdlist, &tcp_show_cmdlist);

  add_setshow_uinteger_cmd ("connect-timeout", class_obscure,
			    &tcp_retry_limit, _("\
Set timeout limit for socket connection"), _("\
Show timeout limit for socket connection"),
			   NULL, NULL, NULL,
			   &tcp_set_cmdlist, &tcp_show_cmdlist);
}
Commit	Line	Data
f9f87d2c MK	1	/* Serial interface for raw TCP connections on Un*x like systems.
f9f87d2c MK	2
6aba47ca	3	Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2001, 2005, 2006,
4c38e0a4	4	2007, 2008, 2009, 2010 Free Software Foundation, Inc.
c906108c	5
c5aa993b	6	This file is part of GDB.
c906108c	7
c5aa993b JM	8	This program is free software; you can redistribute it and/or modify
c5aa993b JM	9	it under the terms of the GNU General Public License as published by
a9762ec7	10	the Free Software Foundation; either version 3 of the License, or
c5aa993b	11	(at your option) any later version.
c906108c	12
c5aa993b JM	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.
c906108c	17
c5aa993b	18	You should have received a copy of the GNU General Public License
a9762ec7	19	along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c SS	20
	21	#include "defs.h"
	22	#include "serial.h"
3eb25fda	23	#include "ser-base.h"
0ea3f30e	24	#include "ser-tcp.h"
84603566 SL	25	#include "gdbcmd.h"
	26	#include "cli/cli-decode.h"
	27	#include "cli/cli-setshow.h"
c2c6d25f	28
c906108c	29	#include <sys/types.h>
0cf3e697 MH	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
c906108c	38	#include <sys/time.h>
b4505029 MM	39
	40	#ifdef USE_WIN32API
	41	#include <winsock2.h>
	42	#define ETIMEDOUT WSAETIMEDOUT
056d7646	43	#define close(fd) closesocket (fd)
b4505029 MM	44	#define ioctl ioctlsocket
b4505029 MM	45	#else
c906108c SS	46	#include <netinet/in.h>
	47	#include <arpa/inet.h>
	48	#include <netdb.h>
	49	#include <sys/socket.h>
c906108c	50	#include <netinet/tcp.h>
b4505029	51	#endif
c906108c	52
042be3a9	53	#include <signal.h>
c906108c	54	#include "gdb_string.h"
84603566	55	#include "gdb_select.h"
c906108c	56
f9f87d2c MK	57	#ifndef HAVE_SOCKLEN_T
	58	typedef int socklen_t;
	59	#endif
	60
c2c6d25f	61	void _initialize_ser_tcp (void);
c906108c	62
84603566 SL	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
98bbd631	76	/* how many times per second to poll deprecated_ui_loop_hook */
84603566 SL	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;
433759f7	122
84603566 SL	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	}
7c7a201a MH	151
7c7a201a MH	152	/* Open a tcp socket */
c906108c	153
0ea3f30e	154	int
9db8d71f	155	net_open (struct serial scb, const char name)
c906108c	156	{
7c7a201a MH	157	char *port_str, hostname[100];
7c7a201a MH	158	int n, port, tmp;
9db8d71f	159	int use_udp;
c906108c SS	160	struct hostent *hostent;
c906108c SS	161	struct sockaddr_in sockaddr;
b4505029 MM	162	#ifdef USE_WIN32API
	163	u_long ioarg;
	164	#else
	165	int ioarg;
	166	#endif
84603566	167	int polls = 0;
c906108c	168
9db8d71f DJ	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
c906108c SS	178	port_str = strchr (name, ':');
	179
	180	if (!port_str)
8a3fe4f8	181	error (_("net_open: No colon in host name!")); /* Shouldn't ever happen */
c906108c SS	182
c906108c SS	183	tmp = min (port_str - name, (int) sizeof hostname - 1);
c5aa993b	184	strncpy (hostname, name, tmp); /* Don't want colon */
c906108c SS	185	hostname[tmp] = '\000'; /* Tie off host name */
	186	port = atoi (port_str + 1);
	187
7c7a201a	188	/* default hostname is localhost */
ad4571f3 CV	189	if (!hostname[0])
	190	strcpy (hostname, "localhost");
	191
c906108c	192	hostent = gethostbyname (hostname);
c906108c SS	193	if (!hostent)
	194	{
	195	fprintf_unfiltered (gdb_stderr, "%s: unknown host\n", hostname);
	196	errno = ENOENT;
	197	return -1;
	198	}
	199
84603566 SL	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
9db8d71f DJ	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
363a6e9f	212	if (scb->fd == -1)
7c7a201a MH	213	return -1;
7c7a201a MH	214
7c7a201a	215	/* set socket nonblocking */
b4505029 MM	216	ioarg = 1;
b4505029 MM	217	ioctl (scb->fd, FIONBIO, &ioarg);
c906108c	218
7c7a201a MH	219	/* Use Non-blocking connect. connect() will return 0 if connected already. */
7c7a201a MH	220	n = connect (scb->fd, (struct sockaddr *) &sockaddr, sizeof (sockaddr));
c906108c	221
84603566 SL	222	if (n < 0)
84603566 SL	223	{
b4505029	224	#ifdef USE_WIN32API
84603566	225	int err = WSAGetLastError();
b4505029	226	#else
84603566	227	int err = errno;
b4505029	228	#endif
84603566 SL	229
	230	/* Maybe we're waiting for the remote target to become ready to
	231	accept connections. */
	232	if (tcp_auto_retry
b4505029	233	#ifdef USE_WIN32API
84603566 SL	234	&& err == WSAECONNREFUSED
	235	#else
	236	&& err == ECONNREFUSED
b4505029	237	#endif
84603566 SL	238	&& wait_for_connect (NULL, &polls) >= 0)
	239	{
	240	close (scb->fd);
	241	goto retry;
	242	}
c906108c	243
84603566 SL	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	}
7c7a201a	258
84603566	259	/* looks like we need to wait for the connect */
7c7a201a MH	260	do
7c7a201a MH	261	{
84603566	262	n = wait_for_connect (scb, &polls);
7c7a201a	263	}
84603566 SL	264	while (n == 0);
84603566 SL	265	if (n < 0)
7c7a201a	266	{
9db8d71f	267	net_close (scb);
7c7a201a MH	268	return -1;
	269	}
	270	}
c906108c	271
7c7a201a MH	272	/* Got something. Is it an error? */
7c7a201a MH	273	{
47b667de AC	274	int res, err;
47b667de AC	275	socklen_t len;
433759f7	276
0ea3f30e	277	len = sizeof (err);
b4505029 MM	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);
7c7a201a MH	283	if (res < 0 \|\| err)
7c7a201a MH	284	{
84603566 SL	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	}
7c7a201a MH	297	if (err)
7c7a201a MH	298	errno = err;
9db8d71f	299	net_close (scb);
7c7a201a MH	300	return -1;
	301	}
	302	}
9db8d71f	303
7c7a201a	304	/* turn off nonblocking */
b4505029 MM	305	ioarg = 0;
b4505029 MM	306	ioctl (scb->fd, FIONBIO, &ioarg);
7c7a201a	307
9db8d71f DJ	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
6d318c73	316	#ifdef SIGPIPE
7c7a201a MH	317	/* If we don't do this, then GDB simply exits
	318	when the remote side dies. */
	319	signal (SIGPIPE, SIG_IGN);
6d318c73	320	#endif
c906108c SS	321
	322	return 0;
	323	}
	324
0ea3f30e	325	void
9db8d71f	326	net_close (struct serial *scb)
c906108c	327	{
363a6e9f	328	if (scb->fd == -1)
c906108c SS	329	return;
c906108c SS	330
c5aa993b	331	close (scb->fd);
c906108c SS	332	scb->fd = -1;
	333	}
	334
0ea3f30e	335	int
b4505029 MM	336	net_read_prim (struct serial *scb, size_t count)
	337	{
	338	return recv (scb->fd, scb->buf, count, 0);
	339	}
	340
0ea3f30e	341	int
b4505029 MM	342	net_write_prim (struct serial scb, const void buf, size_t count)
	343	{
	344	return send (scb->fd, buf, count, 0);
	345	}
	346
8775bb90 MS	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
84603566 SL	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
c906108c	369	void
c2c6d25f	370	_initialize_ser_tcp (void)
c906108c	371	{
b4505029	372	#ifdef USE_WIN32API
0ea3f30e DJ	373	/* Do nothing; the TCP serial operations will be initialized in
0ea3f30e DJ	374	ser-mingw.c. */
0ea3f30e DJ	375	#else
0ea3f30e DJ	376	struct serial_ops *ops;
433759f7	377
b4505029	378	ops = XMALLOC (struct serial_ops);
2fdbdd39	379	memset (ops, 0, sizeof (struct serial_ops));
c2c6d25f JM	380	ops->name = "tcp";
c2c6d25f JM	381	ops->next = 0;
9db8d71f DJ	382	ops->open = net_open;
9db8d71f DJ	383	ops->close = net_close;
b4505029	384	ops->readchar = ser_base_readchar;
dd5da072 MM	385	ops->write = ser_base_write;
	386	ops->flush_output = ser_base_flush_output;
	387	ops->flush_input = ser_base_flush_input;
8775bb90	388	ops->send_break = ser_tcp_send_break;
dd5da072 MM	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;
b4505029 MM	398	ops->read_prim = net_read_prim;
b4505029 MM	399	ops->write_prim = net_write_prim;
c2c6d25f	400	serial_add_interface (ops);
0ea3f30e	401	#endif /* USE_WIN32API */
84603566 SL	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);
c906108c	427	}