/*
Copyright (C) Magna Carta Software, Inc., 1990.  All Rights Reserved.
C COMMUNICATIONS TOOLKIT
RXXFER.C -- ROUTINES TO HANDLE FILE RECEPTION.
*/

#define CCT_DEVELOPMENT
#include <comm.h>
#if (defined(MSC) || defined(__WATCOMC__) || defined(_INTELC32_))
    #include <malloc.h>
#elif defined(__TURBOC__) || defined(__POWERC)
    #include <alloc.h>
#endif
#include <limits.h>
#include <kermit.h>
#include <xmodem.h>
#include <cctz.h>


/*
MSC v6.0A bugs force sub-optimization of this file
To see the problem, try $(C_OPT) instead of $(C_OPTR) in small model
*/
#if defined(_MSC_VER)
    #pragma optimize("e", off)
#endif


char  *ftempname = "temp0001.$$$";
char  fname[PATHLEN];           /* received file name from remote */
unsigned long fsize;            /* received file size from remote */
unsigned long fdate;            /* received file dtae from remote */



/*
C_FPUTC_ -- Add a byte to the receive buffer.  If it is full, write it to
disk.  The disk write resets the buffer pointer.
Return value:
    0           -- Normal return;
    DISK_FULL   -- insufficient disk space for file;
*/
short c_fputc_(COMM_PORT *p, short ch)
{
    short ret = 0;
    XFER *x = p->x;

#if XDEBUG
    if (ch == '\0')
        fputc(ch, stdout);
#endif
    *x->pb = (BYTE) ch;
    x->pb++;
    if (x->pb > x->high) ret = c_fwrite_(p, x);

    return ((short) ret);
}



/*
C_FWRITE_ -- Write the received data in x->buf to disk.
If high level flow control is enabled, it is used.
Return value:
    0          -- no error;
    DISK_FULL  -- insufficient disk space to write file;
*/
short c_fwrite_(COMM_PORT *p, XFER *x)
{
    short save_rts, save_dtr, f_xoff = FALSE;
    short ret = 0;

#if XDEBUG
    printf("\nEntering c_fwrite");
#endif
    /* IF FLOW CONTROL IS ASSERTED, TURN FLOW OFF */
    if (p->flowctl & TX) {
        if (p->flowctl & TXONXOFF) {
            if (p->inhold & TXONXOFF) {
                p->inhold &= ~TXONXOFF;
                f_xoff = TRUE;
            }
            else c_putc(p, p->xoffchar);
        }
        if (p->flowctl & TRTS_CTS) {
            save_rts = get_rts(p);
            set_rts(p, LOW);
        }
        if (p->flowctl & TDTR_DSR) {
            save_dtr = get_dtr(p);
            set_dtr(p, LOW);
        }
        ms_pause(150);       /* wait for flow control to take effect */
    }

    ret = x->pb - x->buf;
    x->pb = x->buf;
    ret = cct_file_write_(x->fh, x->buf, ret);
    if (ret == EOF) {
        if (x->error != NULL) x->error[-DISK_FULL - XERROR_OFFSET]++;
        if (x->p_user != NULL) (*x->p_user)(p, DISK_FULL, 0L);
        ret = DISK_FULL;
    }
    if (ret > 0) ret = 0;

    /* IF FLOW CONTROL IS ASSERTED, TURN FLOW ON */
    if (p->flowctl & TX) {
        if (p->flowctl & TXONXOFF) {
            if (f_xoff) p->inhold |= TXONXOFF;
            else c_putc(p, p->xonchar);
        }
        if (p->flowctl & TRTS_CTS) set_rts(p, save_rts);
        if (p->flowctl & TDTR_DSR) set_dtr(p, save_dtr);
    }

    return ((short) ret);
}



