diff options
Diffstat (limited to 'libraries/thirdparty/ekermit/stm-kermit.c')
| -rw-r--r-- | libraries/thirdparty/ekermit/stm-kermit.c | 434 |
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); +} |