[u/mdw/putty] / unix / uxser.c

/*
 * Serial back end (Unix-specific).
 */

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <limits.h>

#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <termios.h>

#include "putty.h"
#include "tree234.h"

#define SERIAL_MAX_BACKLOG 4096

typedef struct serial_backend_data {
    void *frontend;
    int fd;
    int finished;
    int inbufsize;
    bufchain output_data;
} *Serial;

/*
 * We store our serial backends in a tree sorted by fd, so that
 * when we get an uxsel notification we know which backend instance
 * is the owner of the serial port that caused it.
 */
static int serial_compare_by_fd(void *av, void *bv)
{
    Serial a = (Serial)av;
    Serial b = (Serial)bv;

    if (a->fd < b->fd)
	return -1;
    else if (a->fd > b->fd)
	return +1;
    return 0;
}

static int serial_find_by_fd(void *av, void *bv)
{
    int a = *(int *)av;
    Serial b = (Serial)bv;

    if (a < b->fd)
	return -1;
    else if (a > b->fd)
	return +1;
    return 0;
}

static tree234 *serial_by_fd = NULL;

static int serial_select_result(int fd, int event);
static void serial_uxsel_setup(Serial serial);
static void serial_try_write(Serial serial);

static const char *serial_configure(Serial serial, Config *cfg)
{
    struct termios options;
    int bflag, bval;
    const char *str;
    char *msg;

    if (serial->fd < 0)
	return "Unable to reconfigure already-closed serial connection";

    tcgetattr(serial->fd, &options);

    /*
     * Find the appropriate baud rate flag.
     */
#define SETBAUD(x) (bflag = B ## x, bval = x)
#define CHECKBAUD(x) do { if (cfg->serspeed >= x) SETBAUD(x); } while (0)
    SETBAUD(50);
#ifdef B75
    CHECKBAUD(75);
#endif
#ifdef B110
    CHECKBAUD(110);
#endif
#ifdef B134
    CHECKBAUD(134);
#endif
#ifdef B150
    CHECKBAUD(150);
#endif
#ifdef B200
    CHECKBAUD(200);
#endif
#ifdef B300
    CHECKBAUD(300);
#endif
#ifdef B600
    CHECKBAUD(600);
#endif
#ifdef B1200
    CHECKBAUD(1200);
#endif
#ifdef B1800
    CHECKBAUD(1800);
#endif
#ifdef B2400
    CHECKBAUD(2400);
#endif
#ifdef B4800
    CHECKBAUD(4800);
#endif
#ifdef B9600
    CHECKBAUD(9600);
#endif
#ifdef B19200
    CHECKBAUD(19200);
#endif
#ifdef B38400
    CHECKBAUD(38400);
#endif
#ifdef B57600
    CHECKBAUD(57600);
#endif
#ifdef B76800
    CHECKBAUD(76800);
#endif
#ifdef B115200
    CHECKBAUD(115200);
#endif
#ifdef B230400
    CHECKBAUD(230400);
#endif
#undef CHECKBAUD
#undef SETBAUD
    cfsetispeed(&options, bflag);
    cfsetospeed(&options, bflag);
    msg = dupprintf("Configuring baud rate %d", bval);
    logevent(serial->frontend, msg);
    sfree(msg);

    options.c_cflag &= ~CSIZE;
    switch (cfg->serdatabits) {
      case 5: options.c_cflag |= CS5; break;
      case 6: options.c_cflag |= CS6; break;
      case 7: options.c_cflag |= CS7; break;
      case 8: options.c_cflag |= CS8; break;
      default: return "Invalid number of data bits (need 5, 6, 7 or 8)";
    }
    msg = dupprintf("Configuring %d data bits", cfg->serdatabits);
    logevent(serial->frontend, msg);
    sfree(msg);

    if (cfg->serstopbits >= 4) {
	options.c_cflag |= CSTOPB;
    } else {
	options.c_cflag &= ~CSTOPB;
    }
    msg = dupprintf("Configuring %d stop bits",
		    (options.c_cflag & CSTOPB ? 2 : 1));
    logevent(serial->frontend, msg);
    sfree(msg);

    options.c_iflag &= ~(IXON|IXOFF);
#ifdef CRTSCTS
    options.c_cflag &= ~CRTSCTS;
#endif
#ifdef CNEW_RTSCTS
    options.c_cflag &= ~CNEW_RTSCTS;
#endif
    if (cfg->serflow == SER_FLOW_XONXOFF) {
	options.c_iflag |= IXON | IXOFF;
	str = "XON/XOFF";
    } else if (cfg->serflow == SER_FLOW_RTSCTS) {
#ifdef CRTSCTS
	options.c_cflag |= CRTSCTS;
#endif
#ifdef CNEW_RTSCTS
	options.c_cflag |= CNEW_RTSCTS;
#endif
	str = "RTS/CTS";
    } else
	str = "no";
    msg = dupprintf("Configuring %s flow control", str);
    logevent(serial->frontend, msg);
    sfree(msg);

    /* Parity */
    if (cfg->serparity == SER_PAR_ODD) {
	options.c_cflag |= PARENB;
	options.c_cflag |= PARODD;
	str = "odd";
    } else if (cfg->serparity == SER_PAR_EVEN) {
	options.c_cflag |= PARENB;
	options.c_cflag &= ~PARODD;
	str = "even";
    } else {
	options.c_cflag &= ~PARENB;
	str = "no";
    }
    msg = dupprintf("Configuring %s parity", str);
    logevent(serial->frontend, msg);
    sfree(msg);

    options.c_cflag |= CLOCAL | CREAD;
    options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
    options.c_iflag &= ~(ISTRIP | IGNCR | INLCR | ICRNL
#ifdef IUCLC
			 | IUCLC
#endif
			 );
    options.c_oflag &= ~(OPOST
#ifdef ONLCR
			 | ONLCR
#endif
			 | OCRNL | ONOCR | ONLRET);
    options.c_cc[VMIN] = 1;
    options.c_cc[VTIME] = 0;

    if (tcsetattr(serial->fd, TCSANOW, &options) < 0)
	return "Unable to configure serial port";

    return NULL;
}

