telnet.c

/*
 *
 * Copyright (C) portshare Corporation, 1999-1999. All rights reserved.
 *
 *
 * telnet.c
 * Telnet Network Virtual Terminal routines
 *
 * History
 * 08/17/1999 V.1.0.0 Initial revision
 *
 * History
 * 22/12/1999 V.1.0.1 Some debug enhancements
 *
 */

#include <sys/types.h>
#include <stdio.h>
#include <string.h>

#define _TSR_TELNET_

#include "inc/portshare-ser-cli.h"
#include "inc/system.h"
#include "inc/tsrio.h"
#include "inc/telnet.h"
#include "inc/sock.h"

/*
 * Telnet Protocol Internal Routines
 */

void do_option(int option);
void dont_option(int option);
void will_option(int option);
void wont_option(int option);
void send_option(int type, int option);
void handle_suboption(unsigned char *suboptp, int subsize);

/*
 * RFC 2217 Com Port Routines
 */

void comport_config(void);
void comport_default(void);
int sync_comport_command(int command, int arg);
int comport_command(int command, int arg);
void handle_com_port_command(unsigned char *buf);

/*
 * Debug Routines
 */

void print_all(void);
void print_option(unsigned char c);
void print_control(unsigned char c);

void print_linestate(int state);
void print_modemstate(int state);
void print_speed(int speed);
void print_datasize(int datasize);
void print_stopsize(int stopsize);
void print_parity(int parity);
void print_setcontrol(int control);
void print_purge(int purge);
void print_command(int cmdidx);

/*
 * Internal Variables
 */

struct comport Comport;

# define SUBOPT_MAXSIZE	64

unsigned char Suboptbuf[SUBOPT_MAXSIZE];
int Suboptsize;

unsigned char Comibuf[SOCK_MAXIOSZ];
unsigned char Comobuf[SOCK_MAXIOSZ];

/*
 *	Telnet Protocol Access Routines	
 */

int
tel_init(int netsize, struct buffer *ibp, struct buffer *obp)
{
    int retries = 0;

    Nvt.iosize = netsize;
    Nvt.inbuff = ibp;
    Nvt.outbuff = obp;
    Nvt.comport = &Comport;

    comport_default();		/* Initialize with default values */

    if (Nvt.servertype == SRV_SOCKET)
	return (E_NORMAL);

    sysdelay(SERVER_DELAY);	/* Wait telnet startup */

    SET_I_WANT_TO_SUPPORT(NVT_BINARY);
    SET_HE_MAY_SUPPORT(NVT_BINARY);

    SET_I_WANT_TO_SUPPORT(NVT_COM_PORT_OPTION);
    SEND_WILL(NVT_COM_PORT_OPTION);
    SET_I_SENT_IT(NVT_COM_PORT_OPTION);

    SET_HE_MAY_SUPPORT(NVT_SUPP_GO_AHEAD);
    SEND_DO(NVT_SUPP_GO_AHEAD);
    SET_HE_RECV_IT(NVT_SUPP_GO_AHEAD);

    tel_getdata();

    do {
	sysdelay(OPTION_DELAY);
	tel_getdata();
    } while (!I_DO_SUPPORT(NVT_COM_PORT_OPTION) && retries++ < 2);

    if (I_DO_SUPPORT(NVT_COM_PORT_OPTION)) {
	comport_config();
    }

    return (E_NORMAL);
}


/*
 * Telnet Protocol state
 */

int S_state = S_DATA;

