OpenSolaris_b135/cmd/bnu/eio.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2007 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
#pragma ident "%Z%%M% %I% %E% SMI"
#include "uucp.h"
#ifdef E_PROTOCOL
#ifndef MIN
#define MIN(a,b) (((a)<(b))?(a):(b))
#endif
#if defined(BSD4_2) || defined (ATTSVR4)
#include <netinet/in.h>
#endif /* BSD4_2 || ATTSVR4 */
#define EBUFSIZ 1024
#define EMESGLEN 20
#define TBUFSIZE 1024
#define TPACKSIZE 512
extern long lseek(); /* Find offset into the file. */
static jmp_buf Failbuf;
extern int erdblk();
extern unsigned msgtime;
static char Erdstash[EBUFSIZ];
static int Erdlen;
/*
* error-free channel protocol
*/
/* ARGSUSED */
static void
ealarm(sig)
int sig;
{
longjmp(Failbuf, 1);
}
static void (*esig)();
/*
* turn on protocol timer
*/
int
eturnon()
{
esig=signal(SIGALRM, ealarm);
return(0);
}
int
eturnoff()
{
signal(SIGALRM, esig);
return(0);
}
/*
* write message across link
* type -> message type
* str -> message body (ascii string)
* fn -> link file descriptor
* return
* FAIL -> write failed
* SUCCESS -> write succeeded
*/
int
ewrmsg(type, str, fn)
char *str;
int fn;
char type;
{
return(etwrmsg(type, str, fn, 0));
}
/*
* read message from link
* str -> message buffer
* fn -> file descriptor
* return
* FAIL -> read timed out
* SUCCESS -> ok message in str
*/
int
erdmsg(str, fn)
char *str;
{
return(etrdmsg(str, fn, 0));
}
/*
* read data from file fp1 and write
* on link
* fp1 -> file descriptor
* fn -> link descriptor
* returns:
* FAIL ->failure in link
* SUCCESS -> ok
*/
int
ewrdata(fp1, fn)
FILE *fp1;
int fn;
{
int ret;
int fd1;
int len;
unsigned long bytes;
char bufr[EBUFSIZ];
struct stat statbuf;
off_t msglen;
char cmsglen[EMESGLEN];
off_t startPoint; /* Offset from begining of the file in
* case we are restarting from a check
* point.
*/
if (setjmp(Failbuf)) {
DEBUG(7, "ewrdata failed\n%s", "");
return(FAIL);
}
bytes = 0L;
fd1 = fileno(fp1);
fstat(fd1, &statbuf);
startPoint = lseek(fd1, 0L, 1);
if (startPoint < 0)
{
DEBUG(7, "ewrdata lseek failed. Errno=%d\n", errno);
return(FAIL);
}
msglen = statbuf.st_size - startPoint;
if (msglen < 0)
{
DEBUG(7, "ewrdata: startPoint past end of file.\n%s", "");
return(FAIL);
}
sprintf(cmsglen, "%ld", (long) msglen);
DEBUG(9, "ewrdata writing %d ...", sizeof(cmsglen));
alarm(msgtime);
ret = (*Write)(fn, cmsglen, sizeof(cmsglen));
alarm(0);
DEBUG(9, "ret %d\n", ret);
if (ret != sizeof(cmsglen))
return(FAIL);
DEBUG(7, "ewrdata planning to send %ld bytes to remote.\n", msglen);
while ((len = read( fd1, bufr, EBUFSIZ )) > 0) {
DEBUG(9, "ewrdata writing %d ...", len);
alarm(msgtime);
bytes += len;
putfilesize(bytes);
ret = (*Write)(fn, bufr, (unsigned) len);
alarm(0);
DEBUG(9, "ewrdata ret %d\n", ret);
if (ret != len)
return(FAIL);
if ((msglen -= len) <= 0)
break;
}
if (len < 0 || (len == 0 && msglen != 0)) return(FAIL);
return(SUCCESS);
}
/*
* read data from link and
* write into file
* fp2 -> file descriptor
* fn -> link descriptor
* returns:
* SUCCESS -> ok
* FAIL -> failure on link
*/
int
erddata(fn, fp2)
FILE *fp2;
{
int ret;
int fd2;
char bufr[EBUFSIZ];
int len;
long msglen, bytes;
char cmsglen[EMESGLEN], *cptr, *erdptr = Erdstash;
DEBUG(9, "erddata wants %d\n", sizeof(cmsglen));
if (Erdlen > 0) {
DEBUG(9, "%d bytes stashed\n", Erdlen);
if (Erdlen >= sizeof(cmsglen)) {
memcpy(cmsglen, erdptr, sizeof(cmsglen));
Erdlen -= sizeof(cmsglen);
erdptr += sizeof(cmsglen);
ret = len = 0;
} else {
memcpy(cmsglen, Erdstash, Erdlen);
cptr = cmsglen + Erdlen;
len = sizeof(cmsglen) - Erdlen;
ret = erdblk(cptr, len, fn);
Erdlen = 0;
}
} else {
len = sizeof(cmsglen);
ret = erdblk(cmsglen, sizeof(cmsglen), fn);
}
if (ret != len)
return(FAIL);
ret = SUCCESS;
sscanf(cmsglen, "%ld", &msglen);
if ( ((msglen-1)/512 +1) > Ulimit )
ret = EFBIG;
DEBUG(7, "erddata file is %ld bytes\n", msglen);
fd2 = fileno( fp2 );
if (Erdlen > 0) {
DEBUG(9, "%d bytes stashed\n", Erdlen);
if (write(fileno(fp2), erdptr, Erdlen) != Erdlen)
return(FAIL);
msglen -= Erdlen;
Erdlen = 0;
DEBUG(7, "erddata remainder is %ld bytes\n", msglen);
}
for (;;) {
len = erdblk(bufr, (int) MIN(msglen, EBUFSIZ), fn);
DEBUG(9, "erdblk ret %d\n", len);
if (len < 0) {
DEBUG(7, "erdblk failed\n%s", "");
return(FAIL);
}
/*
* handle the case for remote socket close.
*/
if (len == 0) {
ret = errno;
DEBUG(7, "erddata: remote socket closed, errno %d\n",
ret);
break;
}
bytes += len;
putfilesize(bytes);
if ((msglen -= len) < 0) {
DEBUG(7, "erdblk read too much\n%s", "");
return(FAIL);
}
/* this write is to file -- use write(2), not (*Write) */
if ( ret == SUCCESS && write( fd2, bufr, len ) != len ) {
ret = errno;
DEBUG(7, "erddata: write to file failed, errno %d\n", ret);
}
if (msglen == 0)
break;
}
return(ret);
}
/*
* read block from link
* reads are timed
* blk -> address of buffer
* len -> size to read
* fn -> link descriptor
* returns:
* FAIL -> link error timeout on link
* i -> # of bytes read (must not be 0)
*/
int
erdblk(blk, len, fn)
char *blk;
{
int i, ret;
if(setjmp(Failbuf)) {
DEBUG(7, "timeout (%d sec)\n", msgtime);
return(FAIL);
}
alarm(msgtime);
for (i = 0; i < len; i += ret) {
DEBUG(9, "erdblk ask %d ", len - i);
if ((ret = (*Read)(fn, blk, (unsigned) len - i)) < 0) {
alarm(0);
DEBUG(7, "erdblk read failed\n%s", "");
return(FAIL);
}
DEBUG(9, "erdblk got %d\n", ret);
if (ret == 0)
break;
blk += ret;
}
alarm(0);
return(i);
}
struct tbuf {
long t_nbytes;
char t_data[TBUFSIZE];
};
/*
* read message from link
* str -> message buffer
* fn -> file descriptor
* return
* FAIL -> read timed out
* SUCCESS -> ok message in str
*/
int
trdmsg(str, fn)
char *str;
{
return(etrdmsg(str, fn, TPACKSIZE));
}
/*
* write message across link
* type -> message type
* str -> message body (ascii string)
* fn -> link file descriptor
* return
* FAIL -> write failed
* SUCCESS -> write succeeded
*/
int
twrmsg(type, str, fn)
char type;
char *str;
{
return(etwrmsg(type, str, fn, TPACKSIZE));
}
/*
* read data from file fp1 and write on link
* fp1 -> file descriptor
* fn -> link descriptor
* returns:
* FAIL ->failure in link
* SUCCESS -> ok
*/
int
twrdata(fp1, fn)
FILE *fp1;
int fn;
{
int ret;
int len;
unsigned long bytes;
struct tbuf bufr;
struct stat statbuf;
if (setjmp(Failbuf)) {
DEBUG(7, "twrdata failed\n", 0);
return(FAIL);
}
fstat(fileno(fp1), &statbuf);
bytes = 0L;
while ((len = read(fileno(fp1), bufr.t_data, TBUFSIZE)) > 0) {
bufr.t_nbytes = htonl((long)len);
DEBUG(7, "twrdata writing %d ...", len);
bytes += len;
putfilesize(bytes);
len += sizeof(long);
alarm(msgtime);
ret = (*Write)(fn, (char *)&bufr, (unsigned) len);
alarm(0);
DEBUG(7, "ret %d\n", ret);
if (ret != len)
return(FAIL);
if (len != TBUFSIZE+sizeof(long))
break;
}
bufr.t_nbytes = 0;
alarm(msgtime);
ret = write(fn, (char *)&bufr, sizeof(long));
alarm(0);
if (ret != sizeof(long))
return FAIL;
return(SUCCESS);
}
/*
* read data from link and write into file
* fp2 -> file descriptor
* fn -> link descriptor
* returns:
* SUCCESS -> ok
* FAIL -> failure on link
*/
int
trddata(fn, fp2)
FILE *fp2;
{
int len, nread;
long Nbytes;
unsigned long bytes = 0L;
char bufr[TBUFSIZE];
for (;;) {
len = erdblk((char *)&Nbytes, sizeof(Nbytes), fn);
DEBUG(7, "trddata ret %d\n", len);
if (len != sizeof(Nbytes))
return(FAIL);
Nbytes = ntohl(Nbytes);
DEBUG(7,"trddata expecting %ld bytes\n", Nbytes);
nread = Nbytes;
if (nread == 0)
break;
len = erdblk(bufr, nread, fn);
if (len != Nbytes)
return(FAIL);
bytes += len;
putfilesize(bytes);
if (write(fileno(fp2), bufr, len) != len)
return(FAIL);
}
return(SUCCESS);
}
/*
* read message from link
* str -> message buffer
* fn -> file descriptor
* i -> if non-zero, amount to read; o.w., read up to '\0'
* return
* FAIL -> read timed out
* SUCCESS -> ok message in str
*
* 'e' is fatally flawed -- in a byte stream world, rdmsg can pick up
* the cmsglen on a R request. if this happens, we stash the excess
* where rddata can pick it up.
*/
int
etrdmsg(str, fn, i)
char *str;
int i;
{
int len;
int nullterm = 0;
char *null, *argstr;
if (i == 0) {
DEBUG(9, "etrdmsg looking for null terminator\n", 0);
nullterm++;
i = EBUFSIZ;
argstr = str;
}
if(setjmp(Failbuf)) {
DEBUG(7, "timeout (%d sec)\n", msgtime);
return(FAIL);
}
alarm(msgtime);
for (;;) {
DEBUG(9, "etrdmsg want %d ...", i);
len = (*Read)(fn, str, i);
DEBUG(9, "got %d\n", len);
if (len == 0)
continue; /* timeout will get this */
if (len < 0) {
alarm(0);
return(FAIL);
}
str += len;
i -= len;
if (nullterm) {
/* no way can a msg be as long as EBUFSIZ-1 ... */
*str = 0;
null = strchr(argstr, '\0');
if (null != str) {
null++; /* start of stash */
memcpy(Erdstash + Erdlen, null, str - null);
Erdlen += str - null;
break;
} else
argstr = str;
} else {
if (i == 0)
break;
}
}
alarm(0);
return(SUCCESS);
}
/*
* write message across link
* type -> message type
* str -> message body (ascii string)
* fn -> link file descriptor
* len -> if non-zero, amount to write;
o.w., write up to '\0' (inclusive)
* return
* FAIL -> write failed
* SUCCESS -> write succeeded
*/
int
etwrmsg(type, str, fn, len)
char type;
char *str;
int fn, len;
{
char bufr[EBUFSIZ], *endstr;
int ret;
bufr[0] = type;
/* point endstr to last character to be sent */
if ((endstr = strchr(str, '\n')) != 0)
*endstr = 0;
else
endstr = str + strlen(str);
memcpy(bufr+1, str, (endstr - str) + 1); /* include '\0' */
if (len == 0)
len = (endstr - str) + 2; /* include bufr[0] and '\0' */
else
bufr[len-1] = 0; /* 't' needs this terminator */
if (setjmp(Failbuf)) {
DEBUG(7, "etwrmsg write failed\n", 0);
return(FAIL);
}
DEBUG(9, "etwrmsg want %d ... ", len);
alarm(msgtime);
ret = (*Write)(fn, bufr, (unsigned) len);
alarm(0);
DEBUG(9, "sent %d\n", ret);
if (ret != len)
return(FAIL);
return(SUCCESS);
}
#endif /* E_PROTOCOL */