deb-mbse/mbsebbs/ymsend.c

/*****************************************************************************
 *
 * $Id: ymsend.c,v 1.14 2005/10/11 20:49:48 mbse Exp $
 * Purpose ...............: Ymodem sender
 *
 *****************************************************************************
 * Copyright (C) 1997-2005
 *   
 * Michiel Broek                FIDO:           2:280/2802
 * Beekmansbos 10
 * 1971 BV IJmuiden
 * the Netherlands
 *
 * This file is part of MBSE BBS.
 *
 * This BBS is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * MBSE BBS is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with MBSE BBS; see the file COPYING.  If not, write to the Free
 * Software Foundation, 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 *****************************************************************************/

#include "../config.h"
#include "../lib/mbselib.h"
#include "../lib/mbse.h"
#include "ttyio.h"
#include "zmmisc.h"
#include "transfer.h"
#include "openport.h"
#include "timeout.h"
#include "term.h"
#include "ymsend.h"


#define MAX_BLOCK 8192
#define sendline(c) PUTCHAR((c & 0377))


FILE		*input_f;
char		Crcflg;
char		Lastrx;
int		Fullname = 0;		/* transmit full pathname */
int		Filesleft;
int		Totalleft;
int		bytes_sent;
int		firstsec;
int		Optiong;		/* Let it rip no wait for sector ACK's */
int		Totsecs;		/* total number of sectors this file */
char		*txbuf;
size_t		blklen = 128;		/* length of transmitted records */
int		zmodem_requested = FALSE;
static int	no_unixmode;
struct timeval  starttime, endtime;
struct timezone	tz;
int		skipsize;


extern int  Rxtimeout;


static int wctxpn(char *);
static int getnak(void);
static int wctx(int);
static int wcputsec(char *, int, size_t);
static size_t filbuf(char *, size_t);



int ymsndfiles(down_list *lst, int use1k)
{
    int         maxrc = 0;
    down_list   *tmpf;

    Syslog('+', "%s: start send files", protname());
    txbuf = malloc(MAX_BLOCK);

    /*
     * Count files to transmit
     */
    Totalleft = Filesleft = 0;
    for (tmpf = lst; tmpf; tmpf = tmpf->next) {
	if (tmpf->remote) {
	    Filesleft++;
	    Totalleft += tmpf->size;
	}
    }
    Syslog('x', "%s: %d files, size %d bytes", protname(), Filesleft, Totalleft);

    /*
     * This is not documented as auto start sequence, but a lot of terminal
     * programs seem to react on this.
     */
    if (protocol == ZM_YMODEM)
	PUTSTR((char *)"rb\r");

    for (tmpf = lst; tmpf && (maxrc < 2); tmpf = tmpf->next) {
	if (tmpf->remote) {
	    bytes_sent = 0;
	    skipsize = 0L;
	    Totsecs = 0;

	    switch (wctxpn(tmpf->remote)) {
		case TERROR:	Syslog('x', "wctxpn returns error");
				tmpf->failed = TRUE;
				maxrc = 2;
				break;
		case ZSKIP:	Syslog('x', "wctxpn returns skip");
				tmpf->failed = TRUE;
				break;
		case OK:	gettimeofday(&starttime, &tz);
				if ((blklen == 128) && use1k) {
				    Syslog('x', "%s: will use 1K blocks", protname());
				    blklen = 1024;
				}
				if (wctx(tmpf->size) == TERROR) {
				    Syslog('+', "%s: wctx returned error", protname());
				    tmpf->failed = TRUE;
				} else {
				    tmpf->sent = TRUE;
				    gettimeofday(&endtime, &tz);
				    Syslog('+', "%s: OK %s", protname(), 
					    transfertime(starttime, endtime, (unsigned int)tmpf->size - skipsize, TRUE));
				}
	    }

	} else if (maxrc == 0) {
	    tmpf->failed = TRUE;
	}
	if (unlink(tmpf->remote))
	    Syslog('+', "%s: could not unlink %s", protname(), tmpf->remote);
    }

    if (maxrc == 2) {
	canit(1);
	purgeline(50);
    } else {
	if (protocol == ZM_YMODEM) {
	    /*
	     * Send empty filename to signal end of batch
	     */
	    wctxpn((char *)"");
	}
    }

    if (txbuf)
	free(txbuf);
    txbuf = NULL;
    io_mode(0, 1);

    Syslog('+', "%s: end send files rc=%d", protname(), maxrc);
    return (maxrc < 2)?0:maxrc;
}



