/*  Receive.c:  File reception routines for xprzmodem.library;
    Version 2.0, 28 October 1989, by Rick Huebner.
    Based closely on Chuck Forsberg's rz.c example ZModem code,
    but too pervasively modified to even think of detailing the changes.
    Released to the Public Domain; do as you like with this code.  */


#include <proto/all.h>
#include <exec/types.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "xproto.h"
#include "zmodem.h"
#include "xprzmodem.h"

#ifdef DEBUGLOG
extern void *DebugLog;
#endif



/* Main file reception routine; called by comm program */
long __saveds XProtocolReceive(struct XPR_IO *io) {
  struct SetupVars *sv;
  struct Vars *v;
  UBYTE err = FALSE;

  /* Perform common setup and initializations */
  if (!(v = setup(io))) return XPRS_FAILURE;
  v->Tryzhdrtype = ZRINIT;
  v->Rxtimeout = 100;

  sv = v->io.xpr_data;
  if (sv->bufpos) {
    v->Modemchar = v->Modembuf;
    if (sv->buflen > sizeof(v->Modembuf)) sv->buflen = sizeof(v->Modembuf);
    memcpy(v->Modembuf,sv->bufpos,sv->buflen);
    v->Modemcount = sv->buflen;
  }

  /* Transfer the files */  
  if (rcvbatch(v) == ERROR) {
    upderr(v,"Download cancelled or timed out");
    err = TRUE;
  } else updmsg(v,"Done.");

  /* Clean up and return */
  if (v->io.xpr_setserial) (*v->io.xpr_setserial)(v->Oldstatus);
  FreeMem(v->Filebuf,v->Filebufmax);
  FreeMem(v,(long)sizeof(struct Vars));

#ifdef DEBUGLOG
  if (DebugLog) {
    (*v->io.xpr_fclose)(DebugLog);
    DebugLog = NULL;
  }
#endif

  return (err) ? XPRS_FAILURE : XPRS_SUCCESS;
}



/* Start the batch transfer */
short rcvbatch(struct Vars *v) {
  switch (tryz(v)) {
    case ZCOMPL:
      return OK;
    case ZFILE:
      if (rzfiles(v) == OK) return OK;
  }
  canit(v);
  return ERROR;
}



/* Negotiate with sender to start a file transfer */
short tryz(struct Vars *v) {
  short n, errors = 0;

  for (n=10; --n>=0; ) {
    /* Set max frame length and capability flags */
    stohdr(v,(long)v->Tframlen);
    v->Txhdr[ZF0] = CANFDX | CANOVIO;
    zshhdr(v,v->Tryzhdrtype);
again:
    switch (zgethdr(v)) {
      case ZFILE:    /* File name and info packet */
        v->Zconv  = v->Rxhdr[ZF0];  /* Suggested text mode; ZCNL = text, ZCBIN = binary, 0 = don't know */
        v->Zmanag = v->Rxhdr[ZF1];  /* Suggested file management mode */
        v->Ztrans = v->Rxhdr[ZF2];  /* Suggested file transport mode */
        v->Tryzhdrtype = ZRINIT;
        if (zrdata(v,v->Pktbuf,KSIZE) == GOTCRCW) return ZFILE;
        zshhdr(v,ZNAK);   /* Packet mangled, ask for retry */
        goto again;
      case ZSINIT:   /* Special attention-grabbing string to use to interrupt sender */
        if (zrdata(v,v->Attn,ZATTNLEN) == GOTCRCW) zshhdr(v,ZACK);
        else zshhdr(v,ZNAK);
        goto again;
      case ZFREECNT: /* Sender wants to know how much room we've got */
        stohdr(v,getfree());
        zshhdr(v,ZACK);
        goto again;
      case ZCOMMAND: /* Sender wants us to do remote commands, but we don't do requests */
        if (zrdata(v,v->Pktbuf,KSIZE) == GOTCRCW) {
          sprintf(v->Msgbuf,"Ignoring command: %s",v->Pktbuf);
          upderr(v,v->Msgbuf); /* Ignore and report all uploaded commands */
          stohdr(v,0L);        /* whilst telling sender they worked; */
          do zshhdr(v,ZCOMPL); /* paranoia can be good for you... */
          while (++errors < 10 && zgethdr(v) != ZFIN);
          ackbibi(v);
          return ZCOMPL;
        } else zshhdr(v,ZNAK);
        goto again;
      case ZCOMPL:
        goto again;
      case ZFIN:    /* Sender has ended batch */
        ackbibi(v);
        return ZCOMPL;
      case ZCAN:
      case RCDO:
        return ERROR;
    }
  }
  return ERROR;
}



