通讯/手机编程

开发平台：

Windows_Unix

ckutio.c：源码内容

debug(F101,"in_chk COHERENT select","",n);
#else
#ifdef SVR4
n = select( FD_SETSIZE, &rfds, (fd_set *)0, (fd_set *)0, &tv );
debug(F101,"in_chk SVR4 select","",n);
#else
#ifdef __linux__
n = select( FD_SETSIZE, &rfds, (fd_set *)0, (fd_set *)0, &tv );
debug(F101,"in_chk LINUX select","",n);
#else
n = select( FD_SETSIZE, &rfds, (int *)0, (int *)0, &tv );
debug(F101,"in_chk catchall select","",n);
#endif /* __linux__ */
#endif /* SVR4 */
#endif /* COHERENT */
#endif /* QNX */
#endif /* SOLARIS */
#endif /* BSD43 */
#endif /* BSD44 */
#endif /* BELLV10 */
#endif /* Plan9 */
}
#else /* Not SELECT */
#ifdef CK_POLL
{
struct pollfd pfd;
pfd.fd = fd;
pfd.events = POLLIN;
pfd.revents = 0;
n = poll(&pfd, 1, 0);
debug(F101,"in_chk poll","",n);
if ((n > 0) && (pfd.revents & POLLIN))
n = 1;
}
#endif /* CK_POLL */
#endif /* SELECT */
#endif /* RDCHK */
#endif /* PROVX1 */
#endif /* V7 */
#endif /* FIONREAD */
/* From here down, treat console and communication device differently... */
if (channel == 0) { /* Console */
#ifdef SVORPOSIX
#ifndef FIONREAD
#ifndef SELECT
#ifndef CK_POLL
#ifndef RDCHK
/*
This is the hideous hack used in System V and POSIX systems that don't
support FIONREAD, rdchk(), select(), poll(), etc, in which the user's
CONNECT-mode escape character is attached to SIGQUIT. Used, obviously,
only on the console.
*/
if (conesc) { /* Escape character typed == SIGQUIT */
debug(F100,"in_chk conesc","",conesc);
conesc = 0;
signal(SIGQUIT,esctrp); /* Restore signal */
n += 1;
}
#endif /* RDCHK */
#endif /* CK_POLL */
#endif /* SELECT */
#endif /* FIONREAD */
#endif /* SVORPOSIX */
return(n); /* Done with console */
}
if (channel != 0) { /* Communications connection */
#ifdef MYREAD
#ifndef FIONREAD
/*
select() or rdchk(), etc, has told us that something is waiting, but we
don't know how much. So we do a read to get it and then we know. Note:
This read is NOT nonblocking if nothing is there (because of VMIN=1), but
it should be safe in this case since the OS tells us at least one byte is
waiting to be read, and MYREAD reads return as much as is there without
waiting for any more. Controlled tests on Solaris and Unixware (with
FIONREAD deliberately undefined) show this to be true.
*/
debug(F101,"in_chk read my_count","",my_count);
debug(F101,"in_chk read n","",n);
if (n > 0 && my_count == 0) {
/* This also catches disconnects etc */
/* Do what mygetbuf does except don't grab a character */
my_count = myfillbuf();
my_item = -1; /* ^^^ */
debug(F101,"in_chk myfillbuf my_count","",my_count);
if (my_count < 0)
return(-1);
else
n = 0; /* NB: n is replaced by my_count */
}
#endif /* FIONREAD */
/*
Here we add whatever we think is unread to what is still in our
our internal buffer. Thus the importance of setting n to 0 just above.
*/
debug(F101,"in_chk my_count","",my_count);
debug(F101,"in_chk n","",n);
if (my_count > 0)
n += my_count;
#endif /* MYREAD */
}
debug(F101,"in_chk result","",n);
/* Errors here don't prove the connection has dropped so just say 0 */
return(n < 0 ? 0 : n);
}
/* T T C H K -- Tell how many characters are waiting in tty input buffer */
int
ttchk() {
int fd;
#ifdef NETCMD
if (ttpipe)
fd = fdin;
else
#endif /* NETCMD */
fd = ttyfd;
return(in_chk(1,fd));
}
/* T T X I N -- Get n characters from tty input buffer */
/* Returns number of characters actually gotten, or -1 on failure */
/* Intended for use only when it is known that n characters are actually */
/* Available in the input buffer. */
int
ttxin(n,buf) int n; CHAR *buf; {
register int x = 0, i = 0, c = -2;
char cc;
int fd;
if (n < 1) /* Nothing to do */
return(0);
#ifdef TTLEBUF
if (ttpush >= 0) {
buf[0] = ttpush; /* Put pushed char in buffer*/
ttpush = -1; /* Clear the push buffer */
if (ttchk() > 0)
return(ttxin(n-1, &buf[1]) + 1);
else
return(1);
}
if (le_data) {
while (le_inbuf() > 0) {
if (le_getchar(&buf[i])) {
i++;
n--;
}
}
if (ttchk() > 0)
return(ttxin(n,&buf[i])+i);
else
return(i);
}
#endif /* TTLEBUF */
#ifdef NETCMD
if (ttpipe)
fd = fdin;
else
#endif /* NETCMD */
fd = ttyfd;
#ifdef SUNX25
if (netconn && (ttnet == NET_SX25)) /* X.25 connection */
return(x25xin(n,buf));
#endif /* SUNX25 */
#ifdef IBMX25
/* riehm: possibly not needed. Test worked with normal reads and writes */
if (netconn && (ttnet == NET_IX25)) { /* X.25 connection */
x = x25xin(n,buf);
if (x > 0) buf[x] = '';
return(x);
}
#endif /* IBMX25 */
#ifdef MYREAD
debug(F101,"ttxin MYREAD","",n);
while (x < n) {
c = myread();
if (c < 0) {
debug(F101,"ttxin myread returns","",c);
if (c == -3) x = -1;
break;
}
buf[x++] = c & ttpmsk;
#ifdef RLOGCODE
#ifdef CK_KERBEROS
/* It is impossible to know how many characters are waiting */
/* to be read when you are using Encrypted Rlogin or SSL */
/* as the transport since the number of real data bytes */
/* can be greater or less than the number of bytes on the */
/* wire which is what ttchk() returns. */
if (netconn && (ttnproto == NP_EK4LOGIN || ttnproto == NP_EK5LOGIN))
if (ttchk() <= 0)
break;
#endif /* CK_KERBEROS */
#endif /* RLOGCODE */
#ifdef CK_SSL
if (ssl_active_flag || tls_active_flag)
if (ttchk() <= 0)
break;
#endif /* CK_SSL */
}
#else
debug(F101,"ttxin READ","",n);
x = read(fd,buf,n);
for (c = 0; c < n; c++) /* Strip any parity */
buf[c] &= ttpmsk;
#endif /* MYREAD */
debug(F101,"ttxin x","",x); /* Done */
if (x > 0) buf[x] = '';
if (x < 0) x = -1;
return(x);
}
/* T T O L -- Write string s, length n, to communication device. */
/*
Returns:
>= 0 on success, number of characters actually written.
-1 on failure.
*/
#ifdef CK_ENCRYPTION
CHAR * xpacket = NULL;
int nxpacket = 0;
#endif /* CK_ENCRYPTION */
#define TTOLMAXT 5
int
ttol(s,n) int n; CHAR *s; {
int x, len, tries, fd;
#ifdef CKXXCHAR
extern int dblflag; /* For SET SEND DOUBLE-CHARACTER */
extern short dblt[];
CHAR *p = NULL, *p2, *s2, c;
int n2 = 0;
#endif /* CKXXCHAR */
if (ttyfd < 0) /* Not open? */
return(-3);
#ifdef DEBUG
if (deblog) hexdump("ttol s",s,n);
#endif /* DEBUG */
#ifdef NETCMD
if (ttpipe)
fd = fdout;
else
#endif /* NETCMD */
fd = ttyfd;
#ifdef CKXXCHAR
/* Double any characters that must be doubled. */
debug(F101,"ttol dblflag","",dblflag);
if (dblflag) {
p = (CHAR *) malloc(n + n + 1);
if (p) {
s2 = s;
p2 = p;
n2 = 0;
while (*s2) {
c = *s2++;
*p2++ = c;
n2++;
if (dblt[(unsigned) c] & 2) {
*p2++ = c;
n2++;
}
}
s = p;
n = n2;
s[n] = '';
}
}
debug(F111,"ttol doubled",s,n);
#endif /* CKXXCHAR */
tries = TTOLMAXT; /* Allow up to this many tries */
len = n; /* Remember original length */
#ifdef CK_ENCRYPTION
/*
This is to avoid encrypting a packet that is already encrypted, e.g.
when we resend a packet directly out of the packet buffer, and also to
avoid encrypting a constant (literal) string, which can cause a memory
fault.
*/
if (TELOPT_ME(TELOPT_ENCRYPTION)) {
int x;
if (nxpacket < n) {
if (xpacket) {
free(xpacket);
xpacket = NULL;
nxpacket = 0;
}
x = n > 10240 ? n : 10240;
xpacket = (CHAR *)malloc(x);
if (!xpacket) {
fprintf(stderr,"ttol malloc failuren");
return(-1);
} else
nxpacket = x;
}
memcpy((char *)xpacket,(char *)s,n);
s = xpacket;
ck_tn_encrypt((char *)s,n);
}
#endif /* CK_ENCRYPTION */
while (n > 0 &&
(tries-- > 0
#ifdef CK_ENCRYPTION
/* keep trying if we are encrypting */
|| TELOPT_ME(TELOPT_ENCRYPTION)
#endif /* CK_ENCRYPTION */
)) { /* Be persistent */
debug(F101,"ttol try","",TTOLMAXT - tries);
#ifdef BEOSORBEBOX
if (netconn && !ttpipe && !ttpty)
x = nettol(s,n); /* Write string to device */
else
#endif /* BEOSORBEBOX */
#ifdef IBMX25
if (ttnet == NET_IX25)
/*
* this is a more controlled way of writing to X25
* STREAMS, however write should also work!
*/
x = x25write(ttyfd, s, n);
else
#endif /* IBMX25 */
#ifdef CK_SSL
if (ssl_active_flag || tls_active_flag) {
int error;
/* Write using SSL */
if (ssl_active_flag)
x = SSL_write(ssl_con, s, n);
else
x = SSL_write(tls_con, s, n);
switch (SSL_get_error(ssl_active_flag?ssl_con:tls_con,x)) {
case SSL_ERROR_NONE:
break;
case SSL_ERROR_WANT_WRITE:
case SSL_ERROR_WANT_READ:
x = 0;
break;
case SSL_ERROR_SYSCALL:
case SSL_ERROR_WANT_X509_LOOKUP:
case SSL_ERROR_SSL:
case SSL_ERROR_ZERO_RETURN:
default:
ttclos(0);
return(-3);
}
} else
#endif /* CK_SSL */
#ifdef RLOGCODE
#ifdef CK_KERBEROS
#ifdef KRB4
if (ttnproto == NP_EK4LOGIN) {
return(krb4_des_write(ttyfd,s,n));
} else
#endif /* KRB4 */
#ifdef KRB5
if (ttnproto == NP_EK5LOGIN) {
return(krb5_des_write(ttyfd,s,n));
} else
#endif /* KRB5 */
#endif /* CK_KERBEROS */
#endif /* RLOGCODE */
x = write(fd,s,n); /* Write string to device */
if (x == n) { /* Worked? */
debug(F101,"ttol ok","",x); /* OK */
#ifdef CKXXCHAR
if (p) free(p);
#endif /* CKXXCHAR */
return(len); /* Done */
} else if (x < 0) { /* No, got error? */
debug(F101,"ttol write error","",errno);
#ifdef EWOULDBLOCK
if (errno == EWOULDBLOCK) {
msleep(10);
continue;
} else
#endif /* EWOULDBLOCK */
#ifdef TCPSOCKET
if (netconn && ttnet == NET_TCPB) {
debug(F101,"ttol TCP error","",errno);
ttclos(0); /* Close the connection. */
x = -3;
}
#endif /* TCPSOCKET */
#ifdef CKXXCHAR
if (p) free(p);
#endif /* CKXXCHAR */
return(x);
} else { /* No error, so partial success */
debug(F101,"ttol partial","",x); /* This never happens */
s += x; /* Point to part not written yet */
n -= x; /* Adjust length */
if (x > 0) msleep(10); /* Wait 10 msec */
} /* Go back and try again */
}
#ifdef CKXXCHAR
if (p) free(p);
#endif /* CKXXCHAR */
return(n < 1 ? len : -1); /* Return the results */
}
/* T T O C -- Output a character to the communication line */
/*
This function should only be used for interactive, character-mode operations,
like terminal connection, script execution, dialer i/o, where the overhead
of the signals and alarms does not create a bottleneck.
*/
int
#ifdef CK_ANSIC
ttoc(char c)
#else
ttoc(c) char c;
#endif /* CK_ANSIC */
/* ttoc */ {
#define TTOC_TMO 15 /* Timeout in case we get stuck */
int xx, fd;
if (ttyfd < 0) /* Check for not open. */
return(-1);
#ifdef NETCMD
if (ttpipe)
fd = fdout;
else
#endif /* NETCMD */
fd = ttyfd;
c &= 0xff;
/* debug(F101,"ttoc","",(CHAR) c); */
saval = signal(SIGALRM,timerh); /* Enable timer interrupt */
xx = alarm(TTOC_TMO); /* for this many seconds. */
if (xx < 0) xx = 0; /* Save old alarm value. */
/* debug(F101,"ttoc alarm","",xx); */
if (
#ifdef CK_POSIX_SIG
sigsetjmp(sjbuf,1)
#else
setjmp(sjbuf)
#endif /* CK_POSIX_SIG */
) { /* Timer went off? */
ttimoff(); /* Yes, cancel this alarm. */
if (xx - TTOC_TMO > 0) alarm(xx - TTOC_TMO); /* Restore previous one */
/* debug(F100,"ttoc timeout","",0); */
#ifdef NETCONN
if (!netconn) {
#endif /* NETCONN */
debug(F101,"ttoc timeout","",c);
if (ttflow == FLO_XONX) {
debug(F101,"ttoc flow","",ttflow); /* Maybe we're xoff'd */
#ifndef Plan9
#ifdef POSIX
/* POSIX way to unstick. */
debug(F100,"ttoc tcflow","",tcflow(ttyfd,TCOON));
#else
#ifdef BSD4 /* Berkeley way to do it. */
#ifdef TIOCSTART
/* .... Used to be "ioctl(ttyfd, TIOCSTART, 0);". Who knows? */
{
int x = 0;
debug(F101,"ttoc TIOCSTART","",ioctl(ttyfd, TIOCSTART, &x));
}
#endif /* TIOCSTART */
#endif /* BSD4 */
/* Is there a Sys V way to do this? */
#endif /* POSIX */
#endif /* Plan9 */
}
#ifdef NETCONN
}
#endif /* NETCONN */
return(-1); /* Return failure code. */
} else {
int rc;
#ifdef BEOSORBEBOX
#ifdef NETCONN
if (netconn && !ttpipe && !ttpty)
rc = nettoc(c);
else
#endif /* BEOSORBEBOX */
#endif /* NETCONN */
#ifdef CK_ENCRYPTION
if (TELOPT_ME(TELOPT_ENCRYPTION))
ck_tn_encrypt(&c,1);
#endif /* CK_ENCRYPTION */
#ifdef IBMX25
/* riehm: maybe this isn't necessary after all. Test program
* worked fine with data being sent and retrieved with normal
* read's and writes!
*/
if (ttnet == NET_IX25)
rc = x25write(ttyfd,&c,1); /* as above for X25 streams */
else
#endif /* IBMX25 */
#ifdef CK_SSL
if (ssl_active_flag || tls_active_flag) {
int error;
/* Write using SSL */
if (ssl_active_flag)
rc = SSL_write(ssl_con, &c, 1);
else
rc = SSL_write(tls_con, &c, 1);
switch (SSL_get_error(ssl_active_flag?ssl_con:tls_con,rc)){
case SSL_ERROR_NONE:
break;
case SSL_ERROR_WANT_WRITE:
case SSL_ERROR_WANT_READ:
rc = 0;
break;
case SSL_ERROR_SYSCALL:
case SSL_ERROR_WANT_X509_LOOKUP:
case SSL_ERROR_SSL:
case SSL_ERROR_ZERO_RETURN:
default:
ttclos(0);
return(-1);
}
} else
#endif /* CK_SSL */
#ifdef RLOGCODE
#ifdef CK_KERBEROS
#ifdef KRB4
if (ttnproto == NP_EK4LOGIN) {
rc = (krb4_des_write(ttyfd,&c,1) == 1);
} else
#endif /* KRB4 */
#ifdef KRB5
if (ttnproto == NP_EK5LOGIN) {
rc = (krb5_des_write(ttyfd,&c,1) == 1);
} else
#endif /* KRB5 */
#endif /* CK_KERBEROS */
#endif /* RLOGCODE */
rc = write(fd,&c,1); /* Try to write the character. */
if (rc < 1) { /* Failed */
ttimoff(); /* Turn off the alarm. */
alarm(xx); /* Restore previous alarm. */
debug(F101,"ttoc errno","",errno); /* Log the error, */
return(-1); /* and return the error code. */
}
}
ttimoff(); /* Success, turn off the alarm. */
alarm(xx); /* Restore previous alarm. */
return(0); /* Return good code. */
}
/* T T I N L -- Read a record (up to break character) from comm line. */
/*
Reads up to "max" characters from the communication line, terminating on:
(a) the packet length field if the "turn" argument is zero, or
(b) on the packet-end character (eol) if the "turn" argument is nonzero
(c) a certain number of Ctrl-C's in a row
Returns:
>= 0, the number of characters read upon success;
-1 if "max" exceeded, timeout, or other correctable error;
-2 on user interruption (c);
-3 on fatal error like connection lost.
The characters that were input are copied into "dest" with their parity bits
stripped if parity was selected. Returns the number of characters read.
Characters after the eol are available upon the next call to this function.
The idea is to minimize the number of system calls per packet, and also to
minimize timeouts. This function is the inner loop of the protocol and must
be as efficient as possible. The current strategy is to use myread().
WARNING: This function calls parchk(), which is defined in another module.
Normally, ckutio.c does not depend on code from any other module, but there
is an exception in this case because all the other ck?tio.c modules also
need to call parchk(), so it's better to have it defined in a common place.
*/
#ifdef CTRLC
#undef CTRLC
#endif /* CTRLC */
#define CTRLC '3'
/*
We have four different declarations here because:
(a) to allow Kermit to be built without the automatic parity sensing feature
(b) one of each type for ANSI C, one for non-ANSI.
*/
static int csave = -1;
#ifndef NOXFER
int
#ifdef PARSENSE
#ifdef CK_ANSIC
ttinl(CHAR *dest, int max,int timo, CHAR eol, CHAR start, int turn)
#else
ttinl(dest,max,timo,eol,start,turn) int max,timo,turn; CHAR *dest, eol, start;
#endif /* CK_ANSIC */
#else /* not PARSENSE */
#ifdef CK_ANSIC
ttinl(CHAR *dest, int max,int timo, CHAR eol)
#else
ttinl(dest,max,timo,eol) int max,timo; CHAR *dest, eol;
#endif /* __SDTC__ */
#endif /* PARSENSE */
/* ttinl */ {
#ifndef MYREAD
CHAR ch, dum;
#endif /* MYREAD */
#ifdef PARSENSE
int pktlen = -1;
int lplen = 0;
int havelen = 0;
#endif /* PARSENSE */
int cc = 0; /* Character count */
int fd;
int sopmask = 0xff; /* Start-Of-Packet mask */
#ifdef CKXXCHAR
extern short dblt[]; /* Ignore-character table */
extern int ignflag;
#endif /* CKXXCHAR */
#ifdef TCPSOCKET
extern CHAR stchr;
#endif /* TCPSOCKET */
int x;
if (ttyfd < 0) return(-3); /* Not open. */
debug(F101,"ttinl max","",max);
debug(F101,"ttinl timo","",timo);
#ifdef NETCMD
if (ttpipe)
fd = fdin;
else
#endif /* NETCMD */
fd = ttyfd;
#ifdef COMMENT
if (xlocal && conchk() > 0) /* Allow for console interruptions */
return(-1);
#endif /* COMMENT */
*dest = ''; /* Clear destination buffer */
if (timo < 0) timo = 0; /* Safety */
if (timo) { /* Don't time out if timo == 0 */
int xx;
saval = signal(SIGALRM,timerh); /* Enable timer interrupt */
xx = alarm(timo); /* Set it. */
debug(F101,"ttinl alarm","",xx);
}
if (
#ifdef CK_POSIX_SIG
sigsetjmp(sjbuf,1)
#else
setjmp(sjbuf)
#endif /* CK_POSIX_SIG */
) { /* Timer went off? */
debug(F100,"ttinl timout","",0); /* Get here on timeout. */
/* debug(F110," with",(char *) dest,0); */
ttimoff(); /* Turn off timer */
return(-1); /* and return error code. */
} else {
register int i, n; /* local variables */
int ccn = 0;
#ifdef PARSENSE
register int flag = 0;
debug(F000,"ttinl start","",start);
#endif /* PARSENSE */
ttpmsk = ttprty ? 0177 : 0377; /* Set parity stripping mask. */
sopmask = needpchk ? 0177 : ttpmsk; /* And SOP matching mask. */
/* Now read into destination, stripping parity and looking for the */
/* the packet terminator, and also for several Ctrl-C's typed in a row. */
i = 0; /* Destination index */
debug(F101,"ttinl eol","",eol);
while (i < max-1) {
#ifdef MYREAD
/* debug(F101,"ttinl i","",i); */
errno = 0;
if (csave > -1) {
n = csave;
debug(F101,"ttinl unsaving","",n);
} else
#ifdef COMMENT
if (xlocal && conchk() > 0) {
/* Here we could catch keyboard interruptions. */
/* But this would be VERY expensive. */
/* We could also do it in myread() but it would be */
/* expensive there too -- even if done with select()... */
}
#endif /* COMMENT */
if ((n = myread()) < 0) { /* Timeout or i/o error? */
#ifdef DEBUG
if (deblog) {
debug(F101,"ttinl myread failure, n","",n);
debug(F101,"ttinl myread errno","",errno);
}
#endif /* DEBUG */
/* Don't let EINTR break packets. */
if (n == -3) {
if (errno == EINTR && i > 0) {
debug(F111,"ttinl EINTR myread i","continuing",i);
continue;
} else {
debug(F110,"ttinl non-EINTR -3","closing",0);
wasclosed = 1;
ttimoff(); /* Turn off timer */
ttclos(0);
return(n);
}
} else if (n == -2 && netconn /* && timo == 0 */ ) {
/* Here we try to catch broken network connections */
/* even when ioctl() and read() do not catch them */
debug(F111,"ttinl network myread failure","closing",n);
wasclosed = 1;
ttimoff();
ttclos(0);
return(-3);
}
break; /* Break out of while loop */
}
#else /* not MYREAD (is this code used anywhere any more?) */
if (csave > -1) /* Char saved from last time */
ch = csave;
else if ((n = read(fd, &ch, 1)) < 1)
break; /* Error - break out of while loop */
n = ch;
#endif /* MYREAD */
/* Get here with char in n */
#ifdef CK_ENCRYPTION
/* If csave > -1 we already decrypted this character */
/* So don't decrypt it again */
if (TELOPT_U(TELOPT_ENCRYPTION) && csave == -1) {
CHAR ch = n;
ck_tn_decrypt(&ch,1);
n = ch;
}
#endif /* CK_ENCRYPTION */
csave = -1; /* Unflag that we unsaved a char */
#ifdef TCPSOCKET
if (n == IAC && /* Handle Telnet options */
((xlocal && netconn && (ttnproto == NP_TELNET)) ||
(!xlocal && sstelnet))) {
n = tt_tnopt(n);
if (n < 0)
return(n);
else if (n == 1)
start = stchr;
if (n != 255) /* No data - go back for next char */
continue;
} /* Quoted IAC - keep going */
#endif /* TCPSOCKET */
#ifdef CKXXCHAR
if (ignflag)
if (dblt[(unsigned) n] & 1) /* Character to ignore? */
continue;
#endif /* CKXXCHAR */
/*
Use parity mask, rather than always stripping parity, to check for
cancellation. Otherwise, runs like x03x83x03 in a packet could cancel
the transfer when parity is NONE. (Note that x03x03x03 is extremely
unlikely due to run-length encoding.)
*/
/* Check cancellation */
if (!xlocal && xfrcan && ((n & ttpmsk) == xfrchr)) {
if (++ccn >= xfrnum) { /* If xfrnum in a row, bail out. */
if (timo) { /* Clear timer. */
ttimoff();
}
if (xfrchr < 32)
printf("^%c...rn",(char)(xfrchr+64));
else
printf("Canceled...rn");
return(-2);
}
} else ccn = 0; /* No cancellation, reset counter, */
#ifdef PARSENSE
if (flag == 0) { /* Find the Start-Of-Packet. */
if ((n & sopmask) == start) { /* Got it */
flag = 1;
} else { /* Keep looking... */
debug(F000,"ttinl skipping","",n);
continue;
}
}
dest[i++] = n & ttpmsk;
/*
If we have not been instructed to wait for a turnaround character, we
can go by the packet length field. If turn != 0, we must wait for the
end of line (eol) character before returning. This is an egregious
violation of all principles of layering...
*/
if (!havelen) {
if (i == 2) {
pktlen = xunchar(dest[1] & 0x7f);
if (pktlen > 1) {
havelen = 1;
debug(F101,"ttinl length","",pktlen);
}
} else if (i == 5 && pktlen == 0) {
lplen = xunchar(dest[4] & 0x7f);
} else if (i == 6 && pktlen == 0) {
pktlen = lplen * 95 + xunchar(dest[5] & 0x7f) + 5;
havelen = 1;
debug(F101,"ttinl extended length","",pktlen);
}
}
/*
Suppose we looked at the sequence number here and found it was out of
range? This would mean either (a) incoming packets had SOP unprefixed
and we are out of sync, or (b) the packet is damaged. Since (a) is bad
practice, let's ignore it. So what should we do here if we know the
packet is damaged?
1. Nothing -- keep trying to read the packet till we find what we think
is the end, or we time out, and let the upper layer decide what to
do. But since either the packet is corrupt or we are out of sync,
our criterion for finding the end does not apply and we are likely
to time out (or swallow a piece of the next packet) if our assumed
length is too long. (This was the behavior prior to version 7.0.)
2. set flag = 0 and continue? This would force us to wait for the
next packet to come in, and therefore (in the nonwindowing case),
would force a timeout in the other Kermit.
3. set flag = 0 and continue, but only if the window size is > 1 and
the window is not blocked? Talk about cheating!
4. Return a failure code and let the upper layer decide what to do.
This should be equivalent to 3, but without the cheating. So let's
do it that way...
*/
if (i == 3) { /* Peek at sequence number */
x = xunchar(dest[i-1]); /* If it's not in range... */
if (x < 0 || x > 63) {
debug(F111,"ttinl bad seq",dest,x);
if (timo) ttimoff();
return(-1); /* return a nonfatal error */
}
}
#else /* PARSENSE */
dest[i++] = n & ttpmsk;
#endif /* PARSENSE */
/* Check for end of packet */
if (
#ifdef PARSENSE
/*
Purely length-driven if SET HANDSHAKE NONE (i.e. turn == 0).
This allows packet terminators and handshake characters to appear
literally inside a packet data field.
*/
(havelen && (i > pktlen+1) &&
(!turn || (turn && (n & 0x7f) == turn))) /* (turn, not eol) */
#else /* !PARSENSE */
/*
Built without PARSENSE, so just look for packet terminator.
*/
((n & 0x7f) == eol)
#endif /* PARSENSE */
) {
#ifndef PARSENSE
debug(F101,"ttinl got eol","",eol); /* (or turn) */
dest[i] = ''; /* Yes, terminate the string, */
/* debug(F101,"ttinl i","",i); */
#else
#ifdef DEBUG
if (deblog) {
if ((n & 0x7f) != eol) {
debug(F101,"ttinl EOP length","",pktlen);
debug(F101,"ttinl i","",i);
#ifdef MYREAD
#ifdef PARSENSE
/*
We read a packet based on its length. This leaves the EOP character still
unread, and so ttchk() will always return at least 1 because of this. But
if we know it is there, we can safely get rid of it. So...
*/
{
int x;
while (my_count > 0) {
x = ttinc(0);
/* Start of next packet */
if (x == start) { /* Save for next time */
csave = (unsigned)((unsigned)x & 0xff);
debug(F000,"ttinl csaved","",x);
break;
}
debug(F000,"ttinl removed","",x);
}
}
#endif /* PARSENSE */
#endif /* MYREAD */
} else debug(F101,"ttinl got eol","",eol); /* (or turn) */
}
#endif /* DEBUG */
dest[i] = ''; /* Terminate the string, */
if (needpchk) { /* Parity checked yet? */
if (ttprty == 0) { /* No, check. */
if ((ttprty = parchk(dest,start,i)) > 0) {
int j;
debug(F101,"ttinl senses parity","",ttprty);
debug(F110,"ttinl packet before",dest,0);
ttpmsk = 0x7f;
for (j = 0; j < i; j++)
dest[j] &= 0x7f; /* Strip parity from packet */
debug(F110,"ttinl packet after ",dest,0);
} else ttprty = 0; /* Restore if parchk error */
}
sopmask = ttprty;
needpchk = 0;
}
#endif /* PARSENSE */
if (timo) { /* Turn off timer. */
ttimoff();
}
debug(F011,"ttinl got", dest, (i < 60) ? i : -60);
return(i);
}
} /* End of while() */
ttimoff();
return(n);
}
}
#endif /* NOXFER */
/* T T I N C -- Read a character from the communication line */
/*
On success, returns the character that was read, >= 0.
On failure, returns -1 or other negative myread error code,
or -2 if connection is broken or ttyfd < 0.
or -3 if session limit has expired,
or -4 if something or other...
NOTE: The API does not provide for ttinc() returning a special code
upon timeout, but we need it. So for this we have a global variable,
ttinctimo.
*/
static int ttinctimo = 0; /* Yuk */
int
ttinc(timo) int timo; {
int n = 0, fd;
int is_tn = 0;
CHAR ch = 0;
ttinctimo = 0;
if (ttyfd < 0) return(-2); /* Not open. */
is_tn = (xlocal && netconn && ttnproto == NP_TELNET) ||
(!xlocal && sstelnet);
#ifdef TTLEBUF
if (ttpush >= 0) {
debug(F111,"ttinc","ttpush",ttpush);
ch = ttpush;
ttpush = -1;
return(ch);
}
if (le_data) {
if (le_getchar(&ch) > 0) {
debug(F111,"ttinc le_getchar","ch",ch);
return(ch);
}
}
#endif /* TTLEBUF */
#ifdef NETCMD
if (ttpipe)
fd = fdin;
else
#endif /* NETCMD */
fd = ttyfd;
if ((timo <= 0) /* Untimed. */
#ifdef MYREAD
|| (my_count > 0) /* Buffered char already waiting. */
#endif /* MYREAD */
) {
#ifdef MYREAD
/* Comm line failure returns -1 thru myread, so no &= 0377 */
n = myread(); /* Wait for a character... */
/* debug(F000,"ttinc MYREAD n","",n); */
#ifdef CK_ENCRYPTION
/* debug(F101,"ttinc u_encrypt","",TELOPT_U(TELOPT_ENCRYPTION)); */
if (TELOPT_U(TELOPT_ENCRYPTION) && n >= 0) {
ch = n;
ck_tn_decrypt(&ch,1);
n = ch;
}
#endif /* CK_ENCRYPTION */
#ifdef NETPTY
if (ttpty && n < 0) {
debug(F101,"ttinc error on pty","",n);
ttclos(0);
return(n);
}
#endif /* NETPTY */
#ifdef TNCODE
if ((n > -1) && is_tn)
return((unsigned)(n & 0xff));
else
#endif /* TNCODE */
return(n < 0 ? n : (unsigned)(n & ttpmsk));
#else /* MYREAD */
while ((n = read(fd,&ch,1)) == 0) /* Wait for a character. */
/* Shouldn't have to loop in ver 5A. */
#ifdef NETCONN
if (netconn) { /* Special handling for net */
netclos(); /* If read() returns 0 it means */
netconn = 0; /* the connection has dropped. */
errno = ENOTCONN;
return(-2);
}
#endif /* NETCONN */
;
/* debug(F101,"ttinc","",ch); */
#ifdef TNCODE
if ((n > 0) && is_tn) {
#ifdef CK_ENCRYPTION
if (TELOPT_U(TELOPT_ENCRYPTION)) {
ck_tn_decrypt(&ch,1);
n = ch;
}
#endif /* CK_ENCRYPTION */
return((unsigned)(ch & 0xff));
} else
#endif /* TNCODE */
return((n < 0) ? -4 : ((n == 0) ? -1 : (unsigned)(ch & ttpmsk)));
#endif /* MYREAD */
} else { /* Timed read */
int oldalarm;
saval = signal(SIGALRM,timerh); /* Set up handler, save old one. */
oldalarm = alarm(timo); /* Set alarm, save old one. */
if (
#ifdef CK_POSIX_SIG
sigsetjmp(sjbuf,1)
#else
setjmp(sjbuf)
#endif /* CK_POSIX_SIG */
) { /* Timer expired */
ttinctimo = 1;
n = -1; /* set flag */
} else {
#ifdef MYREAD
n = myread(); /* If managing own buffer... */
debug(F101,"ttinc myread","",n);
ch = n;
#else
n = read(fd,&ch,1); /* Otherwise call the system. */
if (n == 0) n = -1;
debug(F101,"ttinc read","",n);
#endif /* MYREAD */
#ifdef CK_ENCRYPTION
if (TELOPT_U(TELOPT_ENCRYPTION) && n >= 0) {
ck_tn_decrypt(&ch,1);
}
#endif /* CK_ENCRYPTION */
if (n >= 0)
n = (unsigned) (ch & 0xff);
else
n = (n < 0) ? -4 : -2; /* Special return codes. */
}
ttimoff(); /* Turn off the timer */
if (oldalarm > 0) {
if (n == -1) /* and restore any previous alarm */
oldalarm -= timo;
if (oldalarm < 0) /* adjusted by our timeout interval */
oldalarm = 0;
if (oldalarm) {
debug(F101,"ttinc restoring oldalarm","",oldalarm);
alarm(oldalarm);
}
}
#ifdef NETCONN
if (netconn) {
if (n == -2) { /* read() returns 0 */
netclos(); /* on network read failure */
netconn = 0;
errno = ENOTCONN;
}
}
#endif /* NETCONN */
#ifdef TNCODE
if ((n > -1) && is_tn)
return((unsigned)(n & 0xff));
else
#endif /* TNCODE */
/* Return masked char or neg. */
return( (n < 0) ? n : (unsigned)(n & ttpmsk) );
}
}
/* S N D B R K -- Send a BREAK signal of the given duration */
static int
#ifdef CK_ANSIC
sndbrk(int msec) { /* Argument is milliseconds */
#else
sndbrk(msec) int msec; {
#endif /* CK_ANSIC */
#ifndef POSIX
int x, n;
#endif /* POSIX */
#ifdef OXOS
#define BSDBREAK
#endif /* OXOS */
#ifdef ANYBSD
#define BSDBREAK
#endif /* ANYBSD */
#ifdef BSD44
#define BSDBREAK
#endif /* BSD44 */
#ifdef COHERENT
#ifdef BSDBREAK
#undef BSDBREAK
#endif /* BSDBREAK */
#endif /* COHERENT */
#ifdef BELLV10
#ifdef BSDBREAK
#undef BSDBREAK
#endif /* BSDBREAK */
#endif /* BELLV10 */
#ifdef PROVX1
char spd;
#endif /* PROVX1 */
debug(F101,"ttsndb ttyfd","",ttyfd);
if (ttyfd < 0) return(-1); /* Not open. */
#ifdef Plan9
return p9sndbrk(msec);
#else
#ifdef NETCONN
#ifdef NETCMD
if (ttpipe) /* Pipe */
return(ttoc(''));
#endif /* NETCMD */
#ifdef NETPTY
if (ttpty)
return(ttoc(''));
#endif /* NETPTY */
if (netconn) /* Send network BREAK */
return(netbreak());
#endif /* NETCONN */
if (msec < 1 || msec > 5000) return(-1); /* Bad argument */
#ifdef POSIX /* Easy in POSIX */
debug(F101,"sndbrk POSIX","",msec);
return(tcsendbreak(ttyfd,msec / 375));
#else
#ifdef PROVX1
gtty(ttyfd,&ttbuf); /* Get current tty flags */
spd = ttbuf.sg_ospeed; /* Save speed */
ttbuf.sg_ospeed = B50; /* Change to 50 baud */
stty(ttyfd,&ttbuf); /* ... */
n = (int)strlen(brnuls); /* Send the right number of nulls */
x = msec / 91;
if (x > n) x = n;
write(ttyfd,brnuls,n);
ttbuf.sg_ospeed = spd; /* Restore speed */
stty(ttyfd,&ttbuf); /* ... */
return(0);
#else
#ifdef aegis
sio_$control((short)ttyfd, sio_$send_break, msec, st);
return(0);
#else
#ifdef BSDBREAK
n = FWRITE; /* Flush output queue. */
/* Watch out for int vs long problems in &n arg! */
debug(F101,"sndbrk BSDBREAK","",msec);
ioctl(ttyfd,TIOCFLUSH,&n); /* Ignore any errors.. */
if (ioctl(ttyfd,TIOCSBRK,(char *)0) < 0) { /* Turn on BREAK */
perror("Can't send BREAK");
return(-1);
}
x = msleep(msec); /* Sleep for so many milliseconds */
if (ioctl(ttyfd,TIOCCBRK,(char *)0) < 0) { /* Turn off BREAK */
perror("BREAK stuck!!!");
doexit(BAD_EXIT,-1); /* Get out, closing the line. */
/* with bad exit status */
}
return(x);
#else
#ifdef ATTSV
/*
No way to send a long BREAK in Sys V, so send a bunch of regular ones.
(Actually, Sys V R4 is *supposed* to have the POSIX tcsendbreak() function,
but there's no way for this code to know for sure.)
*/
debug(F101,"sndbrk ATTSV","",msec);
x = msec / 275;
for (n = 0; n < x; n++) {
/* Reportedly the cast breaks this function on some systems */
/* But then why was it here in the first place? */
if (ioctl(ttyfd,TCSBRK, /* (char *) */ 0) < 0) {
perror("Can't send BREAK");
return(-1);
}
}
return(0);
#else
#ifdef V7
debug(F101,"sndbrk V7","",msec);
return(genbrk(ttyfd,250)); /* Simulate a BREAK */
#else
debug(F101,"sndbrk catchall","",msec);
ttoc(0);ttoc(0);ttoc(0);ttoc(0);
return(0);
#endif /* V7 */
#endif /* BSDBREAK */
#endif /* ATTSV */
#endif /* aegis */
#endif /* PROVX1 */
#endif /* POSIX */
#endif /* Plan9 */
}
/* T T S N D B -- Send a BREAK signal */
int
ttsndb() {
return(sndbrk(275));
}
/* T T S N D L B -- Send a Long BREAK signal */
int
ttsndlb() {
return(sndbrk(1500));
}
/* M S L E E P -- Millisecond version of sleep(). */
/*
Call with number of milliseconds (thousandths of seconds) to sleep.
Intended only for small intervals. For big ones, just use sleep().
Highly system-dependent.
Returns 0 always, even if it didn't work.
*/
/* Define MSLFTIME for systems that must use an ftime() loop. */
#ifdef ANYBSD /* For pre-4.2 BSD versions */
#ifndef BSD4
#define MSLFTIME
#endif /* BSD4 */
#endif /* ANYBSD */
#ifdef TOWER1 /* NCR Tower OS 1.0 */
#define MSLFTIME
#endif /* TOWER1 */
#ifdef COHERENT /* Coherent... */
#ifndef _I386 /* Maybe Coherent/386 should get this, too */
#define MSLFTIME /* Opinions are divided */
#endif /* _I386 */
#endif /* COHERENT */
#ifdef COMMENT
#ifdef GETMSEC
/* Millisecond timer */
static long msecbase = 0L; /* Unsigned long not portable */
long
getmsec() { /* Milliseconds since base time */
struct timeval xv;
struct timezone xz;
long secs, msecs;
if (
#ifdef GTODONEARG
gettimeofday(&tv)
#else
#ifdef PTX
gettimeofday(&tv, NULL)
#else
gettimeofday(&tv, &tz)
#endif /* PTX */
#endif /* GTODONEARG */
< 0)
return(-1);
if (msecbase == 0L) { /* First call, set base time. */
msecbase = tv.tv_sec;
debug(F101,"getmsec base","",msecbase);
}
return(((tv.tv_sec - msecbase) * 1000L) + (tv.tv_usec / 1000L));
}
#endif /* GETMSEC */
#endif /* COMMENT */
#ifdef SELECT
int
ttwait(fd, secs) int fd, secs; {
int x;
fd_set rfds;
FD_ZERO(&rfds);
FD_SET(fd,&rfds);
tv.tv_sec = secs;
tv.tv_usec = 0L;
errno = 0;
if ((x = select(FD_SETSIZE,
#ifdef HPUX9
(int *)
#else
#ifdef HPUX1000
(int *)
#endif /* HPUX1000 */
#endif /* HPUX9 */
&rfds,
0, 0, &tv)) < 0) {
debug(F101,"ttwait select errno","",errno);
return(0);
} else {
debug(F101,"ttwait OK","",errno);
x = FD_ISSET(fd, &rfds);
debug(F101,"ttwait select x","",x);
return(x ? 1 : 0);
}
}
#endif /* SELECT */
int
msleep(m) int m; {
/*
Other possibilities here are:
nanosleep(), reportedly defined in POSIX.4.
sginap(), IRIX only (back to what IRIX version I don't know).
*/
#ifdef Plan9
return _SLEEP(m);
#else
#ifdef BEOSORBEBOX
snooze(m*1000);
#else /* BEOSORBEBOX */
#ifdef SELECT
int t1, x;
debug(F101,"msleep SELECT 1","",m);
if (m <= 0) return(0);
if (m >= 1000) { /* Catch big arguments. */
sleep(m/1000);
m = m % 1000;
if (m < 10) return(0);
}
debug(F101,"msleep SELECT 2","",m);
#ifdef BELLV10
x = select( 0, (fd_set *)0, (fd_set *)0, (fd_set *)0, m );
debug(F101,"msleep BELLV10 select","",x);
#else /* BELLV10 */
#ifdef HPUX9
gettimeofday(&tv, &tz);
#else
#ifndef COHERENT
#ifdef GTODONEARG
if (gettimeofday(&tv) < 0)
#else
#ifdef PTX
if (gettimeofday(&tv,NULL) < 0)
#else
if (gettimeofday(&tv, &tz) < 0)
#endif /* PTX */
#endif /* GTODONEARG */
return(-1);
t1 = tv.tv_sec; /* Seconds */
#endif /* COHERENT */
#endif /* HPUX9 */
tv.tv_sec = 0; /* Use select() */
tv.tv_usec = m * 1000L;
#ifdef BSD44
x = select( 0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv );
debug(F101,"msleep BSD44 select","",x);
#else /* BSD44 */
#ifdef __linux__
x = select( 0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv );
debug(F101,"msleep __linux__ select","",x);
#else /* __linux__ */
#ifdef BSD43
x = select( 0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv );
debug(F101,"msleep BSD43 select","",x);
#else /* BSD43 */
#ifdef QNX
x = select( 0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv );
debug(F101,"msleep QNX select","",x);
#else /* QNX */
#ifdef COHERENT
x = select( 0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv );
debug(F101,"msleep COHERENT select","",x);
#else /* COHERENT */
#ifdef HPUX1000 /* 10.00 only, not 10.10 or later */
x = select( 0, (int *)0, (int *)0, (int *)0, &tv );
debug(F101,"msleep HP-UX 10.00 select","",x);
#else /* HPUX1000 */
#ifdef SVR4
x = select( 0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv );
debug(F101,"msleep SVR4 select","",x);
#else /* SVR4 */
#ifdef OSF40
x = select( 0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv );
debug(F101,"msleep OSF40 select","",x);
#else /* OSF40 */
#ifdef PTX
x = select( 0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv );
debug(F101,"msleep OSF40 select","",x);
#else
x = select( 0, (int *)0, (int *)0, (int *)0, &tv );
debug(F101,"msleep catch-all select","",x);
#endif /* PTX */
#endif /* OSF40 */
#endif /* HP1000 */
#endif /* SVR4 */
#endif /* COHERENT */
#endif /* QNX */
#endif /* BSD43 */
#endif /* __linux__ */
#endif /* BSD44 */
#endif /* BELLV10 */
return(0);
#else /* Not SELECT */
#ifdef CK_POLL /* We have poll() */
struct pollfd pfd; /* Supply a valid address for poll() */
#ifdef ODT30 /* But in SCO ODT 3.0 */
#ifdef NAP /* we should use nap() instead */
debug(F101,"msleep ODT 3.0 NAP","",m); /* because using poll() here */
nap((long)m); /* seems to break dialing. */
return(0);
#else
debug(F101,"msleep ODT 3.0 POLL","",m);
poll(&pfd, 0, m);
return(0);
#endif /* NAP */
#else
debug(F101,"msleep POLL","",m);
poll(&pfd, 0, m);
return(0);
#endif /* ODT30 */
/*
We could handle the above more cleanly by just letting nap() take
always take precedence over poll() in this routine, but there is no way
to know whether that would break something else.
*/
#else /* Not POLL */
#ifdef USLEEP
/*
"This routine is implemented using setitimer(2); it requires eight
system calls...". In other words, it might take 5 minutes to sleep
10 milliseconds...
*/
debug(F101,"msleep USLEEP","",m);
if (m >= 1000) { /* Catch big arguments. */
sleep(m/1000);
m = m % 1000;
if (m < 10) return(0);
}
usleep((unsigned int)(m * 1000));
return(0);
#else
#ifdef aegis
time_$clock_t dur;
debug(F101,"msleep aegis","",m);
dur.c2.high16 = 0;
dur.c2.low32 = 250 * m; /* one millisecond = 250 four microsecond ticks */
time_$wait(time_$relative, dur, st);
return(0);
#else
#ifdef PROVX1
debug(F101,"msleep Venix","",m);
if (m <= 0) return(0);
sleep(-((m * 60 + 500) / 1000));
return(0);
#else
#ifdef NAP
debug(F101,"msleep NAP","",m);
nap((long)m);
return(0);
#else
#ifdef ATTSV
#ifndef BSD44
extern long times(); /* Or #include <times.h> ? */
#endif /* BSD44 */
long t1, t2, tarray[4];
int t3;
char *cp = getenv("HZ");
int CLOCK_TICK;
int hertz;
if (cp && (hertz = atoi(cp))) {
CLOCK_TICK = 1000 / hertz;
} else { /* probably single user mode */
#ifdef HZ
CLOCK_TICK = 1000 / HZ;
#else
static warned = 0;
/* HZ always exists in, for instance, SCO Xenix, so you don't have to
* make special #ifdefs for XENIX here, like in ver 4F. Also, if you
* have Xenix, you have should have nap(), so the best is to use -DNAP
* in the makefile. Most systems have HZ.
*/
CLOCK_TICK = 17; /* 1/60 sec */
if (!warned) {
printf("warning: environment variable HZ bad... using HZ=%drn",
1000 / CLOCK_TICK);
warned = 1;
}
#endif /* !HZ */
}
debug(F101,"msleep ATTSV","",m);
if (m <= 0) return(0);
if (m >= 1000) { /* Catch big arguments. */
sleep(m/1000);
m = m % 1000;
if (m < 10) return(0);
}
if ((t1 = times(tarray)) < 0) return(-1);
while (1) {
if ((t2 = times(tarray)) < 0) return(-1);
t3 = ((int)(t2 - t1)) * CLOCK_TICK;
if (t3 > m) return(t3);
}
#else /* Not ATTSV */
#ifdef MSLFTIME /* Use ftime() loop... */
int t1, t3 = 0;
debug(F101,"msleep MSLFTIME","",m);
if (m <= 0) return(0);
if (m >= 1000) { /* Catch big arguments. */
sleep(m/1000);
m = m % 1000;
if (m < 10) return(0);
}
#ifdef QNX
ftime(&ftp); /* void ftime() in QNX */
#else
if (ftime(&ftp) < 0) return(-1); /* Get base time. */
#endif /* QNX */
t1 = ((ftp.time & 0xff) * 1000) + ftp.millitm;
while (1) {
ftime(&ftp); /* Get current time and compare. */
t3 = (((ftp.time & 0xff) * 1000) + ftp.millitm) - t1;
if (t3 > m) return(0);
}
#else
/* This includes true POSIX, which has no way to do this. */
debug(F101,"msleep busy loop","",m);
if (m >= 1000) { /* Catch big arguments. */
sleep(m/1000);
m = m % 1000;
if (m < 10) return(0);
}
if (m > 0) while (m > 0) m--; /* Just a dumb busy loop */
return(0);
#endif /* MSLFTIME */
#endif /* ATTSV */
#endif /* NAP */
#endif /* PROVX1 */
#endif /* aegis */
#endif /* CK_POLL */
#endif /* SELECT */
#endif /* BEOSORBEBOX */
#endif /* USLEEP */
#endif /* Plan9 */
}
/* R T I M E R -- Reset elapsed time counter */
VOID
rtimer() {
tcount = time( (time_t *) 0 );
}
/* G T I M E R -- Get current value of elapsed time counter in seconds */
int
gtimer() {
int x;
x = (int) (time( (time_t *) 0 ) - tcount);
debug(F101,"gtimer","",x);
return( (x < 0) ? 0 : x );
}
#ifdef GFTIMER
/*
Floating-point timers. Require not only floating point support, but
also gettimeofday().
*/
static struct timeval tzero;
VOID
rftimer() {
#ifdef GTODONEARG /* Account for Mot's definition */
(VOID) gettimeofday(&tzero);
#else
(VOID) gettimeofday(&tzero, (struct timezone *)0);
#endif /* GTODONEARG */
}
CKFLOAT
gftimer() {
struct timeval tnow, tdelta;
CKFLOAT s, sb;
#ifdef DEBUG
char fpbuf[64];
#endif /* DEBUG */
#ifdef GTODONEARG /* Acount for Mot's definition */
(VOID) gettimeofday(&tnow);
#else
(VOID) gettimeofday(&tnow, (struct timezone *)0);
#endif /* GTODONEARG */
tdelta.tv_sec = tnow.tv_sec - tzero.tv_sec;
tdelta.tv_usec = tnow.tv_usec - tzero.tv_usec;
if (tdelta.tv_usec < 0) {
tdelta.tv_sec--;
tdelta.tv_usec += 1000000;
}
s = (CKFLOAT) tdelta.tv_sec + ((CKFLOAT) tdelta.tv_usec / 1000000.0);
if (s < GFMINTIME)
s = GFMINTIME;
#ifdef DEBUG
if (deblog) {
sprintf(fpbuf,"%f",s);
debug(F110,"gftimer",fpbuf,0);
}
#endif /* DEBUG */
return(s);
}
#endif /* GFTIMER */
/* Z T I M E -- Return asctime()-format date/time string */
/*
NOTE: as a side effect of calling this routine, we can also set the
following two variables, giving the micro- and milliseconds (fractions of
seconds) of the clock time. Currently this is done only in BSD-based builds
that use gettimeofday(). When these variables are not filled in, they are
left with a value of -1L.
*/
VOID
ztime(s) char **s; {
#ifdef GFTIMER
/*
The gettimeofday() method, which also sets ztmsec and ztusec, works for
all GFTIMER builds. NOTE: ztmsec and ztusec are defined in ckcmai.c,
and extern declarations for them are in ckcdeb.h; thus they are
declared in this file by inclusion of ckcdeb.h.
*/
char *asctime();
struct tm *localtime();
struct tm *tp;
ztmsec = -1L;
ztusec = -1L;
#ifdef GTODONEARG
/* No 2nd arg in Motorola SV88 and some others */
if (gettimeofday(&tv) > -1)
#else
#ifndef COHERENT
#ifdef PTX
if (gettimeofday(&tv,NULL) > -1)
#else
if (gettimeofday(&tv,&tz) > -1)
#endif /* PTX */
#endif /* COHERENT */
#endif /* GTODONEARG */
{ /* Fill in tm struct */
ztusec = tv.tv_usec; /* Microseconds */
ztmsec = ztusec / 1000L; /* Milliseconds */
#ifdef HPUX9
{
time_t zz;
zz = tv.tv_sec;
tp = localtime(&zz); /* Convert to local time */
}
#else
#ifdef HPUX1000
{
time_t zz;
zz = tv.tv_sec;
tp = localtime(&zz);
}
#else
#ifdef LINUX
{ /* avoid unaligned access trap on 64-bit platforms */
time_t zz;
zz = tv.tv_sec;
tp = localtime(&zz);
}
#else
#ifdef MACOSX
tp = localtime((time_t *)&tv.tv_sec); /* Convert to local time */
#else
tp = localtime(&tv.tv_sec);
#endif /* MACOSX */
#endif /* LINUX */
#endif /* HPUX1000 */
#endif /* HPUX9 */
*s = asctime(tp); /* Convert result to ASCII string */
debug(F111,"ztime GFTIMER gettimeofday",*s,ztusec);
}
#else /* Not GFTIMER */
#undef ZTIMEV7 /* Which systems need to use */
#ifdef COHERENT /* old UNIX Version 7 way... */
#define ZTIMEV7
#endif /* COHERENT */
#ifdef TOWER1
#define ZTIMEV7
#endif /* TOWER1 */
#ifdef ANYBSD
#ifndef BSD42
#define ZTIMEV7
#endif /* BSD42 */
#endif /* ANYBSD */
#ifdef V7
#ifndef MINIX
#define ZTIMEV7
#endif /* MINIX */
#endif /* V7 */
#ifdef POSIX
#define ZTIMEV7
#endif /* POSIX */
#ifdef HPUX1020
/*
Prototypes are in <time.h>, included above.
*/
time_t clock_storage;
clock_storage = time((void *) 0);
*s = ctime(&clock_storage);
debug(F110,"ztime: HPUX 10.20",*s,0);
#else
#ifdef ATTSV /* AT&T way */
/* extern long time(); */ /* Theoretically these should */
char *ctime(); /* already been dcl'd in <time.h> */
time_t clock_storage;
clock_storage = time(
#ifdef IRIX60
(time_t *)
#else
#ifdef BSD44
(time_t *)
#else
(long *)
#endif /* BSD44 */
#endif /* IRIX60 */
0 );
*s = ctime( &clock_storage );
debug(F110,"ztime: ATTSV",*s,0);
#else
#ifdef PROVX1 /* Venix 1.0 way */
int utime[2];
time(utime);
*s = ctime(utime);
debug(F110,"ztime: PROVX1",*s,0);
#else
#ifdef BSD42 /* 4.2BSD way */
char *asctime();
struct tm *localtime();
struct tm *tp;
gettimeofday(&tv, &tz);
ztusec = tv.tv_usec;
ztmsec = tv.tv_usec / 1000L;
tp = localtime(&tv.tv_sec);
*s = asctime(tp);
debug(F111,"ztime: BSD42",*s,ztusec);
#else
#ifdef MINIX /* MINIX way */
#ifdef COMMENT
extern long time(); /* Already got these from <time.h> */
extern char *ctime();
#endif /* COMMENT */
time_t utime[2];
time(utime);
*s = ctime(utime);
debug(F110,"ztime: MINIX",*s,0);
#else
#ifdef ZTIMEV7 /* The regular way */
char *asctime();
struct tm *localtime();
struct tm *tp;
long xclock; /* or unsigned long for BeBox? */
time(&xclock);
tp = localtime(&xclock);
*s = asctime(tp);
debug(F110,"ztime: ZTIMEV7",*s,0);
#else /* Catch-all for others... */
*s = "Day Mon 00 00:00:00 0000n"; /* Return dummy in asctime() format */
debug(F110,"ztime: catch-all",*s,0);
#endif /* ZTIMEV7 */
#endif /* MINIX */
#endif /* BSD42 */
#endif /* PROVX1 */
#endif /* ATTSV */
#endif /* HPUX1020 */
#endif /* GFTIMER */
}
/* C O N G M -- Get console terminal modes. */
/*
Saves initial console mode, and establishes variables for switching
between current (presumably normal) mode and other modes.
Should be called when program starts, but only after establishing
whether program is in the foreground or background.
Returns 1 if it got the modes OK, 0 if it did nothing, -1 on error.
*/
int
congm() {
int fd;
if (backgrd || !isatty(0)) { /* If in background. */
cgmf = -1; /* Don't bother, modes are garbage. */
return(-1);
}
if (cgmf > 0) return(0); /* Already did this. */
debug(F100,"congm getting modes","",0); /* Need to do it. */
#ifdef aegis
ios_$inq_type_uid(ios_$stdin, conuid, st);
if (st.all != status_$ok) {
fprintf(stderr, "problem getting stdin objtype: ");
error_$print(st);
}
concrp = (conuid == mbx_$uid);
conbufn = 0;
#endif /* aegis */
#ifndef BEBOX
if ((fd = open(CTTNAM,2)) < 0) { /* Open controlling terminal */
#ifdef COMMENT
fprintf(stderr,"Error opening %sn", CTTNAM);
perror("congm");
return(-1);
#else
fd = 0;
#endif /* COMMENT */
}
#else
fd = 0;
#endif /* !BEBOX */
#ifdef BSD44ORPOSIX
if (tcgetattr(fd,&ccold) < 0) return(-1);
if (tcgetattr(fd,&cccbrk) < 0) return(-1);
if (tcgetattr(fd,&ccraw) < 0) return(-1);
#else
#ifdef ATTSV
if (ioctl(fd,TCGETA,&ccold) < 0) return(-1);
if (ioctl(fd,TCGETA,&cccbrk) < 0) return(-1);
if (ioctl(fd,TCGETA,&ccraw) < 0) return(-1);
#ifdef VXVE
cccbrk.c_line = 0; /* STTY line 0 for CDC VX/VE */
if (ioctl(fd,TCSETA,&cccbrk) < 0) return(-1);
ccraw.c_line = 0; /* STTY line 0 for CDC VX/VE */
if (ioctl(fd,TCSETA,&ccraw) < 0) return(-1);
#endif /* VXVE */
#else
#ifdef BELLV10
if (ioctl(fd,TIOCGETP,&ccold) < 0) return(-1);
if (ioctl(fd,TIOCGETP,&cccbrk) < 0) return(-1);
if (ioctl(fd,TIOCGETP,&ccraw) < 0) return(-1);
debug(F101,"cccbrk.sg_flags orig","", cccbrk.sg_flags);
#else
if (gtty(fd,&ccold) < 0) return(-1);
if (gtty(fd,&cccbrk) < 0) return(-1);
if (gtty(fd,&ccraw) < 0) return(-1);
#endif /* BELLV10 */
#endif /* ATTSV */
#endif /* BSD44ORPOSIX */
#ifdef sony_news /* Sony NEWS */
if (ioctl(fd,TIOCKGET,&km_con) < 0) { /* Get console Kanji mode */
perror("congm error getting Kanji mode");
debug(F101,"congm error getting Kanji mode","",0);
km_con = -1; /* Make sure this stays undefined. */
return(-1);
}
#endif /* sony_news */
if (fd > 0)
close(fd);
cgmf = 1; /* Flag that we got them. */
return(1);
}
/* C O N C B -- Put console in cbreak mode. */
/* Returns 0 if ok, -1 if not */
int
#ifdef CK_ANSIC
concb(char esc)
#else
concb(esc) char esc;
#endif /* CK_ANSIC */
/* concb */ {
int x;
debug(F101,"concb cgmf","",cgmf);
debug(F101,"concb backgrd","",backgrd);
if (cgmf < 1) /* Did we get console modes yet? */
if (!backgrd) /* No, in background? */
congm(); /* No, try to get them now. */
if (cgmf < 1) /* Still don't have them? */
return(0); /* Give up. */
debug(F101,"concb ttyfd","",ttyfd);
debug(F101,"concb ttfdflg","",ttfdflg);
#ifdef COMMENT
/* This breaks returning to prompt after protocol with "-l 0" */
/* Commented out July 1998 */
if (ttfdflg && ttyfd >= 0 && ttyfd < 3)
return(0);
#endif /* COMMENT */
x = isatty(0);
debug(F101,"concb isatty","",x);
if (!x) return(0); /* Only when running on real ttys */
debug(F101,"concb suspend","",suspend);
if (backgrd) return(0); /* Do nothing if in background. */
escchr = esc; /* Make this available to other fns */
ckxech = 1; /* Program can echo characters */
#ifdef aegis
conbufn = 0;
if (concrp) return(write(1, "3502", 2));
if (conuid == input_pad_$uid) {pad_$raw(ios_$stdin, st); return(0);}
#endif /* aegis */
#ifdef COHERENT
#define SVORPOSIX
#endif /* COHERENT */
#ifdef Plan9
x = p9concb();
#else
#ifndef SVORPOSIX /* BSD, V7, etc */
debug(F101,"cccbrk.sg_flags concb 1","", cccbrk.sg_flags);
debug(F101,"concb stty CBREAK","",0);
cccbrk.sg_flags |= (CBREAK|CRMOD); /* Set to character wakeup, */
cccbrk.sg_flags &= ~ECHO; /* no echo. */
debug(F101,"cccbrk.sg_flags concb 2","", cccbrk.sg_flags);
#ifdef BELLV10
x = ioctl(0,TIOCSETP,&cccbrk);
#else
x = stty(0,&cccbrk);
debug(F101,"cccbrk.sg_flags concb x","", x);
#endif /* BELLV10 */
#else /* Sys V and POSIX */
#ifndef OXOS
debug(F101,"concb cccbrk.c_flag","",cccbrk.c_lflag);
#ifdef QNX
/* Don't mess with IEXTEN */
cccbrk.c_lflag &= ~(ICANON|ECHO);
#else
#ifdef COHERENT
cccbrk.c_lflag &= ~(ICANON|ECHO);
#else
cccbrk.c_lflag &= ~(ICANON|ECHO|IEXTEN);
#endif /* COHERENT */
#endif /* QNX */
cccbrk.c_lflag |= ISIG; /* Allow signals in command mode. */
cccbrk.c_iflag |= IGNBRK; /* But ignore BREAK signal */
cccbrk.c_iflag &= ~BRKINT;
#else /* OXOS */
debug(F100,"concb OXOS is defined","",0);
cccbrk.c_lflag &= ~(ICANON|ECHO);
cccbrk.c_cc[VDISCARD] = cccbrk.c_cc[VLNEXT] = CDISABLE;
#endif /* OXOS */
#ifdef COMMENT
/*
Believe it or not, in SCO UNIX, VSUSP is greater than NCC, and so this
array reference is out of bounds. It's only a debug() call so who needs it.
*/
#ifdef VSUSP
debug(F101,"concb c_cc[VSUSP]","",cccbrk.c_cc[VSUSP]);
#endif /* VSUSP */
#endif /* COMMENT */
#ifndef VINTR
debug(F101,"concb c_cc[0]","",cccbrk.c_cc[0]);
cccbrk.c_cc[0] = 003; /* Interrupt char is Control-C */
#else
debug(F101,"concb c_cc[VINTR]","",cccbrk.c_cc[0]);
cccbrk.c_cc[VINTR] = 003;
#endif /* VINTR */
#ifndef VQUIT
cccbrk.c_cc[1] = escchr; /* escape during packet modes */
#else
cccbrk.c_cc[VQUIT] = escchr;
#endif /* VQUIT */
#ifndef VEOF
cccbrk.c_cc[4] = 1;
#else
#ifndef OXOS
#ifdef VMIN
cccbrk.c_cc[VMIN] = 1;
#endif /* VMIN */
#else /* OXOS */
cccbrk.c_min = 1;
#endif /* OXOS */
#endif /* VEOF */
#ifdef ZILOG
cccbrk.c_cc[5] = 0;
#else
#ifndef VEOL
cccbrk.c_cc[5] = 1;
#else
#ifndef OXOS
#ifdef VTIME
cccbrk.c_cc[VTIME] = 1;
#endif /* VTIME */
#else /* OXOS */
cccbrk.c_time = 1;
#endif /* OXOS */
#endif /* VEOL */
#endif /* ZILOG */
#ifdef BSD44ORPOSIX /* Set new modes */
x = tcsetattr(0,TCSADRAIN,&cccbrk);
#else /* ATTSV */ /* or the POSIX way */
x = ioctl(0,TCSETAW,&cccbrk); /* the Sys V way */
#endif /* BSD44ORPOSIX */
#endif /* SVORPOSIX */
#ifdef COHERENT
#undef SVORPOSIX
#endif /* COHERENT */
#ifndef aegis
#ifndef NOSETBUF
if (x > -1) setbuf(stdout,NULL); /* Make console unbuffered. */
#endif /* NOSETBUF */
#endif /* aegis */
#ifdef V7
#ifndef MINIX
if (kmem[CON] < 0) {
qaddr[CON] = initrawq(0);
if((kmem[CON] = open("/dev/kmem", 0)) < 0) {
fprintf(stderr, "Can't read /dev/kmem in concb.n");
perror("/dev/kmem");
exit(1);
}
}
#endif /* MINIX */
#endif /* V7 */
#endif /* Plan9 */
debug(F101,"concb returns","",x);
return(x);
}
/* C O N B I N -- Put console in binary mode */
/* Returns 0 if ok, -1 if not */
int
#ifdef CK_ANSIC
conbin(char esc)
#else
conbin(esc) char esc;
#endif /* CK_ANSIC */
/* conbin */ {
if (!isatty(0)) return(0); /* only for real ttys */
congm(); /* Get modes if necessary. */
debug(F100,"conbin","",0);
escchr = esc; /* Make this available to other fns */
ckxech = 1; /* Program can echo characters */
#ifdef aegis
conbufn = 0;
if (concrp) return(write(1, "3502", 2));
if (conuid == input_pad_$uid) {
pad_$raw(ios_$stdin, st);
return(0);
}
#endif /* aegis */
#ifdef COHERENT
#define SVORPOSIX
#endif /* COHERENT */
#ifdef Plan9
return p9conbin();
#else
#ifdef SVORPOSIX
#ifndef OXOS
#ifdef QNX
ccraw.c_lflag &= ~(ISIG|ICANON|ECHO);
#else
#ifdef COHERENT
ccraw.c_lflag &= ~(ISIG|ICANON|ECHO);
#else
ccraw.c_lflag &= ~(ISIG|ICANON|ECHO|IEXTEN);
#endif /* COHERENT */
#endif /* QNX */
#else /* OXOS */
ccraw.c_lflag &= ~(ISIG|ICANON|ECHO);
ccraw.c_cc[VDISCARD] = ccraw.c_cc[VLNEXT] = CDISABLE;
#endif /* OXOS */
ccraw.c_iflag |= IGNPAR;
/*
Note that for terminal sessions we disable Xon/Xoff flow control to allow
the passage ^Q and ^S as data characters for EMACS, and to allow XMODEM
transfers to work when C-Kermit is in the middle, etc. Hardware flow
control, if in use, is not affected.
*/
#ifdef ATTSV
#ifdef BSD44
ccraw.c_iflag &= ~(IGNBRK|INLCR|IGNCR|ICRNL|IXON|IXANY|IXOFF
|INPCK|ISTRIP);
#else
ccraw.c_iflag &= ~(IGNBRK|INLCR|IGNCR|ICRNL|IUCLC|IXON|IXANY|IXOFF
|INPCK|ISTRIP);
#endif /* BSD44 */
#else /* POSIX */
ccraw.c_iflag &= ~(IGNBRK|INLCR|IGNCR|ICRNL|IXON|IXOFF|INPCK|ISTRIP);
#endif /* ATTSV */
ccraw.c_oflag &= ~OPOST;
#ifdef COMMENT
/*
WHAT THE HECK WAS THIS FOR?
The B9600 setting (obviously) prevents CONNECT from working at any
speed other than 9600 when you are logged in to the 7300 on a serial
line. Maybe some of the other flags are necessary -- if so, put back
the ones that are needed. This code is supposed to work the same, no
matter whether you are logged in to the 7300 on the real console device,
or through a serial port.
*/
#ifdef ATT7300
ccraw.c_cflag = CLOCAL | B9600 | CS8 | CREAD | HUPCL;
#endif /* ATT7300 */
#endif /* COMMENT */
/*** Kermit used to put the console in 8-bit raw mode, but some users have
*** pointed out that this should not be done, since some sites actually
*** use terminals with parity settings on their Unix systems, and if we
*** override the current settings and stop doing parity, then their terminals
*** will display blotches for characters whose parity is wrong. Therefore,
*** the following two lines are commented out (Larry Afrin, Clemson U):
***
*** ccraw.c_cflag &= ~(PARENB|CSIZE);
*** ccraw.c_cflag |= (CS8|CREAD);
***
*** Sys III/V sites that have trouble with this can restore these lines.
***/
#ifndef VINTR
ccraw.c_cc[0] = 003; /* Interrupt char is Ctrl-C */
#else
ccraw.c_cc[VINTR] = 003;
#endif /* VINTR */
#ifndef VQUIT
ccraw.c_cc[1] = escchr; /* Escape during packet mode */
#else
ccraw.c_cc[VQUIT] = escchr;
#endif /* VQUIT */
#ifndef VEOF
ccraw.c_cc[4] = 1;
#else
#ifndef OXOS
#ifdef VMIN
ccraw.c_cc[VMIN] = 1;
#endif /* VMIN */
#else /* OXOS */
ccraw.c_min = 1;
#endif /* OXOS */
#endif /* VEOF */
#ifdef ZILOG
ccraw.c_cc[5] = 0;
#else
#ifndef VEOL
ccraw.c_cc[5] = 1;
#else
#ifndef OXOS
#ifdef VTIME
ccraw.c_cc[VTIME] = 1;
#endif /* VTIME */
#else /* OXOS */
ccraw.c_time = 1;
#endif /* OXOS */
#endif /* VEOL */
#endif /* ZILOG */
#ifdef BSD44ORPOSIX
return(tcsetattr(0,TCSADRAIN,&ccraw));
#else
return(ioctl(0,TCSETAW,&ccraw)); /* Set new modes. */
#endif /* BSD44ORPOSIX */
#else /* Berkeley, etc. */
ccraw.sg_flags |= (RAW|TANDEM); /* Set rawmode, XON/XOFF (ha) */
ccraw.sg_flags &= ~(ECHO|CRMOD); /* Set char wakeup, no echo */
#ifdef BELLV10
return(ioctl(0,TIOCSETP,&ccraw));
#else
return(stty(0,&ccraw));
#endif /* BELLV10 */
#endif /* SVORPOSIX */
#endif /* Plan9 */
#ifdef COHERENT
#undef SVORPOSIX
#endif /* COHERENT */
}
/* C O N R E S -- Restore the console terminal */
int
conres() {
debug(F101,"conres cgmf","",cgmf);
if (cgmf < 1) return(0); /* Do nothing if modes unchanged */
if (!isatty(0)) return(0); /* only for real ttys */
debug(F100,"conres isatty ok","",0);
ckxech = 0; /* System should echo chars */
#ifdef aegis
conbufn = 0;
if (concrp) return(write(1, "3501", 2));
if (conuid == input_pad_$uid) {
pad_$cooked(ios_$stdin, st);
return(0);
}
#endif /* aegis */
#ifdef Plan9
p9conres();
#else
#ifdef BSD44ORPOSIX
debug(F100,"conres restoring tcsetattr","",0);
return(tcsetattr(0,TCSADRAIN,&ccold));
#else
#ifdef ATTSV
debug(F100,"conres restoring ioctl","",0);
return(ioctl(0,TCSETAW,&ccold));
#else /* BSD, V7, and friends */
#ifdef sony_news /* Sony NEWS */
if (km_con != -1)
ioctl(0,TIOCKSET,&km_con); /* Restore console Kanji mode */
#endif /* sony_news */
msleep(100);
debug(F100,"conres restoring stty","",0);
#ifdef BELLV10
return(ioctl(0,TIOCSETP,&ccold));
#else
return(stty(0,&ccold));
#endif /* BELLV10 */
#endif /* ATTSV */
#endif /* BSD44ORPOSIX */
#endif /* Plan9 */
}
/* C O N O C -- Output a character to the console terminal */
int
#ifdef CK_ANSIC
conoc(char c)
#else
conoc(c) char c;
#endif /* CK_ANSIC */
/* conoc */ {
#ifdef IKSD
if (inserver && !local)
return(ttoc(c));
#ifdef CK_ENCRYPTION
if (inserver && TELOPT_ME(TELOPT_ENCRYPTION))
ck_tn_encrypt(&c,1);
#endif /* CK_ENCRYPTION */
#endif /* IKSD */
#ifdef Plan9
return conwrite(&c,1);
#else
return(write(1,&c,1));
#endif /* Plan9 */
}
/* C O N X O -- Write x characters to the console terminal */
int
conxo(x,s) int x; char *s; {
#ifdef IKSD
if (inserver && !local)
return(ttol((CHAR *)s,x));
#ifdef CK_ENCRYPTION
if (inserver && TELOPT_ME(TELOPT_ENCRYPTION))
ck_tn_encrypt(s,x);
#endif /* CK_ENCRYPTION */
#endif /* IKSD */
#ifdef Plan9
return(conwrite(s,x));
#else
return(write(1,s,x));
#endif /* Plan9 */
}
/* C O N O L -- Write a line to the console terminal */
int
conol(s) char *s; {
int len;
if (!s) s = ""; /* Always do this! */
len = strlen(s);
#ifdef IKSD
if (inserver && !local)
return(ttol((CHAR *)s,len));
#ifdef CK_ENCRYPTION
if (inserver && TELOPT_ME(TELOPT_ENCRYPTION)) {
if (nxpacket < len) {
if (xpacket) {
free(xpacket);
xpacket = NULL;
nxpacket = 0;
}
len = len > 10240 ? len : 10240;
xpacket = (char *)malloc(len);
if (!xpacket) {
fprintf(stderr,"ttol malloc failuren");
return(-1);
} else
nxpacket = len;
}
memcpy(xpacket,s,len);
s = xpacket;
ck_tn_encrypt(s,len);
}
#endif /* CK_ENCRYPTION */
#endif /* IKSD */
#ifdef Plan9
return(conwrite(s,len));
#else
return(write(1,s,len));
#endif /* Plan9 */
}
/* C O N O L A -- Write an array of lines to the console terminal */
int
conola(s) char *s[]; {
char * p;
int i, x;
if (!s) return(0);
for (i = 0; ; i++) {
p = s[i];
if (!p) p = ""; /* Let's not dump core shall we? */
if (!*p)
break;
#ifdef IKSD
if (inserver && !local)
x = ttol((CHAR *)p,(int)strlen(p));
else
#endif /* IKSD */
x = conol(p);
if (x < 0)
return(-1);
}
return(0);
}
/* C O N O L L -- Output a string followed by CRLF */
int
conoll(s) char *s; {
CHAR buf[3];
buf[0] = 'r';
buf[1] = 'n';
buf[2] = '';
if (!s) s = "";
#ifdef IKSD
if (inserver && !local) {
ttol((CHAR *)s,(int)strlen(s));
return(ttol(buf,2));
}
#endif /* IKSD */
conol(s);
#ifdef IKSD
#ifdef CK_ENCRYPTION
if (inserver && TELOPT_ME(TELOPT_ENCRYPTION))
ck_tn_encrypt(buf,2);
#endif /* CK_ENCRYPTION */
#endif /* IKSD */
#ifdef Plan9
return(conwrite(buf, 2));
#else
return(write(1,buf,2));
#endif /* Plan9 */
}
/* C O N C H K -- Return how many characters available at console */
/*
We could also use select() here to cover a few more systems that are not
covered by any of the following, e.g. HP-UX 9.0x on the model 800.
*/
int
conchk() {
static int contyp = 0; /* +1 for isatty, -1 otherwise */
if (contyp == 0) /* This prevents unnecessary */
contyp = (isatty(0) ? 1 : -1); /* duplicated calls to isatty() */
debug(F101,"conchk contyp","",contyp);
if (backgrd || (contyp < 0))
return(0);
#ifdef aegis
if (conbufn > 0) return(conbufn); /* use old count if nonzero */
/* read in more characters */
conbufn = ios_$get(ios_$stdin,
ios_$cond_opt, conbuf, (long)sizeof(conbuf), st);
if (st.all != status_$ok) conbufn = 0;
conbufp = conbuf;
return(conbufn);
#else
#ifdef IKSD
if (inserver && !local)
return(in_chk(1,ttyfd));
else
#endif /* IKSD */
return(in_chk(0,0));
#endif /* aegis */
}
/* C O N I N C -- Get a character from the console */
/*
Call with timo > 0 to do a timed read, timo == 0 to do an untimed blocking
read. Upon success, returns the character. Upon failure, returns -1.
A timed read that does not complete within the timeout period returns -2.
*/
int
coninc(timo) int timo; {
int n = 0; CHAR ch;
int xx;
errno = 0; /* Clear this */
#ifdef IKSD
if (inserver && !local) {
xx = ttinc(timo);
if (xx < 0)
return(ttinctimo ? -2 : -1);
else
return(xx);
}
#endif /* IKSD */
#ifdef aegis /* Apollo Aegis only... */
debug(F101,"coninc timo","",timo);
fflush(stdout);
if (conchk() > 0) {
--conbufn;
return((unsigned)(*conbufp++ & 0xff));
}
#endif /* aegis */
#ifdef TTLEBUF
if (
#ifdef IKSD
inserver &&
#endif /* IKSD */
!xlocal
) {
if (ttpush >= 0) {
debug(F111,"ttinc","ttpush",ttpush);
ch = ttpush;
ttpush = -1;
return(ch);
}
if (le_data) {
if (le_getchar(&ch) > 0) {
debug(F111,"ttinc LocalEchoInBuf","ch",ch);
return(ch);
}
}
}
#endif /* TTLEBUF */
if (timo <= 0) { /* Untimed, blocking read. */
while (1) { /* Keep trying till we get one. */
n = read(0, &ch, 1); /* Read a character. */
if (n == 0) continue; /* Shouldn't happen. */
if (n > 0) { /* If read was successful, */
#ifdef IKSD
#ifdef CK_ENCRYPTION
debug(F100,"coninc decrypt 1","",0);
if (inserver && !local && TELOPT_U(TELOPT_ENCRYPTION))
ck_tn_decrypt(&ch,1);
#endif /* CK_ENCRYPTION */
#endif /* IKSD */
return((unsigned)(ch & 0xff)); /* return the character. */
}
/* Come here if read() returned an error. */
debug(F101, "coninc(0) errno","",errno); /* Log the error. */
#ifndef OXOS
#ifdef SVORPOSIX
#ifdef CIE /* CIE Regulus has no EINTR symbol? */
#ifndef EINTR
#define EINTR 4
#endif /* EINTR */
#endif /* CIE */
/*
This routine is used for several different purposes. In CONNECT mode, it is
used to do an untimed, blocking read from the keyboard in the lower CONNECT
fork. During local-mode file transfer, it reads a character from the
console to interrupt the file transfer (like A for a status report, X to
cancel a file, etc). Obviously, we don't want the reads in the latter case
to be blocking, or the file transfer would stop until the user typed
something. Unfortunately, System V does not allow the console device input
buffer to be sampled nondestructively (e.g. by conchk()), so a kludge is
used instead. During local-mode file transfer, the SIGQUIT signal is armed
and trapped by esctrp(), and this routine pretends to have read the quit
character from the keyboard normally. But, kludge or no kludge, the read()
issued by this command, under System V only, can fail if a signal -- ANY
signal -- is caught while the read is pending. This can occur not only when
the user types the quit character, but also during telnet negotiations, when
the lower CONNECT fork signals the upper one about an echoing mode change.
When this happens, we have to post the read() again. This is apparently not
a problem in BSD-based UNIX versions.
*/
if (errno == EINTR) /* Read interrupted. */
if (conesc) { /* If by SIGQUIT, */
conesc = 0; /* the conesc variable is set, */
return(escchr); /* so return the escape character. */
} else continue; /* By other signal, try again. */
#else
/*
This might be dangerous, but let's do this on non-System V versions too,
since at least one SunOS 4.1.2 user complains of immediate disconnections
upon first making a TELNET connection.
*/
if (errno == EINTR) /* Read interrupted. */
continue;
#endif /* SVORPOSIX */
#else /* OXOS */
if (errno == EINTR) /* Read interrupted. */
continue;
#endif /* OXOS */
return(-1); /* Error */
}
}
#ifdef DEBUG
if (deblog && timo <= 0) {
debug(F100,"coninc timeout logic error","",0);
timo = 1;
}
#endif /* DEBUG */
/* Timed read... */
saval = signal(SIGALRM,timerh); /* Set up timeout handler. */
xx = alarm(timo); /* Set the alarm. */
debug(F101,"coninc alarm set","",timo);
if (
#ifdef CK_POSIX_SIG
sigsetjmp(sjbuf,1)
#else
setjmp(sjbuf)
#endif /* CK_POSIX_SIG */
) /* The read() timed out. */
n = -2; /* Code for timeout. */
else
n = read(0, &ch, 1);
ttimoff(); /* Turn off timer */
if (n > 0) { /* Got character OK. */
#ifdef IKSD
#ifdef CK_ENCRYPTION
debug(F100,"coninc decrypt 2","",0);
if (inserver && !local && TELOPT_U(TELOPT_ENCRYPTION))
ck_tn_decrypt(&ch,1);
#endif /* CK_ENCRYPTION */
#endif /* IKSD */
return((unsigned)(ch & 0xff)); /* Return it. */
}
/*
read() returned an error. Same deal as above, but without the loop.
*/
debug(F101, "coninc(timo) n","",n);
debug(F101, "coninc(timo) errno","",errno);
#ifndef OXOS
#ifdef SVORPOSIX
if (n == -1 && errno == EINTR && conesc != 0) {
conesc = 0;
return(escchr); /* User entered escape character. */
}
#endif /* SVORPOSIX */
if (n == 0 && errno > 0) { /* It's an error */
return(-1);
}
#endif /* ! OXOS */
return(n);
}
/* C O N G K S -- Console Get Keyboard Scancode */
#ifndef congks
/*
This function needs to be filled in with the various system-dependent
system calls used by SUNOS, NeXT OS, Xenix, Aviion, etc, to read a full
keyboard scan code. For now, it's a dummy.
*/
int
congks(timo) int timo; {
#ifdef IKSD
if (inserver && !local)
return(ttinc(timo));
#endif /* IKSD */
return(coninc(timo));
}
#endif /* congks */
#ifdef ATT7300
/* A T T D I A L -- Dial up the remote system using internal modem
* Purpose: to open and dial a number on the internal modem available on the
* ATT7300 UNIX PC. Written by Joe Doupnik. Superceeds version written by
* Richard E. Hill, Dickinson, TX. which employed dial(3c).
* Uses information in <sys/phone.h> and our status int attmodem.
*/
attdial(ttname,speed,telnbr) char *ttname,*telnbr; long speed; {
char *telnum;
attmodem &= ~ISMODEM; /* modem not in use yet */
/* Ensure O_NDELAY is set, else i/o traffic hangs */
/* We turn this flag off once the dial is complete */
fcntl(ttyfd, F_SETFL, fcntl(ttyfd, F_GETFL, 0) | O_NDELAY);
/* Condition line, check availability & DATA mode, turn on speaker */
if (ioctl(ttyfd,PIOCOFFHOOK, &dialer) == -1) {
printf("cannot access phonen");
ttclos(0);
return (-2);
}
ioctl(ttyfd,PIOCGETP,&dialer); /* get phone dialer parameters */
if (dialer.c_lineparam & VOICE) { /* phone must be in DATA mode */
printf(" Should not dial with modem in VOICE mode.n");
printf(" Exit Kermit, switch to DATA and retry call.n");
ttclos(0);
return (-2);
}
#ifdef ATTTONED /* Old way, tone dialing only. */
dialer.c_lineparam = DATA | DTMF; /* Dial with tones, */
dialer.c_lineparam &= ~PULSE; /* not with pulses. */
#else
/* Leave current pulse/tone state alone. */
/* But what about DATA? Add it back if you have trouble. */
/* sys/phone says you get DATA automatically by opening device RDWR */
#endif
dialer.c_waitdialtone = 5; /* wait 5 sec for dialtone */
#ifdef COMMENT
dialer.c_feedback = SPEAKERON|NORMSPK|RINGON; /* control speaker */
#else
/* sys/phone says RINGON used only for incoming voice calls */
dialer.c_feedback &= ~(SOFTSPK|LOUDSPK);
dialer.c_feedback |= SPEAKERON|NORMSPK;
#endif
dialer.c_waitflash = 500; /* 0.5 sec flash hook */
if(ioctl(ttyfd,PIOCSETP,&dialer) == -1) { /* set phone parameters */
printf("Cannot set modem characteristicsn");
ttclos(0);
return (-2);
}
ioctl(ttyfd,PIOCRECONN,0); /* Turns on speaker for pulse */
#ifdef COMMENT
fprintf(stderr,"Phone line status. line_par:%o dialtone_wait:%o
line_status:%o feedback:%on",
dialer.c_lineparam, dialer.c_waitdialtone,
dialer.c_linestatus, dialer.c_feedback);
#endif
attmodem |= ISMODEM; /* modem is now in-use */
sleep(1);
for (telnum = telnbr; *telnum != ''; telnum++) /* dial number */
#ifdef ATTTONED
/* Tone dialing only */
if (ioctl(ttyfd,PIOCDIAL,telnum) != 0) {
perror("Error in dialing");
ttclos(0);
return(-2);
}
#else /* Allow Pulse or Tone dialing */
switch (*telnum) {
case 't': case 'T': case '%': /* Tone dialing requested */
dialer.c_lineparam |= DTMF;
dialer.c_lineparam &= ~PULSE;
if (ioctl(ttyfd,PIOCSETP,&dialer) == -1) {
printf("Cannot set modem to tone dialingn");
ttclos(0);
return(-2);
}
break;
case 'd': case 'D': case 'p': case 'P': case '^':
dialer.c_lineparam |= PULSE;
dialer.c_lineparam &= ~DTMF;
if (ioctl(ttyfd,PIOCSETP,&dialer) == -1) {
printf("Cannot set modem to pulse dialingn");
ttclos(0);
return(-2);
}
break;
default:
if (ioctl(ttyfd,PIOCDIAL,telnum) != 0) {
perror("Dialing error");
ttclos(0);
return(-2);
}
break;
}
#endif
ioctl(ttyfd,PIOCDIAL,"@"); /* terminator for data call */
do { /* wait for modems to Connect */
if (ioctl(ttyfd,PIOCGETP,&dialer) != 0) { /* get params */
perror("Cannot get modems to connect");
ttclos(0);
return(-2);
}
} while ((dialer.c_linestatus & MODEMCONNECTED) == 0);
/* Turn off O_NDELAY flag now. */
fcntl(ttyfd, F_SETFL, fcntl(ttyfd, F_GETFL, 0) & ~O_NDELAY);
signal(SIGHUP, sighup); /* hangup on loss of carrier */
return(0); /* return success */
}
/*
Offgetty, ongetty functions. These function get the 'getty(1m)' off
and restore it to the indicated line. Shell's return codes are:
0: Can't do it. Probably a user logged on.
1: No need. No getty on that line.
2: Done, you should restore the getty when you're done.
DOGETY System(3), however, returns them as 0, 256, 512, respectively.
Thanks to Kevin O'Gorman, Anarm Software Systems.
getoff.sh looks like: geton.sh looks like:
setgetty $1 0 setgetty $1 1
err=$? exit $?
sleep 2
exit $err
*/
/* O F F G E T T Y -- Turn off getty(1m) for the communications tty line
* and get status so it can be restarted after the line is hung up.
*/
int
offgetty(ttname) char *ttname; {
char temp[30];
while (*ttname != '') ttname++; /* seek terminator of path */
ttname -= 3; /* get last 3 chars of name */
sprintf(temp,"/usr/bin/getoff.sh %s",ttname);
return(zsyscmd(temp));
}
/* O N G E T T Y -- Turn on getty(1m) for the communications tty line */
int
ongetty(ttname) char *ttname; {
char temp[30];
while (*ttname != '') ttname++; /* comms tty path name */
ttname -= 3;
sprintf(temp,"/usr/bin/geton.sh %s",ttname);
return(zsyscmd(temp));
}
#endif /* ATT7300 */
/* T T S C A R R -- Set ttcarr variable, controlling carrier handling.
*
* 0 = Off: Always ignore carrier. E.g. you can connect without carrier.
* 1 = On: Heed carrier, except during dialing. Carrier loss gives disconnect.
* 2 = Auto: For "modem direct": The same as "Off".
* For real modem types: Heed carrier during connect, but ignore
* it anytime else. Compatible with pre-5A C-Kermit versions.
*
* As you can see, this setting does not affect dialing, which always ignores
* carrier (unless there is some special exception for some modem type). It
* does affect ttopen() if it is set before ttopen() is used. This setting
* takes effect on the next call to ttopen()/ttpkt()/ttvt(). And they are
* (or should be) always called before any communications is tried, which
* means that, practically speaking, the effect is immediate.
*
* Of course, nothing of this applies to remote mode (xlocal = 0).
*
* Someone has yet to uncover how to manipulate the carrier in the BSD
* environment (or any non-termio using environment). Until that time, this
* will simply be a no-op for BSD.
*
* Note that in previous versions, the carrier was most often left unchanged
* in ttpkt()/ttvt() unless they were called with FLO_DIAL or FLO_DIAX. This
* has changed. Now it is controlled by ttcarr in conjunction with these
* modes.
*/
int
ttscarr(carrier) int carrier; {
ttcarr = carrier;
debug(F101, "ttscarr","",ttcarr);
return(ttcarr);
}
/* C A R R C T L -- Set tty modes for carrier treatment.
*
* Sets the appropriate bits in a termio or sgttyb struct for carrier control
* (actually, there are no bits in sgttyb for that), or performs any other
* operations needed to control this on the current system. The function does
* not do the actual TCSETA or stty, since often we want to set other bits too
* first. Don't call this function when xlocal is 0, or the tty is not opened.
*
* We don't know how to do anything like carrier control on non-ATTSV systems,
* except, apparently, ultrix. See above. It is also known that this doesn't
* have much effect on a Xenix system. For Xenix, one should switch back and
* forth between the upper and lower case device files. Maybe later.
* Presently, Xenix will stick to the mode it was opened with.
*
* carrier: 0 = ignore carrier, 1 = require carrier.
* The current state is saved in curcarr, and checked to save labour.
*/
#ifdef SVORPOSIX
int
#ifdef BSD44ORPOSIX
carrctl(ttpar, carrier) struct termios *ttpar; int carrier;
#else /* ATTSV */
carrctl(ttpar, carrier) struct termio *ttpar; int carrier;
#endif /* BSD44ORPOSIX */
/* carrctl */ {
debug(F101, "carrctl","",carrier);
if (carrier)
ttpar->c_cflag &= ~CLOCAL;
else
ttpar->c_cflag |= CLOCAL;
return(0);
}
#else /* Berkeley, V7, et al... */
int
carrctl(ttpar, carrier) struct sgttyb *ttpar; int carrier; {
debug(F101, "carrctl","",carrier);
if (carrier == curcarr)
return(0);
curcarr = carrier;
#ifdef ultrix
#ifdef COMMENT
/*
Old code from somebody at DEC that tends to get stuck, time out, etc.
*/
if (carrier) {
ioctl(ttyfd, TIOCMODEM, &temp);
ioctl(ttyfd, TIOCHPCL, 0);
} else {
/* (According to the manuals, TIOCNCAR should be preferred */
/* over TIOCNMODEM...) */
ioctl(ttyfd, TIOCNMODEM, &temp);
}
#else
/*
New code from Jamie Watson that, he says, eliminates the problems.
*/
if (carrier) {
ioctl(ttyfd, TIOCCAR);
ioctl(ttyfd, TIOCHPCL);
} else {
ioctl(ttyfd, TIOCNCAR);
}
#endif /* COMMENT */
#endif /* ultrix */
return(0);
}
#endif /* SVORPOSIX */
/* T T G M D M -- Get modem signals */
/*
Looks for RS-232 modem signals, and returns those that are on in as its
return value, in a bit mask composed of the BM_xxx values defined in ckcdeb.h.
Returns:
-3 Not implemented
-2 if the communication device does not have modem control (e.g. telnet)
-1 on error.
>= 0 on success, with a bit mask containing the modem signals that are on.
*/
/*
Define the symbol K_MDMCTL if we have Sys V R3 / 4.3 BSD style
modem control, namely the TIOCMGET ioctl.
*/
#ifdef BSD43
#define K_MDMCTL
#endif /* BSD43 */
#ifdef SUNOS4
#define K_MDMCTL
#endif /* SUNOS4 */
/*
SCO OpenServer R5.0.4. The TIOCMGET definition is hardwired in because it
is skipped in termio.h when _POSIX_SOURCE is defined. But _POSIX_SOURCE
must be defined in order to get the high serial speeds that are new to
5.0.4. However, the regular SCO drivers do not implement TIOCMGET, so the
ioctl() returns -1 with errno 22 (invalid function). But third-party
drivers, e.g. for Digiboard, do implement it, and so it should work on ports
driven by those drivers.
*/
#ifdef SCO_OSR504
#ifndef TIOCMGET
#define TIOCMGET (('t'<<8)|29)
#endif /* TIOCMGET */
#endif /* SCO_OSR504 */
#ifdef QNX
#define K_MDMCTL
#else
#ifdef TIOCMGET
#define K_MDMCTL
#endif /* TIOCMGET */
#endif /* QNX */
/*
"A serial communication program that can't read modem signals
is like a car without windows."
*/
int
ttgmdm() {
#ifdef QNX
#include <sys/qioctl.h>
unsigned long y, mdmbits[2] = { 0L, 0L };
int z = 0;
if (xlocal && ttyfd < 0)
return(-1);
#ifdef NETCMD
if (ttpipe) return(-2);
#endif /* NETCMD */
#ifdef NETPTY
if (ttpty) return(-2);
#endif /* NETPTY */
if (!qnx_ioctl(ttyfd, QCTL_DEV_CTL, &mdmbits[0], 8, &mdmbits[0], 4)) {
y = mdmbits[0];
if (y & 0x100000L) z |= BM_CTS; /* Values from comment */
if (y & 0x200000L) z |= BM_DSR; /* in sys/qioctl.h */
if (y & 0x800000L) z |= BM_DCD;
if (y & 0x400000L) z |= BM_RNG;
if (y & 0x000001L) z |= BM_DTR;
if (y & 0x000002L) z |= BM_RTS;
return(z);
} else return(-1);
#else
#ifdef HPUX /* HPUX has its own way */
int x, z;
#ifdef HPUX10 /* Modem flag word */
mflag y; /* mflag typedef'd in <sys/modem.h> */
#else
#ifdef HPUX9
mflag y;
#else
#ifdef HPUX8
mflag y;
#else
unsigned long y; /* Not sure about pre-8.0... */
#endif /* HPUX8 */
#endif /* HPUX9 */
#endif /* HPUX10 */
if (xlocal && ttyfd < 0)
return(-1);
if (netconn) /* Network connection */
return(-2); /* No modem signals */
#ifdef NETCMD
if (ttpipe) return(-2);
#endif /* NETCMD */
#ifdef NETPTY
if (ttpty) return(-2);
#endif /* NETPTY */
if (xlocal) /* Get modem signals */
x = ioctl(ttyfd,MCGETA,&y);
else
x = ioctl(0,MCGETA,&y);
if (x < 0) return(-1);
debug(F101,"ttgmdm","",y);
z = 0; /* Initialize return value */
/* Now set bits for each modem signal that is reported to be on. */
#ifdef MCTS
/* Clear To Send */
if (y & MCTS) z |= BM_CTS;
#endif
#ifdef MDSR
/* Data Set Ready */
if (y & MDSR) z |= BM_DSR;
#endif
#ifdef MDCD
/* Carrier */
if (y & MDCD) z |= BM_DCD;
#endif
#ifdef MRI
/* Ring Indicate */
if (y & MRI) z |= BM_RNG;
#endif
#ifdef MDTR
/* Data Terminal Ready */
if (y & MDTR) z |= BM_DTR;
#endif
#ifdef MRTS
/* Request To Send */
if (y & MRTS) z |= BM_RTS;
#endif
return(z);
#else /* ! HPUX */
#ifdef K_MDMCTL
/*
Note, TIOCMGET might already have been defined in <sys/ioctl.h> or elsewhere.
If not, we try including <sys/ttycom.h> -- if this blows up then more ifdefs
are needed.
*/
#ifndef TIOCMGET
#include <sys/ttycom.h>
#endif /* TIOCMGET */
int x, y, z;
debug(F100,"ttgmdm K_MDMCTL defined","",0);
if (netconn) /* Network connection */
return(-2); /* No modem signals */
#ifdef NETCMD
if (ttpipe) return(-2);
#endif /* NETCMD */
#ifdef NETPTY
if (ttpty) return(-2);
#endif /* NETPTY */
if (xlocal && ttyfd < 0)
return(-1);
if (xlocal)
x = ioctl(ttyfd,TIOCMGET,&y); /* Get modem signals. */
else
x = ioctl(0,TIOCMGET,&y);
debug(F101,"ttgmdm TIOCMGET ioctl","",x);
if (x < 0) {
debug(F101,"ttgmdm errno","",errno);
return(-1);
}
debug(F101,"ttgmdm bits","",y);
z = 0; /* Initialize return value. */
#ifdef TIOCM_CTS
/* Clear To Send */
if (y & TIOCM_CTS) z |= BM_CTS;
#endif
#ifdef TIOCM_DSR
/* Data Set Ready */
if (y & TIOCM_DSR) z |= BM_DSR;
#endif
#ifdef TIOCM_CAR
/* Carrier */
if (y & TIOCM_CAR) z |= BM_DCD;
#endif
#ifdef TIOCM_RNG
/* Ring Indicate */
if (y & TIOCM_RNG) z |= BM_RNG;
#endif
#ifdef TIOCM_DTR
/* Data Terminal Ready */
if (y & TIOCM_DTR) z |= BM_DTR;
#endif
#ifdef TIOCM_RTS
/* Request To Send */
if (y & TIOCM_RTS) z |= BM_RTS;
#endif
return(z);
#else /* !K_MDMCTL catch-All */
debug(F100,"ttgmdm K_MDMCTL not defined","",0);
#ifdef TIOCMGET
debug(F100,"ttgmdm TIOCMGET defined","",0);
#else
debug(F100,"ttgmdm TIOCMGET not defined","",0);
#endif /* TIOCMGET */
#ifdef _SVID3
debug(F100,"ttgmdm _SVID3 defined","",0);
#else
debug(F100,"ttgmdm _SVID3 not defined","",0);
#endif /* _SVID3 */
if (netconn) /* Network connection */
return(-2); /* No modem signals */
#ifdef NETCMD
if (ttpipe) return(-2);
#endif /* NETCMD */
#ifdef NETPTY
if (ttpty) return(-2);
#endif /* NETPTY */
return(-3); /* Sorry, I don't know how... */
#endif /* K_MDMCTL */
#endif /* HPUX */
#endif /* QNX */
}
/* P S U S P E N D -- Put this process in the background. */
/*
Call with flag nonzero if suspending is allowed, zero if not allowed.
Returns 0 on apparent success, -1 on failure (flag was zero, or
kill() returned an error code.
*/
int
psuspend(flag) int flag; {
#ifdef RTU
extern int rtu_bug;
#endif /* RTU */
if (flag == 0) return(-1);
#ifdef NOJC
return(-1);
#else
#ifdef SIGTSTP
/*
The big question here is whether job control is *really* supported.
There's no way Kermit can know for sure. The fact that SIGTSTP is
defined does not guarantee the Unix kernel supports it, and the fact
that the Unix kernel supports it doesn't guarantee that the user's
shell (or other process that invoked Kermit) supports it.
*/
#ifdef RTU
rtu_bug = 1;
#endif /* RTU */
if (kill(0,SIGSTOP) < 0
#ifdef MIPS
/* Let's try this for MIPS too. */
&& kill(getpid(),SIGSTOP) < 0
#endif /* MIPS */
) { /* If job control, suspend the job */
perror("suspend");
debug(F101,"psuspend error","",errno);
return(-1);
}
debug(F100,"psuspend ok","",0);
return(0);
#else
return(-1);
#endif /* SIGTSTP */
#endif /* NOJC */
}
/*
setuid package, by Kristoffer Eriksson, with contributions from Dean
Long and fdc.
*/
/* The following is for SCO when CK_ANSILIBS is defined... */
#ifdef M_UNIX
#ifdef CK_ANSILIBS
#ifndef NOGETID_PROTOS
#define NOGETID_PROTOS
#endif /* NOGETID_PROTOS */
#endif /* CK_ANSILIBS */
#endif /* M_UNIX */
#ifndef _POSIX_SOURCE
#ifndef SUNOS4
#ifndef NEXT
#ifndef PS2AIX10
#ifndef sequent
#ifndef HPUX9
#ifndef COHERENT
#ifndef NOGETID_PROTOS
extern UID_T getuid(), geteuid(), getreuid();
extern GID_T getgid(), getegid(), getregid();
#endif /* NOGETID_PROTOS */
#else
extern UID_T getreuid();
extern GID_T getregid();
#endif /* COHERENT */
#endif /* HPUX9 */
#endif /* sequent */
#endif /* PS2AIX10 */
#endif /* NEXT */
#endif /* SUNOS4 */
#endif /* _POSIX_SOURCE */
/*
Subject: Set-user-id
To: fdc@watsun.cc.columbia.edu (Frank da Cruz)
Date: Sat, 21 Apr 90 4:48:25 MES
From: Kristoffer Eriksson <ske@pkmab.se>
This is a set of functions to be used in programs that may be run set-user-id
and/or set-group-id. They handle both the case where the program is not run
with such privileges (nothing special happens then), and the case where one
or both of these set-id modes are used. The program is made to run with the
user's real user and group ids most of the time, except for when more
privileges are needed. Don't set-user-id to "root".
This works on System V and POSIX. In BSD, it depends on the
"saved-set-user-id" feature.
*/
#define UID_ROOT 0 /* Root user and group ids */
#define GID_ROOT 0
/*
The following code defines the symbol SETEUID for UNIX systems based
on BSD4.4 (either -Encumbered or -Lite). This program will then use
seteuid() and setegid() instead of setuid() and setgid(), which still
don't allow arbitrary switching. It also avoids setreuid() and
setregid(), which are included in BSD4.4 for compatibility only, are
insecure, and print warnings to stderr under at least one system (NetBSD
1.0). Note that POSIX systems should still use setuid() and setgid();
the seteuid() and setegid() functions are BSD4.4 extensions to the
POSIX model. Mike Long <mike.long@analog.com>, 8/94.
*/
#ifdef BSD44
#define SETEUID
#endif /* BSD44 */
/*
The following construction automatically defines the symbol SETREUID for
UNIX versions based on Berkeley Unix 4.2 and 4.3. If this symbol is
defined, then this program will use getreuid() and getregid() calls in
preference to getuid() and getgid(), which in Berkeley-based Unixes do
not allow arbitrary switching back and forth of real & effective uid.
This construction also allows -DSETREUID to be put on the cc command line
for any system that has and wants to use setre[ug]id(). It also prevents
automatic definition of SETREUID if -DNOSETREU is included on the cc
command line (or otherwise defined).
*/
#ifdef FT18 /* None of this for Fortune. */
#define NOSETREU
#endif /* FT18 */
#ifdef ANYBSD
#ifndef BSD29
#ifndef BSD41
#ifndef SETREUID
#ifndef NOSETREU
#ifndef SETEUID
#define SETREUID
#endif /* SETEUID */
#endif /* NOSETREU */
#endif /* SETREUID */
#endif /* !BSD41 */
#endif /* !BSD29 */
#endif /* ANYBSD */
/* Variables for user and group IDs. */
static UID_T realuid = (UID_T) -1, privuid = (UID_T) -1;
static GID_T realgid = (GID_T) -1, privgid = (GID_T) -1;
/* P R I V _ I N I -- Initialize privileges package */
/* Called as early as possible in a set-uid or set-gid program to store the
* set-to uid and/or gid and step down to the users real uid and gid. The
* stored id's can be temporarily restored (allowed in System V) during
* operations that require the privilege. Most of the time, the program
* should execute in unpriviliged state, to not impose any security threat.
*
* Note: Don't forget that access() always uses the real id:s to determine
* file access, even with privileges restored.
*
* Returns an error mask, with error values or:ed together:
* 1 if setuid() fails,
* 2 if setgid() fails, and
* 4 if the program is set-user-id to "root", which can't be handled.
*
* Only the return value 0 indicates real success. In case of failure,
* those privileges that could be reduced have been, at least, but the
* program should be aborted none-the-less.
*
* Also note that these functions do not expect the uid or gid to change
* without their knowing. It may work if it is only done temporarily, but
* you're on your own.
*/
int
priv_ini() {
int err = 0;
/* Save real ID:s. */
realuid = getuid();
realgid = getgid();
/* Save current effective ID:s, those set to at program exec. */
privuid = geteuid();
privgid = getegid();
/* If running set-uid, go down to real uid, otherwise remember that
* no privileged uid is available.
*
* Exceptions:
*
* 1) If the real uid is already "root" and the set-uid uid (the
* initial effective uid) is not "root", then we would have trouble
* if we went "down" to "root" here, and then temporarily back to the
* set-uid uid (not "root") and then again tried to become "root". I
* think the "saved set-uid" is lost when changing uid from effective
* uid "root", which changes all uid, not only the effective uid. But
* in this situation, we can simply go to "root" and stay there all
* the time. That should give sufficient privilege (understatement!),
* and give the right uids for subprocesses.
*
* 2) If the set-uid (the initial effective uid) is "root", and we
* change uid to the real uid, we can't change it back to "root" when
* we need the privilege, for the same reason as in 1). Thus, we can't
* handle programs that are set-user-id to "root" at all. The program
* should be stopped. Use some other uid. "root" is probably too
* privileged for such things, anyway. (The uid is reverted to the
* real uid until termination.)
*
* These two exceptions have the effect that the "root" uid will never
* be one of the two uids that are being switched between, which also
* means we don't have to check for such cases in the switching
* functions.
*
* Note that exception 1) is handled by these routines (by constantly
* running with uid "root", while exception 2) is a serious error, and
* is not provided for at all in the switching functions.
*/
if (realuid == privuid)
privuid = (UID_T) -1; /* Not running set-user-id. */
/* If running set-gid, go down to real gid, otherwise remember that
* no privileged gid is available.
*
* There are no exception like there is for the user id, since there
* is no group id that is privileged in the manner of uid "root".
* There could be equivalent problems for group changing if the
* program sometimes ran with uid "root" and sometimes not, but
* that is already avoided as explained above.
*
* Thus we can expect always to be able to switch to the "saved set-
* gid" when we want, and back to the real gid again. You may also
* draw the conclusion that set-gid provides for fewer hassles than
* set-uid.
*/
if (realgid == privgid) /* If not running set-user-id, */
privgid = (GID_T) -1; /* remember it this way. */
err = priv_off(); /* Turn off setuid privilege. */
if (privuid == UID_ROOT) /* If setuid to root, */
err |= 4; /* return this error. */
if (realuid == UID_ROOT) { /* If real id is root, */
privuid = (UID_T) -1; /* stay root at all times. */
#ifdef ATT7300
/* If Kermit installed SUID uucp and user is running as root */
err &= ~1; /* System V R0 does not save UID */
#endif /* ATT7300 */
}
return(err);
}
/* Macros for hiding the differences in UID/GID setting between various Unix
* systems. These macros should always be called with both the privileged ID
* and the non-privileged ID. The one in the second argument, will become the
* effective ID. The one in the first argument will be retained for later
* retrieval.
*/
#ifdef SETREUID
#ifdef SAVEDUID
/* On BSD systems with the saved-UID feature, we just juggle the effective
* UID back and forth, and leave the real UID at its true value. The kernel
* allows switching to both the current real UID, the effective UID, and the
* UID which the program is set-UID to. The saved set-UID always holds the
* privileged UID for us, and the real UID will always be the non-privileged,
* and we can freely choose one of them for the effective UID at any time.
*/
#define switchuid(hidden,active) setreuid( (UID_T) -1, active)
#define switchgid(hidden,active) setregid( (GID_T) -1, active)
#else /* SETREUID,!SAVEDUID */
/* On systems with setreXid() but without the saved-UID feature, notably
* BSD 4.2, we swap the real and effective UIDs each time. It's
* the effective UID that we are interested in, but we have to retain the
* unused UID somewhere to enable us to restore it later, and we do this
* in the real UID. The kernel only allows switching to either the current
* real or the effective UID, unless you're "root".
*/
#define switchuid(hidden,active) setreuid(hidden,active)
#define switchgid(hidden,active) setregid(hidden,active)
#endif
#else /* !SETREUID, !SAVEDUID */
#ifdef SETEUID
/*
BSD 4.4 works similarly to System V and POSIX (see below), but uses
seteXid() instead of setXid() to change effective IDs. In addition, the
seteXid() functions work the same for "root" as for other users.
*/
#define switchuid(hidden,active) seteuid(active)
#define switchgid(hidden,active) setegid(active)
#else /* !SETEUID */
/* On System V and POSIX, the only thing we can change is the effective UID
* (unless the current effective UID is "root", but initsuid() avoids that for
* us). The kernel allows switching to the current real UID or to the saved
* set-UID. These are always set to the non-privileged UID and the privileged
* UID, respectively, and we only change the effective UID. This breaks if
* the current effective UID is "root", though, because for "root" setuid/gid
* becomes more powerful, which is why initsuid() treats "root" specially.
* Note: That special treatment maybe could be ignored for BSD? Note: For
* systems that don't fit any of these four cases, we simply can't support
* set-UID.
*/
#define switchuid(hidden,active) setuid(active)
#define switchgid(hidden,active) setgid(active)
#endif /* SETEUID */
#endif /* SETREUID */
/* P R I V _ O N -- Turn on the setuid and/or setgid */
/* Go to the privileged uid (gid) that the program is set-user-id
* (set-group-id) to, unless the program is running unprivileged.
* If setuid() fails, return value will be 1. If getuid() fails it
* will be 2. Return immediately after first failure, and the function
* tries to restore any partial work done. Returns 0 on success.
* Group id is changed first, since it is less serious than user id.
*/
int
priv_on() {
if (privgid != (GID_T) -1)
if (switchgid(realgid,privgid))
return(2);
if (privuid != (UID_T) -1)
if (switchuid(realuid,privuid)) {
if (privgid != (GID_T) -1)
switchgid(privgid,realgid);
return(1);
}
return(0);
}
/* P R I V _ O F F -- Turn on the real uid and gid */
/* Return to the unprivileged uid (gid) after an temporary visit to
* privileged status, unless the program is running without set-user-id
* (set-group-id). Returns 1 for failure in setuid() and 2 for failure
* in setgid() or:ed together. The functions tries to return both uid
* and gid to unprivileged state, regardless of errors. Returns 0 on
* success.
*/
int
priv_off() {
int err = 0;
if (privuid != (UID_T) -1)
if (switchuid(privuid,realuid))
err |= 1;
if (privgid != (GID_T) -1)
if (switchgid(privgid,realgid))
err |= 2;
return(err);
}
/* Turn off privilege permanently. No going back. This is necessary before
* a fork() on BSD43 machines that don't save the setUID or setGID, because
* we swap the real and effective ids, and we don't want to let the forked
* process swap them again and get the privilege back. It will work on other
* machines too, such that you can rely on its effect always being the same,
* for instance, even when you're in priv_on() state when this is called.
* (Well, that part about "permanent" is on System V only true if you follow
* this with a call to exec(), but that's what we want it for anyway.)
* Added by Dean Long -- dlong@midgard.ucsc.edu
*/
int
priv_can() {
#ifdef SETREUID
int err = 0;
if (privuid != (UID_T) -1)
if (setreuid(realuid,realuid))
err |= 1;
if (privgid != (GID_T) -1)
if (setregid(realgid,realgid))
err |= 2;
return(err);
#else
#ifdef SETEUID
int err = 0;
if (privuid != (UID_T) -1)
if (setuid(realuid)) {
debug(F101,"setuid failed","",errno);
err |= 1;
debug(F101,"ruid","",getuid());
debug(F101,"euid","",geteuid());
}
debug(F101,"setuid","",realuid);
if (privgid != (GID_T) -1)
if (setgid(realgid)) {
debug(F101,"setgid failed","",errno);
err |= 2;
debug(F101,"rgid","",getgid());
debug(F101,"egid","",getegid());
}
debug(F101,"setgid","",realgid);
return(err);
#else
/* Easy way of using setuid()/setgid() instead of setreuid()/setregid().*/
return(priv_off());
#endif /* SETEUID */
#endif /* SETREUID */
}
/* P R I V _ O P N -- For opening protected files or devices. */
int
priv_opn(name, modes) char *name; int modes; {
int x;
priv_on(); /* Turn privileges on */
x = open(name, modes); /* Try to open the device */
priv_off(); /* Turn privileges off */
return(x); /* Return open's return code */
}
/* P R I V _ C H K -- Check privileges. */
/* Try to turn them off. If turning them off did not succeed, cancel them */
int
priv_chk() {
int x, y = 0;
x = priv_off(); /* Turn off privs. */
if (x != 0 || getuid() == privuid || geteuid() == privuid)
y = priv_can();
if (x != 0 || getgid() == privgid || getegid() == privgid)
y = y | priv_can();
return(y);
}
UID_T
real_uid() {
return(realuid);
}
VOID
ttimoff() { /* Turn off any timer interrupts */
/* int xx; */
/*
As of 5A(183), we set SIGALRM to SIG_IGN (to ignore alarms) rather than to
SIG_DFL (to catch alarms, or if there is no handler, to exit). This is to
cure (mask, really) a deeper problem with stray alarms that occurs on some
systems, possibly having to do with sleep(), that caused core dumps. It
should be OK to do this, because no code in this module uses nested alarms.
(But we still have to watch out for SCRIPT and DIAL...)
*/
/* xx = */ alarm(0);
/* debug(F101,"ttimoff alarm","",xx); */
if (saval) { /* Restore any previous */
signal(SIGALRM,saval); /* alarm handler. */
/* debug(F101,"ttimoff alarm restoring saval","",saval); */
saval = NULL;
} else {
signal(SIGALRM,SIG_IGN); /* Used to be SIG_DFL */
/* debug(F100,"ttimoff alarm SIG_IGN","",0); */
}
}
#ifdef CK_REDIR
#ifdef COMMENT
/* Old way - not portable */
int
ttruncmd(s) char *s; {
int r = 0; /* Return code */
/* 0 = failure, 1 = success */
#ifdef WIFEXITED
#ifndef WEXITSTATUS
#ifdef w_retcode
#define WEXITSTATUS(x) ((x).w_retcode)
#endif /* w_retcode */
#endif /* WEXITSTATUS */
#ifdef WEXITSTATUS
#define CK_FUN_OK
#endif /* WEXITSTATUS */
#endif /* WIFEXITED */
#ifdef NEXT
#define waitpid(pid,status,option) wait4((pid),(status),(option),NULL)
#else
#ifdef sony_news
#define waitpid(pid,status,option) wait4((pid),(status),(option),NULL)
#endif /* sony_news */
#endif /* NEXT */
#ifdef CK_FUN_OK
PID_T pid;
if (ttyfd == -1) {
printf("?Sorry, device is not openn");
return(0);
}
if (nopush) {
debug(F100,"ttruncmd fail: nopush","",0);
return(0);
}
conres(); /* Make console normal */
if ((pid = fork()) == 0) { /* Make a child fork */
/* give it stdin,out to the line */
if (priv_can()) /* Turn off privs. */
exit(1);
dup2(ttyfd, 0);
dup2(ttyfd, 1);
_exit(system(s) ? BAD_EXIT : 0);
} else {
WAIT_T status; /* This is int for all but NeXT */
SIGTYP (*istat)(), (*qstat)();
if (pid == (PID_T) -1) /* fork() failed? */
return(0);
istat = signal(SIGINT,SIG_IGN); /* Let the fork handle keyboard */
qstat = signal(SIGQUIT,SIG_IGN); /* interrupts itself... */
if (waitpid(pid, &status, 0) != pid) {
printf("?Can't wait for child process?rn");
} else {
if (WIFEXITED(status)) {
if (WEXITSTATUS(status)) {
printf("?Command exit status: %drn",
WEXITSTATUS(status));
} else r = 1;
} else {
printf("?Command did not exit - cancelling it now.rn");
kill(pid, SIGKILL);
}
}
signal(SIGINT,istat); /* Restore interrupts */
signal(SIGQUIT,qstat);
}
concb((char)escchr); /* Restore console to CBREAK mode */
#else
printf("?Sorry, can't execute this command - pieces missing.n");
#endif /* CK_FUN_OK */
return(r);
}
#else
int
ttruncmd(s) char *s; {
PID_T pid; /* pid of lower fork */
int wstat; /* for wait() */
int x;
#ifdef OSF40
/*
This is to shut up warnings from DECC - if it causes trouble, just remove
it, since the warnings don't seem to affect correct operation at runtime.
*/
union wait statusp_w;
int statusp;
#else
int statusp;
#endif /* OSF40 */
if (ttyfd == -1) {
printf("?Sorry, device is not openn");
return(0);
}
if (nopush) {
debug(F100,"ttruncmd fail: nopush","",0);
return(0);
}
conres(); /* Make console normal */
pexitstat = -4;
if ((pid = fork()) == 0) { /* Make a child fork */
if (priv_can()) /* Child: turn off privs. */
exit(1);
dup2(ttyfd, 0); /* Give stdin/out to the line */
dup2(ttyfd, 1);
x = system(s);
debug(F101,"ttruncmd system",s,x);
_exit(x ? BAD_EXIT : 0);
} else {
SIGTYP (*istat)(), (*qstat)();
if (pid == (PID_T) -1) /* fork() failed? */
return(0);
istat = signal(SIGINT,SIG_IGN); /* Let the fork handle keyboard */
qstat = signal(SIGQUIT,SIG_IGN); /* interrupts itself... */
#ifdef COMMENT
while (((wstat = wait(
#ifdef OSF40
&statusp_w
#else
&statusp
#endif /* OSF40 */
)) != pid)
&& (wstat != -1))
;
#else /* Not COMMENT */
while (1) {
wstat = wait(
#ifdef OSF40
&statusp_w
#else
&statusp
#endif /* OSF40 */
);
debug(F101,"ttruncmd wait","",wstat);
if (wstat == pid || wstat == -1)
break;
}
#endif /* COMMENT */
#ifdef OSF40
statusp = (*(int *)&(statusp_w));
#endif /* OSF40 */
pexitstat = (statusp & 0xff) ? statusp : statusp >> 8;
debug(F101,"ttruncmd wait statusp","",statusp);
debug(F101,"ttruncmd wait pexitstat","",pexitstat);
signal(SIGINT,istat); /* Restore interrupts */
signal(SIGQUIT,qstat);
}
concb((char)escchr); /* Restore console to CBREAK mode */
return(statusp == 0 ? 1 : 0);
}
#endif /* COMMENT */
#endif /* CK_REDIR */
struct tm *
#ifdef CK_ANSIC
cmdate2tm(char * date, int gmt) /* date as "yyyymmdd hh:mm:ss" */
#else
cmdate2tm(date,gmt) char * date; int gmt;
#endif
{
/* date as "yyyymmdd hh:mm:ss" */
static struct tm _tm;
time_t now;
if (strlen(date) != 17 ||
date[8] != ' ' ||
date[11] != ':' ||
date[14] != ':')
return(NULL);
time(&now);
if (gmt)
_tm = *gmtime(&now);
else
_tm = *localtime(&now);
_tm.tm_year = (date[0]-'0')*1000 + (date[1]-'0')*100 +
(date[2]-'0')*10 + (date[3]-'0')-1900;
_tm.tm_mon = (date[4]-'0')*10 + (date[5]-'0')-1;
_tm.tm_mday = (date[6]-'0')*10 + (date[7]-'0');
_tm.tm_hour = (date[9]-'0')*10 + (date[10]-'0');
_tm.tm_min = (date[12]-'0')*10 + (date[13]-'0');
_tm.tm_sec = (date[15]-'0')*10 + (date[16]-'0');
_tm.tm_wday = 0;
_tm.tm_yday = 0;
return(&_tm);
}
#ifdef OXOS
#undef kill
#endif /* OXOS */
#ifdef OXOS
int
priv_kill(pid, sig) int pid, sig; {
int i;
if (priv_on())
debug(F100,"priv_kill priv_on failed","",0);
i = kill(pid, sig);
if (priv_off())
debug(F100,"priv_kill priv_off failed","",0);
return(i);
}
#endif /* OXOS */
#ifdef BEOSORBEBOX
/* #ifdef BE_DR_7 */
/*
alarm() function not supplied with Be OS DR7 - this one contributed by
Neal P. Murphy.
*/
/*
This should mimic the UNIX/POSIX alarm() function well enough, with the
caveat that one's SIGALRM handler must call alarm_expired() to clean up vars
and wait for the alarm thread to finish.
*/
unsigned int
alarm(unsigned int seconds) {
long time_left = 0;
/* If an alarm is active, turn it off, saving the unused time */
if (alarm_thread != -1) {
/* We'll be generous and count partial seconds as whole seconds. */
time_left = alarm_struct.time -
((system_time() - time_started) / 1000000.0);
/* Kill the alarm thread */
kill_thread (alarm_thread);
/* We need to clean up as though the alarm occured. */
time_started = 0;
alarm_struct.thread = -1;
alarm_struct.time = 0;
alarm_expired();
}
/* Set a new alarm clock, if requested. */
if (seconds > 0) {
alarm_struct.thread = find_thread(NULL);
alarm_struct.time = seconds;
time_started = system_time();
alarm_thread = spawn_thread (do_alarm,
"alarm_thread",
B_NORMAL_PRIORITY,
(void *) &alarm_struct
);
resume_thread (alarm_thread);
}
/* Now return [unused time | 0] */
return ((unsigned int) time_left);
}
/*
This function is the departure from UNIX/POSIX alarm handling. In the case
of Be's missing alarm() function, this stuff needs to be done in the SIGALRM
handler. When Be implements alarm(), this function call can be eliminated
from user's SIGALRM signal handlers.
*/
void
alarm_expired(void) {
long ret_val;
if (alarm_thread != -1) {
wait_for_thread (alarm_thread, &ret_val);
alarm_thread = -1;
}
}
/*
This is the function that snoozes the requisite number of seconds and then
SIGALRMs the calling thread. Note that kill() wants a pid_t arg, whilst Be
uses thread_id; currently they are both typdef'ed as long, but I'll do the
cast anyway. This function is run in a separate thread.
*/
long
do_alarm (void *alarm_struct) {
snooze ((double) ((struct ALARM_STRUCT *) alarm_struct)->time * 1000000.0);
kill ((pid_t)((struct ALARM_STRUCT *) alarm_struct)->thread, SIGALRM);
time_started = 0;
((struct ALARM_STRUCT *) alarm_struct)->thread = -1;
((struct ALARM_STRUCT *) alarm_struct)->time = 0;
}
/* #endif */ /* BE_DR_7 */
#endif /* BEOSORBEBOX */
#ifdef Plan9
int
p9ttyctl(char letter, int num, int param) {
char cmd[20];
int len;
if (ttyctlfd < 0)
return -1;
cmd[0] = letter;
if (num)
len = sprintf(cmd + 1, "%d", param) + 1;
else {
cmd[1] = param;
len = 2;
}
if (write(ttyctlfd, cmd, len) == len) {
cmd[len] = 0;
/* fprintf(stdout, "wrote '%s'n", cmd); */
return 0;
}
return -1;
}
int
p9ttyparity(char l) {
return p9ttyctl('p', 0, l);
}
int
p9tthflow(int flow, int status) {
return p9ttyctl('m', 1, status);
}
int
p9ttsspd(int cps) {
if (p9ttyctl('b', 1, cps * 10) < 0)
return -1;
ttylastspeed = cps * 10;
return 0;
}
int
p9openttyctl(char *ttname) {
char name[100];
if (ttyctlfd >= 0) {
close(ttyctlfd);
ttyctlfd = -1;
ttylastspeed = -1;
}
sprintf(name, "%sctl", ttname);
ttyctlfd = open(name, 1);
return ttyctlfd;
}
int
p9concb() {
if (consctlfd >= 0) {
if (write(consctlfd, "rawon", 5) == 5)
return 0;
}
return -1;
}
int
p9conbin() {
return p9concb();
}
int
p9conres() {
if (consctlfd >= 0) {
if (write(consctlfd, "rawoff", 6) == 6)
return 0;
}
return -1;
}
int
p9sndbrk(int msec) {
if (ttyctlfd >= 0) {
char cmd[20];
int i = sprintf(cmd, "k%d", msec);
if (write(ttyctlfd, cmd, i) == i)
return 0;
}
return -1;
}
int
conwrite(char *buf, int n) {
int x;
static int length = 0;
static int holdingcr = 0;
int normal = 0;
for (x = 0; x < n; x++) {
char c = buf[x];
if (c == 007) {
if (normal) {
write(1, buf + (x - normal), normal);
length += normal;
normal = 0;
}
/* write(noisefd, "1000 300", 8); */
holdingcr = 0;
} else if (c == 'r') {
if (normal) {
write(1, buf + (x - normal), normal);
length += normal;
normal = 0;
}
holdingcr = 1;
} else if (c == 'n') {
write(1, buf + (x - normal), normal + 1);
normal = 0;
length = 0;
holdingcr = 0;
} else if (c == 'b') {
if (normal) {
write(1, buf + (x - normal), normal);
length += normal;
normal = 0;
}
if (length) {
write(1, &c, 1);
length--;
}
holdingcr = 0;
} else {
if (holdingcr) {
char b = 'b';
while (length-- > 0)
write(1, &b, 1);
length = 0; /* compiler bug */
}
holdingcr = 0;
normal++;
}
}
if (normal) {
write(1, buf + (x - normal), normal);
length += normal;
}
return n;
}
void
conprint(char *fmt, ...) {
char buf[1000];
va_list ap;
int i;
va_start(ap, fmt);
i = vsprintf(buf, fmt, ap);
conwrite(buf, i);
}
#endif /* Plan9 */
/* fprintf, printf, perror replacements... */
/* f p r i n t f */
#ifdef UNIX
#ifdef CK_ANSIC
#include <stdarg.h>
#else /* CK_ANSIC */
#include <varargs.h>
#endif /* CK_ANSIC */
static char str1[1024];
static char str2[1024];
#ifdef fprintf
#undef fprintf
int
#ifdef CK_ANSIC
ckxfprintf(FILE * file, const char * format, ...)
#else /* CK_ANSIC */
ckxfprintf(va_alist) va_dcl
#endif /* CK_ANSIC */
/* ckxfprintf */ {
int i, j, len, got_cr;
va_list args;
int rc = 0;
#ifdef CK_ANSIC
va_start(args, format);
#else /* CK_ANSIC */
char * format;
FILE * file;
va_start(args);
file = va_arg(args,FILE *);
format = va_arg(args,char *);
#endif /* CK_ANSIC */
if (!inserver || (file != stdout && file != stderr && file != stdin)) {
rc = vfprintf(file,format,args);
} else {
unsigned int c;
rc = vsprintf(str1, format, args);
for (i = 0, j = 0, len = strlen(str1), got_cr = 0;
i < len && j < 1022;
i++, j++ ) {
/* We can't use 255 as a case label because of signed chars */
c = (unsigned)(str1[i] & 0xff);
#ifdef TNCODE
if (c == 255) {
if (got_cr && !TELOPT_ME(TELOPT_BINARY))
str2[j++] = '';
str2[j++] = IAC;
str2[j] = IAC;
got_cr = 0;
} else
#endif /* TNCODE */
switch (c) {
case 'r':
if (got_cr
#ifdef TNCODE
&& !TELOPT_ME(TELOPT_BINARY)
#endif /* TNCODE */
)
str2[j++] = '';
str2[j] = str1[i];
got_cr = 1;
break;
case 'n':
if (!got_cr)
str2[j++] = 'r';
str2[j] = str1[i];
got_cr = 0;
break;
default:
if (got_cr
#ifdef TNCODE
&& !TELOPT_ME(TELOPT_BINARY)
#endif /* TNCODE */
)
str2[j++] = '';
str2[j] = str1[i];
got_cr = 0;
}
}
if (got_cr
#ifdef TNCODE
&& !TELOPT_ME(TELOPT_BINARY)
#endif /* TNCODE */
)
str2[j++] = '';
#ifdef CK_ENCRYPTION
#ifdef TNCODE
if (TELOPT_ME(TELOPT_ENCRYPTION))
ck_tn_encrypt(str2,j);
#endif /* TNCODE */
#endif /* CK_ENCRYPTION */
#ifdef CK_SSL
if (inserver && ssl_active_flag) {
/* Write using SSL */
rc = SSL_write(ssl_con, str2, j);
debug(F111,"ckxfprintf","SSL_write",rc);
} else if (inserver && tls_active_flag) {
/* Write using SSL */
rc = SSL_write(tls_con, str2, j);
debug(F111,"ckxfprintf","TLS_write",rc);
} else
#endif /* CK_SSL */
fwrite(str2,sizeof(char),j,stdout);
}
va_end(args);
return(rc);
}
#endif /* fprintf */
/* p r i n t f */
#ifdef printf
#undef printf
int
#ifdef CK_ANSIC
ckxprintf(const char * format, ...)
#else /* CK_ANSIC */
ckxprintf(va_alist) va_dcl
#endif /* CK_ANSIC */
/* ckxprintf */ {
int i, j, len, got_cr;
va_list args;
int rc = 0;
#ifdef CK_ANSIC
va_start(args, format);
#else /* CK_ANSIC */
char * format;
va_start(args);
format = va_arg(args,char *);
#endif /* CK_ANSIC */
if (!inserver) {
rc = vprintf(format, args);
} else {
unsigned int c;
rc = vsprintf(str1, format, args);
for (i = 0, j = 0, len = strlen(str1), got_cr=0;
i < len && j < 1022;
i++, j++ ) {
c = (unsigned)(str1[i] & 0xff);
#ifdef TNCODE
if (c == 255) {
if (got_cr && !TELOPT_ME(TELOPT_BINARY))
str2[j++] = '';
str2[j++] = IAC;
str2[j] = IAC;
got_cr = 0;
} else
#endif /* TNCODE */
switch (c) {
case 'r':
if (got_cr
#ifdef TNCODE
&& !TELOPT_ME(TELOPT_BINARY)
#endif /* TNCODE */
)
str2[j++] = '';
str2[j] = str1[i];
got_cr = 1;
break;
case 'n':
if (!got_cr)
str2[j++] = 'r';
str2[j] = str1[i];
got_cr = 0;
break;
default:
if (got_cr
#ifdef TNCODE
&& !TELOPT_ME(TELOPT_BINARY)
#endif /* TNCODE */
)
str2[j++] = '';
str2[j] = str1[i];
got_cr = 0;
break;
}
}
if (got_cr
#ifdef TNCODE
&& !TELOPT_ME(TELOPT_BINARY)
#endif /* TNCODE */
)
str2[j++] = '';
#ifdef CK_ENCRYPTION
#ifdef TNCODE
if (TELOPT_ME(TELOPT_ENCRYPTION))
ck_tn_encrypt(str2,j);
#endif /* TNCODE */
#endif /* CK_ENCRYPTION */
#ifdef CK_SSL
if (inserver && ssl_active_flag) {
/* Write using SSL */
rc = SSL_write(ssl_con, str2, j);
debug(F111,"ckxprintf","SSL_write",rc);
} else if (inserver && tls_active_flag) {
/* Write using SSL */
rc = SSL_write(tls_con, str2, j);
debug(F111,"ckxprintf","TLS_write",rc);
} else
#endif /* CK_SSL */
rc = fwrite(str2,sizeof(char),j,stdout);
}
va_end(args);
return(rc);
}
#endif /* printf */
/* p e r r o r */
#ifdef perror
#undef perror
_PROTOTYP(char * ck_errstr,(VOID));
#ifdef NEXT
void
#else
#ifdef CK_SCOV5
void
#else
int
#endif /* CK_SCOV5 */
#endif /* NEXT */
#ifdef CK_ANSIC
ckxperror(const char * str)
#else /* CK_ANSIC */
ckxperror(str) char * str;
#endif /* CK_ANSIC */
/* ckxperror */ {
char * errstr = ck_errstr();
#ifndef NEXT
#ifndef CK_SCOV5
return
#endif /* CK_SCOV5 */
#endif /* NEXT */
ckxprintf("%s%s %sn",str,*errstr?":":"",errstr);
}
#endif /* perror */
#endif /* UNIX */
#ifdef MINIX2
/* Minix doesn't have a gettimeofday call. We fake one here using time(2) */
int
gettimeofday(struct timeval *tp, struct timezone *tzp) {
tp->tv_usec = 0L; /* Close enough for horseshoes */
if(time(&(tp->tv_sec))==-1)
return(-1);
return(0);
}
/* Minix does not support symbolic links. We implement a version of
readlink that always fails */
int
readlink(const char *path, void *buf, size_t bufsiz) {
errno = ENOSYS;
return(-1);
}
#endif /* MINIX2 */