int
tel_getdata(void)
{
    int i;
    int ret;

    struct buffer *bp = Nvt.inbuff;

    unsigned char c;

    if ((ret = sock_read(Comibuf, Nvt.iosize)) <= 0)
	return -1;
    if (Debug > 2) {
	sysmessage(MSG_DEBUG,
		   "Sock_read, %d bytes: %02X %02X %02X %02X %02X %02X %02X %02X\n",
		   ret, Comibuf[0], Comibuf[1], Comibuf[2], Comibuf[3],
		   Comibuf[4], Comibuf[5], Comibuf[6], Comibuf[7]);
    }

    if (Nvt.servertype == SRV_SOCKET) {
	COPY_TO_BUFFER(bp, Comibuf, ret);
	SET_EVENT(EV_RN, EV_RNDATA, 0, 0);
	return (0);
    }

    for (i = 0; i < ret; i++) {
	c = Comibuf[i];
	switch (S_state) {
	case S_DATA:
	    if (c == IAC) {
		S_state = S_IAC;
		print_control(c);
	    }
	    else {
		PUT_BUFFER(bp, c);
/* Event EV_RNDATA will be set at end */
	    }
	    break;
	case S_IAC:
	    switch (c) {
	    case DO:
		S_state = S_DO;
		print_control(c);
		break;
	    case DONT:
		S_state = S_DONT;
		print_control(c);
		break;
	    case WILL:
		S_state = S_WILL;
		print_control(c);
		break;
	    case WONT:
		S_state = S_WONT;
		print_control(c);
		break;
	    case SB:
		S_state = S_SB;
		print_control(c);
		Suboptsize = 0;
		break;
	    case IAC:
	    default:
		S_state = S_DATA;
		PUT_BUFFER(bp, c);
		break;
	    }
	    break;
	case S_DO:
	    print_option(c);
	    S_state = S_DATA;
	    do_option(c);
	    break;
	case S_DONT:
	    print_option(c);
	    S_state = S_DATA;
	    dont_option(c);
	    break;
	case S_WILL:
	    print_option(c);
	    S_state = S_DATA;
	    will_option(c);
	    break;
	case S_WONT:
	    print_option(c);
	    S_state = S_DATA;
	    wont_option(c);
	    break;
	case S_SB:
	    if (c == IAC) {
		S_state = S_SE;
		print_control(c);
	    }
	    else {
		if (Suboptsize > SUBOPT_MAXSIZE) {
		    sysmessage(MSG_WARNING, "Suboption too large\n");
		}
		else {
		    Suboptbuf[Suboptsize++] = c;
		}
	    }
	    break;
	case S_SE:
	    if (c == SE) {
		S_state = S_DATA;
		print_control(c);
		handle_suboption(Suboptbuf, Suboptsize);
		Suboptsize = 0;
	    }
	    else {
		S_state = S_DATA;
		sysmessage(MSG_WARNING, "Suboption not terminated: %d", c);
	    }
	    break;
	}
    }
    if (bp->b_hold) {
	SET_EVENT(EV_RN, EV_RNDATA, 0, 0);
    }

    print_all();
    return (0);
}

int
tel_putdata(struct buffer *bp)
{
    unsigned char c;
    int ret;
    int size;
    int frombuf;

    while (bp->b_hold) {
	if (Nvt.servertype == SRV_SOCKET) {
	    size = min(bp->b_hold, Nvt.iosize);
	    COPY_FROM_BUFFER(bp, Comobuf, size);
	    if ((ret = sock_write(Comobuf, size)) != size) {
		if (ret < 0) {
		    return (ret);
		}
		else {
		    frombuf = size - ret;
		    REWIND_BUFFER(bp, frombuf);
		}
		break;
	    }
	}
	else {			/* OH OH -> Handling IAC */
	    frombuf = min(bp->b_hold, Nvt.iosize);
	    size = 0;
	    while (frombuf--) {
		c = GET_BUFFER(bp);
		if (c == IAC) {
		    if (size == Nvt.iosize - 1) {
			/* avoid break IAC mapping */
			REWIND_BUFFER(bp, 1);
			frombuf++;
			break;
		    }
		    Comobuf[size++] = IAC;
		}
		Comobuf[size++] = c;
		if (size == Nvt.iosize) {
		    break;
		}
	    }
/* the following used to be #if 1 in the linux tree and not included for HPUX */
#ifdef __linux__
	    frombuf = 0;
	    while (size > 0) {
		if ((ret = sock_write(&Comobuf[frombuf], size)) == size) {
		    break;
		}
		if (Debug > 2) {
		    sysmessage(MSG_DEBUG, "Sock write: %d of %d\n", ret,
			       size);
		}
		if (ret < 0) {
		    return (ret);
		}
		frombuf += ret;
		size -= ret;
	    }
#else
	    if ((ret = sock_write(Comobuf, size)) != size) {
		if (Debug > 2) {
		    sysmessage(MSG_DEBUG, "Sock write: %d\n", ret);
		}
		if (ret < 0) {
		    return (ret);
		}
		else {
		    frombuf = 0;
		    while (size-- > ret) {
			if ((c = Comobuf[size - 1])
			    == IAC) {
			    continue;
			}
			frombuf++;
		    }
		}
		if (Debug > 2) {
		    sysmessage(MSG_DEBUG, "Buffer rewind %d\n", frombuf);
		}
		REWIND_BUFFER(bp, frombuf);
		break;
	    }
#endif
	}

    }
    if (bp->b_hold == 0) {
	RESET_BUFFER(bp);
    }
    return (0);
}

