[deliverable/binutils-gdb.git] / gdb / serial.c

/* Generic serial interface routines
   Copyright 1992, 1993, 1996 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 2 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, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#include "defs.h"
#include <ctype.h>
#include "serial.h"
#include "gdb_string.h"
#include "gdbcmd.h"

/* Linked list of serial I/O handlers */

static struct serial_ops *serial_ops_list = NULL;

/* This is the last serial stream opened.  Used by connect command. */

static serial_t last_serial_opened = NULL;

/* Pointer to list of scb's. */

static serial_t scb_base;

/* Non-NULL gives filename which contains a recording of the remote session,
   suitable for playback by gdbserver. */

char *serial_logfile = NULL;
FILE *serial_logfp = NULL;

\f
static int serial_reading = 0;
static int serial_writing = 0;

void
serial_log_command (cmd)
     const char *cmd;
{
  if (serial_reading || serial_writing)
    {
      fputc_unfiltered ('\n', serial_logfp);
      serial_reading = 0;
      serial_writing = 0;
    }
  fprintf_unfiltered (serial_logfp, "c %s\n", cmd);
  /* Make sure that the log file is as up-to-date as possible,
     in case we are getting ready to dump core or something. */
  fflush (serial_logfp);
}

static void
serial_logchar (ch)
     int ch;
{
  switch (ch)
    {
    case '\\':	fputs_unfiltered ("\\\\", serial_logfp); break;	
    case '\b':	fputs_unfiltered ("\\b", serial_logfp); break;	
    case '\f':	fputs_unfiltered ("\\f", serial_logfp); break;	
    case '\n':	fputs_unfiltered ("\\n", serial_logfp); break;	
    case '\r':	fputs_unfiltered ("\\r", serial_logfp); break;	
    case '\t':	fputs_unfiltered ("\\t", serial_logfp); break;	
    case '\v':	fputs_unfiltered ("\\v", serial_logfp); break;	
    default:	fprintf_unfiltered (serial_logfp, isprint (ch) ? "%c" : "\\x%02x", ch & 0xFF); break;
    }
}

int
serial_write (scb, str, len)
     serial_t scb;
     const char *str;
     int len;
{
  int count;

  if (serial_logfp != NULL)
    {
      if (serial_reading)
	{
	  fputc_unfiltered ('\n', serial_logfp);
	  serial_reading = 0;
	}
      if (!serial_writing)
	{
	  serial_logchar ('w');
	  serial_logchar (' ');
	  serial_writing = 1;
	}
      for (count = 0; count < len; count++)
	{
	  serial_logchar (str[count]);
	}
      /* Make sure that the log file is as up-to-date as possible,
	 in case we are getting ready to dump core or something. */
      fflush (serial_logfp);
    }
  return (scb -> ops -> write (scb, str, len));
}

int
serial_readchar (scb, timeout)
     serial_t scb;
     int timeout;
{
  int ch;

  ch = scb -> ops -> readchar (scb, timeout);
  if (serial_logfp != NULL)
    {
      if (serial_writing)
	{
	  fputc_unfiltered ('\n', serial_logfp);
	  serial_writing = 0;
	}
      if (!serial_reading)
	{
	  serial_logchar ('r');
	  serial_logchar (' ');
	  serial_reading = 1;
	}
      serial_logchar (ch);
      /* Make sure that the log file is as up-to-date as possible,
	 in case we are getting ready to dump core or something. */
      fflush (serial_logfp);
    }
  return (ch);
}

static struct serial_ops *
serial_interface_lookup (name)
     char *name;
{
  struct serial_ops *ops;

  for (ops = serial_ops_list; ops; ops = ops->next)
    if (strcmp (name, ops->name) == 0)
      return ops;

  return NULL;
}

void
serial_add_interface(optable)
     struct serial_ops *optable;
{
  optable->next = serial_ops_list;
  serial_ops_list = optable;
}

/* Open up a device or a network socket, depending upon the syntax of NAME. */