/*
 * generate and transmit pathname block consisting of
 *  pathname (null terminated),
 *  file length, mode time and file mode in octal
 *  as provided by the Unix fstat call.
 *  N.B.: modifies the passed name, may extend it!
 */
static int wctxpn(char *fname)
{
    register char   *p, *q;
    char	    *name2;
    struct stat	    f;

    name2 = alloca(PATH_MAX+1);

    if ((input_f = fopen(fname, "r"))) {
	fstat(fileno(input_f), &f);

	Syslog('+', "%s: send \"%s\"", protname(), MBSE_SS(fname));
	Syslog('+', "%s: size %lu bytes, dated %s", protname(), (unsigned int)f.st_size, rfcdate(f.st_mtime));
	    
	if (protocol == ZM_XMODEM) {
	    if (*fname) {
		snprintf(name2, PATH_MAX +1, "Sending %s, %d blocks: ", fname, (int) (f.st_size >> 7));
		PUTSTR(name2);
		Enter(1);
	    }
	    PUTSTR((char *)"Give your local XMODEM receive command now.");
	    Enter(1);
	    return OK;
	}
    } else {
	/*
	 * Reset, this normally happens for the ymodem end of batch block.
	 */
	f.st_size = 0;
	f.st_mtime = 0;
	f.st_mode = 0;
    }

    if (!zmodem_requested)
	if (getnak()) {
	    Syslog('+', "%s: timeout sending filename %s", protname(), MBSE_SS(fname));
	    return TERROR;
	}

    q = (char *) 0;

    for (p = fname, q = txbuf ; *p; )
	if ((*q++ = *p++) == '/' && !Fullname)
	    q = txbuf;
    *q++ = 0;
    p = q;
    while (q < (txbuf + MAX_BLOCK))
	*q++ = 0;

    /* 
     * note that we may lose some information here in case mode_t is wider than an 
     * int. But i believe sending %lo instead of %o _could_ break compatability
     */
    if ((input_f != stdin) && *fname)
	snprintf(p, MAXBLOCK + 1024, "%u %o %o 0 %d %d", (int) f.st_size, (int) f.st_mtime,
	    (unsigned int)((no_unixmode) ? 0 : f.st_mode), Filesleft, Totalleft);

    Totalleft -= f.st_size;
    if (--Filesleft <= 0)
	Totalleft = 0;
    if (Totalleft < 0)
	Totalleft = 0;

    purgeline(1);
    if (wcputsec(txbuf, 0, 128) == TERROR) {
	Syslog('+', "%s: failed to send filename", protname());
	return TERROR;
    }
    return OK;
}



/*
 * Get NAK, C or G
 */
static int getnak(void)
{
    int firstch;
    int tries = 0;

    Syslog('x', "getnak()");
    Lastrx = 0;

    for (;;) {
	tries++;
	switch (firstch = GETCHAR(10)) {
	    case TIMEOUT:
			Syslog('x', "getnak: timeout try %d", tries);
			/* 50 seconds are enough (was 30, 26-11-2004 MB) */
			if (tries == 5) {
			    Syslog('x', "Timeout on pathname");
			    return TRUE;
			}
			continue;
	    case WANTG:
			Syslog('x', "getnak: got WANTG");
			io_mode(0, 2);  /* Set cbreak, XON/XOFF, etc. */
			if (!Optiong)
			    Syslog('+', "%s: using Ymodem-G", protname());
			Optiong = TRUE;
			blklen=1024;
			Crcflg = TRUE;
			return FALSE;
	    case WANTCRC:
			Syslog('x', "getnak: got WANTCRC");
			Crcflg = TRUE;
			return FALSE;
	    case NAK:
			Syslog('x', "getnak: got NAK");
			return FALSE;
	    case CAN:
			Syslog('x', "getnak: got CAN");
			if ((firstch = GETCHAR(2)) == CAN && Lastrx == CAN) {
			    Syslog('+', "%s: Receiver cancelled", protname());
			    return TRUE;
			}
	    default:
			Syslog('x', "got %d", firstch);
			break;
	}
    Lastrx = firstch;
    }
    Syslog('x', "getnak: done");
}