int
tel_putcmd(int command, int arg)
{
    return (comport_command(command, arg));
}

void
tel_free(void)
{
    int opt;
    /* Set Telnet protocol in a initial state */

    S_state = S_DATA;
    Suboptsize = 0;

    for (opt = 0; opt < NVT_NUMOPTS; opt++) {
	CLR_I_WANT_TO_SUPPORT(opt);
    }

    (void) sock_unlink();
}

/*
 * Telnet Protocol Internal Routines
 */

void
do_option(int opt)
{
    if (I_WANT_TO_SUPPORT(opt)) {
	SET_I_DO_SUPPORT(opt);
	if (!I_SENT_IT(opt)) {
	    SEND_WILL(opt);
	    SET_I_SENT_IT(opt);
	}
    }
    else {
	SEND_WONT(opt);
    }
}

void
dont_option(int opt)
{
    CLR_I_DO_SUPPORT(opt);
}

void
will_option(int opt)
{
    if (HE_MAY_SUPPORT(opt)) {
	SET_HE_DOES_SUPPORT(opt);
	if (!HE_RECV_IT(opt)) {
	    SEND_DO(opt);
	    SET_HE_RECV_IT(opt);
	}
    }
    else {
	SEND_DONT(opt);
    }
}

void
wont_option(int opt)
{
    CLR_HE_DOES_SUPPORT(opt);
}


void
send_option(int type, int opt)
{
    int ret;
    int size;
    unsigned char *obp;

    obp = &Comobuf[0];

    *obp++ = IAC;
    *obp++ = type;
    *obp++ = opt;

    size = 3;
    obp = &Comobuf[0];

    if (Debug > 2) {
	sysmessage(MSG_DEBUG, "Sock_write, 3 bytes: %02X %02X %02X\n",
		   Comobuf[0], Comobuf[1], Comobuf[2]);
    }

    while (size) {
	if ((ret = sock_write(obp, size)) == -1) {
	    SET_EVENT(EV_RN, EV_RNHANG, 0, 0);
	    break;
	}
	else if (ret != size) {
	    sysmessage(MSG_NOTICE,
		       "Partial write in send_option: %d/%d\n", ret, size);
	    sysdelay(ROOM_DELAY);	/* Wait for room */
	}
	size -= ret;
	obp += ret;
    }
}

void
handle_suboption(unsigned char *suboptp, int subsize)
{
    unsigned char subopt = *suboptp;

    print_option(subopt);

    switch (subopt) {
    case NVT_COM_PORT_OPTION:
	handle_com_port_command(++suboptp);
	subsize--;
	break;
    default:
	sysmessage(MSG_WARNING, "suboption not supported: %d\n", subopt);
	break;
    }
}


