E-Kermit, for file upload goodness

1 files changed, 434 insertions, 0 deletions

diff --git a/libraries/thirdparty/ekermit/stm-kermit.c b/libraries/thirdparty/ekermit/stm-kermit.c
new file mode 100644
index 0000000..09eca96
--- /dev/null
+++ b/libraries/thirdparty/ekermit/stm-kermit.c
@@ -0,0 +1,434 @@
+/*
+ * stm-kermit.c
+ * ------------
+ * Interface to the E-Kermit library.
+ *
+ * Copyright (C) 1995, 2011, 
+ * Trustees of Columbia University in the City of New York.
+ * All rights reserved.
+ *
+ * Copyright (c) 2016, NORDUnet A/S All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the copyright holders nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+ * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* This file is based on unixio.c and main.c from the E-Kermit distribution,
+ * with extensive modifications for the Cryptech environment.
+ */
+
+#include <ctype.h>
+#include <string.h>
+
+#include "cdefs.h"
+#include "debug.h"
+#include "platform.h"
+#include "kermit.h"
+
+/* The following symbols, defined in kermit.h, conflict with stm32f429xx.h.
+ * Neither one is used in the file.
+ */
+#undef CR
+#undef SUCCESS
+
+#include "stm-uart.h"
+#include "ringbuf.h"
+#include "stm-kermit.h"
+
+static ringbuf_t uart_ringbuf;
+
+/* current character received from UART */
+static uint8_t uart_rx;
+
+/* Callback for HAL_UART_Receive_IT(). Must be public. */
+void HAL_UART1_RxCpltCallback(UART_HandleTypeDef *huart)
+{
+    ringbuf_write_char(&uart_ringbuf, uart_rx);
+    HAL_UART_Receive_IT(huart, &uart_rx, 1);
+}
+
+static void uart_init(void)
+{
+    ringbuf_init(&uart_ringbuf);
+    HAL_UART_Receive_IT(&huart_mgmt, &uart_rx, 1);
+}
+
+#ifdef DEBUG
+/* This is public because it's prototyped in debug.h */
+void
+dodebug(int fc, UCHAR * label, UCHAR * sval, long nval)
+{
+    if (label == (UCHAR *)"==========")
+        uart_send_string("\r\n");
+    uart_send_integer(HAL_GetTick(), 8);
+    uart_send_char(' ');
+    
+    if (!label)
+        label = (UCHAR *)"";
+
+    switch (fc) {			/* Function code */
+    case DB_OPN:			/* Open debug log */
+	uart_send_string("DEBUG LOG OPEN\r\n");
+	return;
+    case DB_MSG:			/* Write a message */
+        uart_send_string((char *)label);
+        if (nval) {
+            uart_send_char(' ');
+            uart_send_integer(nval, 1);
+        }
+        uart_send_string("\r\n");
+	return;
+    case DB_CHR:			/* Write label and character */
+        uart_send_string((char *)label);
+        uart_send_string("=[");
+        uart_send_char((uint8_t)nval);
+        uart_send_string("]\r\n");
+	return;
+    case DB_PKT:			/* Log a packet */
+        uart_send_string((char *)label);
+        uart_send_char(' ');
+        uart_send_integer(nval, 1);
+        uart_send_char('[');
+        /* It would be great if we could interpret the packet.
+         * For now, just dump the raw data.
+         */
+        for (int i = 0; i < nval; ++i, ++sval) {
+            if (*sval == '\\')
+                uart_send_string("\\\\");
+            else if (isprint(*sval))
+                uart_send_char(*sval);
+            else {
+                uart_send_char('\\');
+                uart_send_hex(*sval, 2);
+            }
+        }
+        uart_send_string("]\r\n");
+	return;
+    case DB_LOG:			/* Write label and string or number */
+        uart_send_string((char *)label);
+	if (sval) {
+            uart_send_char('[');
+            uart_send_string((char *)sval);
+            uart_send_char(']');
+        }
+	else {
+            uart_send_char('=');
+            uart_send_integer(nval, 1);
+        }
+        uart_send_string("\r\n");
+	return;
+    case DB_CLS:			/* Close debug log */
+        return;
+    }
+}
+#endif
+
+/*  R E A D P K T  --  Read a Kermit packet from the communications device  */
+/*
+  Call with:
+  k   - Kermit struct pointer
+  p   - pointer to read buffer
+  len - length of read buffer
+
+  When reading a packet, this function looks for start of Kermit packet
+  (k->r_soh), then reads everything between it and the end of the packet
+  (k->r_eom) into the indicated buffer.  Returns the number of bytes read, or:
+  0   - timeout or other possibly correctable error;
+  -1   - fatal error, such as loss of connection, or no buffer to read into.
+*/
+
+static int
+readpkt(struct k_data * k, UCHAR *p, int len)
+{
+    int n;
+    short flag;
+    UCHAR x, c;
+#ifdef DEBUG
+    UCHAR * p2;
+#endif
+
+#ifdef F_CTRLC
+    short ccn;
+    ccn = 0;
+#endif
+
+    flag = n = 0;                       /* Init local variables */
+
+#ifdef DEBUG
+    p2 = p;
+#endif
+
+    uart_init();
+
+    while (1) {
+        /* wait for the next character */
+        while (ringbuf_read_char(&uart_ringbuf, &x) == 0) { ; }
+
+        c = (k->parity) ? x & 0x7f : x & 0xff; /* Strip parity */
+
+#ifdef F_CTRLC
+	/* In remote mode only: three consecutive ^C's to quit */
+        if (k->remote && c == (UCHAR) 3) {
+            if (++ccn > 2) {
+		debug(DB_MSG,"readpkt ^C^C^C",0,0);
+		return(-1);
+	    }
+        } else {
+	    ccn = 0;
+	}
+#endif
+
+        if (!flag && c != k->r_soh)	/* No start of packet yet */
+            continue;                     /* so discard these bytes. */
+        if (c == k->r_soh) {		/* Start of packet */
+            flag = 1;                   /* Remember */
+            continue;                   /* But discard. */
+        } else if (c == k->r_eom	/* Packet terminator */
+		   || c == '\012'	/* 1.3: For HyperTerminal */
+            ) {
+#ifdef DEBUG
+	    debug(DB_PKT,"RPKT",p2,n);
+#endif
+            return(n);
+        } else {                        /* Contents of packet */
+            if (n++ > k->r_maxlen)	/* Check length */
+                return(0);
+            else
+                *p++ = x & 0xff;
+        }
+    }
+    debug(DB_MSG,"READPKT FAIL (end)",0,0);
+    return(-1);
+}
+
+/*  T X _ D A T A  --  Writes n bytes of data to communication device.  */
+/*
+  Call with:
+  k = pointer to Kermit struct.
+  p = pointer to data to transmit.
+  n = length.
+  Returns:
+  X_OK on success.
+  X_ERROR on failure to write - i/o error.
+*/
+static int 
+tx_data(struct k_data * k, UCHAR *p, int n)
+{
+    return (uart_send_bytes(STM_UART_MGMT, p, n) == HAL_OK) ? X_OK : X_ERROR;
+}
+
+__weak int kermit_openfile(UCHAR * name) { return X_OK; }
+
+/*  O P E N F I L E  --  Open output file  */
+/*
+  Call with:
+  Pointer to filename.
+  Size in bytes.
+  Creation date in format yyyymmdd hh:mm:ss, e.g. 19950208 14:00:00
+  Mode: 1 = read, 2 = create, 3 = append.
+  Returns:
+  X_OK on success.
+  X_ERROR on failure, including rejection based on name, size, or date.    
+*/
+static int
+openfile(struct k_data * k, UCHAR * s, int mode)
+{
+    int rc;
+
+    switch (mode) {
+    case 2:				/* Write (create) */
+        rc = kermit_openfile(s); 
+	debug(DB_LOG,"openfile write ",s,rc);
+	return(rc);
+    default:
+	debug(DB_LOG,"openfile unsupported mode",0,mode);
+        return(X_ERROR);
+    }
+}
+
+__weak int kermit_writefile(UCHAR * s, int n) { return X_OK; }
+
+/*  W R I T E F I L E  --  Write data to file  */
+/*
+  Call with:
+  Kermit struct
+  String pointer
+  Length
+  Returns:
+  X_OK on success
+  X_ERROR on failure, such as i/o error, space used up, etc
+*/
+static int
+writefile(struct k_data * k, UCHAR * s, int n)
+{
+    debug(DB_LOG,"writefile binary",0,k->binary);
+    return kermit_writefile(s, n);
+}
+
+__weak int kermit_closefile(void) { return X_OK; }
+__weak int kermit_cancelfile(void) { return X_OK; }
+
+/*  C L O S E F I L E  --  Close output file  */
+/*
+  Mode = 1 for input file, mode = 2 or 3 for output file.
+
+  For output files, the character c is the character (if any) from the Z
+  packet data field.  If it is D, it means the file transfer was canceled
+  in midstream by the sender, and the file is therefore incomplete.  This
+  routine should check for that and decide what to do.  It should be
+  harmless to call this routine for a file that that is not open.
+*/
+static int
+closefile(struct k_data * k, UCHAR c, int mode)
+{
+    switch (mode) {
+    case 2:				/* Closing output file */
+	debug(DB_LOG,"closefile (output) name",k->filename,0);
+        if (c == 'D')
+            return kermit_cancelfile();
+        else
+            return kermit_closefile();
+    default:
+	debug(DB_LOG,"closefile unsupported mode",0,mode);
+        return(X_ERROR);
+    }
+}
+
+static UCHAR o_buf[OBUFLEN+8];		/* File output buffer */
+
+int
+kermit_main(void)
+{
+    struct k_data k;                    /* Kermit data structure */
+    struct k_response r;                /* Kermit response structure */
+    int status, rx_len;
+    UCHAR *inbuf;
+    short r_slot;
+
+    debug(DB_MSG,"==========",0,0);
+    debug(DB_OPN,"debug.log",0,0);
+    debug(DB_MSG,"Initializing...",0,0);
+
+/*  Fill in parameters for this run */
+
+    memset(&k, 0, sizeof(k));
+
+    k.remote = 1;			/* 0 = local, 1 = remote */
+    k.xfermode = 1;			/* 0 = automatic, 1 = manual */
+    k.binary = BINARY;			/* 0 = text, 1 = binary */
+    k.parity = P_PARITY;                /* Default parity = PAR_NONE */
+    k.bct = 1;                       	/* Block check type */
+
+/*  Fill in the i/o pointers  */
+  
+    k.obuf   = o_buf;			/* File output buffer */
+    k.obuflen = OBUFLEN;		/* File output buffer length */
+
+/* Fill in function pointers */
+
+    k.rxd    = readpkt;			/* for reading packets */
+    k.txd    = tx_data;			/* for sending packets */
+    k.openf  = openfile;                /* for opening files */
+    k.writef = writefile;               /* for writing to output file */
+    k.closef = closefile;               /* for closing files */
+#ifdef DEBUG
+    k.dbf    = dodebug;			/* for debugging */
+#endif
+
+/* Initialize Kermit protocol */
+
+    status = kermit(K_INIT, &k, 0, 0, "", &r);
+#ifdef DEBUG
+    debug(DB_LOG,"init status:",0,status);
+    debug(DB_LOG,"version:",k.version,0);
+#endif
+    if (status == X_ERROR)
+        return(FAILURE);
+/*
+  Now we read a packet ourselves and call Kermit with it.  Normally, Kermit
+  would read its own packets, but in the embedded context, the device must be
+  free to do other things while waiting for a packet to arrive.  So the real
+  control program might dispatch to other types of tasks, of which Kermit is
+  only one.  But in order to read a packet into Kermit's internal buffer, we
+  have to ask for a buffer address and slot number.
+
+  To interrupt a transfer in progress, set k.cancel to I_FILE to interrupt
+  only the current file, or to I_GROUP to cancel the current file and all
+  remaining files.  To cancel the whole operation in such a way that the
+  both Kermits return an error status, call Kermit with K_ERROR.
+*/
+    while (status != X_DONE) {
+/*
+  Here we block waiting for a packet to come in (unless readpkt times out).
+  Another possibility would be to call inchk() to see if any bytes are waiting
+  to be read, and if not, go do something else for a while, then come back
+  here and check again.
+*/
+        inbuf = getrslot(&k,&r_slot);	/* Allocate a window slot */
+        rx_len = k.rxd(&k,inbuf,P_PKTLEN); /* Try to read a packet */
+/*
+  For simplicity, kermit() ACKs the packet immediately after verifying it was
+  received correctly.  If, afterwards, the control program fails to handle the
+  data correctly (e.g. can't open file, can't write data, can't close file),
+  then it tells Kermit to send an Error packet next time through the loop.
+*/
+        if (rx_len < 1) {               /* No data was read */
+            freerslot(&k,r_slot);	/* So free the window slot */
+            if (rx_len < 0)             /* If there was a fatal error */
+                return(FAILURE);          /* give up */
+
+	    /* This would be another place to dispatch to another task */
+	    /* while waiting for a Kermit packet to show up. */
+
+        }
+        /* Handle the input */
+
+        switch (status = kermit(K_RUN, &k, r_slot, rx_len, "", &r)) {
+        case X_OK:
+#ifdef DEBUG
+/*
+  This shows how, after each packet, you get the protocol state, file name,
+  date, size, and bytes transferred so far.  These can be used in a
+  file-transfer progress display, log, etc.
+*/
+	    debug(DB_LOG,"NAME",r.filename ? r.filename : (UCHAR *)"(NULL)",0);
+	    debug(DB_LOG,"DATE",r.filedate ? r.filedate : (UCHAR *)"(NULL)",0);
+	    debug(DB_LOG,"SIZE",0,r.filesize);
+	    debug(DB_LOG,"STATE",0,r.status);
+	    debug(DB_LOG,"SOFAR",0,r.sofar);
+#endif
+	    /* Maybe do other brief tasks here... */
+	    continue;			/* Keep looping */
+        case X_DONE:
+            debug(DB_LOG,"X_DONE exiting",0,SUCCESS);
+	    break;			/* Finished */
+        case X_ERROR:
+            debug(DB_LOG,"X_ERROR exiting",0,FAILURE);
+	    return(FAILURE);		/* Failed */
+	}
+    }
+    return(SUCCESS);
+}