/* Receive a batch of files */
short rzfiles(struct Vars *v) {
  struct SetupVars *sv;
  short c;

  /* Keep receiving files until end of batch or error */
  while (TRUE) {
    switch (c = rzfile(v)) {
      case ZEOF:
      case ZSKIP:
        switch (tryz(v)) {
          case ZCOMPL:
            return OK;
          default:
            return ERROR;
          case ZFILE:
            break;
        }
        break;
      default:
        bfclose(v);
        sv = v->io.xpr_data;
        if (*sv->option_k == 'N' && v->io.xpr_extension >= 2 && v->io.xpr_unlink) {
          updmsg(v,"Deleting partially received file");
          (*v->io.xpr_unlink)(v->Filename);
        } else updmsg(v,"Keeping partially received file");
        return c;
    }
  }
}



/* Receive one file; file name packet already read into Pktbuf by tryz() */
short rzfile(struct Vars *v) {
  short c, n;

  /* Process file name packet; either open file and prepare to receive,
     or tell us to skip this one. */
  if (procheader(v) == ERROR) return v->Tryzhdrtype = ZSKIP;

  n = 10;
  v->Rxbytes = v->Strtpos;
  v->Eofseen = FALSE;

  /* Receive ZDATA frames until finished */
  while (TRUE) {
    stohdr(v,v->Rxbytes);      /* Tell sender where to start frame */
    zshhdr(v,ZRPOS);
nxthdr:
    switch (c = zgethdr(v)) {  /* Wait for frame header */
      default:
#ifdef DEBUGLOG
        sprintf(v->Msgbuf,"rzfile: zgethdr returned %d\n",c);
        dlog(v,v->Msgbuf);
#endif
        return ERROR;
      case ZNAK:
      case TIMEOUT:
        if (--n < 0) return ERROR;
#ifdef DEBUGLOG
        dlog(v,"rzfile: zgethdr NAK/Timeout\n");
#endif
        v->xpru.xpru_updatemask = XPRU_ERRORMSG | XPRU_TIMEOUTS;
        sprintf(strchr(v->Msgbuf,'\0'),"@ %ld; %d retries left",v->Rxbytes,n);
        v->xpru.xpru_errormsg = (char *)v->Msgbuf;
        ++v->xpru.xpru_timeouts;
        (*v->io.xpr_update)(&v->xpru);
        continue;
      case ZFILE:     /* Sender didn't see our ZRPOS yet; try again */
        zrdata(v,v->Pktbuf,KSIZE);  /* Read and discard redundant filename packet */
        continue;
      case ZEOF:      /* End of file data */
        if (v->Rxpos != v->Rxbytes) {  /* We aren't in sync; go back */
          sprintf(v->Msgbuf,"Bad EOF; here=%ld, there=%ld",v->Rxbytes,v->Rxpos);
          upderr(v,v->Msgbuf);
          continue;
        }
        bfclose(v);  /* All done; close file */
#ifdef DEBUGLOG
        dlog(v,"rzfile: EOF\n");
#endif
        updmsg(v,"EOF received; checking for next file");
        return c;
      case ERROR:     /* Too much garbage while waiting for frame header */
        if ( --n < 0) return ERROR;
#ifdef DEBUGLOG
        dlog(v,"rzfile: zgethdr garbage overflow\n");
#endif
        v->xpru.xpru_updatemask = XPRU_ERRORMSG | XPRU_ERRORS;
        sprintf(strchr(v->Msgbuf,'\0'),"@ %ld; %d retries left",v->Rxbytes,n);
        v->xpru.xpru_errormsg = (char *)v->Msgbuf;
        ++v->xpru.xpru_errors;
        (*v->io.xpr_update)(&v->xpru);
        zmputs(v,v->Attn);
        continue;
      case ZDATA:     /* More file data packets forthcoming */
        if (v->Rxpos != v->Rxbytes) {   /* We aren't in sync; go back */
          if ( --n < 0) return ERROR;
          v->xpru.xpru_updatemask = XPRU_ERRORMSG | XPRU_ERRORS;
          sprintf(v->Msgbuf,"Data at bad position; here=%ld, there=%ld",v->Rxbytes,v->Rxpos);
          v->xpru.xpru_errormsg = (char *)v->Msgbuf;
          ++v->xpru.xpru_errors;
          (*v->io.xpr_update)(&v->xpru);
          zmputs(v,v->Attn);
          continue;
        }
        /* Receive file data packet(s) */
moredata:
        /* Give comm program its timeslice if it needs one */
        if (v->io.xpr_chkmisc) (*v->io.xpr_chkmisc)();
        /* Check for abort from comm program */
        if (v->io.xpr_chkabort && (*v->io.xpr_chkabort)()) goto aborted;
        switch (c = zrdata(v,v->Pktbuf,KSIZE)) {
          case ZCAN:
          case RCDO:
aborted:
#ifdef DEBUGLOG
            dlog(v,"rzfile: zrdata returned CAN\n");
#endif
            upderr(v,"Transfer cancelled");
            return ERROR;
          case ERROR:     /* CRC error or packet too long */
            if ( --n < 0) return ERROR;
#ifdef DEBUGLOG
            dlog(v,"rzfile: zrdata returned error\n");
#endif
            v->xpru.xpru_updatemask = XPRU_ERRORMSG | XPRU_ERRORS;
            sprintf(strchr(v->Msgbuf,'\0'),"@ %ld; %d retries left",v->Rxbytes,n);
            v->xpru.xpru_errormsg = (char *)v->Msgbuf;
            ++v->xpru.xpru_errors;
            (*v->io.xpr_update)(&v->xpru);
#ifdef DEBUGLOG
            dlog(v,v->Msgbuf);
            dlog(v,"\n");
#endif
            zmputs(v,v->Attn);
            continue;
          case TIMEOUT:
            if ( --n < 0) return ERROR;
#ifdef DEBUGLOG
            dlog(v,"rzfile: zrdata returned timeout\n");
#endif
            v->xpru.xpru_updatemask = XPRU_ERRORMSG | XPRU_TIMEOUTS;
            sprintf(strchr(v->Msgbuf,'\0'),"@ %ld; %d retries left",v->Rxbytes,n);
            v->xpru.xpru_errormsg = (char *)v->Msgbuf;
            ++v->xpru.xpru_timeouts;
            (*v->io.xpr_update)(&v->xpru);
#ifdef DEBUGLOG
            dlog(v,v->Msgbuf);
            dlog(v,"\n");
#endif
            continue;
          case GOTCRCW:   /* Sender says it's waiting for an ACK */
            n = 10;
            if (putsec(v) == ERROR) return ERROR;
            stohdr(v,v->Rxbytes);
            zshhdr(v,ZACK);
            goto nxthdr;
          case GOTCRCQ:   /* Sender says it's not waiting, but ACK anyway (rarely used) */
            n = 10;
            if (putsec(v) == ERROR) return ERROR;
            stohdr(v,v->Rxbytes);
            zshhdr(v,ZACK);
            goto moredata;
          case GOTCRCG:   /* Sender says keep receiving, there's more coming */
            n = 10;
            if (putsec(v) == ERROR) return ERROR;
            goto moredata;
          case GOTCRCE:   /* Sender says this is the last packet */
            n = 10;
            if (putsec(v) == ERROR) return ERROR;
            goto nxthdr;
        }
    }
  }
}