/*
 * RFC 2217 Com Port Routines
 */

void
comport_config(void)
{
    int mask;

    Comport.support = TRUE;

    /* Get configuration values */
    sync_comport_command(USR_COM_SET_BAUDRATE, COM_BAUD_REQ);
    sync_comport_command(USR_COM_SET_DATASIZE, COM_DSIZE_REQ);
    sync_comport_command(USR_COM_SET_PARITY, COM_PARITY_REQ);
    sync_comport_command(USR_COM_SET_STOPSIZE, COM_SSIZE_REQ);
    sync_comport_command(USR_COM_SET_CONTROL, COM_FLOW_REQ);

    /* Set port events mask */
    mask = MODEM_DCD | MODEM_CTS;
    sync_comport_command(USR_COM_SET_MODEMSTATE_MASK, mask);
    mask = LINE_BREAK_ERROR | LINE_PARITY_ERROR;
    sync_comport_command(USR_COM_SET_LINESTATE_MASK, mask);

    sysdelay(NOTIFY_DELAY);	/* Wait for notifications */

    tel_getdata();

}

void
comport_default(void)
{

    Comport.support = FALSE;

/*96008N1, No flow , aLL signals ON, noerrors  */

    Comport.portconfig.speed = 9600;
    Comport.portconfig.datasize = 8;
    Comport.portconfig.stopsize = COM_SSIZE_ONE;
    Comport.portconfig.parity = COM_PARITY_NONE;
    Comport.portconfig.flowc = COM_FLOW_NONE;

    Comport.portstate.modemstate = MODEM_DCD | MODEM_DSR | MODEM_CTS;
    Comport.portstate.linestate = 0;
}

int
sync_comport_command(int command, int arg)
{

    if (comport_command(command, arg) == -1)
	return -1;

    SET_CMD_ACTIVE(command);

    do {
	sysdelay(COMPORT_DELAY);
	tel_getdata();
    } while (IS_CMD_ACTIVE(command));
    return 0;
}

int
comport_command(int command, int arg)
{
    int size;
    int ret;
    unsigned char *obp;

    if (Nvt.comport->support == FALSE) {
	CLR_CMD_ACTIVE(command);	/* Synchronous operation */
	SET_EVENT(EV_RN, EV_RNCMDOK, 0, 0);
	return (0);
    }

    obp = &Comobuf[0];

    *obp++ = IAC;
    *obp++ = SB;
    *obp++ = NVT_COM_PORT_OPTION;
    *obp++ = (unsigned char) command;
    switch (command) {
    case USR_COM_SET_BAUDRATE:
	SET_VALUE_4(obp, arg);
	obp += 4;
	break;
    default:
	SET_VALUE_1(obp, arg);
	obp += 1;
	break;
    }
    *obp++ = IAC;
    *obp++ = SE;

    size = (int) (obp - &Comobuf[0]);
    obp = &Comobuf[0];

    if (Debug > 2) {
	sysmessage(MSG_DEBUG,
		   "Sock_write, %d bytes: %02X %02X %02X %02X %02X %02X %02X %02X\n",
		   size, Comobuf[0], Comobuf[1], Comobuf[2], Comobuf[3],
		   Comobuf[4], Comobuf[5], Comobuf[6], Comobuf[7]);
    }
    while (size) {
	if ((ret = sock_write(obp, size)) == -1) {
	    SET_EVENT(EV_RN, EV_RNHANG, 0, 0);
	    return (-1);
	}
	else if (ret != size) {
	    sysmessage(MSG_NOTICE,
		       "Partial write in send_comport: %d/%d\n", ret, size);
	    sysdelay(ROOM_DELAY);	/* Wait for room */
	}
	size -= ret;
	obp += ret;
    }
    return (0);
}