/*
 * Called to set up the serial connection.
 * 
 * Returns an error message, or NULL on success.
 *
 * Also places the canonical host name into `realhost'. It must be
 * freed by the caller.
 */
static const char *serial_init(void *frontend_handle, void **backend_handle,
			       Config *cfg,
			       char *host, int port, char **realhost, int nodelay,
			       int keepalive)
{
    Serial serial;
    const char *err;

    serial = snew(struct serial_backend_data);
    *backend_handle = serial;

    serial->frontend = frontend_handle;
    serial->finished = FALSE;
    serial->inbufsize = 0;
    bufchain_init(&serial->output_data);

    {
	char *msg = dupprintf("Opening serial device %s", cfg->serline);
	logevent(serial->frontend, msg);
    }

    serial->fd = open(cfg->serline, O_RDWR | O_NOCTTY | O_NDELAY | O_NONBLOCK);
    if (serial->fd < 0)
	return "Unable to open serial port";

    fcntl(serial->fd, F_SETFD, FD_CLOEXEC);

    err = serial_configure(serial, cfg);
    if (err)
	return err;

    *realhost = dupstr(cfg->serline);

    if (!serial_by_fd)
	serial_by_fd = newtree234(serial_compare_by_fd);
    add234(serial_by_fd, serial);

    serial_uxsel_setup(serial);

    /*
     * Specials are always available.
     */
    update_specials_menu(serial->frontend);

    return NULL;
}

static void serial_close(Serial serial)
{
    if (serial->fd >= 0) {
	close(serial->fd);
	serial->fd = -1;
    }
}

static void serial_free(void *handle)
{
    Serial serial = (Serial) handle;

    serial_close(serial);

    bufchain_clear(&serial->output_data);

    sfree(serial);
}

static void serial_reconfig(void *handle, Config *cfg)
{
    Serial serial = (Serial) handle;
    const char *err;

    err = serial_configure(serial, cfg);

    /*
     * FIXME: what should we do if err returns something?
     */
}

