mirror of
https://github.com/bobbimanners/emailler.git
synced 2024-06-01 00:41:30 +00:00
29793d4814
IP65 doesn't support TCP flow control. Therefore it doesn't make sense to write a program receiving a significant amount of data via TCP using IP65. From that perspective it makes sense that IP65's HTTP client doesn't allow to handle incoming data with a callback but requires a buffer being able to hold the whole HTTP body. However, on the Apple II there's the Uthernet II card with its W5100 Ethernet controller chip. That chip has it's own TCP implementation supporting TCP flow control. Therefore the wget65 program uses the W5100 TCP capabilities for the HTTP client. But even with the W5100 TCP implementation in place IP65 still plays a role for the wget65 program as it desires DHCP and requires (usually) DNS. Both are not supported by the W5100 capabilities.
553 lines
16 KiB
C
553 lines
16 KiB
C
/* linenoise.c -- guerrilla line editing library against the idea that a
|
|
* line editing lib needs to be 20,000 lines of C code.
|
|
*
|
|
* You can find the latest source code at:
|
|
*
|
|
* http://github.com/antirez/linenoise
|
|
*
|
|
* Does a number of crazy assumptions that happen to be true in 99.9999% of
|
|
* the 2010 UNIX computers around.
|
|
*
|
|
* ------------------------------------------------------------------------
|
|
*
|
|
* Copyright (c) 2010-2016, Salvatore Sanfilippo <antirez at gmail dot com>
|
|
* Copyright (c) 2010-2013, Pieter Noordhuis <pcnoordhuis at gmail dot com>
|
|
*
|
|
* 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.
|
|
*
|
|
* 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.
|
|
*
|
|
* ------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <ctype.h>
|
|
#include <conio.h>
|
|
#include <apple2_filetype.h>
|
|
|
|
#include "linenoise.h"
|
|
|
|
#define LINENOISE_HISTORY_MAX_LEN 20
|
|
#define LINENOISE_MAX_LINE 256
|
|
|
|
static char buf[LINENOISE_MAX_LINE];
|
|
|
|
static linenoiseCompletionCallback *completionCallback = NULL;
|
|
|
|
static int history_len = 0;
|
|
static char **history = NULL;
|
|
|
|
/* The linenoiseState structure represents the state during line editing.
|
|
* We pass this state to functions implementing specific editing
|
|
* functionalities. */
|
|
struct linenoiseState {
|
|
char *buf; /* Edited line buffer. */
|
|
size_t buflen; /* Edited line buffer size. */
|
|
const char *prompt; /* Prompt to display. */
|
|
size_t plen; /* Prompt length. */
|
|
size_t pos; /* Current cursor position. */
|
|
size_t oldpos; /* Previous refresh cursor position. */
|
|
size_t len; /* Current edited line length. */
|
|
size_t cols; /* Number of columns in terminal. */
|
|
int history_index; /* The history index we are currently editing. */
|
|
};
|
|
|
|
enum KEY_ACTION{
|
|
CTRL_A = 1, /* Ctrl+a */
|
|
CTRL_B = 2, /* Ctrl-b */
|
|
CTRL_C = 3, /* Ctrl-c */
|
|
CTRL_D = 4, /* Ctrl-d */
|
|
CTRL_E = 5, /* Ctrl-e */
|
|
CTRL_F = 6, /* Ctrl-f */
|
|
CTRL_N = 14, /* Ctrl-n */
|
|
CTRL_P = 16 /* Ctrl-p */
|
|
};
|
|
|
|
static void refreshLine(struct linenoiseState *l);
|
|
|
|
/* ======================= Low level terminal handling ====================== */
|
|
|
|
#ifdef __APPLE2__
|
|
#pragma code-name (push, "LC")
|
|
#endif
|
|
|
|
/* Try to get the number of columns in the current terminal, or assume 80
|
|
* if it fails. */
|
|
static int getColumns() {
|
|
unsigned char cols, rows;
|
|
|
|
screensize(&cols,&rows);
|
|
return cols;
|
|
}
|
|
|
|
/* Beep, used for completion when there is nothing to complete or when all
|
|
* the choices were already shown. */
|
|
static void linenoiseBeep(void) {
|
|
putchar('\a');
|
|
}
|
|
|
|
/* ============================== Completion ================================ */
|
|
|
|
/* Free a list of completion option populated by linenoiseAddCompletion(). */
|
|
static void freeCompletions(linenoiseCompletions *lc) {
|
|
size_t i;
|
|
for (i = 0; i < lc->len; i++)
|
|
free(lc->cvec[i]);
|
|
if (lc->cvec != NULL)
|
|
free(lc->cvec);
|
|
}
|
|
|
|
/* This is an helper function for linenoiseEdit() and is called when the
|
|
* user types the <tab> key in order to complete the string currently in the
|
|
* input.
|
|
*
|
|
* The state of the editing is encapsulated into the pointed linenoiseState
|
|
* structure as described in the structure definition. */
|
|
static int completeLine(register struct linenoiseState *ls) {
|
|
linenoiseCompletions lc = { 0, NULL };
|
|
int nwritten;
|
|
char c = 0;
|
|
|
|
completionCallback(ls->buf,&lc);
|
|
if (lc.len == 0) {
|
|
linenoiseBeep();
|
|
} else {
|
|
size_t stop = 0, i = 0;
|
|
|
|
while(!stop) {
|
|
/* Show completion or original buffer */
|
|
if (i < lc.len) {
|
|
struct linenoiseState saved;
|
|
saved = *ls;
|
|
|
|
ls->len = ls->pos = strlen(lc.cvec[i]);
|
|
ls->buf = lc.cvec[i];
|
|
refreshLine(ls);
|
|
ls->len = saved.len;
|
|
ls->pos = saved.pos;
|
|
ls->buf = saved.buf;
|
|
} else {
|
|
refreshLine(ls);
|
|
}
|
|
|
|
c = cgetc();
|
|
switch(c) {
|
|
case '\t': /* tab */
|
|
i = (i+1) % (lc.len+1);
|
|
if (i == lc.len) linenoiseBeep();
|
|
break;
|
|
case CH_ESC: /* escape */
|
|
/* Re-show original buffer */
|
|
if (i < lc.len) refreshLine(ls);
|
|
stop = 1;
|
|
break;
|
|
default:
|
|
/* Update buffer and return */
|
|
if (i < lc.len) {
|
|
nwritten = snprintf(ls->buf,ls->buflen,"%s",lc.cvec[i]);
|
|
ls->len = ls->pos = nwritten;
|
|
}
|
|
stop = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
freeCompletions(&lc);
|
|
return c; /* Return last read character */
|
|
}
|
|
|
|
/* Register a callback function to be called for tab-completion. */
|
|
void linenoiseSetCompletionCallback(linenoiseCompletionCallback *fn) {
|
|
completionCallback = fn;
|
|
}
|
|
|
|
/* This function is used by the callback function registered by the user
|
|
* in order to add completion options given the input string when the
|
|
* user typed <tab>. See the example.c source code for a very easy to
|
|
* understand example. */
|
|
void linenoiseAddCompletion(linenoiseCompletions *lc, const char *str) {
|
|
size_t len = strlen(str);
|
|
char *copy, **cvec;
|
|
|
|
copy = malloc(len+1);
|
|
if (copy == NULL) return;
|
|
memcpy(copy,str,len+1);
|
|
cvec = realloc(lc->cvec,sizeof(char*)*(lc->len+1));
|
|
if (cvec == NULL) {
|
|
free(copy);
|
|
return;
|
|
}
|
|
lc->cvec = cvec;
|
|
lc->cvec[lc->len++] = copy;
|
|
}
|
|
|
|
/* =========================== Line editing ================================= */
|
|
|
|
/* Low level line refresh.
|
|
*
|
|
* Rewrite the currently edited line accordingly to the buffer content,
|
|
* cursor position, and number of columns of the terminal. */
|
|
static void refreshLine(struct linenoiseState *l) {
|
|
char tmp;
|
|
size_t plen = strlen(l->prompt);
|
|
char *buf = l->buf;
|
|
size_t len = l->len;
|
|
size_t pos = l->pos;
|
|
|
|
while((plen+pos) >= l->cols) {
|
|
buf++;
|
|
len--;
|
|
pos--;
|
|
}
|
|
while (plen+len > l->cols) {
|
|
len--;
|
|
}
|
|
|
|
/* Cursor to left edge */
|
|
gotox(0);
|
|
/* Write the prompt */
|
|
cputs(l->prompt);
|
|
/* Write the current buffer content */
|
|
tmp = buf[len];
|
|
buf[len] = '\0';
|
|
cputs(buf);
|
|
buf[len] = tmp;
|
|
/* Erase to right */
|
|
if (wherex()) {
|
|
cclear(l->cols-wherex());
|
|
}
|
|
/* Move cursor to original position. */
|
|
gotox((unsigned char)(pos+plen));
|
|
}
|
|
|
|
/* Insert the character 'c' at cursor current position. */
|
|
void linenoiseEditInsert(register struct linenoiseState *l, char c) {
|
|
if (l->len < l->buflen) {
|
|
if (l->len == l->pos) {
|
|
l->buf[l->pos] = c;
|
|
l->pos++;
|
|
l->len++;
|
|
l->buf[l->len] = '\0';
|
|
if ((l->plen+l->len < l->cols)) {
|
|
/* Avoid a full update of the line in the
|
|
* trivial case. */
|
|
cputc(c);
|
|
} else {
|
|
refreshLine(l);
|
|
}
|
|
} else {
|
|
memmove(l->buf+l->pos+1,l->buf+l->pos,l->len-l->pos);
|
|
l->buf[l->pos] = c;
|
|
l->len++;
|
|
l->pos++;
|
|
l->buf[l->len] = '\0';
|
|
refreshLine(l);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Move cursor on the left. */
|
|
void linenoiseEditMoveLeft(struct linenoiseState *l) {
|
|
if (l->pos > 0) {
|
|
l->pos--;
|
|
refreshLine(l);
|
|
}
|
|
}
|
|
|
|
/* Move cursor on the right. */
|
|
void linenoiseEditMoveRight(struct linenoiseState *l) {
|
|
if (l->pos != l->len) {
|
|
l->pos++;
|
|
refreshLine(l);
|
|
}
|
|
}
|
|
|
|
/* Move cursor to the start of the line. */
|
|
void linenoiseEditMoveHome(struct linenoiseState *l) {
|
|
if (l->pos != 0) {
|
|
l->pos = 0;
|
|
refreshLine(l);
|
|
}
|
|
}
|
|
|
|
/* Move cursor to the end of the line. */
|
|
void linenoiseEditMoveEnd(struct linenoiseState *l) {
|
|
if (l->pos != l->len) {
|
|
l->pos = l->len;
|
|
refreshLine(l);
|
|
}
|
|
}
|
|
|
|
/* Substitute the currently edited line with the next or previous history
|
|
* entry as specified by 'dir'. */
|
|
#define LINENOISE_HISTORY_NEXT 0
|
|
#define LINENOISE_HISTORY_PREV 1
|
|
void linenoiseEditHistoryNext(register struct linenoiseState *l, int dir) {
|
|
if (history_len > 1) {
|
|
/* Update the current history entry before to
|
|
* overwrite it with the next one. */
|
|
free(history[history_len - 1 - l->history_index]);
|
|
history[history_len - 1 - l->history_index] = strdup(l->buf);
|
|
/* Show the new entry */
|
|
l->history_index += (dir == LINENOISE_HISTORY_PREV) ? 1 : -1;
|
|
if (l->history_index < 0) {
|
|
l->history_index = 0;
|
|
return;
|
|
} else if (l->history_index >= history_len) {
|
|
l->history_index = history_len-1;
|
|
return;
|
|
}
|
|
strncpy(l->buf,history[history_len - 1 - l->history_index],l->buflen);
|
|
l->buf[l->buflen-1] = '\0';
|
|
l->len = l->pos = strlen(l->buf);
|
|
refreshLine(l);
|
|
}
|
|
}
|
|
|
|
/* Delete the character at the right of the cursor without altering the cursor
|
|
* position. Basically this is what happens with the "Delete" keyboard key. */
|
|
void linenoiseEditDelete(register struct linenoiseState *l) {
|
|
if (l->len > 0 && l->pos < l->len) {
|
|
memmove(l->buf+l->pos,l->buf+l->pos+1,l->len-l->pos-1);
|
|
l->len--;
|
|
l->buf[l->len] = '\0';
|
|
refreshLine(l);
|
|
}
|
|
}
|
|
|
|
/* Backspace implementation. */
|
|
void linenoiseEditBackspace(register struct linenoiseState *l) {
|
|
if (l->pos > 0 && l->len > 0) {
|
|
memmove(l->buf+l->pos-1,l->buf+l->pos,l->len-l->pos);
|
|
l->pos--;
|
|
l->len--;
|
|
l->buf[l->len] = '\0';
|
|
refreshLine(l);
|
|
}
|
|
}
|
|
|
|
/* This function is the core of the line editing capability of linenoise.
|
|
*
|
|
* The resulting string is put into 'buf' when the user type enter.
|
|
*
|
|
* The function returns the length of the current buffer. */
|
|
static int linenoiseEdit(const char *prompt)
|
|
{
|
|
struct linenoiseState l;
|
|
|
|
/* Populate the linenoise state that we pass to functions implementing
|
|
* specific editing functionalities. */
|
|
l.buf = buf;
|
|
l.buflen = LINENOISE_MAX_LINE;
|
|
l.prompt = prompt;
|
|
l.plen = strlen(prompt);
|
|
l.oldpos = l.pos = 0;
|
|
l.len = 0;
|
|
l.cols = getColumns();
|
|
l.history_index = 0;
|
|
|
|
/* Buffer starts empty. */
|
|
l.buf[0] = '\0';
|
|
l.buflen--; /* Make sure there is always space for the nulterm */
|
|
|
|
/* The latest history entry is always our current buffer, that
|
|
* initially is just an empty string. */
|
|
linenoiseHistoryAdd("");
|
|
|
|
cputs(prompt);
|
|
while(1) {
|
|
char c;
|
|
|
|
c = cgetc();
|
|
|
|
/* Only autocomplete when the callback is set. It will return the
|
|
* character that should be handled next. */
|
|
if (c == '\t' && completionCallback != NULL) {
|
|
c = completeLine(&l);
|
|
/* Read next character when 0 */
|
|
if (c == 0) continue;
|
|
}
|
|
|
|
switch(c) {
|
|
case CH_ENTER:
|
|
history_len--;
|
|
free(history[history_len]);
|
|
return (int)l.len;
|
|
case CTRL_C:
|
|
errno = EAGAIN;
|
|
return -1;
|
|
case CH_DEL: /* backspace */
|
|
linenoiseEditBackspace(&l);
|
|
break;
|
|
case CTRL_D: /* ctrl-d, remove char at right of cursor. */
|
|
if (l.len > 0) {
|
|
linenoiseEditDelete(&l);
|
|
}
|
|
break;
|
|
case CTRL_B: /* ctrl-b */
|
|
case CH_CURS_LEFT:
|
|
linenoiseEditMoveLeft(&l);
|
|
break;
|
|
case CTRL_F: /* ctrl-f */
|
|
case CH_CURS_RIGHT:
|
|
linenoiseEditMoveRight(&l);
|
|
break;
|
|
case CTRL_P: /* ctrl-p */
|
|
case CH_CURS_UP:
|
|
linenoiseEditHistoryNext(&l, LINENOISE_HISTORY_PREV);
|
|
break;
|
|
case CTRL_N: /* ctrl-n */
|
|
case CH_CURS_DOWN:
|
|
linenoiseEditHistoryNext(&l, LINENOISE_HISTORY_NEXT);
|
|
break;
|
|
case CTRL_A: /* Ctrl+a, go to the start of the line */
|
|
linenoiseEditMoveHome(&l);
|
|
break;
|
|
case CTRL_E: /* ctrl+e, go to the end of the line */
|
|
linenoiseEditMoveEnd(&l);
|
|
break;
|
|
default:
|
|
if (isprint(c)) linenoiseEditInsert(&l,c);
|
|
break;
|
|
}
|
|
}
|
|
return l.len;
|
|
}
|
|
|
|
#ifdef __APPLE2__
|
|
#pragma code-name (pop)
|
|
#endif
|
|
|
|
/* The high level function that is the main API of the linenoise library. */
|
|
char *linenoise(const char *prompt) {
|
|
unsigned char oldcursor;
|
|
int count;
|
|
|
|
oldcursor = cursor(1);
|
|
count = linenoiseEdit(prompt);
|
|
cursor(oldcursor);
|
|
|
|
if (count == -1) return NULL;
|
|
return buf;
|
|
}
|
|
|
|
/* ================================ History ================================= */
|
|
|
|
/* Reseet the history. */
|
|
void linenoiseHistoryReset(void) {
|
|
if (history) {
|
|
int j;
|
|
|
|
for (j = 0; j < history_len; j++)
|
|
free(history[j]);
|
|
free(history);
|
|
|
|
history_len = 0;
|
|
history = NULL;
|
|
}
|
|
}
|
|
|
|
/* This is the API call to add a new entry in the linenoise history.
|
|
* It uses a fixed array of char pointers that are shifted (memmoved)
|
|
* when the history max length is reached in order to remove the older
|
|
* entry and make room for the new one, so it is not exactly suitable for huge
|
|
* histories, but will work well for a few hundred of entries.
|
|
*
|
|
* Using a circular buffer is smarter, but a bit more complex to handle. */
|
|
int linenoiseHistoryAdd(const char *line) {
|
|
char *linecopy;
|
|
|
|
/* Initialization on first call. */
|
|
if (history == NULL) {
|
|
history = malloc(sizeof(char*)*LINENOISE_HISTORY_MAX_LEN);
|
|
if (history == NULL) return 0;
|
|
memset(history,0,(sizeof(char*)*LINENOISE_HISTORY_MAX_LEN));
|
|
}
|
|
|
|
/* Don't add duplicated lines. */
|
|
if (history_len && !strcmp(history[history_len-1], line)) return 0;
|
|
|
|
/* Add an heap allocated copy of the line in the history.
|
|
* If we reached the max length, remove the older line. */
|
|
linecopy = strdup(line);
|
|
if (!linecopy) return 0;
|
|
if (history_len == LINENOISE_HISTORY_MAX_LEN) {
|
|
free(history[0]);
|
|
memmove(history,history+1,sizeof(char*)*(LINENOISE_HISTORY_MAX_LEN-1));
|
|
history_len--;
|
|
}
|
|
history[history_len] = linecopy;
|
|
history_len++;
|
|
return 1;
|
|
}
|
|
|
|
/* Save the history in the specified file. On success 0 is returned
|
|
* otherwise -1 is returned. */
|
|
int linenoiseHistorySave(const char *filename) {
|
|
FILE *fp;
|
|
int j;
|
|
|
|
#ifdef __APPLE2__
|
|
unsigned char oldfiletype = _filetype;
|
|
_filetype = PRODOS_T_TXT;
|
|
#endif
|
|
|
|
fp = fopen(filename,"w");
|
|
|
|
#ifdef __APPLE2__
|
|
_filetype = oldfiletype;
|
|
#endif
|
|
|
|
if (fp == NULL) return -1;
|
|
for (j = 0; j < history_len; j++)
|
|
fprintf(fp,"%s\n",history[j]);
|
|
fclose(fp);
|
|
return 0;
|
|
}
|
|
|
|
/* Load the history from the specified file. If the file does not exist
|
|
* zero is returned and no operation is performed.
|
|
*
|
|
* If the file exists and the operation succeeded 0 is returned, otherwise
|
|
* on error -1 is returned. */
|
|
int linenoiseHistoryLoad(const char *filename) {
|
|
FILE *fp = fopen(filename,"r");
|
|
|
|
if (fp == NULL) return -1;
|
|
while (fgets(buf,LINENOISE_MAX_LINE,fp) != NULL) {
|
|
char *p;
|
|
|
|
p = strchr(buf,'\r');
|
|
if (!p) p = strchr(buf,'\n');
|
|
if (p) *p = '\0';
|
|
linenoiseHistoryAdd(buf);
|
|
}
|
|
fclose(fp);
|
|
return 0;
|
|
}
|