void
handle_com_port_command(unsigned char *buf)
{
    unsigned char cmd = *buf++;
    int cmdarg;
    int cmdidx;
    int is_notify = 0;
    int notify;

    cmdidx = (int) cmd;

    if (cmd >= RAS_COM_START && cmd <= RAS_COM_END) {
	cmdidx -= RAS_COM_START;
    }

    print_command(cmdidx);

    switch (cmd) {
    case RAS_COM_SIGNATURE:
    case RAS_COM_FLOWCONTROL_SUSPEND:
    case RAS_COM_FLOWCONTROL_RESUME:
	break;
    case RAS_COM_SET_BAUDRATE:
	Comport.portconfig.speed = GET_VALUE_4(buf);
	print_speed(Comport.portconfig.speed);
	break;
    case RAS_COM_SET_DATASIZE:
	Comport.portconfig.datasize = GET_VALUE_1(buf);
	print_datasize(Comport.portconfig.datasize);
	break;
    case RAS_COM_SET_PARITY:
	Comport.portconfig.parity = GET_VALUE_1(buf);
	print_parity(Comport.portconfig.parity);
	break;

    case RAS_COM_SET_STOPSIZE:
	Comport.portconfig.stopsize = GET_VALUE_1(buf);
	print_stopsize(Comport.portconfig.stopsize);
	break;

    case RAS_COM_SET_CONTROL:
	cmdarg = GET_VALUE_1(buf);
	print_setcontrol(cmdarg);
	switch (cmdarg) {
	case COM_OFLOW_NONE:
	case COM_OFLOW_SOFT:
	case COM_OFLOW_HARD:
	    Comport.portconfig.flowc = cmdarg;
	    break;
	default:
	    break;
	}

	break;

    case RAS_COM_NOTIFY_LINESTATE:
	is_notify = 1;
	cmdarg = GET_VALUE_1(buf);
	print_linestate(cmdarg);
	Comport.portstate.linestate = cmdarg;
	if (cmdarg & LINE_BREAK_ERROR) {
	    notify = NT_BREAK;
	    SET_EVENT(EV_RN, EV_RNNTFY, &notify, sizeof(int));
	}
	if (cmdarg & LINE_PARITY_ERROR) {
	    notify = NT_PARITY;
	    SET_EVENT(EV_RN, EV_RNNTFY, &notify, sizeof(int));
	}
	break;

    case RAS_COM_SET_LINESTATE_MASK:
	cmdarg = GET_VALUE_1(buf);
	print_linestate(cmdarg);
	break;

    case RAS_COM_NOTIFY_MODEMSTATE:
	is_notify = 1;
	cmdarg = GET_VALUE_1(buf);
	if ((cmdarg ^ Comport.portstate.modemstate) & MODEM_DCD) {
	    if (Comport.portstate.modemstate & MODEM_DCD) {
		notify = NT_DCDOFF;
		SET_EVENT(EV_RN, EV_RNNTFY, &notify, sizeof(int));
	    }
	    else {
		notify = NT_DCDON;
		SET_EVENT(EV_RN, EV_RNNTFY, &notify, sizeof(int));
	    }
	}
	Comport.portstate.modemstate &= ~0xff;
	Comport.portstate.modemstate |= (cmdarg & 0xff);
	print_modemstate(cmdarg);
	break;

    case RAS_COM_SET_MODEMSTATE_MASK:
	cmdarg = GET_VALUE_1(buf);
	print_modemstate(cmdarg);
	break;
    case RAS_COM_PURGE_DATA:
	cmdarg = GET_VALUE_1(buf);
	print_purge(cmdarg);
	break;
    default:
	sysmessage(MSG_NOTICE, "Unnimplemented command: %d\n", cmd);
	break;
    }

    if (!is_notify) {
	if (IS_CMD_ACTIVE(cmdidx)) {
	    CLR_CMD_ACTIVE(cmdidx);	/* Synchronous operation */
	}
	else {
	    SET_EVENT(EV_RN, EV_RNCMDOK, 0, 0);
	}
    }
    print_all();
}