serial_t
serial_open (name)
     const char *name;
{
  serial_t scb;
  struct serial_ops *ops;

  for (scb = scb_base; scb; scb = scb->next)
    if (scb->name && strcmp (scb->name, name) == 0)
      {
	scb->refcnt++;
	return scb;
      }

  if (strcmp (name, "pc") == 0)
    ops = serial_interface_lookup ("pc");
  else if (strchr (name, ':'))
    ops = serial_interface_lookup ("tcp");
  else if (strncmp (name, "lpt", 3) == 0)
    ops = serial_interface_lookup ("parallel");
  else
    ops = serial_interface_lookup ("hardwire");

  if (!ops)
    return NULL;

  scb = (serial_t)xmalloc (sizeof (struct _serial_t));

  scb->ops = ops;

  scb->bufcnt = 0;
  scb->bufp = scb->buf;

  if (scb->ops->open(scb, name))
    {
      free (scb);
      return NULL;
    }

  scb->name = strsave (name);
  scb->next = scb_base;
  scb->refcnt = 1;
  scb_base = scb;

  last_serial_opened = scb;

  if (serial_logfile != NULL)
    {
      serial_logfp = fopen (serial_logfile, "w");
      if (serial_logfp == NULL)
	{
	  perror_with_name (serial_logfile);
	}
    }

  return scb;
}

serial_t
serial_fdopen (fd)
     const int fd;
{
  serial_t scb;
  struct serial_ops *ops;

  for (scb = scb_base; scb; scb = scb->next)
    if (scb->fd == fd)
      {
	scb->refcnt++;
	return scb;
      }

  ops = serial_interface_lookup ("hardwire");

  if (!ops)
    return NULL;

  scb = (serial_t)xmalloc (sizeof (struct _serial_t));

  scb->ops = ops;

  scb->bufcnt = 0;
  scb->bufp = scb->buf;

  scb->fd = fd;

  scb->name = NULL;
  scb->next = scb_base;
  scb->refcnt = 1;
  scb_base = scb;

  last_serial_opened = scb;

  return scb;
}

void
serial_close(scb, really_close)
     serial_t scb;
     int really_close;
{
  serial_t tmp_scb;

  last_serial_opened = NULL;

  if (serial_logfp)
    {
      if (serial_reading || serial_writing)
	{
	  fputc_unfiltered ('\n', serial_logfp);
	  serial_reading = 0;
	  serial_writing = 0;
	}
      fclose (serial_logfp);
      serial_logfp = NULL;
    }

/* This is bogus.  It's not our fault if you pass us a bad scb...!  Rob, you
   should fix your code instead.  */

  if (!scb)
    return;

  scb->refcnt--;
  if (scb->refcnt > 0)
    return;

  if (really_close)
    scb->ops->close (scb);

  if (scb->name)
    free (scb->name);

  if (scb_base == scb)
    scb_base = scb_base->next;
  else
    for (tmp_scb = scb_base; tmp_scb; tmp_scb = tmp_scb->next)
      {
	if (tmp_scb->next != scb)
	  continue;

	tmp_scb->next = tmp_scb->next->next;
	break;
      }

  free(scb);
}

#if 0
/*
The connect command is #if 0 because I hadn't thought of an elegant
way to wait for I/O on two serial_t's simultaneously.  Two solutions
came to mind:

	1) Fork, and have have one fork handle the to user direction,
	   and have the other hand the to target direction.  This
	   obviously won't cut it for MSDOS.

	2) Use something like select.  This assumes that stdin and
	   the target side can both be waited on via the same
	   mechanism.  This may not be true for DOS, if GDB is
	   talking to the target via a TCP socket.
-grossman, 8 Jun 93
*/

/* Connect the user directly to the remote system.  This command acts just like
   the 'cu' or 'tip' command.  Use <CR>~. or <CR>~^D to break out.  */

static serial_t tty_desc;		/* Controlling terminal */

