424 lines
9.3 KiB
C
424 lines
9.3 KiB
C
/* cli.c */
|
|
/*
|
|
This file is part of the ARM-Crypto-Lib.
|
|
Copyright (C) 2008 Daniel Otte (daniel.otte@rub.de)
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
/**
|
|
*
|
|
* author: Daniel Otte
|
|
* email: daniel.otte@rub.de
|
|
* license: GPLv3 or later
|
|
*
|
|
* components to help implementing simple command based interaction
|
|
*
|
|
**/
|
|
|
|
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
#include <ctype.h>
|
|
#include <string.h>
|
|
#include "string-extras.h"
|
|
#include "cli.h"
|
|
#include "hexdigit_tab.h"
|
|
|
|
#ifndef MAX
|
|
#define MAX(a,b) ((a>b)?(a):(b))
|
|
#endif
|
|
|
|
|
|
cli_rx_fpt cli_rx = NULL;
|
|
cli_tx_fpt cli_tx = NULL;
|
|
uint8_t cli_echo=1;
|
|
|
|
/**
|
|
* \brief output a character to the console
|
|
*
|
|
*/
|
|
|
|
void cli_putc(char c){
|
|
if(cli_tx)
|
|
cli_tx(c);
|
|
}
|
|
|
|
/**
|
|
* \brief get a character from the console
|
|
* Gets a character from the console input and blocks
|
|
* until a character is recieved
|
|
*/
|
|
uint16_t cli_getc(void){
|
|
if(cli_rx)
|
|
return cli_rx();
|
|
return ((uint16_t)-1);
|
|
}
|
|
|
|
/**
|
|
* \brief get a character from the console
|
|
* Gets a char from the console input (like cli_getc())
|
|
* and echos it back to the console if echo is enabled.
|
|
*/
|
|
uint16_t cli_getc_cecho(void){
|
|
char c;
|
|
if(cli_rx){
|
|
c = cli_rx();
|
|
if(cli_tx && cli_echo)
|
|
cli_tx(c);
|
|
return c;
|
|
}
|
|
return ((uint16_t)-1);
|
|
}
|
|
|
|
/**
|
|
* \brief ouputs a zero-terminated string from ram to the console
|
|
*/
|
|
void cli_putstr(const char* s){
|
|
if(!cli_tx)
|
|
return;
|
|
while(*s)
|
|
cli_tx(*s++);
|
|
}
|
|
|
|
|
|
/**
|
|
* \brief reads a line or max n characters from the console
|
|
* Writes characters from the console into the supplyed buffer until a '\r'
|
|
* character is recieved or until n character a read (whatever happens first).
|
|
* The string will always be terminated by a '\0' character, so the buffer
|
|
* should have at least a size of n+1.
|
|
*/
|
|
uint8_t cli_getsn(char* s, uint32_t n){
|
|
char c;
|
|
if(n==0)
|
|
return 2;
|
|
while((c=cli_getc_cecho())!='\0' && c!='\r' && n){
|
|
--n;
|
|
*s++=c;
|
|
}
|
|
*s='\0';
|
|
return (c=='\r')?0:1;
|
|
}
|
|
|
|
void cli_hexdump_byte(uint8_t byte){
|
|
cli_tx(hexdigit_tab[byte>>4]);
|
|
cli_tx(hexdigit_tab[byte & 0xf]);
|
|
}
|
|
|
|
/**
|
|
* \brief dumps the contents of a buffer to the console
|
|
* Dumps length bytes from data to the console output. The dump
|
|
* will have 2*n continuous hexadecimal characters.
|
|
*/
|
|
void cli_hexdump(const void* data, uint32_t length){
|
|
if(!cli_tx)
|
|
return;
|
|
while(length--){
|
|
cli_hexdump_byte(*((uint8_t*)data));
|
|
data = (uint8_t*)data +1;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* \brief dumps the contents of a buffer to the console
|
|
* This function behaves like cli_hexdump except that the
|
|
* bytes are dumped in reverse order. This is useful to dump
|
|
* integers which are in little endian order.
|
|
*/
|
|
void cli_hexdump_rev(const void* data, uint32_t length){
|
|
if(!cli_tx)
|
|
return;
|
|
data = (uint8_t*)data + length -1;
|
|
while(length--){
|
|
cli_hexdump_byte(*((uint8_t*)data));
|
|
data = (uint8_t*)data -1;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* \brief dumps the contents of a buffer to the console
|
|
* Like cli_hexdump but bytes are seperated with a single space
|
|
* on the console output.
|
|
*/
|
|
void cli_hexdump2(const void* data, uint32_t length){
|
|
if(!cli_tx)
|
|
return;
|
|
while(length--){
|
|
cli_hexdump_byte(*((uint8_t*)data));
|
|
cli_tx(' ');
|
|
data = (uint8_t*)data +1;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* \brief dumps the contents of a buffer to the console
|
|
* Like cli_hexdump but bytes are separated with a single space
|
|
* on the console output.
|
|
*/
|
|
void cli_hexdump_block(const void* data, uint32_t length, uint8_t indent, uint8_t width){
|
|
uint16_t i;
|
|
uint8_t j;
|
|
if(!cli_tx)
|
|
return;
|
|
for(i=0; i<length; ++i){
|
|
if(i%width==0){
|
|
cli_putstr("\r\n");
|
|
for(j=0; j<indent; ++j){
|
|
cli_tx(' ');
|
|
}
|
|
}
|
|
cli_hexdump_byte(*((uint8_t*)data));
|
|
cli_tx(' ');
|
|
data = (uint8_t*)data +1;
|
|
}
|
|
}
|
|
|
|
static
|
|
void cli_auto_help(uint32_t maxcmdlength, const cmdlist_entry_t* cmdlist){
|
|
cmdlist_entry_t item;
|
|
uint16_t i;
|
|
if(!cli_tx)
|
|
return;
|
|
|
|
cli_putstr("\r\n[auto help] available commands:\r\n"
|
|
" <command> - <params> - <address>\r\n");
|
|
for(;;){
|
|
memcpy(&item, cmdlist, sizeof(cmdlist_entry_t));
|
|
cmdlist += 1;
|
|
if(item.cmd_name==NULL){
|
|
return;
|
|
}
|
|
cli_tx(' ');
|
|
cli_putstr(item.cmd_name);
|
|
i=MAX(maxcmdlength, strlen("<command>"))-strlen(item.cmd_name);
|
|
while(i--)
|
|
cli_tx(' ');
|
|
cli_putstr(" - ");
|
|
if(item.cmd_param_str==NULL){
|
|
cli_putstr("none \t- 0x");
|
|
} else {
|
|
if(item.cmd_param_str==(void*)1){
|
|
cli_putstr("yes \t- 0x");
|
|
} else {
|
|
cli_putstr(item.cmd_param_str);
|
|
cli_putstr(" \t- 0x");
|
|
}
|
|
}
|
|
cli_hexdump_rev(&item.cmd_function, sizeof(void*));
|
|
cli_putstr("\r\n");
|
|
}
|
|
}
|
|
|
|
void echo_ctrl(char* s){
|
|
s = strstrip(s);
|
|
if(s==NULL || *s=='\0'){
|
|
cli_putstr("\r\necho is ");
|
|
cli_putstr(cli_echo?"on":"off");
|
|
cli_putstr("\r\n");
|
|
}
|
|
strlwr(s);
|
|
if(!strcmp(s, "true") || !strcmp(s, "on") || *s=='1'){
|
|
cli_echo=1;
|
|
}
|
|
if(!strcmp(s, "false") || !strcmp(s, "off") || *s=='0'){
|
|
cli_echo=0;
|
|
}
|
|
}
|
|
|
|
|
|
typedef void(*str_fpt)(char*);
|
|
#define CLI_ENTER 13
|
|
#define CLI_BACKSPACE 8
|
|
#define CLI_TABULATOR 9
|
|
|
|
static
|
|
int8_t search_and_call(char* cmd, uint32_t maxcmdlength, const cmdlist_entry_t* cmdlist){
|
|
const cmdlist_entry_t* cmdlist_orig=cmdlist;
|
|
if(!cmdlist){
|
|
return 3;
|
|
}
|
|
if(*cmd=='\0' || *cmd=='#')
|
|
return 1;
|
|
if(!strcmp(cmd, "exit"))
|
|
return 0;
|
|
if((!strcmp(cmd, "help")) || (!strcmp(cmd, "?"))){
|
|
cli_auto_help(maxcmdlength, cmdlist);
|
|
return 1;
|
|
}
|
|
uint16_t fwlength=firstword_length(cmd);
|
|
char fw[fwlength+1];
|
|
memcpy(fw, cmd, fwlength);
|
|
fw[fwlength] = '\0';
|
|
cmdlist_entry_t item;
|
|
while(cmdlist->cmd_name && strcmp(fw, cmdlist->cmd_name)){
|
|
++cmdlist;
|
|
}
|
|
if(!cmdlist->cmd_name){
|
|
cli_auto_help(maxcmdlength, cmdlist_orig);
|
|
} else {
|
|
memcpy(&item, cmdlist, sizeof(cmdlist_entry_t));
|
|
switch((uint32_t)item.cmd_param_str){
|
|
case 0:
|
|
item.cmd_function();
|
|
break;
|
|
case 1:
|
|
if(cmd[fwlength]=='\0'){
|
|
((str_fpt)item.cmd_function)(cmd+fwlength);
|
|
} else {
|
|
((str_fpt)item.cmd_function)(cmd+fwlength+1);
|
|
}
|
|
break;
|
|
default:
|
|
cli_putstr("\r\nparam parsing currently not implemented!\r\n");
|
|
break;
|
|
}
|
|
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static
|
|
uint16_t max_cmd_length(const cmdlist_entry_t* cmdlist){
|
|
uint16_t t,ret=0;
|
|
const char* str;
|
|
for(;;){
|
|
str = cmdlist->cmd_name;
|
|
++cmdlist;
|
|
if(str==NULL){
|
|
return ret;
|
|
}
|
|
t = strlen(str);
|
|
if(t>ret){
|
|
ret=t;
|
|
}
|
|
}
|
|
}
|
|
|
|
uint8_t cli_completion(char* buffer, uint16_t maxcmdlength, const cmdlist_entry_t* cmdlist){
|
|
uint8_t i=0;
|
|
char ref[maxcmdlength+1];
|
|
const char* itemstr;
|
|
ref[0]='\0';
|
|
/* check if we are behind the first word */
|
|
while(buffer[i]){
|
|
if(!isgraph((uint8_t)(buffer[i++])))
|
|
return 0;
|
|
}
|
|
for(;;){
|
|
itemstr = cmdlist->cmd_name;
|
|
if(itemstr==NULL)
|
|
break;
|
|
++cmdlist;
|
|
if(!strncmp(buffer, itemstr, i)){
|
|
if(!ref[0]){
|
|
strcpy(ref, itemstr);
|
|
}else{
|
|
ref[stridentcnt(ref, itemstr)]='\0';
|
|
}
|
|
}
|
|
}
|
|
i = strcmp(buffer, ref);
|
|
if(i)
|
|
strcpy(buffer, ref);
|
|
return ~i;
|
|
}
|
|
|
|
void cli_option_listing(char* buffer, const cmdlist_entry_t* cmdlist){
|
|
const char* itemstr;
|
|
uint16_t len=strlen(buffer);
|
|
for(;;){
|
|
itemstr = cmdlist->cmd_name;
|
|
if(itemstr==NULL){
|
|
cli_putstr("\r\n>");
|
|
cli_putstr(buffer);
|
|
return;
|
|
}
|
|
cmdlist += 1;
|
|
if(!strncmp(buffer, itemstr, len)){
|
|
cli_putstr("\r\n ");
|
|
cli_putstr(itemstr);
|
|
}
|
|
}
|
|
}
|
|
|
|
int8_t cmd_interface(const cmdlist_entry_t* cmd_desc){
|
|
uint16_t cli_buffer_size;
|
|
uint16_t cli_buffer_index;
|
|
int8_t exit_code;
|
|
uint8_t completion_failed=0;
|
|
char* cli_buffer;
|
|
char c;
|
|
uint16_t maxcmdlength = max_cmd_length(cmd_desc);
|
|
cli_buffer = calloc(1,cli_buffer_size=maxcmdlength+2);
|
|
cli_buffer_index=0;
|
|
if(!cli_rx)
|
|
return -1;
|
|
if(cli_tx)
|
|
cli_tx('>');
|
|
for(;;){
|
|
c = cli_rx();
|
|
switch (c){
|
|
case CLI_ENTER:
|
|
if((exit_code = search_and_call(cli_buffer, maxcmdlength, cmd_desc))<=0){
|
|
free(cli_buffer);
|
|
return exit_code;
|
|
}
|
|
memset(cli_buffer, 0, cli_buffer_size);
|
|
cli_buffer_index=0;
|
|
cli_putstr("\r\n>");
|
|
completion_failed=0;
|
|
break;
|
|
case CLI_BACKSPACE:
|
|
completion_failed=0;
|
|
if(cli_buffer_index==0)
|
|
break;
|
|
cli_buffer_index--;
|
|
cli_buffer[cli_buffer_index] = '\0';
|
|
if(cli_echo && cli_tx){
|
|
cli_tx(c);
|
|
}
|
|
break;
|
|
case CLI_TABULATOR:
|
|
if(completion_failed || cli_buffer_index==0){
|
|
if(cli_tx)
|
|
cli_option_listing(cli_buffer, cmd_desc);
|
|
} else {
|
|
uint16_t old_idx = cli_buffer_index;
|
|
completion_failed =
|
|
~cli_completion(cli_buffer, maxcmdlength, cmd_desc);
|
|
cli_buffer_index = strlen(cli_buffer);
|
|
if(cli_echo && cli_tx){
|
|
while(old_idx<cli_buffer_index){
|
|
cli_tx(cli_buffer[old_idx++]);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
completion_failed=0;
|
|
if(cli_echo && cli_tx){
|
|
cli_tx(c);
|
|
}
|
|
if(cli_buffer_index+1==cli_buffer_size){
|
|
cli_buffer = realloc(cli_buffer, cli_buffer_size+=CLI_BUFFER_BS);
|
|
if(!cli_buffer){
|
|
return -2;
|
|
}
|
|
memset(cli_buffer+cli_buffer_index+1, 0, CLI_BUFFER_BS);
|
|
}
|
|
cli_buffer[cli_buffer_index++] = c;
|
|
}
|
|
}
|
|
}
|
|
|