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;
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
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;
}
}
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);
}
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);
}
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
dev_getaddr(char *dname)
{
int fd;
int mode;
char stty[16], ctty[16];
int found;
struct stat statb;
int tries;
int i;
if (lstat(dname, &statb) >= 0) { /* File exists */
if (S_ISLNK(statb.st_mode)) {
sysmessage(MSG_WARNING, "Removing old sym-link \"%s\".\n", dname);
unlink(dname);
}
else if (!S_ISCHR(statb.st_mode)) {
sysmessage(MSG_ERR, "%s already exists\n", dname);
return (E_PARMINVAL);
}
}
else if (errno != ENOENT) { /* generic stat error */
sysmessage(MSG_ERR, "Can't lstat %s : %s\n", dname, strerror(errno));
return (E_FILEIO);
}
mode = O_RDWR;
# ifdef USE_POSIX_NONBLOCK
mode |= O_NONBLOCK;
# elif defined USE_STD_NDELAY
mode |= O_NDELAY;
# endif
/*
* Warning: most PTY implementation puts master side as controlling terminal if
* O_NOCTTY is not set !!!
*/
mode |= O_NOCTTY;
found = FALSE;
for (tries = 0; tries < NTRIES; tries++) {
for (i = 0; i < MAXPTY; i++) {
sprintf(ctty, "%s%d", CONTROL_PREFIX, i);
if ((fd = open(ctty, mode)) >= 0) {
sysmessage(MSG_NOTICE, "open %s pseudo-tty\n", ctty);
found = TRUE;
goto out;
}
}
sysdelay(PTYDELAY);
}
out:
if (found == FALSE) {
sysmessage(MSG_ERR, "Can't get a free pseudo-tty :\n");
(void) close(fd);
return (E_FILEIO);
}
mode = 1;
if (ioctl(fd, TIOCPKT, &mode) == -1) {
sysmessage(MSG_ERR,
"Can't put master pty in packet mode: %s\n",
strerror(errno));
close(fd);
return (E_FILEIO);
}
sprintf(stty, "%s%d", SLAVE_PREFIX, i);
if (lstat(stty, &statb) == -1) { /* File exists */
sysmessage(MSG_ERR, "Can't sstat slave pty : %s\n", strerror(errno));
close(fd);
return (E_FILEIO);
}
P_devnumber = statb.st_rdev;
if (link(stty, dname) == -1) {
sysmessage(MSG_ERR, "Can't link dev : %s\n", strerror(errno));
return (E_FILEIO);
}
else {
sysmessage(MSG_NOTICE, "Using %s pseudo-tty\n", stty);
}
P_mfd = fd;
strcpy(P_sname, stty);
strcpy(P_devname, dname);
return (E_NORMAL);
}
//******************************************************
// evalstatus - evaluates the status returned from
// acceptscreen library function
//*******************************************************
void evalstatus(unsigned int status, const int bVerbose)
{
unsigned char type;
char dir;
int mode, cols, page, attr, len=0;
static char *goodmsg= "GOOD DATA ";
static char *lenmsg= "LENGTH ERR ";
static char *inputmsg= "INPUT TYPE ERR";
static char *barmsg= "BAR KEY ";
static char *farmsg= "FAR KEY ";
static char *darmsg= "DAR KEY ";
static char *uarmsg= "UAR KEY ";
static char *clrmsg= "CLR KEY ";
static char *bskeymsg= "BS KEY ";
static char *delmsg= "DELETE KEY ";
static char *ltormsg= "L to R SCAN ";
static char *rtolmsg= "R to L SCAN ";
static char *unknown= "UNKNOWN RETVAL";
attr = NORMAL_VID;
getvidmode(&mode, &cols, &page);
setcurpos(page, 4, 2);
switch (status)
{
case GOOD_DATA :
if (bVerbose) writestr (page, goodmsg, len, attr);
break;
case LENGTH_ERR :
if (bVerbose) writestr (page, lenmsg, len, attr);
break;
case INPUT_TYPE_ERR :
if (bVerbose) writestr (page, inputmsg, len, attr);
break;
case WND :
dir = getlabeltype(&type);
if ( dir == L_TO_R)
if (bVerbose) writestr(page, ltormsg, len, attr);
else
if (bVerbose) writestr(page, rtolmsg, len, attr);
switch (type)
{
case PLESSEY:
if (bVerbose) writestr(page, "Plessey", len, attr);
break;
case ALPHA_PLESS:
if (bVerbose) writestr(page, "Alpha Plessey", len, attr);
break;
case ISBN_PLESS:
if (bVerbose) writestr(page, "Isbn Plessey", len, attr);
break;
case PURE_PLESS:
if (bVerbose) writestr(page, "Pure Plessey", len, attr);
break;
case SAIN_PLESS:
if (bVerbose) writestr(page, "Sainesbury Plessey", len, attr);
break;
case UPC:
if (bVerbose) writestr(page, "UPC", len, attr);
break;
case EAN:
if (bVerbose) writestr(page, "Ean", len, attr);
break;
case UPC_EAN:
if (bVerbose) writestr(page, "Upc Ean", len, attr);
break;
case CODABAR:
if (bVerbose) writestr(page, "Codabar", len, attr);
break;
case CODE_3_9:
if (bVerbose) writestr(page, "Code 3 of 9", len, attr);
break;
case CODE_2_5:
if (bVerbose) writestr(page, "Code 2 of 5", len, attr);
break;
case DISCR_2_5:
if (bVerbose) writestr(page, "Discr 2 of 5", len, attr);
break;
case INTERL_2_5:
if (bVerbose) writestr(page, "Interl 2 of 5", len, attr);
break;
case INDUST_2_5:
if (bVerbose) writestr(page, "Indust 2 of 5", len, attr);
break;
case CODE_11:
if (bVerbose) writestr(page, "Code 11", len, attr);
break;
case CODE_128:
if (bVerbose) writestr(page, "Code 128", len, attr);
break;
}
break;
case BAR :
if (bVerbose) writestr (page, barmsg, len, attr);
break;
case FAR :
if (bVerbose) writestr (page, farmsg, len, attr);
break;
case DAR :
if (bVerbose) writestr (page, darmsg, len, attr);
break;
case UAR :
if (bVerbose) writestr (page, uarmsg, len, attr);
break;
case CLR :
if (bVerbose) writestr (page, clrmsg, len, attr);
break;
case BSKEY :
if (bVerbose) writestr (page, bskeymsg, len, attr);
break;
case DEL :
if (bVerbose) writestr (page, delmsg, len, attr);
break;
default : if (bVerbose) write(page, unknown, len, attr);
break;
}
sysdelay(SECOND);
}
int
main(int argc, char **argv)
{
int i;
char *device;
char *rasname;
int physport;
int ptyiosize;
int netiosize;
int retrydelay;
int retry, nretries;
int opt;
int retst;
int devmodem;
int closemode;
int baseport;
struct sockaddr_un control_addr;
struct sigaction act;
struct stat stat_buf;
act.sa_handler = SIG_IGN;
if (sigaction(SIGPIPE, &act, NULL))
sysmessage(MSG_ERR, "Can't block SIGPIPE.\n");
ptyiosize = DEV_DEFIOSZ;
netiosize = SOCK_DEFIOSZ;
retrydelay = RETRY_DELAY;
nretries = NUM_RETRIES;
Nvt.servertype = SRV_RTELNET;
devmodem = DEV_MODEM;
closemode = CLOSE_HANG;
baseport = 0;
Console = FALSE;
Foreground = FALSE;
LogFile = NULL;
Pgname = argv[0];
Debug = 0;
while ((opt = getopt(argc, argv, "u:n:r:fi:st:m:c:p:d:xvhHl:")) != EOF) {
switch (opt) {
case 'u':
ptyiosize = atoi(optarg);
if (ptyiosize > DEV_MAXIOSZ) {
ptyiosize = DEV_MAXIOSZ;
}
break;
case 'n':
netiosize = atoi(optarg);
if (netiosize > SOCK_MAXIOSZ) {
netiosize = SOCK_MAXIOSZ;
}
break;
case 'r':
nretries = atoi(optarg);
break;
case 'f':
Foreground = TRUE;
break;
case 'i':
retrydelay = atoi(optarg) * 1000;
break;
case 's':
Nvt.servertype = SRV_SOCKET;
if (!baseport)
baseport = SOCKET_BASE;
break;
case 'm':
devmodem = atoi(optarg);
break;
case 'c':
closemode = atoi(optarg);
break;
case 'p':
baseport = atoi(optarg);
break;
case 'd':
Debug = atoi(optarg);
break;
case 'x':
Console = TRUE;
Foreground = TRUE;
break;
case 'v':
printf("%s\n", Version);
exit(E_NORMAL);
case 'l':
LogFile = strdup(optarg);
break;
case 'h':
case 'H':
default:
helpmsg();
exit(E_PARMINVAL);
}
}
if (!baseport)
baseport = RTELNET_BASE;
argc -= optind;
argv += optind;
if (argc != 3) {
helpmsg();
exit(E_PARMINVAL);
}
device = argv[0];
mkidmsg(Pgname, device);
rasname = argv[1];
physport = atoi(argv[2]);
if (physport == 0) {
if (Nvt.servertype == SRV_RTELNET) {
baseport = RTELNET_STD;
}
else {
fprintf(stderr,
"%s: Physical port must be > 0 for socket service\n",
Idmsg);
exit(E_PARMINVAL);
}
}
init_system();
/* Get socket and device addresses */
if ((retst = dev_getaddr(device)) != E_NORMAL) {
exit(retst);
}
if (Nvt.servertype == SRV_RTELNET) {
P_contr_listen = socket(PF_UNIX, SOCK_STREAM, 0);
if (P_contr_listen == -1) {
sysmessage(MSG_ERR, "Can't create Unix socket.\n");
exit(1);
}
control_addr.sun_family = AF_UNIX;
snprintf(P_contrname, sizeof(P_contrname), "%s.control", device);
P_contrname[sizeof(P_contrname) - 1] = '\0';
if (!stat(P_contrname, &stat_buf)) {
sysmessage(MSG_WARNING, "Removing old control socket \"%s\".\n",
P_contrname);
unlink(P_contrname);
}
strcpy(control_addr.sun_path, P_contrname);
if (bind
(P_contr_listen, (struct sockaddr *) &control_addr,
sizeof(control_addr)) || listen(P_contr_listen, 8)) {
sysmessage(MSG_ERR, "Can't bind Unix socket.\n");
exit(1);
}
for (i = 0; i < MAX_CONTROL_SOCKS; i++)
P_contr[i] = -1;
}
if ((retst = sock_getaddr(rasname, baseport, physport)) != E_NORMAL)
exit(retst);
retry = 0;
if (!Foreground)
daemon(0, 0);
while (retry < nretries) {
if (retry) {
if (retrydelay) {
sysdelay(retrydelay);
}
sysmessage(MSG_WARNING, "Trying again ... \n");
}
if ((retst = sock_link(netiosize)) != E_NORMAL) {
if (retst != E_CONNECT) {
doexit(retst);
}
retry++;
continue;
}
retry = 0;
tsr_init(netiosize, ptyiosize, devmodem, closemode);
/* Main scheduler */
tsr_io();
retry++;
}
sysmessage(MSG_ERR, "Exiting ...\n");
doexit(E_RETRYEND);
/* Not Reached */
return 0; /* gcc gives a warning otherwise */
}