static int serial_select_result(int fd, int event)
{
    Serial serial;
    char buf[4096];
    int ret;
    int finished = FALSE;

    serial = find234(serial_by_fd, &fd, serial_find_by_fd);

    if (!serial)
	return 1;		       /* spurious event; keep going */

    if (event == 1) {
	ret = read(serial->fd, buf, sizeof(buf));

	if (ret == 0) {
	    /*
	     * Shouldn't happen on a real serial port, but I'm open
	     * to the idea that there might be two-way devices we
	     * can treat _like_ serial ports which can return EOF.
	     */
	    finished = TRUE;
	} else if (ret < 0) {
	    perror("read serial port");
	    exit(1);
	} else if (ret > 0) {
	    serial->inbufsize = from_backend(serial->frontend, 0, buf, ret);
	    serial_uxsel_setup(serial); /* might acquire backlog and freeze */
	}
    } else if (event == 2) {
	/*
	 * Attempt to send data down the pty.
	 */
	serial_try_write(serial);
    }

    if (finished) {
	serial_close(serial);

	serial->finished = TRUE;

	notify_remote_exit(serial->frontend);
    }

    return !finished;
}

static void serial_uxsel_setup(Serial serial)
{
    int rwx = 0;

    if (serial->inbufsize <= SERIAL_MAX_BACKLOG)
	rwx |= 1;
    if (bufchain_size(&serial->output_data))
        rwx |= 2;                      /* might also want to write to it */
    uxsel_set(serial->fd, rwx, serial_select_result);
}

static void serial_try_write(Serial serial)
{
    void *data;
    int len, ret;

    assert(serial->fd >= 0);

    while (bufchain_size(&serial->output_data) > 0) {
        bufchain_prefix(&serial->output_data, &data, &len);
	ret = write(serial->fd, data, len);

        if (ret < 0 && (errno == EWOULDBLOCK)) {
            /*
             * We've sent all we can for the moment.
             */
            break;
        }
	if (ret < 0) {
	    perror("write serial port");
	    exit(1);
	}
	bufchain_consume(&serial->output_data, ret);
    }

    serial_uxsel_setup(serial);
}

/*
 * Called to send data down the serial connection.
 */
static int serial_send(void *handle, char *buf, int len)
{
    Serial serial = (Serial) handle;

    if (serial->fd < 0)
	return 0;

    bufchain_add(&serial->output_data, buf, len);
    serial_try_write(serial);

    return bufchain_size(&serial->output_data);
}

/*
 * Called to query the current sendability status.
 */
static int serial_sendbuffer(void *handle)
{
    Serial serial = (Serial) handle;
    return bufchain_size(&serial->output_data);
}

/*
 * Called to set the size of the window
 */
static void serial_size(void *handle, int width, int height)
{
    /* Do nothing! */
    return;
}

/*
 * Send serial special codes.
 */
static void serial_special(void *handle, Telnet_Special code)
{
    Serial serial = (Serial) handle;

    if (serial->fd >= 0 && code == TS_BRK) {
	tcsendbreak(serial->fd, 0);
	logevent(serial->frontend, "Sending serial break at user request");
    }

    return;
}

/*
 * Return a list of the special codes that make sense in this
 * protocol.
 */
static const struct telnet_special *serial_get_specials(void *handle)
{
    static const struct telnet_special specials[] = {
	{"Break", TS_BRK},
	{NULL, TS_EXITMENU}
    };
    return specials;
}

static int serial_connected(void *handle)
{
    return 1;			       /* always connected */
}

static int serial_sendok(void *handle)
{
    return 1;
}

static void serial_unthrottle(void *handle, int backlog)
{
    Serial serial = (Serial) handle;
    serial->inbufsize = backlog;
    serial_uxsel_setup(serial);
}

static int serial_ldisc(void *handle, int option)
{
    /*
     * Local editing and local echo are off by default.
     */
    return 0;
}

static void serial_provide_ldisc(void *handle, void *ldisc)
{
    /* This is a stub. */
}

static void serial_provide_logctx(void *handle, void *logctx)
{
    /* This is a stub. */
}

static int serial_exitcode(void *handle)
{
    Serial serial = (Serial) handle;
    if (serial->fd >= 0)
        return -1;                     /* still connected */
    else
        /* Exit codes are a meaningless concept with serial ports */
        return INT_MAX;
}

/*
 * cfg_info for Serial does nothing at all.
 */