/* Process file name & info packet; either open file and prepare to receive,
   or return ERROR if we should skip this one for some reason */
short procheader(struct Vars *v) {
  struct SetupVars *sv;
  UBYTE *p, *openmode;

  openmode = "w";
  v->Strtpos = 0;

  /* Extract expected filesize from file info packet, if given */
  v->Fsize = -1;
  p = strchr(v->Pktbuf,'\0') + 1;
  if (*p) v->Fsize = atol(p);
  /* Make sure we have room for file; skip it if not.
     Commented out for now, since getfree() isn't implemented yet.
  if (v->Fsize > getfree()) {
    sprintf(v->Msgbuf,"Insufficient disk space; need %ld bytes, have %ld",v->Fsize,getfree());
    upderr(v,v->Msgbuf);
    v->Noroom = TRUE;
    return ERROR;
  } */

  /* If option RY set, use full received file path */
  sv = v->io.xpr_data;
  if (*sv->option_r == 'Y') strcpy(v->Filename,v->Pktbuf);
  else {
    /* else use the default directory path specified in the setup options */
    strcpy(v->Filename,sv->option_p);
    p = v->Filename + strlen(v->Filename) - 1;
    if (p >= v->Filename && *p != '/' && *p != ':') *++p = '/';
    *++p = '\0';
    /* Append the filename from the file info packet; ignore anything before
       last /, \, or : in filename (received directory path is ignored) */
    p = strchr(v->Pktbuf,'\0'); /* start at end and scan back to start of name */
    while (p >= v->Pktbuf && *p != '/' && *p != '\\' && *p != ':') --p;
    strcat(v->Filename,++p);
  }

  /* Display name of file being received for user */
  v->xpru.xpru_updatemask = XPRU_FILENAME;
  v->xpru.xpru_filename = (char *)v->Filename;
  (*v->io.xpr_update)(&v->xpru);

  /* If a file with this name already exists, handle in accordance with O option */
  if (exist(v)) {
    switch (*sv->option_o) {
      case 'N': /* Don't overwrite; change name to prevent collision */
        while (exist(v)) strcat(v->Filename,".dup");
        /* Update filename display to show new name */
        (*v->io.xpr_update)(&v->xpru);
        break;
      case 'R': /* Resume transfer from current end of file */
        openmode = "a";
        v->Strtpos = (*v->io.xpr_finfo)(v->Filename,1L);
        break;
      case 'S': /* Skip it */
        upderr(v,"File already exists; skipping");
        return ERROR;
      /* Else 'Y', go ahead and overwrite it (openmode = w) */
    }
  }

  /* Set text/binary mode according to options before opening file */
  set_textmode(v);

  /* Figure out file translation mode to use; either binary (verbatim
     transfer) or ASCII (perform end-of-line conversions).  If user has
     specified a mode (TY or TN), that's what we use.  If user says use
     sender's suggestion (T?), set mode according to Zconv flag.  If neither
     side specifies, default to binary mode. */
  v->Thisbinary =  v->Rxbinary || !v->Rxascii;
  if (!v->Rxbinary && v->Zconv == ZCNL) v->Thisbinary = FALSE;
  if (!v->Rxascii && v->Zconv == ZCBIN) v->Thisbinary = TRUE;

  /* Open the file (finally) */
  if (!(v->File = bfopen(v,openmode))) {
    ++v->Errcnt;
    upderr(v,"Can't open file; skipping");
    return ERROR;
  }
  v->Starttime = GetSysTime(NULL);

  /* Initialize comm program transfer status display */
  v->xpru.xpru_updatemask = XPRU_PROTOCOL | XPRU_FILESIZE | XPRU_MSG | XPRU_BLOCKS |
                            XPRU_ERRORS | XPRU_TIMEOUTS | XPRU_BLOCKCHECK | XPRU_BYTES |
                            XPRU_EXPECTTIME | XPRU_ELAPSEDTIME| XPRU_DATARATE;
  v->xpru.xpru_protocol = "ZModem";
  v->xpru.xpru_filesize = v->Fsize;
  v->xpru.xpru_msg = (v->Thisbinary) ? "Receiving binary file..." : "Receiving text file...";
  v->xpru.xpru_blocks = v->xpru.xpru_errors = v->xpru.xpru_timeouts = 0;
  v->xpru.xpru_blockcheck = "CRC-16";
  v->xpru.xpru_bytes = v->Strtpos;
  update_rate(v);
  (*v->io.xpr_update)(&v->xpru);

  return OK;
}