static void
cleanup_tty(ttystate)
     serial_ttystate ttystate;
{
  printf_unfiltered ("\r\n[Exiting connect mode]\r\n");
  SERIAL_SET_TTY_STATE (tty_desc, ttystate);
  free (ttystate);
  SERIAL_CLOSE (tty_desc);
}

static void
connect_command (args, fromtty)
     char	*args;
     int	fromtty;
{
  int c;
  char cur_esc = 0;
  serial_ttystate ttystate;
  serial_t port_desc;		/* TTY port */

  dont_repeat();

  if (args)
    fprintf_unfiltered(gdb_stderr, "This command takes no args.  They have been ignored.\n");
	
  printf_unfiltered("[Entering connect mode.  Use ~. or ~^D to escape]\n");

  tty_desc = SERIAL_FDOPEN (0);
  port_desc = last_serial_opened;

  ttystate = SERIAL_GET_TTY_STATE (tty_desc);

  SERIAL_RAW (tty_desc);
  SERIAL_RAW (port_desc);

  make_cleanup (cleanup_tty, ttystate);

  while (1)
    {
      int mask;

      mask = SERIAL_WAIT_2 (tty_desc, port_desc, -1);

      if (mask & 2)
	{			/* tty input */
	  char cx;

	  while (1)
	    {
	      c = SERIAL_READCHAR(tty_desc, 0);

	      if (c == SERIAL_TIMEOUT)
		  break;

	      if (c < 0)
		perror_with_name("connect");

	      cx = c;
	      SERIAL_WRITE(port_desc, &cx, 1);

	      switch (cur_esc)
		{
		case 0:
		  if (c == '\r')
		    cur_esc = c;
		  break;
		case '\r':
		  if (c == '~')
		    cur_esc = c;
		  else
		    cur_esc = 0;
		  break;
		case '~':
		  if (c == '.' || c == '\004')
		    return;
		  else
		    cur_esc = 0;
		}
	    }
	}

      if (mask & 1)
	{			/* Port input */
	  char cx;

	  while (1)
	    {
	      c = SERIAL_READCHAR(port_desc, 0);

	      if (c == SERIAL_TIMEOUT)
		  break;

	      if (c < 0)
		perror_with_name("connect");

	      cx = c;

	      SERIAL_WRITE(tty_desc, &cx, 1);
	    }
	}
    }
}
#endif /* 0 */

/* VARARGS */
void
#ifdef ANSI_PROTOTYPES
serial_printf (serial_t desc, const char *format, ...)
#else
serial_printf (va_alist)
     va_dcl
#endif
{
  va_list args;
  char *buf;
#ifdef ANSI_PROTOTYPES
  va_start (args, format);
#else
  serial_t desc;
  char *format;

  va_start (args);
  desc = va_arg (args, serial_t);
  format = va_arg (args, char *);
#endif

  vasprintf (&buf, format, args);
  SERIAL_WRITE (desc, buf, strlen (buf));

  free (buf);
  va_end (args);
}

void
_initialize_serial ()
{
#if 0
  add_com ("connect", class_obscure, connect_command,
	   "Connect the terminal directly up to the command monitor.\n\
Use <CR>~. or <CR>~^D to break out.");
#endif /* 0 */

  add_show_from_set (add_set_cmd ("remotelogfile", no_class,
				  var_filename, (char *)&serial_logfile,
				  "Set filename for remote session recording.\n\
This file is used to record the remote session for future playback\n\
by gdbserver.", &setlist),
		     &showlist);

}
Commit	Line	Data
4e772f44	1	/* Generic serial interface routines
c84e5000	2	Copyright 1992, 1993, 1996 Free Software Foundation, Inc.
4e772f44 SG	3
	4	This file is part of GDB.
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2 of the License, or
	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
6c9638b4	18	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
4e772f44 SG	19
4e772f44 SG	20	#include "defs.h"
72ae15f6	21	#include <ctype.h>
4e772f44	22	#include "serial.h"
0694bce6	23	#include "gdb_string.h"
e8f1ad9a	24	#include "gdbcmd.h"
4e772f44	25
38dc5e12	26	/* Linked list of serial I/O handlers */
4e772f44 SG	27
	28	static struct serial_ops *serial_ops_list = NULL;
	29
