OpenSolaris_b135/cmd/bnu/fio.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
*
* flow control protocol.
*
* This protocol relies on flow control of the data stream.
* It is meant for working over links that can (almost) be
* guaranteed to be errorfree, specifically X.25/PAD links.
* A sumcheck is carried out over a whole file only. If a
* transport fails the receiver can request retransmission(s).
* This protocol uses a 7-bit datapath only, so it can be
* used on links that are not 8-bit transparent.
*
* When using this protocol with an X.25 PAD:
* Although this protocol uses no control chars except CR,
* control chars NULL and ^P are used before this protocol
* is started; since ^P is the default char for accessing
* PAD X.28 command mode, be sure to disable that access
* (PAD par 1). Also make sure both flow control pars
* (5 and 12) are set. The CR used in this proto is meant
* to trigger packet transmission, hence par 3 should be
* set to 2; a good value for the Idle Timer (par 4) is 10.
* All other pars should be set to 0.
*
* Normally a calling site will take care of setting the
* local PAD pars via an X.28 command and those of the remote
* PAD via an X.29 command, unless the remote site has a
* special channel assigned for this protocol with the proper
* par settings.
*
* Additional comments for hosts with direct X.25 access:
* - the global variable IsTcpIp, when set, excludes the ioctl's,
* so the same binary can run on X.25 and non-X.25 hosts;
* - reads are done in small chunks, which can be smaller than
* the packet size; your X.25 driver must support that.
*
*
* Author:
* Piet Beertema, CWI, Amsterdam, Sep 1984
* Modified for X.25 hosts:
* Robert Elz, Melbourne Univ, Mar 1985
*/
#include "uucp.h"
#ifdef F_PROTOCOL
extern unsigned msgtime;
/* privates */
static int frdblk(), fwrblk();
#define FIBUFSIZ 4096 /* for X.25 interfaces: set equal to packet size,
* but see comment above
*/
#define FOBUFSIZ 4096 /* for X.25 interfaces: set equal to packet size;
* otherwise make as large as feasible to reduce
* number of write system calls
*/
#ifndef MAXMSGLEN
#define MAXMSGLEN BUFSIZ
#endif /* MAXMSGLEN */
static int fchksum;
static jmp_buf Ffailbuf;
/* ARGSUSED */
static void
falarm(sig)
int sig;
{
signal(SIGALRM, falarm);
longjmp(Ffailbuf, 1);
}
static void (*fsig)();
static int ioctlok;
#ifdef ATTSVTTY
static struct termio ttbuf;
#else
static struct sgttyb ttbuf;
#endif
int
fturnon(void)
{
int ret;
#ifdef ATTSVTTY
struct termio save_ttbuf;
#else
struct sgttyb save_ttbuf;
#endif
#ifdef ATTSVTTY
if (ioctl(Ifn, TCGETA, &ttbuf) >= 0) {
ioctlok = 1;
save_ttbuf = ttbuf;
ioctl(Ifn, TCGETA, &ttbuf);
ttbuf.c_iflag = IXOFF|IXON|ISTRIP;
ttbuf.c_cc[VMIN] = FIBUFSIZ > 64 ? 64 : FIBUFSIZ;
ttbuf.c_cc[VTIME] = 5;
ret = ioctl(Ifn, TCSETA, &ttbuf);
ASSERT(ret >= 0, "STTY FAILED", "", ret);
ttbuf = save_ttbuf;
}
#else /* !ATTSVTTY */
if (ioctl(Ifn, TIOCGETP, &ttbuf) >= 0) {
ioctlok = 1;
save_ttbuf = ttbuf;
ttbuf.sg_flags = ANYP|CBREAK|TANDEM;
ret = ioctl(Ifn, TIOCSETP, &ttbuf);
ASSERT(ret >= 0, "STTY FAILED", "", ret);
ttbuf = save_ttbuf;
}
#endif /* ATTSVTTY */
fsig = signal(SIGALRM, falarm);
/* give the other side time to perform its ioctl;
* otherwise it may flush out the first data this
* side is about to send.
*/
sleep(2);
return SUCCESS;
}
int
fturnoff(void)
{
if (ioctlok) {
#ifdef ATTSVTTY
(void) ioctl(Ifn, TCSETA, &ttbuf);
#else
(void) ioctl(Ifn, TIOCSETP, &ttbuf);
#endif
}
(void) signal(SIGALRM, fsig);
sleep(2);
return SUCCESS;
}
int
fwrmsg(type, str, fn)
char *str;
int fn;
char type;
{
char *s;
char bufr[MAXMSGLEN];
s = bufr;
*s++ = type;
while (*str)
*s++ = *str++;
if (*(s-1) == '\n')
s--;
*s++ = '\r';
*s = 0;
(void) write(fn, bufr, s - bufr);
return SUCCESS;
}
int
frdmsg(str, fn)
char *str;
int fn;
{
char *smax;
if (setjmp(Ffailbuf))
return FAIL;
smax = str + MAXMSGLEN - 1;
(void) alarm(msgtime);
for (;;) {
if (read(fn, str, 1) <= 0)
goto msgerr;
*str &= 0177;
if (*str == '\r')
break;
if (*str < ' ') {
continue;
}
if (str++ >= smax)
goto msgerr;
}
*str = '\0';
(void) alarm(0);
return SUCCESS;
msgerr:
(void) alarm(0);
return FAIL;
}
int
fwrdata(fp1, fn)
FILE *fp1;
int fn;
{
int alen, ret;
char ack, ibuf[MAXMSGLEN];
int flen, retries = 0;
long fbytes;
ret = FAIL;
retry:
fchksum = 0xffff;
fbytes = 0L;
ack = '\0';
do {
alen = fwrblk(fn, fp1, &flen);
fbytes += flen;
if (alen <= 0) {
goto acct;
}
} while (!feof(fp1) && !ferror(fp1));
DEBUG(8, "\nchecksum: %04x\n", fchksum);
if (frdmsg(ibuf, fn) != FAIL) {
if ((ack = ibuf[0]) == 'G')
ret = SUCCESS;
DEBUG(4, "ack - '%c'\n", ack);
}
acct:
DEBUG(7, "%d retries\n", retries);
if (ack == 'R') {
DEBUG(4, "RETRY:\n", 0);
fseek(fp1, 0L, 0);
retries++;
goto retry;
}
return ret;
}
/* max. attempts to retransmit a file: */
#define MAXRETRIES (fbytes < 10000L ? 2 : 1)
int
frddata(fn, fp2)
int fn;
FILE *fp2;
{
int flen;
char eof;
char ibuf[FIBUFSIZ];
int ret, retries = 0;
long alen, fbytes;
ret = FAIL;
retry:
fchksum = 0xffff;
fbytes = 0L;
do {
flen = frdblk(ibuf, fn, &alen);
if (flen < 0)
goto acct;
if (eof = flen > FIBUFSIZ)
flen -= FIBUFSIZ + 1;
fbytes += flen;
if (fwrite(ibuf, sizeof (char), flen, fp2) != flen)
goto acct;
} while (!eof);
ret = SUCCESS;
acct:
DEBUG(7, "%d retries\n", retries);
if (ret == FAIL) {
if (retries++ < MAXRETRIES) {
DEBUG(8, "send ack: 'R'\n", 0);
fwrmsg('R', "", fn);
fseek(fp2, 0L, 0);
DEBUG(4, "RETRY:\n", 0);
goto retry;
}
DEBUG(8, "send ack: 'Q'\n", 0);
fwrmsg('Q', "", fn);
}
else {
DEBUG(8, "send ack: 'G'\n", 0);
fwrmsg('G', "", fn);
}
return ret;
}
static int
frdbuf(blk, len, fn)
char *blk;
int len;
int fn;
{
static int ret = FIBUFSIZ / 2;
if (setjmp(Ffailbuf))
return FAIL;
(void) alarm(msgtime);
ret = read(fn, blk, len);
alarm(0);
return ret <= 0 ? FAIL : ret;
}
#if !defined(ATTSVKILL)
/* call ultouch every TC calls to either frdblk or fwrblk */
#define TC 20
static int tc = TC;
#endif /* !defined(ATTSVKILL) */
/* Byte conversion:
*
* from pre to
* 000-037 172 100-137
* 040-171 040-171
* 172-177 173 072-077
* 200-237 174 100-137
* 240-371 175 040-171
* 372-377 176 072-077
*/
static int
fwrblk(fn, fp, lenp)
int fn;
FILE *fp;
int *lenp;
{
char *op;
int c, sum, nl, len;
char obuf[FOBUFSIZ + 8];
int ret;
#if !defined(ATTSVKILL)
/* call ultouch occasionally */
if (--tc < 0) {
tc = TC;
ultouch();
}
#endif /*!defined(ATTSVKILL)*/
op = obuf;
nl = 0;
len = 0;
sum = fchksum;
while ((c = getc(fp)) != EOF) {
len++;
if (sum & 0x8000) {
sum <<= 1;
sum++;
} else
sum <<= 1;
sum += c;
sum &= 0xffff;
if (c & 0200) {
c &= 0177;
if (c < 040) {
*op++ = '\174';
*op++ = c + 0100;
} else
if (c <= 0171) {
*op++ = '\175';
*op++ = c;
}
else {
*op++ = '\176';
*op++ = c - 0100;
}
nl += 2;
} else {
if (c < 040) {
*op++ = '\172';
*op++ = c + 0100;
nl += 2;
} else
if (c <= 0171) {
*op++ = c;
nl++;
} else {
*op++ = '\173';
*op++ = c - 0100;
nl += 2;
}
}
if (nl >= FOBUFSIZ - 1) {
/*
* peek at next char, see if it will fit
*/
c = getc(fp);
if (c == EOF)
break;
(void) ungetc(c, fp);
if (nl >= FOBUFSIZ || c < 040 || c > 0171)
goto writeit;
}
}
/*
* At EOF - append checksum, there is space for it...
*/
sprintf(op, "\176\176%04x\r", sum);
nl += strlen(op);
writeit:
*lenp = len;
fchksum = sum;
DEBUG(8, "%d/", len);
DEBUG(8, "%d,", nl);
ret = write(fn, obuf, nl);
return ret == nl ? nl : ret < 0 ? 0 : -ret;
}
static int
frdblk(ip, fn, rlen)
char *ip;
int fn;
long *rlen;
{
char *op, c;
int sum, len, nl;
char buf[5], *erbp = ip;
int i;
static char special = 0;
#if !defined(ATTSVKILL)
/* call ultouch occasionally */
if (--tc < 0) {
tc = TC;
ultouch();
}
#endif /*!defined(ATTSVKILL)*/
if ((len = frdbuf(ip, FIBUFSIZ, fn)) == FAIL) {
*rlen = 0;
goto dcorr;
}
*rlen = len;
DEBUG(8, "%d/", len);
op = ip;
nl = 0;
sum = fchksum;
do {
if ((*ip &= 0177) >= '\172') {
if (special) {
DEBUG(8, "%d", nl);
special = 0;
op = buf;
if (*ip++ != '\176' || (i = --len) > 5)
goto dcorr;
while (i--)
*op++ = *ip++ & 0177;
while (len < 5) {
i = frdbuf(&buf[len], 5 - len, fn);
if (i == FAIL) {
len = FAIL;
goto dcorr;
}
DEBUG(8, ",%d", i);
len += i;
*rlen += i;
while (i--)
*op++ &= 0177;
}
if (buf[4] != '\r')
goto dcorr;
sscanf(buf, "%4x", &fchksum);
DEBUG(8, "\nchecksum: %04x\n", sum);
if (fchksum == sum)
return FIBUFSIZ + 1 + nl;
else {
DEBUG(8, "\n", 0);
DEBUG(4, "Bad checksum\n", 0);
return FAIL;
}
}
special = *ip++;
} else {
if (*ip < '\040') {
/* error: shouldn't get control chars */
goto dcorr;
}
switch (special) {
case 0:
c = *ip++;
break;
case '\172':
c = *ip++ - 0100;
break;
case '\173':
c = *ip++ + 0100;
break;
case '\174':
c = *ip++ + 0100;
break;
case '\175':
c = *ip++ + 0200;
break;
case '\176':
c = *ip++ + 0300;
break;
}
*op++ = c;
if (sum & 0x8000) {
sum <<= 1;
sum++;
} else
sum <<= 1;
sum += c & 0377;
sum &= 0xffff;
special = 0;
nl++;
}
} while (--len);
fchksum = sum;
DEBUG(8, "%d,", nl);
return nl;
dcorr:
DEBUG(8, "\n", 0);
DEBUG(4, "Data corrupted\n", 0);
while (len != FAIL) {
if ((len = frdbuf(erbp, FIBUFSIZ, fn)) != FAIL)
*rlen += len;
}
return FAIL;
}
#endif /* F_PROTOCOL */