static int wctx(int bytes_total)
{
    register size_t thisblklen;
    register int    sectnum, attempts, firstch;

    firstsec=TRUE;  
    thisblklen = blklen;
    Syslog('x', "wctx: file length=%ld, blklen=%d", bytes_total, blklen);

    while ((firstch = GETCHAR(Rxtimeout)) != NAK && firstch != WANTCRC
	    && firstch != WANTG && firstch != TIMEOUT && firstch != CAN);
    if (firstch == CAN) {
	Syslog('+', "%s: receiver Cancelled during transfer", protname());
	return TERROR;
    }

    if (firstch == WANTCRC)
	Crcflg = TRUE;
    if (firstch == WANTG)
	Crcflg = TRUE;
    sectnum = 0;

    for (;;) {
	if (bytes_total <= (bytes_sent + 896L))
	    thisblklen = 128;
	if ( !filbuf(txbuf, thisblklen))
	    break;
	if (wcputsec(txbuf, ++sectnum, thisblklen) == TERROR)
	    return TERROR;
	bytes_sent += thisblklen;

	/*
	 * Keep connections alive
	 */
	Nopper();
	alarm_on();
    }
    
    fclose(input_f);
    attempts = 0;
    
    do {
	purgeline(5);
	PUTCHAR(EOT);
	++attempts;
    } while ((firstch = (GETCHAR(Rxtimeout)) != ACK) && attempts < RETRYMAX);
    if (attempts == RETRYMAX) {
	Syslog('x', "No ACK on EOT");
	return TERROR;
    } else
	return OK;
}



static int wcputsec(char *buf, int sectnum, size_t cseclen)
{
    int		Checksum, wcj;
    char	*cp;
    unsigned	oldcrc;
    int		firstch;
    int		attempts;

    firstch = 0;      /* part of logic to detect CAN CAN */
    
    Syslog('x', "%s: wcputsec: sectnum %d, len %d, %s", protname(), sectnum, cseclen, Crcflg ? "crc":"checksum");
    
    for (attempts = 0; attempts <= RETRYMAX; attempts++) {
	Lastrx = firstch;
	sendline(cseclen == 1024 ? STX:SOH);
	sendline(sectnum);
	sendline((-sectnum -1));
	oldcrc = Checksum = 0;
	for (wcj = cseclen, cp = buf; --wcj >= 0; ) {
	    sendline(*cp);
	    oldcrc = updcrc16((0377& *cp), oldcrc);
	    Checksum += *cp++;
	}
	if (Crcflg) {
	    oldcrc = updcrc16(0, updcrc16(0, oldcrc));
	    sendline((int)oldcrc >> 8);
	    sendline((int)oldcrc);
	} else {
	    sendline(Checksum);
	}

	if (Optiong) {
	    firstsec = FALSE; 
	    return OK;
	}
	firstch = GETCHAR(Rxtimeout);
gotnak:
	switch (firstch) {
	    case CAN:
			Syslog('x', "got CAN");
			if(Lastrx == CAN) {
cancan:
			    Syslog('x', "Cancelled");  
			    return TERROR;
			}
			break;
	    case TIMEOUT:
			Syslog('x', "Timeout on sector ACK"); 
			continue;
	    case WANTCRC:
			if (firstsec)
			    Crcflg = TRUE;
	    case NAK:
			Syslog('+', "%s: got NAK on sector %d", protname(), sectnum); 
			purgeline(20);
			continue;
	    case ACK:
			firstsec=FALSE;
			Totsecs += (cseclen>>7);
			return OK;
	    case TERROR:
			Syslog('x', "Got burst for sector ACK"); 
			break;
	    default:
			Syslog('x', "Got %02x for sector ACK", firstch); 
			break;
	}
	for (;;) {
	    Lastrx = firstch;
	    if ((firstch = GETCHAR(Rxtimeout)) == TIMEOUT)
		break;
	    if (firstch == NAK || firstch == WANTCRC)
		goto gotnak;
	    if (firstch == CAN && Lastrx == CAN)
		goto cancan;
	}
    }
    Syslog('x', "Retry Count Exceeded");
    return TERROR;
}



/* 
 * fill buf with count chars padding with ^Z for CPM 
 */
static size_t filbuf(char *buf, size_t count)
{
    size_t  m;

    m = read(fileno(input_f), buf, count);
    if (m <= 0)
	return 0;
    
    while (m < count)
        buf[m++] = 032;
    return count;
}