38dc5e12 SG	30	/* This is the last serial stream opened. Used by connect command. */
	31
	32	static serial_t last_serial_opened = NULL;
	33
bbcc95bd PS	34	/* Pointer to list of scb's. */
	35
	36	static serial_t scb_base;
	37
e8f1ad9a FF	38	/* Non-NULL gives filename which contains a recording of the remote session,
	39	suitable for playback by gdbserver. */
	40
	41	char *serial_logfile = NULL;
	42	FILE *serial_logfp = NULL;
	43
	44	\f
	45	static int serial_reading = 0;
	46	static int serial_writing = 0;
	47
	48	void
	49	serial_log_command (cmd)
	50	const char *cmd;
	51	{
	52	if (serial_reading \|\| serial_writing)
	53	{
0db5a6fe	54	fputc_unfiltered ('\n', serial_logfp);
e8f1ad9a FF	55	serial_reading = 0;
	56	serial_writing = 0;
	57	}
0db5a6fe	58	fprintf_unfiltered (serial_logfp, "c %s\n", cmd);
e8f1ad9a FF	59	/* Make sure that the log file is as up-to-date as possible,
	60	in case we are getting ready to dump core or something. */
	61	fflush (serial_logfp);
	62	}
	63
	64	static void
	65	serial_logchar (ch)
	66	int ch;
	67	{
	68	switch (ch)
	69	{
0db5a6fe FF	70	case '\\': fputs_unfiltered ("\\\\", serial_logfp); break;
	71	case '\b': fputs_unfiltered ("\\b", serial_logfp); break;
	72	case '\f': fputs_unfiltered ("\\f", serial_logfp); break;
	73	case '\n': fputs_unfiltered ("\\n", serial_logfp); break;
	74	case '\r': fputs_unfiltered ("\\r", serial_logfp); break;
	75	case '\t': fputs_unfiltered ("\\t", serial_logfp); break;
	76	case '\v': fputs_unfiltered ("\\v", serial_logfp); break;
	77	default: fprintf_unfiltered (serial_logfp, isprint (ch) ? "%c" : "\\x%02x", ch & 0xFF); break;
e8f1ad9a FF	78	}
	79	}
	80
	81	int
	82	serial_write (scb, str, len)
	83	serial_t scb;
	84	const char *str;
	85	int len;
	86	{
	87	int count;
	88
	89	if (serial_logfp != NULL)
	90	{
	91	if (serial_reading)
	92	{
0db5a6fe	93	fputc_unfiltered ('\n', serial_logfp);
e8f1ad9a FF	94	serial_reading = 0;
	95	}
	96	if (!serial_writing)
	97	{
	98	serial_logchar ('w');
	99	serial_logchar (' ');
	100	serial_writing = 1;
	101	}
	102	for (count = 0; count < len; count++)
	103	{
	104	serial_logchar (str[count]);
	105	}
	106	/* Make sure that the log file is as up-to-date as possible,
	107	in case we are getting ready to dump core or something. */
	108	fflush (serial_logfp);
	109	}
	110	return (scb -> ops -> write (scb, str, len));
	111	}
	112
	113	int
	114	serial_readchar (scb, timeout)
	115	serial_t scb;
	116	int timeout;
	117	{
	118	int ch;
	119
	120	ch = scb -> ops -> readchar (scb, timeout);
	121	if (serial_logfp != NULL)
	122	{
	123	if (serial_writing)
	124	{
0db5a6fe	125	fputc_unfiltered ('\n', serial_logfp);
e8f1ad9a FF	126	serial_writing = 0;
	127	}
	128	if (!serial_reading)
	129	{
	130	serial_logchar ('r');
	131	serial_logchar (' ');
	132	serial_reading = 1;
	133	}
	134	serial_logchar (ch);
	135	/* Make sure that the log file is as up-to-date as possible,
	136	in case we are getting ready to dump core or something. */
	137	fflush (serial_logfp);
	138	}
	139	return (ch);
	140	}
	141
