/*
Copyright (C) Magna Carta Software, Inc. 1988-1990. All Rights Reserved
C COMMUNICATIONS TOOLKIT
KERMIT.C -- ROUTINES TO HANDLE KERMIT FILE TRANSFERS.
Based on "Kermit Protocol Manual" 5ed. & DaCruz (1987).
Note: If you port this to other hardware architectures or non MSDOS based
opertating systems, we would appreciate knowing of any problems due to the
code constructs used below.
Capabilities:
Basic Kermit specification
Eight-bit quoting;
Repeated character quoting;
Explanation of debug codes:
if XDEBUG=1 general purpose debug information is displayed;
*/
#define CCT_DEVELOPMENT
#if (defined(CCTW) || defined(_WINDOWS))
#include <windows.h>
#endif
#include <string.h>
#include <comm.h>
#include <ctype.h>
#include <fcntl.h>
#include <stdlib.h>
#include <xfer.h>
#include <kermit.h>
static char k_error_msg[PATHLEN];
/*
K_INIT -- Prepare for Kermit transfers
a) allocate memory for the transit buffer;
b) allocate memory for the parameter structure;
c) initialize the parameter structure;
Return code:
0 -- normal return;
EOF -- Kermit already initialized;
NO_RAM -- insufficient memory for internal structures or buffers;
*/
short k_init(void *p, XFER *x, KERMIT_PARMS *k)
{
/* IF x->k IS ALREADY INITIALIZED, EXIT */
if (x->k != NULL) return (EOF);
if (k == NULL) {
if ((k = x->k = (KERMIT_PARMS *) memcalloc(1, sizeof(KERMIT_PARMS))) == NULL) return (NO_RAM);
((KERMIT_PARMS *)x->k)->flags |= CCT_DYNAMIC; /* tell CCT it is dynamically allocated */
}
else x->k = k;
if (!k->iobufsize) k->iobufsize = KERMIT_PAK_SIZE;
/* ALLOCATE MEMORY FOR THE RECEIVE BUFFER */
k->rxbuf = (char *) memcalloc(1, k->iobufsize);
if (k->rxbuf == NULL) {
if (isdynamic(k)) memfree(k);
return (NO_RAM);
}
/* ALLOCATE MEMORY FOR THE TRANSMIT BUFFER */
k->txbuf = (char *) memcalloc(1, k->iobufsize);
if (k->txbuf == NULL) {
memfree(k->rxbuf);
k->rxbuf = NULL;
if (isdynamic(k)) memfree(k);
return (NO_RAM);
}
/* INITIALIZE THE KERMIT_PARMS STRUCTURE WITH DEFAULTS */
if (!k->mark) k->mark = K_MARK;
if (!k->maxl) k->maxl = K_MAXL;
if (!k->timeout) k->timeout = K_TIMEOUT;
if (!k->eol) k->eol = K_EOL;
if (!k->qctl) k->qctl = K_QCTL;
if (!k->qbin) k->qbin = K_QBIN;
if (!k->chkt) k->chkt = K_CHKT;
if (!k->rept) k->rept = K_REPT;
if (!k->mmark) k->mmark = K_MARK;
if (!k->mmaxl) k->mmaxl = K_MAXL;
if (!k->mtimeout) k->mtimeout = K_TIMEOUT;
if (!k->meol) k->meol = K_EOL;
if (!k->mqctl) k->mqctl = K_QCTL;
if (!k->mqbin) k->mqbin = K_QBIN;
if (!k->mchkt) k->mchkt = K_CHKT;
if (!k->mrept) k->mrept = K_REPT;
if (!k->max_retry) k->max_retry = 5;
k->parity = get_parity(p);
if (k->port == NULL) k->port = p; /* the CCT COMM_PORT structure */
if (k->x == NULL) k->x = x; /* the CCT XFER structure */
/* THE PORT STRING WRITE FUNCTION */
if (k->c_puts == NULL) k->c_puts = (short (*)(void *, char *)) c_puts;
/* THE WAIT FOR CHAR FN. */
if (k->c_waitc == NULL) k->c_waitc = (short (*)(void *, short, WORD)) c_waitc;
/* THE FN. TO CLEAR THE RECEIVE BUFFER */
if (k->c_rxflush == NULL) k->c_rxflush = (short (*)(void *, WORD)) c_rxflush;
/* THE FN. TO LOAD THE FILE TO SEND */
if (k->fmakebuf_ == NULL) k->fmakebuf_ = (short (*)(void *)) fmakebuf_;
/* THE FN. TO WRITE THE RECEIVED FILE TO DISK */
if (k->c_fwrite_ == NULL) k->c_fwrite_ = (short (*)(void *, void *)) c_fwrite_;
/* THE FN. TO TELL USER WHAT IS GOING ON */
/* if (k->p_user == NULL) k->p_user = (short (*)(void *, void *)) c_fwrite_; */
k->flags |= CCT_INIT_OK;
return (0);
}
/*
K_BUILD_INIT_ -- Build a Kermit 'send_init' packet.
*/
void k_build_init_(KERMIT_PARMS *k)
{
/* WORD chk; */
k->paknum = 0; /* initialize sequence counter */
memset(k->txbuf, 0X0, k->iobufsize);
#if XDEBUG
k->txbuf[0] = (char) k->mmark; /* header */
k->txbuf[1] = (char) SP;
k->txbuf[2] = (BYTE) tochar(0); /* packet sequence number */
k->txbuf[3] = 'S';
#endif
/* DATA FIELD */
k->txbuf[4] = (char) tochar(k->mmaxl); /* maximum packet length */
k->txbuf[5] = (char) tochar(k->mtimeout); /* you time me out after... */
k->txbuf[6] = (char) tochar(k->mnpad); /* no. of pad chars */
k->txbuf[7] = (char) ctl(k->mpadc); /* pad character */
k->txbuf[8] = (char) tochar(k->meol); /* end-of-line character */
k->txbuf[9] = (char) k->mqctl; /* control quote character */
k->txbuf[10] = (char) k->mqbin; /* 8th-bit prefix character */
k->txbuf[11] = (char) k->mchkt; /* type of error checking */
k->txbuf[12] = (char) k->mrept; /* repeat quote character */
#if XDEBUG
printf("\nSend parms: MAXL=%d, TIME=%d, NPAD=%d, PADC=%d, EOL=%d, QCTL=%c "
"QBIN=%c, REPT=%c\n",
k->mmaxl, k->mtimeout, k->mnpad, k->mpadc, k->meol, k->mqctl,
k->mqbin, k->mrept);
#endif
}
/*
K_CHECK_ -- Compute the checksum of a buffer starting at "buf" and extending
for "count" characters.
*/
WORD k_check_(KERMIT_PARMS *k, char *buf, WORD count)
{
WORD chk;
short andval;
andval = (k->parity != PARITY_NONE) ? 0X7F : 0XFF;
for(chk=0; count > 0; count--, buf++) chk += *buf & andval;
return (chk);
}
/*
K_BUILD_PKT_ -- Build a Kermit packet of the specified type.
's' is a pointer to the data field.
*/
short k_build_pkt_(KERMIT_PARMS *k, char *s, short type)
{
short chk;
if (s != NULL) {
memset(&k->txbuf[4], 0X0, k->iobufsize-5);
strcpy(&k->txbuf[4], s); /* data field */
}
k->txbuf[0] = (char) k->mark; /* header */
/* CALCULATE THE PACKET LENGTH */
k->txbuf[1] = (char) tochar(2 + strlen(&k->txbuf[4]) + (k->chkt & 0X0F));
k->txbuf[2] = (char) tochar(k->paknum % 64); /* packet sequence number */
k->txbuf[3] = (char) type; /* packet type */
/* ERROR CHECK VALUE */
if (k->chkt == '1' || type == 'S') {
chk = (char) k_check_(k, &k->txbuf[1], unchar(k->txbuf[1]));
k->txbuf[strlen(k->txbuf)] = (char) tochar((chk + ((chk & 192)/64)) & 63); /* error check value */
}
else if (k->chkt == '2') {
chk = checksumn(&k->txbuf[1], unchar(k->txbuf[1]));
/* ERROR CHECK VALUE BYTE 1 */
k->txbuf[strlen(k->txbuf)] = (char) tochar((chk >> 6) & 0X3F);
k->txbuf[strlen(k->txbuf)] = (char) tochar(chk & 0X3F);
}
/* PACKET TERMINATOR */
k->txbuf[2 + unchar(k->txbuf[1])] = (char) k->eol;
/* TERMINATE THE STRING */
k->txbuf[2 + unchar(k->txbuf[1]) + 1] = '\0';
return(0);
}
/*
K_RECEIVE_PKT_ -- Try to receive a packet from the remote system.
Return Value:
EOF -- character not recieved;
>0 -- packet type;
*/
short k_receive_pkt_(KERMIT_PARMS *k)
{
short chksum, len, i, ch;
char *pk;
k->ptype = 0;
pk = k->rxbuf;
memset(k->rxbuf, 0X0, k->iobufsize);
/* START OF PACKET HEADER */
if ((ch = (*k->c_waitc)(k->port, k->mark, 1000*k->timeout)) < 0) return (ch);
/* PKT. LENGTH */
if ((ch = (*k->c_waitc)(k->port, EOF, 1000*k->timeout)) < 0) return (ch);
#if XDEBUG
printf("LEN=%d ", unchar(ch));
#endif
len = unchar(ch);
k->dlen = len - 3;
chksum = (char) ch; /* initialize checksum */
/* PACKET SEQUENCE NUMBER */
if ((ch = (*k->c_waitc)(k->port, EOF, 1000*k->timeout)) < 0) return (ch);
k->num = unchar(ch);
#if XDEBUG
printf("SEQ=%d ", unchar(ch));
#endif
chksum += (char) ch;
/* TYPE FIELD */
k->ptype = ch = (*k->c_waitc)(k->port, EOF, 1000*k->timeout); /* type field */
chksum += (char) ch;
#if XDEBUG
printf("TYPE=%c\n", ch);
#endif
/* RECEIVE THE DATA FIELD */
for (i=0; i<len-3;i++) {
if ((ch = (*k->c_waitc)(k->port, EOF, 1000*k->timeout)) < 0) break;
chksum += (char) ch;
*pk++ = (char) ch;
}
if (ch == USER_CANCELLED) return (ch);
if (i < len-3) return (EOF);
/* ERROR CHECK VALUE */
if ((ch = (*k->c_waitc)(k->port, EOF, 1000*k->timeout)) < 0) return (ch);
chksum = tochar((chksum + ((chksum & 192)/64)) & 63); /* error check value */
if (chksum != ch) return (EOF); /* invalid checksum */
#if XDEBUG
printf("CHECK=%d ", ch);
set_rx_xlat(k->port, LOCAL_ECHO, OFF);
#endif
return (k->ptype);
}
/*
ISPREFIX_ -- Returns TRUE if a character is in the range of valid Kermit
prefix characters.
*/
short isprefix_(short ch)
{
if (ch >= 33 && ch <= 63) return (TRUE);
if (ch >= 96 && ch <= 126) return (TRUE);
return (FALSE);
}
/*
K_NEG_PARMS_ -- Negotiate Kermit parameters. Called after response from
k_send_init() or receipt of send_init(). In each case, no response or an
invalid response from the remote initiates the use of Kermit defaults.
*/
short k_neg_parms_(KERMIT_PARMS *k)
{
short len, x;
/* MAXIMUM PACKET LENGTH */
len = strlen(&k->rxbuf[0]);
x = (len >= 1) ? unchar(k->rxbuf[0]) : 80;
k->maxl = (x < 10 || x > 94) ? 80 : x;
/* TIMEOUT BETWEEN CHARACTERS */
x = (len >= 2) ? unchar(k->rxbuf[1]) : 5;
k->timeout = (x < 0) ? 5 : x;
/* NUMBER OF PADDING CHARACTERS */
x = (len >= 3) ? unchar(k->rxbuf[2]) : 0;
k->npad = (x < 0) ? 0 : x;
/* PADDING CHARACTER */
k->padc = (len >= 4) ? ctl(k->rxbuf[3]) : '\0';
/* END-OF-LINE SYMBOL */
x = (len >= 5) ? (WORD) unchar(k->rxbuf[4]) : '\r';
k->eol = ((x < 2) || (x > 31)) ? '\r' : x;
/* CONTROL QUOTE CHARACTER */
x = (len >= 6) ? (WORD) k->rxbuf[5] : '#';
k->qctl = (isprefix_(x)) ? x : k->qctl;
/* 8th BIT QUOTING (k->qbin is initialized to 'Y' if no parity, else '&') */
if (k->mqbin == 'N') k->qbin = FALSE;
else {
x = (len >= 7) ? k->rxbuf[6] : FALSE;
#if XDEBUG
printf("\nRequested QBIN=%c", x);
#endif
if (x == 'Y' && isprefix_(k->mqbin));
else if (isprefix_(x)) {
if (x == (short) k->mqbin || k->mqbin == 'Y') k->mqbin = k->qbin = x;
}
else k->qbin = FALSE;
}
/* TYPE OF ERROR CHECKING */
x = (len >= 8) ? k->rxbuf[7] : '1';
/* k->chkt = (x == '2' || x == '3') ? x : '1'; NOT SUPPORTED (YET) */
k->chkt = '1';
/* RUN-LENGTH ENCODING */
x = (len >= 9) ? k->rxbuf[8] : FALSE;
#if XDEBUG
printf("\nRequested REPT=%#X, %c", x, x);
#endif
if (isprefix_(x) && isprefix_(k->mrept)) k->mrept = k->rept = x;
else k->rept = FALSE;
k->dlen = k->maxl - 2 - (k->chkt & 0XF);
#if XDEBUG
printf("\nNEG: MAXL=%d, TIME=%d, NPAD=%d, PADC=%d, EOL=%d, QCTL=%c "
"QBIN=%c, REPT=%c\n",
k->maxl, k->timeout, k->npad, k->padc, k->eol, k->qctl,
k->qbin, k->rept);
#endif
return (0);
}
/*
K_PKT_ -- Send a Kermit packet that requires no character in the data field.
(e.g. ACK, NAK, BREAK).
*/
void k_pkt_(KERMIT_PARMS *k, char ch)
{
k_build_pkt_(k, "", ch);
(*k->c_puts)(k->port, k->txbuf); /* send ACK */
}
/*
K_SEND_PKT_ -- Send a packet and get the response.
*/
short k_send_pkt_(KERMIT_PARMS *k)
{
#if XDEBUG
printf("\nSending %c packet", k->txbuf[3]);
#endif
c_rxflush(k->port, 0);
(*k->c_puts)(k->port, k->txbuf); /* send it */
return (k_receive_pkt_(k));
}
/*
K_S_ -- State S. Transmit the send_init packet and get the response.
Return Value:
EOF -- No response;
'F' -- Success. Go to state 'F'.
*/
short k_s_(KERMIT_PARMS *k)
{
short ret;
short DONE = FALSE;
WORD i;
if (k->p_user != NULL) (*k->p_user)(k->port, K_SINIT | 0X1000, 0L);
k_build_init_(k); /* build a send_init packet */
k_build_pkt_(k, NULL, 'S');
for (i=0; i < k->max_retry && !DONE; i++) {
ret = k_send_pkt_(k);
switch (ret) {
case EOF:
case 'N':
continue;
case USER_CANCELLED:
case 'A':
case 'E':
DONE = TRUE;
break;
case 'Y':
k_neg_parms_(k);
k->paknum++;
ret = 'F';
DONE = TRUE;
break;
}
}
if (i == k->max_retry) ret = EOF;
return (ret);
}
/*
K_SF_ -- State SF. Send the file header.
*/
short k_sf_(KERMIT_PARMS *k)
{
short ret;
short DONE = FALSE;
WORD i;
char *p;
/* ELIMINATE ANY PATH/DRIVE SPEC FROM THE FILE NAME WE SEND */
p = k->x->xf->fspec + strlen(k->x->xf->fspec);
while (*p != ':' && *p != '\\' && p >= k->x->xf->fspec) p--;
k_build_pkt_(k, ++p, 'F');
for (i=0; i < k->max_retry && !DONE; i++) {
ret = k_send_pkt_(k);
switch (ret) {
case EOF:
case 'N':
continue;
case USER_CANCELLED:
case 'A':
case 'E':
DONE = TRUE;
break;
case 'Y':
if (k->num != k->paknum % 64) continue;
else {
if (k->p_user != NULL) (*k->p_user)(k->port, K_FHEAD | 0X1000, 0L);
ret = 'D';
k->paknum++;
DONE = TRUE;
}
}
}
if (i == k->max_retry) ret = EOF;
return (ret);
}
/*
K_ENCODE_ -- Get data from the XFER send buffer and encode it as a Kermit
data pkt. ready for transmission.
Return value:
len -- The length of the packet (after encoding);
*/
short k_encode_(KERMIT_PARMS *k, XFER *x, char *pb)
{
WORD i;
short temp, ch = EOF, len = 0;
/* EACH ITERATION OF LOOP ENCODES ONE CHARACTER AND ADDS IT TO k->txbuf */
do {
temp = (ch == EOF) ? c_fgetc_(x) : ch; /* read from file */
ch = EOF;
/* AT END-OF-FILE WE EXIT HERE */
if (temp == EOF) break;
len++;
/* DO RUN-LENGTH ENCODING */
if (k->rept) {
i = 1;
while (c_fpeekc_(x) == temp && i < 94) {
ch = c_fgetc_(x);
i++;
}
if (i > 2) {
*pb++ = (char) k->rept; /* add the repeat prefix */
*pb++ = (char) tochar(i); /* add the (encoded) count */
ch = EOF;
len += i - 1;
}
}
/* EIGHTH-BIT PREFIXING */
if (k->qbin) {
/* IF HIGH BIT QUOTING IS IN EFFECT -- DO IT */
if (temp & 0X80) {
*pb++ = (char) k->qbin; /* high bit prefix */
temp &= 0X7F;
}
if (temp == (short) k->qbin) { /* is "temp" the high bit prefix */
*pb++ = (char) k->qctl; /* prefix with the ctrl prefix */
}
}
/* SEE IF IT IS A CONTROL CHARACTER */
if (iscntrl(temp & 0X7F)) {
*pb++ = (char) k->qctl; /* prefix it */
*pb++ = (char) ctl(temp); /* do it */
}
else {
if ((temp & 0X7F) == (short) k->qctl) *pb++ = (char) k->qctl;
else if (k->rept && (temp & 0X7F) == (short) k->rept) *pb++ = (char) k->qctl;
*pb++ = (char) temp;
}
} while (pb < k->txbuf + k->maxl - 5 || ch != EOF);
return (len);
}
/*
K_SD_ -- State SD. Send the data packets.
*/
short k_sd_(KERMIT_PARMS *k)
{
short count, ret, DONE, FINISHED;
WORD i;
unsigned long tlen = 0;
FINISHED = FALSE;
if (k->p_user != NULL) (*k->p_user)(k->port, K_DATA | 0X1000, 0L);
do {
DONE = FALSE;
/* BUILD A DATA PACKET DATA FIELD */
memset(k->txbuf, 0X0, k->iobufsize);
/* KERMITIZE THE DATA TO SEND */
count = k_encode_(k, k->x, &k->txbuf[4]);
if (!count) {
ret = 'Z'; /* FINISHED OK */
FINISHED = TRUE;
}
else {
k_build_pkt_(k, NULL, 'D');
for (i=0; i < k->max_retry && !DONE; i++) {
ret = k_send_pkt_(k);
switch (ret) {
case EOF:
case 'N':
continue;
case USER_CANCELLED:
strncpy(k_error_msg, "User Intervention", 80);
case 'A':
case 'E':
DONE = FINISHED = TRUE;
break;
case 'Y':
if (k->num != k->paknum % 64) continue;
else {
if (k->p_user != NULL) (*k->p_user)(k->port, XFER_POSITION, tlen+=count);
k->paknum++;
DONE = TRUE;
}
}
}
if (i == k->max_retry) {
ret = EOF;
FINISHED = TRUE;
}
}
} while (!FINISHED);
return (ret);
}
/*
K_Z_ -- State SZ. Send the end-of-file (Z) packet.
*/
short k_z_(KERMIT_PARMS *k)
{
short ret;
if (k->p_user != NULL) (*k->p_user)(k->port, K_EOF | 0X1000, (DWORD) k->paknum);
k_build_pkt_(k, "", 'Z');
ret = k_send_pkt_(k);
if (ret == EOF) ret = 'A';
else {
k->paknum++;
ret = 'F';
}
return (ret);
}
/*
K_SB_ -- State SB. Send the Break (B) packet (indicates end of transmission).
*/
short k_sb_(KERMIT_PARMS *k)
{
short ret;
if (k->p_user != NULL) (*k->p_user)(k->port, K_BREAK | 0X1000, (DWORD) k->paknum);
k_build_pkt_(k, "", 'B');
ret = k_send_pkt_(k);
if (ret == EOF) ret = 'A';
else k->paknum++;
return (ret);
}
/*
K_SE_ -- State SE. Send the ERROR (E) packet (indicates fatal error).
Parameter:
KERMIT_PARMS *k -- a pointer to the Kermit structure;
const char *s -- the string to send in the ERROR pkt. data field.
*/
short k_se_(KERMIT_PARMS *k, const char *s)
{
short ret;
if (k->p_user != NULL) (*k->p_user)(k->port, K_ERROR | 0X1000, (DWORD) k->paknum);
k_build_pkt_(k, (char *) s, 'E');
ret = k_send_pkt_(k);
if (ret == EOF) ret = 'A';
else k->paknum++;
return (ret);
}
/*
K_SEND_ -- This is the main state table for a Kermit 'send' transaction.
Return value:
Responses obtained from fload():
-1 -- no files queued to send;
-2 -- unable to open file;
NO_RAM -- insufficient memory for file fransfer buffer (less than MIN_BUFFER_SIZE)
-4 -- file length does not match number of bytes read (short count);
'A' -- aborted;
'B' -- success;
'C' --
0 -- unknown state requested;
*/
short k_send_(KERMIT_PARMS *k, XFER *x, WORD len, short (CDECL_ *progress)(struct comm_port *, short, unsigned long))
{
short state = 'S', DONE = FALSE;
if (k == NULL) return (EOF);
if (progress != NULL) k->p_user = progress;
memset(k_error_msg, 0X0, PATHLEN);
/* LET THE RECEIVER CHOOSE 8TH-BIT PREFIXING */
if (k->parity == PARITY_NONE) k->mqbin = 'Y';
(*k->c_rxflush)(k->port, 0);
do {
switch (state) {
case 'A':
if (x->fh) cct_file_close_(x->fh);
funqueue(x, x->fspec);
ffreebuf_(x);
DONE = TRUE;
break;
case 'B': /* BREAK - end of transaction */
k_sb_(k);
DONE = TRUE;
break;
case 'C':
DONE = TRUE;
break;
case 'D': /* FILE DATA - goes to 'Z' if OK */
state = k_sd_(k);
cct_file_close_(x->fh);
break;
case 'E': /* ERROR - send error packet */
k_se_(k, k_error_msg);
state = 'A';
break;
case 'F': /* FILE INFO - goes to 'D' if OK */
if (fmakebuf_(x, len) != 0) state = 'B';
else state = k_sf_(k);
break;
case 'S': /* SEND-INIT - goes to 'F' if OK */
state = k_s_(k);
break;
case 'Z': /* END OF FILE - goes to 'F' if OK */
state = k_z_(k);
funqueue(x, x->fspec);
ffreebuf_(x);
if (!x->num_files && state == 'F') state = 'B';
break;
default:
state = 0;
DONE = TRUE;
break;
}
} while (!DONE);
return (state);
}
/*
K_DECODE_ -- Decodes an encoded Kermit packet data field and stores the
decoded form in the XFER receive buffer.
*/
short k_decode_(KERMIT_PARMS *k, WORD len)
{
WORD i, j, l, count;
short f_qbin, f_qctl, ch;
/* EACH ITERATION OF THIS LOOP TRANSFORMS ONE CHARACTER AND STORES IT */
for (i=0, l=0; i < len;) {
f_qbin = f_qctl = FALSE; /* reset flags */
count = 1;
ch = k->rxbuf[i++];
/* REPEAT CHARACTER PROCESSING */
if (k->rept && (WORD) ch == k->rept) {
count = unchar(k->rxbuf[i++]);
ch = k->rxbuf[i++];
}
/* HIGH BIT FLAG */
if (k->qbin && (WORD) ch == k->qbin) {
f_qbin = TRUE;
ch = k->rxbuf[i++];
}
/* CONTROL CHARACTER FLAG */
if (k->qctl && (WORD) ch == k->qctl) {
f_qctl = TRUE;
ch = k->rxbuf[i++];
}
/* SPECIAL CASES TO DEAL WITH POTENTIAL CONTROL CHARACTERS */
/* THESE LINES ALLOW US TO TREAT PREFIX CHARS AS LITERALS */
if (f_qctl && ((WORD)(ch & 0X7F) == k->qctl)) f_qctl = FALSE;
if (f_qctl && ((WORD)(ch & 0X7F) == k->qbin)) f_qctl = FALSE;
if (f_qctl && ((WORD)(ch & 0X7F) == k->rept)) f_qctl = FALSE;
/* FINALLY, WE CAN DECODE THE CHARACTER */
if (f_qctl) ch = ctl(ch); /* restore ctl chars */
if (f_qbin) ch |= 0X80; /* restore high bit */
for (j=0; j < count; j++) c_fputc_(k->port, ch);
l += count;
}
return (l);
}
/*
K_RD_ -- Receive data packets.
*/
short k_rd_(KERMIT_PARMS *k)
{
short ret;
WORD i, nlen;
short DONE = FALSE;
DWORD len = 0;
for (i=0; i < k->max_retry && !DONE; i++) {
ret = k_receive_pkt_(k);
if (ret == EOF) k_nak_(k); /* invalid packet -- ABORT */
/* valid packet format -- what type is it? */
/* PACKET NUMBER SAME AS PREVIOUS -- ACK AND TRY AGAIN */
else if (ret != USER_CANCELLED && k->num == ((k->paknum - 1) % 64)) {
k->paknum--;
k_ack_(k);
k->paknum++;
}
else switch (ret) {
case 'A': /* ABORT packet received */
ret = 'A';
DONE = TRUE;
if (k->p_user != NULL) (*k->p_user)(k->port, K_ABORT | 0X1000, (DWORD) k->paknum);
break;
case 'D': /* good data */
k_ack_(k);
nlen = k_decode_(k, k->dlen); /* decode data packet, write to disk */
k->paknum++;
if (k->p_user != NULL) (*k->p_user)(k->port, XFER_POSITION, len+=nlen);
i = 0;
ret = 'D';
break;
case 'E': /* ERROR packet received */
k_ack_(k);
ret = 'A';
DONE = TRUE;
if (k->p_user != NULL) (*k->p_user)(k->port, K_ERROR | 0X1000, (DWORD) k->paknum);
break;
case 'Z': /* EOF packet received */
k_ack_(k);
k->paknum++;
if ((*k->c_fwrite_)(k->port, k->x) == DISK_FULL) {
global_com_error = DISK_FULL;
ret = 'A';
cct_file_close_(k->x->fh);
}
else if (cct_file_close_(k->x->fh) < 0) {
global_com_error = EOF;
ret = 'A';
}
else ret = 'F';
DONE = TRUE;
break;
case USER_CANCELLED: /* abort key pressed */
k_se_(k, "User intervention");
k->paknum++;
if ((*k->c_fwrite_)(k->port, k->x) == DISK_FULL) {
global_com_error = DISK_FULL;
cct_file_close_(k->x->fh);
}
else if (cct_file_close_(k->x->fh) < 0) global_com_error = EOF;
ret = USER_CANCELLED;
DONE = TRUE;
break;
default:
ret = 'A';
DONE = TRUE;
}
}
return (ret);
}
/*
K_RF_ -- In state RF. Wait for FILE HEADER packet.
*/
short k_rf_(KERMIT_PARMS *k)
{
short ret, DONE = FALSE;
WORD i = 0;
for (i=0; i < k->max_retry && !DONE; i++) {
ret = k_receive_pkt_(k);
if (ret < 0) k_nak_(k); /* invalid packet -- NAK */
/* valid packet format -- what type is it? */
else switch (ret) {
case 'B': /* BREAK pkt. => last file received */
k_ack_(k);
DONE = TRUE;
ret = 'A';
if (k->p_user != NULL) (*k->p_user)(k->port, K_BREAK | 0X1000, (DWORD) k->paknum);
break;
case 'E': /* ERROR pkt. => abort */
k_ack_(k);
DONE = TRUE;
ret = 'A';
if (k->p_user != NULL) (*k->p_user)(k->port, K_ERROR | 0X1000, (DWORD) k->paknum);
break;
case 'F': /* File header received -- open file */
if (k->p_user != NULL) (*k->p_user)(k->port, K_FHEAD | 0X1000, (DWORD) k->paknum);
if (cct_file_open_(k->rxbuf, O_CREAT|O_RDWR|O_BINARY) == 0) ret = 'A';
else {
/* SAVE THE FILE NAME FOR THE PROGRESS FUNCTION */
strncpy(fname, k->rxbuf, 12);
fname[12] = '\0';
fsize = (long) EOF;
if (k->p_user != NULL)
(*k->p_user)(k->port, FILE_INFO_RECEIVED, 0L);
ret = 'D';
k_ack_(k);
k->paknum++;
}
DONE = TRUE;
break;
case 'S': /* ACK with local parms */
(*k->c_puts)(k->port, k->txbuf); /* ACK with local parms */
i = 0;
break;
case 'Z':
k_ack_(k); /* ACK a lost ACK */
DONE = TRUE;
ret = 'F';
}
}
return (ret);
}
/*
K_R_ -- In state R. Wait to receive a send_init packet from other system.
*/
short k_r_(KERMIT_PARMS *k)
{
short ret;
WORD i;
short DONE = FALSE;
for (i=0; i < k->max_retry; i++) {
ret = k_receive_pkt_(k);
if (ret == EOF) continue;
if (ret == USER_CANCELLED) {
DONE = TRUE;
break;
}
else break;
}
if (i < k->max_retry && !DONE) {
if (k->ptype == 'S') {
if (k->p_user != NULL) (*k->p_user)(k->port, K_SINIT | 0X1000, (DWORD) k->paknum);
k_neg_parms_(k);
k_build_init_(k);
k_build_pkt_(k, NULL, 'Y');
(*k->c_puts)(k->port, k->txbuf); /* ACK with local parms */
k->paknum++;
ret = 'F';
}
}
else ret = 'A';
return (ret);
}
/*
K_RCV_ -- A Kermit 'receive' transaction.
*/
short k_rcv_(KERMIT_PARMS *k)
{
short state = 'R', DONE = FALSE;
k->mqbin = (k->parity == PARITY_NONE) ? 'Y' : '&';
if (get_tx_xlat(k->port, FLOWCTL) & XONXOFF) c_putc(k->port, XON);
k->p_user = k->p_user;
do {
switch (state) {
case 'A':
DONE = TRUE;
break;
case 'C':
DONE = TRUE;
break;
case 'D': /* goes to 'F' if successful */
state = k_rd_(k);
break;
case 'F': /* goes to 'D' or 'A' (last file) if successful */
state = k_rf_(k);
break;
/* START HERE (do not pass go, do not collect $200... */
case 'R': /* goes to 'F' if successful */
state = k_r_(k);
break;
default:
state = EOF;
DONE = TRUE;
break;
}
if (is_key(((COMM_PORT *) k->port)->abort_key)) {
k_se_(k, "User intervention");
state = USER_CANCELLED;
DONE = TRUE;
}
} while (!DONE);
return (state);
}