/*
 * Debug Routines
 */

char Debugbuf[512];

void
print_all(void)
{
    if (Debugbuf[0] != 0) {
	sysmessage(MSG_DEBUG, "%s\n", Debugbuf);
    }
    Debugbuf[0] = 0;
}

/*
 * Telnet Protocol Debug
 */

void
print_control(unsigned char c)
{
    if (Debug > 2) {
	char msgbuf[32];

	switch (c) {
	case DO:
	    sprintf(msgbuf, "DO ");
	    break;
	case DONT:
	    sprintf(msgbuf, "DONT ");
	    break;
	case WILL:
	    sprintf(msgbuf, "WILL ");
	    break;
	case WONT:
	    sprintf(msgbuf, "WONT ");
	    break;
	case IAC:
	    sprintf(msgbuf, "IAC ");
	    break;
	case SE:
	    sprintf(msgbuf, "SE ");
	    break;
	case SB:
	    sprintf(msgbuf, "SB ");
	    break;
	default:
	    sprintf(msgbuf, "Ctl %02X ", c);
	    break;
	}
	strcat(Debugbuf, msgbuf);
    }
}


void
print_option(unsigned char c)
{
    if (Debug > 2) {
	char msgbuf[32];
	switch (c) {
	case NVT_BINARY:
	    sprintf(msgbuf, "BINARY ");
	    break;
	case NVT_ECHO:
	    sprintf(msgbuf, "ECHO ");
	    break;
	case NVT_SUPP_GO_AHEAD:
	    sprintf(msgbuf, "SUPPRESS GO AHEAD ");
	    break;
	case NVT_COM_PORT_OPTION:
	    sprintf(msgbuf, "COMM PORT OPTION ");
	    break;
	default:
	    sprintf(msgbuf, "Cmd %3d ", c);
	    break;
	}
	strcat(Debugbuf, msgbuf);
    }
}

/*
 * Com Port Option Debug
 */

const char *const Command_names[] = {
    "COM_SIGNATURE",
    "COM_SET_BAUDRATE",
    "COM_SET_DATASIZE",
    "COM_SET_PARITY",
    "COM_SET_STOPSIZE",
    "COM_SET_CONTROL",
    "COM_NOTIFY_LINESTATE",
    "COM_NOTIFY_MODEMSTATE",
    "COM_FLOWCONTROL_SUSPEND",
    "COM_FLOWCONTROL_RESUME",
    "COM_SET_LINESTATE_MASK",
    "COM_SET_MODEMSTATE_MASK",
    "COM_PURGE_DATA"
};

const char *const Parity_names[] = {
    "PARITY_REQ",
    "PARITY_NONE",
    "PARITY_ODD",
    "PARITY_EVEN",
    "PARITY_MARK",
    "PARITY_SPACE",
};

const char *const Stop_names[] = {
    "SSIZE_REQ",
    "SSIZE_ONE",
    "SSIZE_TWO",
    "SSIZE_1DOT5",
};

const char *const Control_names[] = {
    "OFLOW_REQ",
    "OFLOW_NONE",
    "OFLOW_SOFT",
    "OFLOW_HARD",
    "BREAK_REQ",
    "BREAK_ON",
    "BREAK_OFF",
    "DTR_REQ",
    "DTR_ON",
    "DTR_OFF",
    "RTS_REQ",
    "RTS_ON",
    "RTS_OFF",
    "IFLOW_REQ",
    "IFLOW_NONE",
    "IFLOW_SOFT",
    "IFLOW_HARD",
    "DCD_FLOW",
    "DTR_FLOW",
    "DSR_FLOW",
};

const char *const Purge_names[] = {
    "What??",
    "COM_PURGE_RECV",
    "COM_PURGE_XMIT",
    "COM_PURGE_BOTH",
};