4e772f44 SG	142	static struct serial_ops *
	143	serial_interface_lookup (name)
	144	char *name;
	145	{
	146	struct serial_ops *ops;
	147
	148	for (ops = serial_ops_list; ops; ops = ops->next)
	149	if (strcmp (name, ops->name) == 0)
	150	return ops;
	151
	152	return NULL;
	153	}
	154
	155	void
	156	serial_add_interface(optable)
	157	struct serial_ops *optable;
	158	{
	159	optable->next = serial_ops_list;
	160	serial_ops_list = optable;
	161	}
	162
38dc5e12 SG	163	/* Open up a device or a network socket, depending upon the syntax of NAME. */
38dc5e12 SG	164
4e772f44	165	serial_t
55679787	166	serial_open (name)
4e772f44 SG	167	const char *name;
	168	{
	169	serial_t scb;
	170	struct serial_ops *ops;
	171
4887063b SG	172	for (scb = scb_base; scb; scb = scb->next)
	173	if (scb->name && strcmp (scb->name, name) == 0)
	174	{
	175	scb->refcnt++;
	176	return scb;
	177	}
	178
55679787 SC	179	if (strcmp (name, "pc") == 0)
	180	ops = serial_interface_lookup ("pc");
	181	else if (strchr (name, ':'))
38dc5e12	182	ops = serial_interface_lookup ("tcp");
c84e5000 SC	183	else if (strncmp (name, "lpt", 3) == 0)
c84e5000 SC	184	ops = serial_interface_lookup ("parallel");
38dc5e12 SG	185	else
38dc5e12 SG	186	ops = serial_interface_lookup ("hardwire");
4e772f44 SG	187
	188	if (!ops)
	189	return NULL;
	190
	191	scb = (serial_t)xmalloc (sizeof (struct _serial_t));
	192
	193	scb->ops = ops;
	194
	195	scb->bufcnt = 0;
	196	scb->bufp = scb->buf;
	197
4febd102	198	if (scb->ops->open(scb, name))
4e772f44 SG	199	{
	200	free (scb);
	201	return NULL;
	202	}
	203
4887063b SG	204	scb->name = strsave (name);
	205	scb->next = scb_base;
	206	scb->refcnt = 1;
	207	scb_base = scb;
	208
38dc5e12 SG	209	last_serial_opened = scb;
38dc5e12 SG	210
e8f1ad9a FF	211	if (serial_logfile != NULL)
	212	{
	213	serial_logfp = fopen (serial_logfile, "w");
	214	if (serial_logfp == NULL)
	215	{
	216	perror_with_name (serial_logfile);
	217	}
	218	}
	219
38dc5e12 SG	220	return scb;
	221	}
	222
	223	serial_t
4887063b	224	serial_fdopen (fd)
38dc5e12 SG	225	const int fd;
	226	{
	227	serial_t scb;
	228	struct serial_ops *ops;
	229
4887063b SG	230	for (scb = scb_base; scb; scb = scb->next)
	231	if (scb->fd == fd)
	232	{
	233	scb->refcnt++;
	234	return scb;
	235	}
	236
38dc5e12 SG	237	ops = serial_interface_lookup ("hardwire");
	238
	239	if (!ops)
	240	return NULL;
	241
	242	scb = (serial_t)xmalloc (sizeof (struct _serial_t));
	243
	244	scb->ops = ops;
	245
	246	scb->bufcnt = 0;
	247	scb->bufp = scb->buf;
	248
	249	scb->fd = fd;
	250
4887063b SG	251	scb->name = NULL;
	252	scb->next = scb_base;
	253	scb->refcnt = 1;
	254	scb_base = scb;
	255
38dc5e12 SG	256	last_serial_opened = scb;
38dc5e12 SG	257
4e772f44 SG	258	return scb;
	259	}
	260