/* Writes the received file data to the output file.
   If in ASCII mode, stops writing at first ^Z, and converts all
   \r\n pairs or solo \r's to \n's. */
short putsec(struct Vars *v) {
  static char nl = '\n';
  UBYTE *p;
  short n;

  /* If in binary mode, write it out verbatim */
  if (v->Thisbinary) {
    if (bfwrite(v,v->Pktbuf,(long)v->Rxcount) != v->Rxcount) goto diskfull;
  /* If in text mode, perform end-of-line cleanup */
  } else {
    if (v->Eofseen) return OK;
    for (p=v->Pktbuf, n=v->Rxcount; --n >= 0; ++p) {
      if (*p == CPMEOF) {
        v->Eofseen = TRUE;
        return OK;
      } else if (*p != '\n' && v->Lastsent == '\r') {
        if (bfwrite(v,&nl,1L) != 1) goto diskfull;
      }  
      if (*p != '\r' && bfwrite(v,p,1L) != 1) goto diskfull;
      v->Lastsent = *p;
    }
  }

  /* Update comm program status display */
  v->xpru.xpru_updatemask = XPRU_BLOCKS | XPRU_BLOCKSIZE | XPRU_BYTES |
                            XPRU_EXPECTTIME | XPRU_ELAPSEDTIME | XPRU_DATARATE;
  ++v->xpru.xpru_blocks;
  v->xpru.xpru_blocksize = v->Rxcount;
  v->xpru.xpru_bytes = v->Rxbytes += v->Rxcount;
  update_rate(v);
  (*v->io.xpr_update)(&v->xpru);

  return OK;

diskfull:
  upderr(v,"Error writing file; disk full?");
  v->Noroom = TRUE;
  return ERROR;
}



/* End of batch transmission; disengage cleanly from sender */
void ackbibi(struct Vars *v) {
  short n;

#ifdef DEBUGLOG
  dlog(v,"ackbibi:\n");
#endif
  stohdr(v,0L);
  for (n=4; --n;) {
    zshhdr(v,ZFIN);
    switch (readock(v,100)) {
      case 'O':
        readock(v,1);    /* Discard 2nd 'O' */
      case TIMEOUT:
      case RCDO:
        return;
    }
  }
}