void
print_linestate(int state)
{
    if (Debug > 2) {
	char linestates[256];
	linestates[0] = 0;

	if (state & LINE_TIMEOUT_ERROR) {
	    strcat(linestates, "LINE_TIMEOUT_ERROR ");
	}
	if (state & LINE_SHIFTREG_EMPTY) {
	    strcat(linestates, "LINE_SHIFTREG_EMPTY ");
	}
	if (state & LINE_HOLDREG_EMPTY) {
	    strcat(linestates, "LINE_HOLDREG_EMPTY ");
	}
	if (state & LINE_BREAK_ERROR) {
	    strcat(linestates, "LINE_BREAK_ERROR ");
	}
	if (state & LINE_FRAME_ERROR) {
	    strcat(linestates, "LINE_FRAME_ERROR ");
	}
	if (state & LINE_PARITY_ERROR) {
	    strcat(linestates, "LINE_PARITY_ERROR ");
	}
	if (state & LINE_OVERRUN_ERROR) {
	    strcat(linestates, "LINE_OVERRUN_ERROR ");
	}
	if (state & LINE_DATA_READY) {
	    strcat(linestates, "LINE_DATA_READY ");
	}
	strcat(Debugbuf, linestates);
    }
}

void
print_modemstate(int state)
{
    if (Debug > 2) {

	char modemstates[256];
	modemstates[0] = 0;

	if (state & MODEM_DTR) {
	    strcat(modemstates, "MODEM_DTR ");
	}
	if (state & MODEM_RTS) {
	    strcat(modemstates, "MODEM_RTS ");
	}
	if (state & MODEM_DCD) {
	    strcat(modemstates, "MODEM_DCD ");
	}
	if (state & MODEM_RI) {
	    strcat(modemstates, "MODEM_RI ");
	}
	if (state & MODEM_DSR) {
	    strcat(modemstates, "MODEM_DSR ");
	}
	if (state & MODEM_CTS) {
	    strcat(modemstates, "MODEM_CTS ");
	}
	if (state & MODEM_DELTA_DCD) {
	    strcat(modemstates, "MODEM_DELTA_DCD ");
	}
	if (state & MODEM_TRAIL_RI) {
	    strcat(modemstates, "MODEM_TRAIL_RI ");
	}
	if (state & MODEM_DELTA_DSR) {
	    strcat(modemstates, "MODEM_DELTA_DSR ");
	}
	if (state & MODEM_DELTA_CTS) {
	    strcat(modemstates, "MODEM_DELTA_CTS ");
	}

	strcat(Debugbuf, modemstates);
    }
}

void
print_speed(int speed)
{
    if (Debug > 2) {
	char buf[32];
	sprintf(buf, "Speed: %d bps ", speed);
	strcat(Debugbuf, buf);
    }
}

void
print_datasize(int datasize)
{
    if (Debug > 2) {
	char buf[32];
	sprintf(buf, "Datasize: %d bits ", datasize);
	strcat(Debugbuf, buf);
    }
}

void
print_stopsize(int stopsize)
{
    if (Debug > 2) {
	char buf[32];
	sprintf(buf, "%s ", Stop_names[stopsize]);
	strcat(Debugbuf, buf);
    }
}

void
print_parity(int parity)
{
    if (Debug > 2) {
	char buf[32];
	sprintf(buf, "%s ", Parity_names[parity]);
	strcat(Debugbuf, buf);
    }
}

void
print_setcontrol(int control)
{
    if (Debug > 2) {
	char buf[32];
	sprintf(buf, "%s ", Control_names[control]);
	strcat(Debugbuf, buf);
    }
}

void
print_purge(int purge)
{
    if (Debug > 2) {
	char buf[32];
	sprintf(buf, "%s ", Purge_names[purge]);
	strcat(Debugbuf, buf);
    }
}

void
print_command(int cmdidx)
{
    if (Debug > 2) {
	char buf[32];
	sprintf(buf, "%s: ", Command_names[cmdidx]);
	strcat(Debugbuf, buf);
    }
}