home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Club Amiga de Montreal - CAM
/
CAM_CD_1.iso
/
files
/
341b.lha
/
uucp1_v1.03d
/
src
/
uucico
/
uucico.c
< prev
next >
Wrap
C/C++ Source or Header
|
1990-01-28
|
33KB
|
1,462 lines
/*
* UUCICO.C
*
* (C) Copyright 1987 by John Gilmore.
* Copying and use of this program are controlled by the terms of the Free
* Software Foundation's GNU Emacs General Public License.
*
* Derived from:
* i[$]uuslave.c 1.7 08/12/85 14:04:20
* which came from the ACGNJ BBS system at +1 201 753 9758. Original
* author unknown.
*
* Ported to Amiga by William Loftus
* Amiga Changes Copyright 1988 by William Loftus. All rights reserved.
* Additional Major Changes (c)Copyright 1989 by Matthew Dillon, All rights reserved
*
* 14-Oct-89, moved modem_init() to before poll_sys.
*
* -r option (-r1 does a call out to all systems we have mail for)
* -D[EVICE] dev sets serial device name (automatic from Getty)
* -U[NIT] unit sets unit name (automatic from Getty)
* -h0 Ignore CD (carrier detect)
*/
#include "/version.h"
#include "includes.h" /* System include files, system dependent */
#include "uucp.h" /* Uucp definitions and parameters */
#include "sysdep.h" /* System dependent parts of gnuucp */
#include "modem.h" /* Modem commands */
#include <log.h>
#include <tmpfile.h>
int sigint();
void modem_init();
void cleanup();
#define MAX_FLAGS 40
extern int errno;
IDENT(".06");
static char *Copyright = COPYRIGHT;
char ttynam[NAMESIZE], /* Name of tty we use as serial port */
srcnam[NAMESIZE], /* Source file name */
dstnam[NAMESIZE], /* Dest file name */
who[NAMESIZE] = "-", /* Who sent the file */
flags[MAX_FLAGS], /* Flags from file xfer cmd */
temp[NAMESIZE]; /* Temp file name */
int ourpid = 0, /* Our process ID */
ignore_time_restrictions = 0, /* Call out even if L.sys sez no */
mode; /* File mode from file xfer cmd */
char host_name[MAX_HOST] = "AmigaUUCP"; /* Other guy's host name */
char our_name[MAX_HOST]; /* Our uucp hostname, set from usenet.ctl */
char path[128];
int debug = -1; /* -1 indicates not set by command line or ctl file */
int f_wait = 0; /* wait for a call (-w) or calls (-w -e) after outbnd */
int loop = 0; /* Loop accepting logins if tty name specified */
int curtemp = 0;
int Overide = 0; /* overide modem protocol */
int Getty = 0; /* -Getty initiated */
int IgnoreCD= 0; /* xgetc() should ignore carrier? */
int OurNameOv= 0;
int WindowOne= 0;
#define MAX_STRING 200 /* Max length string to send/expect */
#define MSGO2IDX 7
/* We print these prompts */
char msgo0[] = "login: ";
char msgo1[] = "Password:";
char msgo2[10+MAX_HOST] = { "\20Shere" }; /* NO = */
char msgo3[] = "\20ROK\0";
char msgo3a[]= "\20P";
char msgo3b[]= "\20Pg\0";
char msgo4[] = "\20OOOOOOO\0";
/* We expect to receive these strings */
char msgi0[] = "uucp\r";
char msgi1[] = "s8000\r";
/* char msgi2[] = "\20S*\0"; We now scan it specially FIXME */
char msgi3[] = "\20Ug\0";
char msgi4[] = "OOOOOO";
#define SPOOLDIR "UUSPOOL:"
/*
* Protocol switch data structure
*/
extern int gturnon(), grdmsg(), gwrmsg(), grddata(), gwrdata(), gturnoff();
#define turnon gturnon
#define rdmsg grdmsg
#define wrmsg gwrmsg
#define rddata grddata
#define wrdata gwrdata
#define turnoff gturnoff
int
getname(isshere)
{
int data, count = 0;
static char msgi[MAX_STRING+SLOP]; /* Incoming trash buffer */
/* Read data until null character */
while ((data = xgetc(BYTE_TO)) != EOF) {
data &= 0x7F;
if (data == 020)
break;
}
if (data == EOF)
return FAIL;
while ((data = xgetc(BYTE_TO)) != EOF && (data & 0x7F)) {
data &= 0x7F;
if (count == 0 && data != 'S')
continue;
if (count > sizeof(msgi) - 2)
continue;
msgi[count++] = (char)data;
}
msgi[count] = 0;
if (debug > 8)
printf("GETNAME MSG (%d): %s\n", count, msgi);
if (msgi[0] != 'S')
return FAIL;
if (isshere) {
for (count = 1; msgi[count] && msgi[count] != '='; ++count);
if (msgi[count] == '=')
++count;
} else {
count = 1;
}
if (msgi[count]) {
if (debug > 8)
printf("Compare host names: '%s' '%s'\n", host_name, msgi + count);
strcpy (host_name, msgi + count);
}
strtok(host_name, " "); /* put \0 after hostname */
if (debug > 8)
printf("Hostname is '%s'\n", host_name);
return SUCCESS;
}
/*
* get_proto() checks the list of protos given by the foriegn machine
* checking for 'g' (which is the only proto we have). Use only in master
* mode.
*/
int
get_proto()
{
int data;
while ((data = xgetc(BYTE_TO)) != EOF) {
data &= 0x7F;
if (data == 0)
break;
if (data == 'g')
return(SUCCESS);
}
return FAIL;
}
/*
* Medium level input routine.
*
* Look for an input string for the send-expect sequence.
* Return 0 for matching string, 1 for timeout before we found it.
* FIXME: we only time out if the other end stops sending. If it
* keeps sending, we keep listening forever.
*/
instr(s, n)
char *s;
int n;
{
int data,count,j;
int i;
static char msgi[512]; /* Incoming trash buffer */
count = 0;
if (debug > 8) {
printf("Expecting ");
for (i = 0; i < n; i++)
printc(s[i]);
printf("\n");
}
while ((data = xgetc(BYTE_TO)) != EOF) {
msgi[count++] = (char)data & 0x7F;
if (count == sizeof(msgi)) { /* throw away first half */
count = sizeof(msgi) / 2;
bcopy(msgi + sizeof(msgi) / 2, msgi, sizeof(msgi) / 2);
}
if (count >= n) {
for (i = n - 1, j = count - 1; i >= 0; i--, j--) {
if (*(s+i) != msgi[j])
break;
}
if (i < 0) {
if (debug > 8)
printf("\n");
return(0);
}
}
}
if (debug > 8)
printf("\n");
msgi[count] = (char)0;
return(1);
}
/*
* Debugging hack for stuff written to the modem.
*/
int
twrite(s, n)
char *s;
int n;
{
int i;
if (debug > 8) {
printf("Wrote: ");
for (i = 0; i < n; i++)
printc(s[i]);
printf("\n");
}
return xwrite(s, n);
}
/*
* MAIN ROUTINE.
*
* This is called at program startup. It parses the arguments to the
* program (if any) and sets up to receive a call on the modem.
*
* If there are no arguments, we assume the caller is already on standard
* input, waiting to do uucp protocols (past the login prompt), and we
* just handle one caller.
*
* If there is an argument, it is the name of the tty device where we
* should listen for multiple callers and handle login and password.
*/
void
main(argc,argv)
int argc;
char *argv[];
{
int i;
char *poll_sys = (char *)NULL; /* System name to poll, or none */
short rmode = 0; /* 1 = master, 0 = slave */
LogProgram = "uucico";
LogHost = host_name;
LogWho = who;
signal(SIGINT,sigint); /* Allow the user to break */
/* FIXME, use getopt */
/* scan command line arguments, kinda kludgy but it works */
for (i = 1; i < argc; ++i) {
if (argv[i][0] != '-') {
printf("uucico: warning, extra args ignored: %s\n", argv[i]);
break;
}
switch (argv[i][1]) {
case 'N':
strcpy(our_name, argv[i] + 2);
OurNameOv = 1;
break;
case 'D': /* Serial Device */
{
extern char *DeviceName;
DeviceName = argv[++i];
}
break;
case 'U': /* Serial Unit */
{
extern long DeviceUnit;
DeviceUnit = atoi(argv[++i]);
}
break;
case 'g':
case 'G':
Getty = 1;
break;
case 'h':
IgnoreCD = atoi(argv[i] + 2);
break;
case 'w':
++f_wait;
break;
case 'r':
rmode = atoi(&argv[i][2]);
break;
case 'x':
debug = atoi(&argv[i][2]);
LogLevel = debug;
LogToStdout = 1;
printf("uucico: debug level set to %d\n", debug);
break;
case 'o':
Overide = 1;
break;
case 'n':
WindowOne = 1; /* force windowing mode to size=1 */
break;
case 'S':
ignore_time_restrictions++;
case 's':
poll_sys = &argv[i][2];
break;
case 'e':
++loop;
break;
/* Is -t needed for MSDOS? Why? -- hoptoad!gnu */
case 't':
curtemp++;
printf("uucico: using ~uutemp.$$$ for temp file\n");
break;
default:
printf("uucico: warning, bad flag %s\n", argv[i]);
break;
}
}
/* If argument provided, use it as name of comm port */
/* FIXME, this needs some thought. */
getcwd(path,128);
if (chdir(SPOOLDIR)) {
perror("Can't chdir to Spool directory");
exit(2);
}
read_ctl(); /* Read control file FIXME */
/*
* If running via getty/login, our debug stdout had better
* go to a file, not to the usual stdout!
*/
if (debug > 0 && Getty) {
freopen("T:uuslave.log", "a", stdout);
}
setvbuf(stdout, NULL, _IOLBF, 0);
/* Timestamp the long debug log */
if (debug > 0) {
long clock;
time(&clock);
printf("\014\nuuslave log on tty '%s' starting %s\n",
ttynam, ctime(&clock));
}
/* Log our presence so we humans reading the logs can find the
entries created by uuslave. */
ulog(-1, "Startup %s", VERSION);
amiga_setup();
modem_init();
if (poll_sys) {
if (*poll_sys == '\0')
poll_sys = (char *)NULL;
call_system(poll_sys);
if (!f_wait)
goto end;
} else {
if (rmode) {
do_outbound();
if (!f_wait)
goto end;
}
}
do {
/*
* Set up serial channel, wait for incoming call.
*/
DEBUG(0, "\nRestarting\n", 0);
if (Getty == 0 && Overide == 0)
openline();
do_session(Getty);
hangup();
DEBUG(0, "\nEnd of call\n", 0);
} while (loop && !Getty);
end:
cleanup();
}
/*
* translate embedded escape characters
*/
void
xlat_str(msg, out)
char *msg;
char *out;
{
int i = 0;
int cr = 1;
/*int j = 0;*/
while (msg[i]) {
if (msg[i] == '\\') {
switch (msg[++i]) {
case 'r': /* carriage return */
twrite("\r", 1);
/*out[j++] = 0x0d;*/
break;
case 'n': /* line feed */
twrite("\n", 1);
/*out[j++] = 0x0a;*/
break;
case '\\': /* back slash */
twrite("\\", 1);
/*out[j++] = '\\';*/
break;
case 't': /* tab */
twrite("\t", 1);
/*out[j++] = '\t';*/
break;
case 'b':
SendBreak();
break;
case 'd': /* delay */
Delay(180);
break;
case 's': /* space */
twrite(" ", 1);
/*out[j++] = ' ';*/
break;
case 'c': /* no CR at end */
cr = 0;
break;
default: /* don't know so skip it */
break;
}
++i;
} else {
twrite(msg + i, 1);
++i;
/*out[j++] = msg[i++];*/
}
}
if (cr) {
twrite("\r", 1);
/*out[j++] = 0x0d;*/
}
/*out[j] = '\0';*/
}
/*
* Read the control file and grab a few parameters.
*/
read_ctl()
{
FILE *fd;
static char buf[MAX_CTLLINE];
if (!(fd = fopen("UULIB:Config", "r"))) {
printf("Can't Find config file");
chdir(path);
exit(3);
}
/* find path to inbound news */
while (NULL != fgets(buf, sizeof buf, fd)) {
if (strncmp(buf, "NodeName", 8) == 0) {
if (OurNameOv == 0)
strcpy(our_name, strtok(&buf[9], CTL_DELIM) ) ;
} else if (strncmp(buf, "Debug", 5) == 0)
if (debug < 0)
debug = atoi(strtok(&buf[6], CTL_DELIM));
}
fclose(fd);
return (1);
}
/*
* Search spool queues for work, call the systems we need to call.
*/
do_outbound()
{
return call_system((char *)NULL);
}
/*
* Call a specific system, or all systems that have work pending.
*/
call_system(sys)
char *sys;
{
FILE *lsys;
static char buf[MAX_LSYS];
static char sysnam[MAX_HOST];
static char prev_name[MAX_HOST];
int called = FAIL;
/*
* Unix uucico just reads the directory, and calls the systems
* in the order of the files in the directory. We want more
* control than that, though I'm not sure that L.sys order is
* best either. For example, in the first call after 11PM,
* I'd like to call the sites that haven't been callable before
* 11PM first, and finish up with the ones I've been able to call
* all day. FIXME.
*/
if (! (lsys = fopen("UULIB:L.sys", "r"))) {
DEBUG(0, "uucico: can't open L.sys, errno %d\n", errno);
return 0;
}
sysnam[0] = '\0'; /* Initially, no previous sys */
/* Once per system in L.sys... */
/* FIXME, handle continuation lines (trailing "\") */
while (fgets(buf, sizeof buf, lsys)) {
if (buf[0] == '#' || buf[0] == '\n')
continue;
/*
* Grab the system name. If same as previous, and
* the previous call worked, skip it.
*/
strcpy(prev_name, sysnam);
(void) sscanf(buf, "%s", sysnam);
if (!strcmp(sysnam, prev_name)) {
if (called == SUCCESS)
continue;
}
/*
* If a system name was specified, skip til we find it
* If none was specified, only call if there is work.
*/
if (sys) {
if (strcmp(sys, sysnam) != 0)
continue;
} else {
DEBUG(3,"searching for outbound to %s\n", sysnam);
if (!work_scan(sysnam)) {
DEBUG(3,"no work for %s\n", sysnam);
called = SUCCESS; /* Don't try further */
continue;
}
DEBUG(2, "uucico: found work for %s\n", sysnam);
}
called = call_sysline(buf);
if (called == SUCCESS && sys)
break;
}
fclose(lsys);
if (called == FAIL && sys)
DEBUG(0, "Could not call system %s\n", sys);
return 0;
}
/*
* Call out to a system, given its L.sys line.
*/
call_sysline(lsysline)
char *lsysline;
{
static char tempname[MAX_HOST + 30 + SLOP];
static char strbuf[MAX_STRING+SLOP];
char *sysnam,
*times,
*acu,
*sbaud,
*telno,
*send,
*expct;
int baud;
who[0] = '-'; who[1] = '\0'; /* No user now (for logit) */
/* FIXME, use the values it is ignoring here */
sysnam = strtok(lsysline, " ");
times = strtok(NULL, " "); /* Time */
acu = strtok(NULL, " "); /* ACU */
sbaud = strtok(NULL, " "); /* Baud */
telno = strtok(NULL," "); /* phone */
strcpy(host_name, sysnam);
if ((!ignore_time_restrictions) && (strcmp(times,"Any"))) {
/* FIXME, check the time parameter and return FAIL if
* it does not allow calls now. Meanwhile, bounce
* all calls unless -S is specified. */
ulog(-1, "Wrong Time To Call %s", sysnam);
return FAIL;
}
baud = atoi(sbaud);
/* FIX ME, acu not implemented ? */
DEBUG(4, "Opening outgoing line %s\n", acu);
if (openout(acu, baud) != SUCCESS)
return FAIL;
if (Overide == 0) {
if (dial_nbr(telno)) {
ulog(-1, "FAILED call to %s", host_name);
return FAIL;
}
}
/* FIXME, log tty, baud rate, ... */
ulog(-1, "DIALED %s", host_name);
/*
* Process send-expect strings.
* FIXME, deal with "-", BREAK, etc.
*/
while (send = (char*)strtok((char *)NULL, " ")) {
if (send[0] != '"' || send[1] != '"' || send[2] != '\0') {
if (instr(send, strlen(send)))
goto bort1;
}
if (expct = (char*)strtok((char *)NULL, " ")) {
/* FIXME secondary strings, e.g. ogin:-EOT-ogin: */
xlat_str(expct, strbuf);
/*twrite(strbuf, strlen(strbuf));*/
}
}
/*
* FIXME, there should be a way to detect login/passwd
* failure here and keep doing the script rather than
* continuing to expect Shere at another login: prompt.
*/
ulog(-1, "SUCCEEDED call to %s", host_name);
if (getname(1)) /* get name */
goto bort1;
/* send response */
sprintf(tempname, "\20S%s -Q0 -x%d\0", our_name, debug);
twrite(tempname, strlen(tempname)+1); /* Including null */
/* wait for ok message, wait for protocol request
* send protocol 'g' response */
/* FIXME, we don't actually wait for the ROK message, since
* it is immediately followed by the Pprotos message. We
* currently just look for a Pg message. This needs work.
* FIXME, WE CAN'T TALK TO SITES THAT SUPPORT more than 'g'.
*/
if (instr(msgo3a, sizeof(msgo3a)-1)) {
if (!get_proto())
goto bort1;
}
twrite( msgi3, sizeof(msgi3)-1);
if (turnon(1))
goto bort1;
ulog(-1, "OK Startup");
top_level(1);
hangup();
return SUCCESS;
bort1:
hangup();
return FAIL;
}
/* Handle a single uucp [slave] login session */
do_session(ontheline)
int ontheline;
{
if (ontheline == 0) {
/* output login request, verify uucp */
twrite(msgo0,sizeof(msgo0)-1);
if (instr(msgi0,sizeof(msgi0)-1)) {
printf("uucico: invalid login name\n");
goto bort;
}
/* output password request, verify s8000 */
twrite(msgo1,sizeof(msgo1)-1);
if (instr(msgi1,sizeof(msgi1)-1)) {
printf("uucico: invalid password\n");
goto bort;
}
printf("uucico: correct login\n");
}
/*
* send Shere=<myhost>
*
* Apparently mac UUCP has a bug that only allows 7
* char host names, and it fails if it gets shere=<myhost>
* where <myhost> is > 7 chars.
*/
/*strcpy(msgo2 + MSGO2IDX, our_name);*/
twrite(msgo2,strlen(msgo2)+1);
/*
* get \020S<host> -Qn n (??)
*/
if (getname(0))
goto bort;
/* output ok message, output protocol request, wait for response */
twrite(msgo3,sizeof(msgo3)-1);
/* FIXME, make the protocol list here, and use it */
twrite(msgo3b,sizeof(msgo3b)-1);
if (instr(msgi3,sizeof(msgi3)-1))
goto bort;
if (turnon(0))
goto bort;
ulog(-1, "OK Startup");
top_level(0);
bort:
if (debug > 0)
printf("uucico: call complete\n");
return (1);
}
/*
* Handle transactions "at top level", as Unix uucp's debug log says.
*
* As master, we scan our queues for work and send requests to the
* other side. When done, we send a hangup request and switch to slave mode.
*
* As slave, we accept requests from the other side; when it is done,
* it sends a hangup request, and we switch to master mode, if we have
* any work queued up for that system.
*
* This repeats as long as either side has work to do. When all the
* queued work is done, we agree to hang up, terminate the packet protocol,
* and return to the caller. (We still haven't hung up the phone line yet.)
*
* A curious feature of the hangup protocol is that it is not a simple
* question-answer. The master says "H", asking about hangup. The
* slave responds "HY" saying OK. The master then says "HY" also,
* then both of them hang up. Maybe this is to make sure the first HY
* got ack'ed? Anyway, an "H" is reported as HANGUP and an "HY" as
* HANGNOW. After we send an HY, we go back to listening for commands;
* if the master sends something other than HY, we'll do it.
*/
#define HANGUP 2 /* Signal to switch master/slave roles */
#define HANGNOW 3 /* Signal to hang up now */
#define COPYFAIL 4 /* File copy failed */
int
top_level(master_mode)
int master_mode;
{
static char buf[MAXMSGLEN]; /* For hangup responses */
if (master_mode) {
(void) work_scan(host_name); /* Kick off queue scan */
goto master;
}
for (;;) {
slave: /* SLAVE SIDE */
for (;;) {
DEBUG(4, "*** TOP *** - slave\n", 0);
switch (do_one_slave()) {
case SUCCESS:
break;
case FAIL:
return FAIL;
case HANGUP:
if (work_scan(host_name)) {
if (wrmsg("HN"))
return FAIL;
goto master;
} else {
if (wrmsg("HY"))
return FAIL;
break; /* go to master mode */
}
case HANGNOW:
goto quit;
}
}
master: /* MASTER SIDE */
for (;;) {
DEBUG(4, "*** TOP *** - master\n", 0);
switch (do_one_master()) {
case SUCCESS:
break;
case FAIL:
return FAIL;
case HANGUP:
/* We wrote an H command, what's the resp? */
if (rdmsg(buf, MAXMSGLEN) != SUCCESS) {
return FAIL;
}
if (buf[0] != 'H')
return FAIL;
if (buf[1] == 'N')
goto slave;
else {
/* Write the final HY */
if (wrmsg("HY"))
return FAIL;
goto quit;
}
}
}
}
quit:
/* Shut down the packet protocol */
turnoff();
/* Write the closing sequence */
twrite(msgo4, sizeof(msgo4)-1);
(void) instr(msgi4, sizeof(msgi4)-1);
twrite(msgo4, sizeof(msgo4)-1);
strcpy(who, "-");
ulog(-1, "OK Conversation complete");
return SUCCESS; /* Go byebye */
}
/*
* We are slave; get a command from the other side and execute it.
*
* Result is SUCCESS, FAIL, HANGUP, or HANGNOW.
*/
int
do_one_slave()
{
static char msg[MAXMSGLEN]; /* Master's message to us */
/* Get master's command */
if (rdmsg(msg, MAXMSGLEN) != SUCCESS)
return FAIL;
/* Print it for easy debugging */
DEBUG(5,"\nCommand: %s\n\n", msg);
switch (msg[0]) {
case 'S':
if (msg[1] != ' ')
break;
return host_send_file(msg);
case 'R':
if (msg[1] != ' ')
break;
return host_receive_file(msg);
case 'X':
/*
* Cause uuxqt to run (on certain files?)
* See Protocol.doc for sketchy details.
*/
break;
case 'H':
if (msg[1] == '\0') return HANGUP;
if (msg[1] == 'Y') return HANGNOW;
if (msg[1] == 'N') return SUCCESS; /* Ignore HN to slave */
break;
}
/* Unrecognized packet from the other end */
DEBUG(0, "Bad control packet refused: %s\n", msg);
if (yesno(msg[0], 0, 0)) /* FIXME: return error code */
return FAIL;
return SUCCESS;
}
/*
* Do one piece of work as master.
*
* FIXME: we don't handle the flags, e.g. -c, properly!
*
* Now only dequeues queue file if all transfers were successful.
*/
int
do_one_master()
{
FILE *fd;
char *sname;
char cmnd[1]; /* Command character */
static char buf[256];
int fail = SUCCESS;
int failaccum = 0;
int num;
int delmeflag;
static char notify[NAMESIZE]; /* A bit large...FIXME */
char *delList[16]; /* delete files list */
short di = 0;
/* FIXME: do the notify stuff */
sname = work_next();
if (!sname) {
/* No more work, time to hang up. */
if (wrmsg("H"))
return FAIL;
return HANGUP;
}
DEBUG(2, "Request file %s\n", sname);
LockFile(sname);
fd = fopen(sname, "r");
if (fd == NULL) {
UnLockFile(sname);
DEBUG(0, "uucico: couldn't open %s\n", sname);
return SUCCESS;
}
while (fgets(buf, sizeof buf, fd)) {
DEBUG(3, "Queued request: %s", buf);
if (buf[1] != ' ')
goto badnum;
num = sscanf(buf, "%s %s %s %s %s %s %o\n",
cmnd, srcnam, dstnam, who, flags, temp, &mode, notify
);
switch (cmnd[0]) {
case 'S':
if (num < 7 || num > 8)
goto badnum;
fail = local_send_file(buf, &delmeflag);
if (delmeflag) {
if (di == sizeof(delList)/sizeof(delList[0])) {
ulog(-1, "Too many source files in Cmd file! %s", sname);
} else {
delList[di] = malloc(strlen(temp) + 1);
strcpy(delList[di], temp);
++di;
}
}
break;
case 'R':
if (num != 5)
goto badnum;
fail = local_receive_file(buf);
break;
default:
badnum:
DEBUG(0, "Unknown/invalid queued request: %s\n", buf);
++fail;
break;
}
if (fail != SUCCESS)
++failaccum;
/* FIXME, what does uucp do if one of N xfers fails? */
if (fail == FAIL) {
ulog(-1, "Error in work file %s", sname);
ulog(-1, "Bad line is: %s", buf);
}
}
fclose(fd);
/*
* If we successfuly copied everything zap the queue file
* and any local data files...
*/
if (failaccum == 0) {
while (di) {
--di;
remove(delList[di]);
free(delList[di]);
}
fail = remove(sname);
UnLockFile(sname);
if (fail != 0) {
ulog(-1, "Unable to remove work file %s", sname);
DEBUG(0, "Can't remove, errno %d\n", errno);
} else {
DEBUG(4, "Removed work file %s\n", sname);
}
} else {
UnLockFile(sname);
}
return SUCCESS;
}
/* Send a "yes or no" packet with character 'c'. */
int
yesno(c, true, err)
char c;
int true;
int err;
{
char buf[21];
buf[0] = c;
buf[1] = true? 'Y': 'N';
buf[2] = 0;
if (err && !true)
sprintf(buf+2,"%d", err);
return wrmsg(buf);
}
/*
* SLAVE MODE, Master wishes to send a file to us
*
* SECURITY: If file is not in list of allowed directories
* disallow transfer. UUSPOOL: is always in the
* list.
*
* If file is for UUSPOOL: (the current dir), disallow "C." files
* NOTE: success return and file redirected to T: as this can
* occur only if somebody purposefully is trying to break us.
*
* Return 0 = success
*/
int
host_send_file(msg)
char *msg;
{
FILE *fddsk; /* Disk file pointer */
char cmnd[1]; /* Command character */
int r;
int nor = 0;
sscanf(msg,"%s %s %s %s %s %s %o",
cmnd, srcnam, dstnam, who, flags, temp, &mode);
ulog(-1, "REQUESTED %s", msg);
munge_filename(dstnam, dstnam); /* Translate to local name */
strcpy (temp, TmpFileName(dstnam)); /* Create a handy temp file */
if (SecurityDisallow(dstnam, 'w')) {
ulog(-1, "REQUEST FAILED -- SECURITY");
if (yesno('S', 0, 4))
return FAIL;
return SUCCESS;
}
if (SecurityDisallow(dstnam, 'c') > 0) {
ulog(-1, "REQUEST FAILED -- SECURITY, REMOTE TRIED TO SEND");
ulog(-1, "US A COMMAND FILE: %s, FILE COPIED TO T:Bad-Cmd", dstnam);
strcpy(dstnam, "T:Bad-Cmd");
nor = 1;
}
/* FIXME: deal with file modes now that we fopen. */
LockFile(temp);
fddsk = fopen(temp, "wb" /*, mode|0600 */);
if (fddsk == NULL) {
UnLockFile(temp);
/* Can't open file -- send error response */
if (debug > 0) {
printf("Cannot open temp file %s (%s) for writing, errno=%d\n",
temp,
dstnam,
errno
);
}
ulog(-1, "REQUEST FAILED -- TEMP FILE");
if (yesno('S', 0, 4))
return FAIL;
return SUCCESS;
}
/* FIXME: Are the above permissions right?? */
/* FIXME: Should we create directories for the file? */
if (yesno('S',1, 0)) { /* Say yes */
fclose(fddsk);
unlink(temp);
UnLockFile(temp);
return 1;
}
r = receive_file(fddsk, temp, dstnam, srcnam, nor);
UnLockFile(temp);
return(r);
}
/*
* SLAVE MODE, Master wants us to send a file to it
*
* SECURITY: If file is not in list of allowed directories
* disallow transfer. UUSPOOL: is always in the
* list.
*
* 0 = sucess
*/
host_receive_file(msg)
char *msg;
{
FILE *fddsk; /* Disk file descriptor */
int x;
char cmnd[1]; /* Command character */
ulog(-1, "REQUESTED %s", msg);
sscanf(msg,"%s %s %s",cmnd,srcnam,dstnam);
munge_filename(srcnam, temp);
if (SecurityDisallow(srcnam, 'r')) {
ulog(-1, "COPY FAILED -- SECURITY");
if (yesno('S', 0, 4))
return FAIL;
return SUCCESS;
}
fddsk = fopen(temp, "rb"); /* Try to open the file */
if (fddsk == NULL) {
/* File didn't open, sigh. */
if (debug > 0) {
printf("Cannot open file %s (%s) for reading, errno=%d\n",
temp, srcnam, errno
);
}
ulog(-1, "DENIED CAN'T OPEN %s", temp);
if (yesno('R', 0, 2))
return 1;
return 0;
}
if (yesno('R',1, 0)) { /* Say yes */
fclose(fddsk);
return 1;
}
x = send_file(fddsk);
switch (x) {
default:
return x;
case COPYFAIL:
/* We don't care if the copy failed, since the master
asked for the file and knows the result. */
return SUCCESS;
}
return 1;
}
/*
* MASTER MODE, We want to send a file.
*
* Return FAIL, SUCCESS, or COPYFAIL.
*
* SUCCESS is returned either if the file was not found locally (local
* error, and the queued transfer should be flushed) or if it was moved
* successfully. COPYFAIL indicates that the queued transfer should be
* left queued, and later retried. FIXME, there are several failure points
* in the transaction (see Protocol.doc) and we need finer control here.
*/
int
local_send_file(workstr, delmeflag)
char *workstr;
int *delmeflag;
{
static char buf[MAXMSGLEN]; /* Used for both xmit and receive */
FILE *fddsk; /* Disk file descriptor */
int res; /* Result and file removal status */
*delmeflag = 0;
/* WHY are temp and srcnam switched? FIXME! And no notify? */
sprintf(buf,"S %s %s %s %s %s 0%o %s",
temp, dstnam, who, flags, srcnam, mode, who
);
ulog(-1, "REQUEST %s", buf);
if (strchr(flags, 'c')) {
munge_filename(srcnam, temp);
} else {
munge_filename(temp, temp);
}
LockFile(temp);
fddsk = fopen(temp, "rb");
if (fddsk == NULL) {
UnLockFile(temp);
/* FIXME -- handle queued request for nonexistent file */
if (debug > 0)
printf("Can't open file %s (%s), errno=%d\n",
temp,
srcnam,
errno
);
ulog(-1, "NOT FOUND %s", temp);
/* return COPYFAIL;*/
return SUCCESS; /* assume file previously sent */
}
/* Tell the other side we want to send this file */
if (wrmsg(buf) != SUCCESS) {
DEBUG(0, "problem sending request\n", 0);
fclose(fddsk);
UnLockFile(temp);
return FAIL;
}
/* See what they have to say about it */
if (rdmsg(buf, MAXMSGLEN) != SUCCESS) {
fclose(fddsk);
UnLockFile(temp);
return FAIL;
}
if ((buf[0] != 'S') || (buf[1] != 'Y')) {
ulog(-1, "REQUEST DENIED %s", buf);
fclose(fddsk);
UnLockFile(temp);
return FAIL;
}
res = send_file(fddsk); /* FAIL, SUCCESS, or COPYFAIL */
/* Delete the source file if it was just a copy */
if (res != SUCCESS) {
UnLockFile(temp);
return res;
}
if (strchr(flags, 'c')) { /* If copied direct from source */
UnLockFile(temp);
return res; /* ...just return. */
}
*delmeflag = 1;
UnLockFile(temp);
return res;
}
/*
* MASTER MODE, We wish to receive a specific file so we ask for it
*
* Return 0 = success
*/
int
local_receive_file()
{
static char buf[MAXMSGLEN];
FILE *fddsk; /* Disk file pointer */
int r;
/* FIXME, test dest file access before we ask for it. */
sprintf(buf,"R %s %s %s %s %s 0%o %s",
srcnam, dstnam, who, flags, temp, mode, who
);
munge_filename(dstnam, dstnam); /* tlate to local name */
strcpy (temp, TmpFileName(dstnam)); /* Create a handy temp file */
/* FIXME: deal with file modes now that we fopen. */
/* FIXME: Are the above permissions right?? */
/* FIXME: Should we create directories for the file? */
LockFile(temp);
fddsk = fopen(temp, "wb" /*, mode|060 */);
if (fddsk == NULL) {
UnLockFile(temp);
/* Can't open temp file -- send error response */
if (debug > 0) {
printf("Cannot open temp file %s (%s) for writing, errno=%d\n",
temp,
dstnam,
errno
);
}
ulog(-1, "REQUEST FAILED -- TEMPFILE");
return FAIL;
}
ulog(-1, "REQUEST %s", buf);
if (wrmsg(buf) != SUCCESS) {
fclose(fddsk);
UnLockFile(temp);
printf("uucico: problem sending request\n");
return FAIL;
}
/* See what the other side has to say about it */
if (rdmsg(buf, MAXMSGLEN) != SUCCESS) {
fclose(fddsk);
UnLockFile(temp);
return FAIL;
}
if ((buf[0] != 'R') || (buf[1] != 'Y')) {
ulog(-1, "REQUEST DENIED %s", buf);
fclose(fddsk);
UnLockFile(temp);
return SUCCESS; /* FIXME, should do something more here */
}
r = receive_file(fddsk, temp, dstnam, srcnam, 0);
UnLockFile(temp);
return(r);
}
/*
* General receive file
*/
int
receive_file(fddsk, temp, dstnam, srcnam, norename)
FILE *fddsk;
char *temp, *dstnam, *srcnam;
{
int status;
int error = 0; /* No errors so far */
if (rddata(fddsk) != SUCCESS)
error++;
status = fclose(fddsk); /* Make sure the data got here */
if (status != 0) {
error++;
DEBUG(0, "fclose errno=%d\n", errno);
}
/*
* Move the file from its temp location to its real location,
* This needs to be able to copy a file if a simple rename
* does not suffice. Should create directories if necesary.
* should use source ]name if target is a directory (i.e. no
* target source name
*/
unlink(dstnam);
if (norename) /* for security redirect */
status = 0;
else
status = rename(temp, dstnam);
if (status != 0) {
error++;
if (debug > 0) {
printf("Cannot rename file %s to %s, errno=%d\n",
temp, dstnam, errno);
}
}
ulog(-1, "COPY %s", error ? "FAILED": "SUCCEEDED");
if (yesno('C', error == 0, 5)) /* Send yes or no */
return FAIL;
return SUCCESS;
}
/*
* general file send routine
* Return SUCCESS, FAIL, or COPYFAIL.
*/
int
send_file(fddsk)
FILE *fddsk; /* Disk file pointer */
{
static char ansbuf[MAXMSGLEN];
if (wrdata(fddsk) != SUCCESS) {
fclose(fddsk);
return COPYFAIL;
}
fclose(fddsk);
/* Await the "CY" or "CNddd" packet, and toss it. */
while (1) {
if (rdmsg(ansbuf, MAXMSGLEN) != SUCCESS)
return COPYFAIL;
if (ansbuf[0] != 'C') {
DEBUG(0,"\nDidn't get 'CY' or 'CN', got %s\n", ansbuf);
/* and loop looking for C message */
} else if (ansbuf[1] == 'Y') {
ulog(-1, "REQUESTED %s", ansbuf);
return SUCCESS;
} else {
ulog(-1, "COPY FAILED %s", ansbuf);
return COPYFAIL;
}
}
return COPYFAIL;
}