4febd102	261	void
bbcc95bd	262	serial_close(scb, really_close)
4febd102	263	serial_t scb;
bbcc95bd	264	int really_close;
4febd102	265	{
4887063b SG	266	serial_t tmp_scb;
4887063b SG	267
38dc5e12 SG	268	last_serial_opened = NULL;
38dc5e12 SG	269
e8f1ad9a FF	270	if (serial_logfp)
	271	{
	272	if (serial_reading \|\| serial_writing)
	273	{
0db5a6fe	274	fputc_unfiltered ('\n', serial_logfp);
e8f1ad9a FF	275	serial_reading = 0;
	276	serial_writing = 0;
	277	}
	278	fclose (serial_logfp);
	279	serial_logfp = NULL;
	280	}
	281
a037b21e SG	282	/* This is bogus. It's not our fault if you pass us a bad scb...! Rob, you
	283	should fix your code instead. */
	284
	285	if (!scb)
	286	return;
	287
4887063b SG	288	scb->refcnt--;
	289	if (scb->refcnt > 0)
	290	return;
	291
bbcc95bd PS	292	if (really_close)
bbcc95bd PS	293	scb->ops->close (scb);
4887063b SG	294
	295	if (scb->name)
	296	free (scb->name);
	297
	298	if (scb_base == scb)
	299	scb_base = scb_base->next;
	300	else
	301	for (tmp_scb = scb_base; tmp_scb; tmp_scb = tmp_scb->next)
	302	{
	303	if (tmp_scb->next != scb)
	304	continue;
	305
	306	tmp_scb->next = tmp_scb->next->next;
	307	break;
	308	}
	309
a037b21e	310	free(scb);
4febd102 SG	311	}
4febd102 SG	312
4e772f44	313	#if 0
bf3b8abd JK	314	/*
	315	The connect command is #if 0 because I hadn't thought of an elegant
	316	way to wait for I/O on two serial_t's simultaneously. Two solutions
	317	came to mind:
	318
	319	1) Fork, and have have one fork handle the to user direction,
	320	and have the other hand the to target direction. This
	321	obviously won't cut it for MSDOS.
	322
	323	2) Use something like select. This assumes that stdin and
	324	the target side can both be waited on via the same
	325	mechanism. This may not be true for DOS, if GDB is
	326	talking to the target via a TCP socket.
	327	-grossman, 8 Jun 93
	328	*/
38dc5e12	329
4e772f44 SG	330	/* Connect the user directly to the remote system. This command acts just like
	331	the 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */
	332