/*
C_CALLOC_ -- Allocate memory for file receive buffer.
Return value:
     0 -- normal return (success);
    -1 -- Insufficient memory for receive buffer;
*/
short c_calloc_(XFER *x, unsigned bufsize)
{
    short ret = 0;
    DWORD ramavail = memavail();

    ramavail = (memavail() > (DWORD) UINT_MAX) ? (DWORD) UINT_MAX : ramavail;
    if (ramavail < MIN_BUFFER_SIZE + HEADROOM) ret = EOF;
    else {
        /* ADJUST BUFSIZE TO > MIN. */
        bufsize = (bufsize > MIN_BUFFER_SIZE) ? bufsize : MIN_BUFFER_SIZE;
        /* ADJUST BUFSIZE FOR AVAILABLE RAM */
        if (ramavail < bufsize + HEADROOM) bufsize = (unsigned) ramavail - HEADROOM;
        x->pb   = x->buf = (char *) memcalloc(bufsize, sizeof(char));
        x->len  = bufsize;    /* file receive buffer length */
        x->high = x->buf + bufsize - MIN_BUFFER_SIZE/2; /* file receive buffer highwater mark */
#if XDEBUG
        printf("\nx->buf is %Fp, x->high is %Fp\n", x->buf, x->high);
        printf("\nThe buffer length (difference) is %ld, x->len is %Fp\n", x->high - x->buf, x->len);
#endif
    }

    return (ret);
}



/*
FRECEIVE - Receive files from a communications port.
Return value:
     0 -- normal return (success);
    -1 -- Insufficient memory for receive buffer;
    -2 -- unable to open file;
*/
short freceive(COMM_PORT *p, XFER *x, short protocol, unsigned bufsize, short (CDECL_ *progress)(struct comm_port *, short, DWORD))
{
    short ret = 0, f_flow = FALSE;
    WORD save_kbd_clear;

    p->x = x;
    x->num_files = 0;

    if ((ret = c_calloc_(x, bufsize)) != 0) return (ret);
    if (!ret) {
        save_kbd_clear = kbd_clear;
        kbd_clear = TRUE;
        if (x->ibdelay == 0) x->ibdelay = XFER_IBDELAY; /* initialize interbyte delay */
        if (x->retries == 0) x->retries = XFER_RETRIES; /* init. retries */
        if (progress != NULL) x->p_user = progress; /* enable progress reports */
        x->error = a_xfer_errors;                   /* enable error recording */

        /* CHOOSE THE FILE TRANSFER PROTOCOL */
        switch(protocol) {
            case ASCII:
                ret = rx_ascii_(p);
                break;

            case KERMIT:
                if (x->k == NULL) k_init(p, x, NULL);
                ret = k_rcv_(x->k);
                break;

            case XMODEM:
                x->chk      = checksum;
                x->poll     = NAK;
                x->protocol = XMODEM;
                ret         = rx_xmodem_(p, x);
                break;

            case XMODEM_CRC:
                x->chk      = crc_ccitt;
                x->poll     = 'C';
                x->protocol = XMODEM_CRC;
                ret  = rx_xmodem_(p, x);
                break;

            case YMODEM:
            case XMODEM_1K:
                x->chk      = crc_ccitt;
                x->poll     = 'C';
                x->protocol = XMODEM_1K;
                ret  = rx_xmodem_(p, x);
                break;

            case YMODEM_G:
                x->chk      = crc_ccitt;
                x->poll     = 'G';
                x->protocol = YMODEM_G;
                /* IF NO FORM OF FLOW CONTROL IS BEING ASSERTED, USE XONXOFF */
                if (!(p->flowctl & TX)) {
                    set_tx_xlat(p, FLOWCTL, XONXOFF);
                    f_flow = TRUE;
                }
                ret  = rx_xmodem_(p, x);
                if (f_flow) p->flowctl &= ~XONXOFF;
                break;

            case ZMODEM:
                if (p->ppb == NULL) z_init(p, CANFDX | CANOVIO | CANBRK | CANFC32, 0, 0);
                ret = z_receive_(p);
                break;

            case FAST:
                break;

            default:
                break;
        }
    }
    ffreebuf_(x);
    kbd_clear = save_kbd_clear;

    return (ret);
}