static int serial_cfg_info(void *handle)
{
    return 0;
}

Backend serial_backend = {
    serial_init,
    serial_free,
    serial_reconfig,
    serial_send,
    serial_sendbuffer,
    serial_size,
    serial_special,
    serial_get_specials,
    serial_connected,
    serial_exitcode,
    serial_sendok,
    serial_ldisc,
    serial_provide_ldisc,
    serial_provide_logctx,
    serial_unthrottle,
    serial_cfg_info,
    1
};
Commit	Line	Data
aef05b78	1	/*
	2	* Serial back end (Unix-specific).
	3	*/
	4
aef05b78	5	#include <stdio.h>
	6	#include <stdlib.h>
	7	#include <assert.h>
	8	#include <limits.h>
	9
	10	#include <errno.h>
	11	#include <unistd.h>
	12	#include <fcntl.h>
	13	#include <termios.h>
	14
	15	#include "putty.h"
	16	#include "tree234.h"
	17
	18	#define SERIAL_MAX_BACKLOG 4096
	19
	20	typedef struct serial_backend_data {
	21	void *frontend;
	22	int fd;
	23	int finished;
	24	int inbufsize;
	25	bufchain output_data;
	26	} *Serial;
	27
	28	/*
	29	* We store our serial backends in a tree sorted by fd, so that
	30	* when we get an uxsel notification we know which backend instance
	31	* is the owner of the serial port that caused it.
	32	*/
	33	static int serial_compare_by_fd(void av, void bv)
	34	{
	35	Serial a = (Serial)av;
	36	Serial b = (Serial)bv;
	37
	38	if (a->fd < b->fd)
	39	return -1;
	40	else if (a->fd > b->fd)
	41	return +1;
	42	return 0;
	43	}
	44
	45	static int serial_find_by_fd(void av, void bv)
	46	{
	47	int a = (int )av;
	48	Serial b = (Serial)bv;
	49
	50	if (a < b->fd)
	51	return -1;
	52	else if (a > b->fd)
	53	return +1;
	54	return 0;
	55	}
	56
	57	static tree234 *serial_by_fd = NULL;
	58
	59	static int serial_select_result(int fd, int event);
	60	static void serial_uxsel_setup(Serial serial);
	61	static void serial_try_write(Serial serial);
	62
	63	static const char serial_configure(Serial serial, Config cfg)
	64	{
	65	struct termios options;
	66	int bflag, bval;
	67	const char *str;
	68	char *msg;
69
70	if (serial->fd < 0)
71	return "Unable to reconfigure already-closed serial connection";
72
73	tcgetattr(serial->fd, &options);
74
75	/*
76	* Find the appropriate baud rate flag.
77	*/
78	#define SETBAUD(x) (bflag = B ## x, bval = x)
79	#define CHECKBAUD(x) do { if (cfg->serspeed >= x) SETBAUD(x); } while (0)
80	SETBAUD(50);
81	#ifdef B75
82	CHECKBAUD(75);
83	#endif
84	#ifdef B110
85	CHECKBAUD(110);
86	#endif
87	#ifdef B134
88	CHECKBAUD(134);
89	#endif
90	#ifdef B150
91	CHECKBAUD(150);
92	#endif
93	#ifdef B200
94	CHECKBAUD(200);
95	#endif
96	#ifdef B300
97	CHECKBAUD(300);
98	#endif
99	#ifdef B600
100	CHECKBAUD(600);
101	#endif
102	#ifdef B1200
103	CHECKBAUD(1200);
104	#endif
105	#ifdef B1800
106	CHECKBAUD(1800);
107	#endif
108	#ifdef B2400
109	CHECKBAUD(2400);
110	#endif
111	#ifdef B4800
112	CHECKBAUD(4800);
113	#endif
114	#ifdef B9600
115	CHECKBAUD(9600);
116	#endif
117	#ifdef B19200
118	CHECKBAUD(19200);
119	#endif
120	#ifdef B38400
121	CHECKBAUD(38400);
122	#endif
123	#ifdef B57600
124	CHECKBAUD(57600);
125	#endif
126	#ifdef B76800
127	CHECKBAUD(76800);
128	#endif
129	#ifdef B115200
130	CHECKBAUD(115200);
131	#endif
132	#ifdef B230400
133	CHECKBAUD(230400);
134	#endif
135	#undef CHECKBAUD
136	#undef SETBAUD
137	cfsetispeed(&options, bflag);
138	cfsetospeed(&options, bflag);
139	msg = dupprintf("Configuring baud rate %d", bval);
140	logevent(serial->frontend, msg);
141	sfree(msg);
142
143	options.c_cflag &= ~CSIZE;
144	switch (cfg->serdatabits) {
145	case 5: options.c_cflag \|= CS5; break;
146	case 6: options.c_cflag \|= CS6; break;
147	case 7: options.c_cflag \|= CS7; break;
148	case 8: options.c_cflag \|= CS8; break;
149	default: return "Invalid number of data bits (need 5, 6, 7 or 8)";
150	}
151	msg = dupprintf("Configuring %d data bits", cfg->serdatabits);
152	logevent(serial->frontend, msg);
153	sfree(msg);
154
155	if (cfg->serstopbits >= 4) {
156	options.c_cflag \|= CSTOPB;
157	} else {
158	options.c_cflag &= ~CSTOPB;
159	}
160	msg = dupprintf("Configuring %d stop bits",
161	(options.c_cflag & CSTOPB ? 2 : 1));
162	logevent(serial->frontend, msg);
163	sfree(msg);
164
e26f8aa1	165	options.c_iflag &= ~(IXON\|IXOFF);
	166	#ifdef CRTSCTS
	167	options.c_cflag &= ~CRTSCTS;
	168	#endif
	169	#ifdef CNEW_RTSCTS
	170	options.c_cflag &= ~CNEW_RTSCTS;
	171	#endif
aef05b78	172	if (cfg->serflow == SER_FLOW_XONXOFF) {
e26f8aa1	173	options.c_iflag \|= IXON \| IXOFF;
aef05b78	174	str = "XON/XOFF";
	175	} else if (cfg->serflow == SER_FLOW_RTSCTS) {
	176	#ifdef CRTSCTS
	177	options.c_cflag \|= CRTSCTS;
	178	#endif
	179	#ifdef CNEW_RTSCTS
	180	options.c_cflag \|= CNEW_RTSCTS;
	181	#endif
	182	str = "RTS/CTS";
	183	} else
	184	str = "no";
	185	msg = dupprintf("Configuring %s flow control", str);
	186	logevent(serial->frontend, msg);
	187	sfree(msg);
	188
	189	/* Parity */
	190	if (cfg->serparity == SER_PAR_ODD) {
	191	options.c_cflag \|= PARENB;
	192	options.c_cflag \|= PARODD;
	193	str = "odd";
	194	} else if (cfg->serparity == SER_PAR_EVEN) {
	195	options.c_cflag \|= PARENB;
	196	options.c_cflag &= ~PARODD;
	197	str = "even";
	198	} else {
	199	options.c_cflag &= ~PARENB;
	200	str = "no";
	201	}
	202	msg = dupprintf("Configuring %s parity", str);
	203	logevent(serial->frontend, msg);
	204	sfree(msg);
	205
	206	options.c_cflag \|= CLOCAL \| CREAD;
	207	options.c_lflag &= ~(ICANON \| ECHO \| ECHOE \| ISIG);
9a41f8d3	208	options.c_iflag &= ~(ISTRIP \| IGNCR \| INLCR \| ICRNL
	209	#ifdef IUCLC
	210	\| IUCLC
	211	#endif
	212	);
	213	options.c_oflag &= ~(OPOST
	214	#ifdef ONLCR
	215	\| ONLCR
	216	#endif
	217	\| OCRNL \| ONOCR \| ONLRET);
aef05b78	218	options.c_cc[VMIN] = 1;
	219	options.c_cc[VTIME] = 0;
	220
	221	if (tcsetattr(serial->fd, TCSANOW, &options) < 0)
	222	return "Unable to configure serial port";
	223
	224	return NULL;
	225	}
	226
	227	/*
	228	* Called to set up the serial connection.
	229	*
	230	* Returns an error message, or NULL on success.
	231	*
	232	* Also places the canonical host name into `realhost'. It must be
	233	* freed by the caller.
	234	*/
	235	static const char serial_init(void frontend_handle, void **backend_handle,
	236	Config *cfg,
	237	char host, int port, char *realhost, int nodelay,
	238	int keepalive)
	239	{
	240	Serial serial;
	241	const char *err;
	242
	243	serial = snew(struct serial_backend_data);
	244	*backend_handle = serial;
	245
	246	serial->frontend = frontend_handle;
	247	serial->finished = FALSE;
	248	serial->inbufsize = 0;
	249	bufchain_init(&serial->output_data);
	250
	251	{
	252	char *msg = dupprintf("Opening serial device %s", cfg->serline);
	253	logevent(serial->frontend, msg);
	254	}
	255
	256	serial->fd = open(cfg->serline, O_RDWR \| O_NOCTTY \| O_NDELAY \| O_NONBLOCK);
	257	if (serial->fd < 0)
	258	return "Unable to open serial port";
	259
89e97516	260	fcntl(serial->fd, F_SETFD, FD_CLOEXEC);
89e97516	261
aef05b78	262	err = serial_configure(serial, cfg);
	263	if (err)
	264	return err;
	265
	266	*realhost = dupstr(cfg->serline);
	267
	268	if (!serial_by_fd)
	269	serial_by_fd = newtree234(serial_compare_by_fd);
	270	add234(serial_by_fd, serial);
	271
	272	serial_uxsel_setup(serial);
	273
45ef7ce3	274	/*
	275	* Specials are always available.
	276	*/
	277	update_specials_menu(serial->frontend);
	278
aef05b78	279	return NULL;
	280	}
	281
	282	static void serial_close(Serial serial)
	283	{
	284	if (serial->fd >= 0) {
	285	close(serial->fd);
	286	serial->fd = -1;
	287	}
	288	}
	289
	290	static void serial_free(void *handle)
	291	{
	292	Serial serial = (Serial) handle;
	293
	294	serial_close(serial);
	295
	296	bufchain_clear(&serial->output_data);
	297
	298	sfree(serial);
	299	}
	300
	301	static void serial_reconfig(void handle, Config cfg)
	302	{
	303	Serial serial = (Serial) handle;
	304	const char *err;
	305
	306	err = serial_configure(serial, cfg);
	307
	308	/*
	309	* FIXME: what should we do if err returns something?
	310	*/
	311	}
	312
	313	static int serial_select_result(int fd, int event)
	314	{
	315	Serial serial;
	316	char buf[4096];
	317	int ret;
	318	int finished = FALSE;
	319
	320	serial = find234(serial_by_fd, &fd, serial_find_by_fd);
	321
	322	if (!serial)
	323	return 1; /* spurious event; keep going */
	324
	325	if (event == 1) {
	326	ret = read(serial->fd, buf, sizeof(buf));
	327
	328	if (ret == 0) {
	329	/*
	330	* Shouldn't happen on a real serial port, but I'm open
	331	* to the idea that there might be two-way devices we
	332	* can treat _like_ serial ports which can return EOF.
	333	*/
	334	finished = TRUE;
	335	} else if (ret < 0) {
	336	perror("read serial port");
	337	exit(1);
	338	} else if (ret > 0) {
	339	serial->inbufsize = from_backend(serial->frontend, 0, buf, ret);
	340	serial_uxsel_setup(serial); /* might acquire backlog and freeze */
	341	}
	342	} else if (event == 2) {
343	/*
344	* Attempt to send data down the pty.
345	*/
346	serial_try_write(serial);
347	}
348
349	if (finished) {
350	serial_close(serial);
351
352	serial->finished = TRUE;
353
354	notify_remote_exit(serial->frontend);
355	}
356
357	return !finished;
358	}
359
360	static void serial_uxsel_setup(Serial serial)
361	{
362	int rwx = 0;
363
364	if (serial->inbufsize <= SERIAL_MAX_BACKLOG)
365	rwx \|= 1;
366	if (bufchain_size(&serial->output_data))
367	rwx \|= 2; /* might also want to write to it */
368	uxsel_set(serial->fd, rwx, serial_select_result);
369	}
370
371	static void serial_try_write(Serial serial)
372	{
373	void *data;
374	int len, ret;
375
376	assert(serial->fd >= 0);
377
378	while (bufchain_size(&serial->output_data) > 0) {
379	bufchain_prefix(&serial->output_data, &data, &len);
380	ret = write(serial->fd, data, len);
381
382	if (ret < 0 && (errno == EWOULDBLOCK)) {
383	/*
384	* We've sent all we can for the moment.
385	*/
386	break;
387	}
388	if (ret < 0) {
389	perror("write serial port");
390	exit(1);
391	}
392	bufchain_consume(&serial->output_data, ret);
393	}
394
395	serial_uxsel_setup(serial);
396	}
397
398	/*
399	* Called to send data down the serial connection.
400	*/
401	static int serial_send(void handle, char buf, int len)
402	{
403	Serial serial = (Serial) handle;
404
405	if (serial->fd < 0)
406	return 0;
407
408	bufchain_add(&serial->output_data, buf, len);
409	serial_try_write(serial);
410
411	return bufchain_size(&serial->output_data);
412	}
413
414	/*
415	* Called to query the current sendability status.
416	*/
417	static int serial_sendbuffer(void *handle)
418	{
419	Serial serial = (Serial) handle;
420	return bufchain_size(&serial->output_data);
421	}
422
423	/*
424	* Called to set the size of the window
425	*/
426	static void serial_size(void *handle, int width, int height)
427	{
428	/* Do nothing! */
429	return;
430	}
431
432	/*
433	* Send serial special codes.
434	*/
435	static void serial_special(void *handle, Telnet_Special code)
436	{
45ef7ce3	437	Serial serial = (Serial) handle;
	438
	439	if (serial->fd >= 0 && code == TS_BRK) {
	440	tcsendbreak(serial->fd, 0);
	441	logevent(serial->frontend, "Sending serial break at user request");
	442	}
	443
aef05b78	444	return;
	445	}
	446
	447	/*
	448	* Return a list of the special codes that make sense in this
	449	* protocol.
	450	*/
	451	static const struct telnet_special serial_get_specials(void handle)
	452	{
45ef7ce3	453	static const struct telnet_special specials[] = {
	454	{"Break", TS_BRK},
	455	{NULL, TS_EXITMENU}
	456	};
	457	return specials;
aef05b78	458	}
	459
	460	static int serial_connected(void *handle)
	461	{
	462	return 1; /* always connected */
	463	}
	464
	465	static int serial_sendok(void *handle)
	466	{
	467	return 1;
	468	}
	469
	470	static void serial_unthrottle(void *handle, int backlog)
	471	{
	472	Serial serial = (Serial) handle;
	473	serial->inbufsize = backlog;
	474	serial_uxsel_setup(serial);
	475	}
	476
	477	static int serial_ldisc(void *handle, int option)
	478	{
	479	/*
	480	* Local editing and local echo are off by default.
	481	*/
	482	return 0;
	483	}
	484
	485	static void serial_provide_ldisc(void handle, void ldisc)
	486	{
	487	/* This is a stub. */
	488	}
	489
	490	static void serial_provide_logctx(void handle, void logctx)
	491	{
	492	/* This is a stub. */
	493	}
	494
	495	static int serial_exitcode(void *handle)
	496	{
	497	Serial serial = (Serial) handle;
	498	if (serial->fd >= 0)
	499	return -1; /* still connected */
	500	else
	501	/* Exit codes are a meaningless concept with serial ports */
	502	return INT_MAX;
	503	}
	504
	505	/*
	506	* cfg_info for Serial does nothing at all.
	507	*/
	508	static int serial_cfg_info(void *handle)
	509	{
	510	return 0;
	511	}
	512
	513	Backend serial_backend = {
	514	serial_init,
	515	serial_free,
	516	serial_reconfig,
	517	serial_send,
	518	serial_sendbuffer,
	519	serial_size,
	520	serial_special,
	521	serial_get_specials,
522	serial_connected,
523	serial_exitcode,
524	serial_sendok,
525	serial_ldisc,
526	serial_provide_ldisc,
527	serial_provide_logctx,
528	serial_unthrottle,
529	serial_cfg_info,
530	1
531	};