38dc5e12 SG	333	static serial_t tty_desc; /* Controlling terminal */
38dc5e12 SG	334
4e772f44 SG	335	static void
4e772f44 SG	336	cleanup_tty(ttystate)
38dc5e12	337	serial_ttystate ttystate;
4e772f44	338	{
199b2450	339	printf_unfiltered ("\r\n[Exiting connect mode]\r\n");
38dc5e12 SG	340	SERIAL_SET_TTY_STATE (tty_desc, ttystate);
	341	free (ttystate);
	342	SERIAL_CLOSE (tty_desc);
4e772f44 SG	343	}
	344
	345	static void
	346	connect_command (args, fromtty)
	347	char *args;
	348	int fromtty;
	349	{
4e772f44 SG	350	int c;
4e772f44 SG	351	char cur_esc = 0;
38dc5e12 SG	352	serial_ttystate ttystate;
38dc5e12 SG	353	serial_t port_desc; /* TTY port */
4e772f44 SG	354
	355	dont_repeat();
	356
4e772f44	357	if (args)
199b2450	358	fprintf_unfiltered(gdb_stderr, "This command takes no args. They have been ignored.\n");
4e772f44	359
199b2450	360	printf_unfiltered("[Entering connect mode. Use ~. or ~^D to escape]\n");
4e772f44	361
38dc5e12 SG	362	tty_desc = SERIAL_FDOPEN (0);
38dc5e12 SG	363	port_desc = last_serial_opened;
4e772f44	364
38dc5e12	365	ttystate = SERIAL_GET_TTY_STATE (tty_desc);
4e772f44	366
38dc5e12 SG	367	SERIAL_RAW (tty_desc);
	368	SERIAL_RAW (port_desc);
	369
	370	make_cleanup (cleanup_tty, ttystate);
4e772f44 SG	371
	372	while (1)
	373	{
38dc5e12	374	int mask;
4e772f44	375
38dc5e12	376	mask = SERIAL_WAIT_2 (tty_desc, port_desc, -1);
4e772f44	377
38dc5e12 SG	378	if (mask & 2)
38dc5e12 SG	379	{ /* tty input */
4e772f44 SG	380	char cx;
4e772f44 SG	381
38dc5e12	382	while (1)
4e772f44	383	{
38dc5e12 SG	384	c = SERIAL_READCHAR(tty_desc, 0);
	385
	386	if (c == SERIAL_TIMEOUT)
	387	break;
	388
	389	if (c < 0)
	390	perror_with_name("connect");
	391
	392	cx = c;
	393	SERIAL_WRITE(port_desc, &cx, 1);
	394
	395	switch (cur_esc)
	396	{
	397	case 0:
	398	if (c == '\r')
	399	cur_esc = c;
	400	break;
	401	case '\r':
	402	if (c == '~')
	403	cur_esc = c;
	404	else
	405	cur_esc = 0;
	406	break;
	407	case '~':
	408	if (c == '.' \|\| c == '\004')
	409	return;
	410	else
	411	cur_esc = 0;
	412	}
4e772f44 SG	413	}
	414	}
	415
38dc5e12 SG	416	if (mask & 1)
	417	{ /* Port input */
	418	char cx;
	419
4e772f44 SG	420	while (1)
4e772f44 SG	421	{
38dc5e12 SG	422	c = SERIAL_READCHAR(port_desc, 0);
	423
	424	if (c == SERIAL_TIMEOUT)
	425	break;
	426
4e772f44	427	if (c < 0)
38dc5e12 SG	428	perror_with_name("connect");
	429
	430	cx = c;
	431
	432	SERIAL_WRITE(tty_desc, &cx, 1);
4e772f44	433	}
4e772f44 SG	434	}
	435	}
	436	}
976bb0be	437	#endif /* 0 */
4e772f44	438
5c8ba017 SG	439	/* VARARGS */
	440	void
	441	#ifdef ANSI_PROTOTYPES
	442	serial_printf (serial_t desc, const char *format, ...)
	443	#else
	444	serial_printf (va_alist)
	445	va_dcl
	446	#endif
	447	{
	448	va_list args;
	449	char *buf;
	450	#ifdef ANSI_PROTOTYPES
	451	va_start (args, format);
	452	#else
	453	serial_t desc;
	454	char *format;
	455
	456	va_start (args);
	457	desc = va_arg (args, serial_t);
	458	format = va_arg (args, char *);
	459	#endif
	460
	461	vasprintf (&buf, format, args);
	462	SERIAL_WRITE (desc, buf, strlen (buf));
	463
	464	free (buf);
	465	va_end (args);
	466	}
	467
4e772f44 SG	468	void
	469	_initialize_serial ()
	470	{
976bb0be	471	#if 0
4e772f44 SG	472	add_com ("connect", class_obscure, connect_command,
	473	"Connect the terminal directly up to the command monitor.\n\
	474	Use <CR>~. or <CR>~^D to break out.");
38dc5e12	475	#endif /* 0 */
e8f1ad9a FF	476
	477	add_show_from_set (add_set_cmd ("remotelogfile", no_class,
	478	var_filename, (char *)&serial_logfile,
	479	"Set filename for remote session recording.\n\
	480	This file is used to record the remote session for future playback\n\
	481	by gdbserver.", &setlist),
	482	&showlist);
	483
976bb0be	484	}