适合嵌入式系统的shell代码

从linux的wifi驱动中移植而来

static struct wpa_cli_cmd wpa_cli_commands[] = {
    { "ping", wpa_cli_cmd_ping, NULL, cli_cmd_flag_none,
      "use ping for debug purpose" },
     
    
   
         
      
                
    { "cls", clear_screen, NULL, cli_cmd_flag_none,
      "clear screen" },
    { "clear", clear_screen, NULL, cli_cmd_flag_none,
      "clear screen" },
    { "ls", ls_cmd, NULL, cli_cmd_flag_none,
      "ls all cmd" },
    { "md", mem_display, NULL, cli_cmd_flag_none,
      "mem all display" },
    { "mw", mem_write, NULL, cli_cmd_flag_none,
      "mem write byte word dword" },
    { "boot", jump_to_app, NULL, cli_cmd_flag_none,
      "mem write byte word dword" },
    { "dumpreg", dump_all_cpu_reg, NULL, cli_cmd_flag_none,
      "dump all cpu reg" },
      
    { "dumpsystick", dump_cpu_sys_tick, NULL, cli_cmd_flag_none,
      "dump the cpu current time tick" },

    { NULL, NULL, NULL, cli_cmd_flag_none, NULL }
};

static int wpa_request( struct wpa_ctrl *ctrl, int argc, char *argv[] )  
{
    struct wpa_cli_cmd *cmd, *match = NULL;
    int count;
    int ret = 0;
    if( argc == 0 ){
        return -1;              
    }                    
    count = 0;
    cmd = wpa_cli_commands;
    while( cmd->cmd ){
      if( os_strncasecmp(cmd->cmd, argv[0], os_strlen(argv[0])) == 0 ){
          match = cmd;
          if( os_strcasecmp(cmd->cmd, argv[0]) == 0 ){
              //we have an exact match
              count = 1;
              break;
          }
          count++;
      }
      cmd++;
    }
     
    if( count > 1 ){
        printf( "Ambiguous command '%s'; possible commands:", argv[0] );    
        cmd = wpa_cli_commands;
        while( cmd->cmd ){
          if( os_strncasecmp(cmd->cmd, argv[0], os_strlen(argv[0])) == 0 ){
              printf(" %s", cmd->cmd);
          }
          cmd++;
        }
        printf("\n");
        ret = 1;
    }else if( count == 0 ){
        printf("Unknown command '%s'\n", argv[0]);
        ls_cmd( ctrl, 0, NULL );
        ret = 1;
    }else{
        ret = match->handler( ctrl, argc - 1, &argv[1] );   
    }
    return ret;
}

static void wpa_cli_edit_cmd_cb( void *ctx, char *cmd )                  
{                                                                 
    char *argv[max_args];               
    int argc;
    printf("cmd = %s\n", cmd);
    argc = tokenize_cmd(cmd, argv);
    if (argc){
        wpa_request(NULL, argc, argv);
    }
}

extern int g_edit_exit;

static void wpa_cli_edit_eof_cb(void *ctx)
{
    //eloop_terminate();
    g_edit_exit = 0x01;
    printf("exit!!!\n");
}

/**
 * os_calloc - Allocate and zero memory for an array
 * @nmemb: Number of members in the array
 * @size: Number of bytes in each member
 * Returns: Pointer to allocated and zeroed memory or %NULL on failure
 *
 * This function can be used as a wrapper for os_zalloc(nmemb * size) when an
 * allocation is used for an array. The main benefit over os_zalloc() is in
 * having an extra check to catch integer overflows in multiplication.
 *
 * Caller is responsible for freeing the returned buffer with os_free().
 */
static inline void * os_calloc(size_t nmemb, size_t size)
{
    //if (size && nmemb > (~(size_t) 0) / size)
        //return NULL;
    return os_zalloc(nmemb * size);
}

static char ** wpa_list_cmd_list(void)
{
    char **res;
    int i, count;

    count = sizeof(wpa_cli_commands) / sizeof(wpa_cli_commands[0]);
    
    res = os_calloc(count + 1, sizeof(char *));
    if (res == NULL)
        return NULL;

    for (i = 0; wpa_cli_commands[i].cmd; i++) {
        res[i] = os_strdup(wpa_cli_commands[i].cmd);
        if (res[i] == NULL)
            break;
    }

    

    

    return res;
}

static char ** wpa_cli_cmd_completion(const char *cmd, const char *str,
                      int pos)
{
    int i;

    for (i = 0; wpa_cli_commands[i].cmd; i++) {
        if (os_strcasecmp(wpa_cli_commands[i].cmd, cmd) == 0) {
            if (wpa_cli_commands[i].completion)
                return wpa_cli_commands[i].completion(str, pos);
            edit_clear_line();
            printf("\r%s\n", wpa_cli_commands[i].usage);
            edit_redraw();
            break;
        }
    }

    return NULL;
}

//edit_completion_cb

static char ** wpa_cli_edit_completion_cb(void *ctx, const char *str, int pos)
{
    char **res;
    const char *end;
    char *cmd;

    //printf("\nwpa_cli_edit_completion_cb!!!\n");
    //printf("ctx = %p\n", ctx);

    //printf("str = %p\n", str);
    //printf("str = %s\n", str);
    //printf("pos = %x\n", pos);

    res = NULL;

    
    if( pos>7 && os_strncasecmp(str, "IFNAME=", 7)==0 ){
        end = os_strchr(str, ' ');

        printf("end1 = %x\n", end);
        if (end && pos > end - str) {
            pos -= end - str + 1;
            str = end + 1;
        }
    }

    end = os_strchr(str, ' ');
    //printf("end = %p\n", end);
    
    if (end == NULL || str + pos < end)
        return wpa_list_cmd_list();

    cmd = os_malloc(pos + 1);
    if (cmd == NULL)
        return NULL;
    os_memcpy(cmd, str, pos);
    cmd[end - str] = '\0';
    res = wpa_cli_cmd_completion(cmd, str, pos);
    os_free(cmd);
    
    
    return res;
}

void start_edit(void)
{    
    
          
    edit_init(wpa_cli_edit_cmd_cb, wpa_cli_edit_eof_cb, wpa_cli_edit_completion_cb, NULL, NULL, "hello");
        
}

/**
 * struct wpa_ctrl - Internal structure for control interface library
 *
 * This structure is used by the wpa_supplicant/hostapd control interface
 * library to store internal data. Programs using the library should not touch
 * this data directly. They can only use the pointer to the data structure as
 * an identifier for the control interface connection and use this as one of
 * the arguments for most of the control interface library functions.
 */
struct wpa_ctrl {
int a;
};

enum wpa_cli_cmd_flags {
    cli_cmd_flag_none        = 0x00,
    cli_cmd_flag_sensitive        = 0x01
};

struct wpa_cli_cmd {
    const char *cmd;
    int (*handler)(struct wpa_ctrl *ctrl, int argc, char *argv[]);
    char ** (*completion)(const char *str, int pos);
    enum wpa_cli_cmd_flags flags;
    const char *usage;
};

/*
 * Command line editing and history
 * Copyright (c) 2010-2011, Jouni Malinen <j@w1.fi>
 *
 * This software may be distributed under the terms of the BSD license.
 * See README for more details.
 */

//#include "includes.h"
//#include "termios.h"

//#include "common.h"
//#include "eloop.h"

#include <stdio.h>
#include "string.h"
#include <stdlib.h>
#include <stdarg.h>
#include "list.h"
#include "edit.h"

//#include "usart.h"

#define size_t  int

//#define CMD_BUF_LEN 256
#define CMD_BUF_LEN   128

int g_edit_exit = 0x00;
static char cmdbuf[CMD_BUF_LEN];
static int cmdbuf_pos = 0;
static int cmdbuf_len = 0;
static char currbuf[CMD_BUF_LEN];
static int currbuf_valid = 0;
static const char *ps2 = NULL;

#define HISTORY_MAX 100

struct edit_history {
    struct dl_list list;
    char str[1];
};

static struct dl_list history_list;
static struct edit_history *history_curr;

static void *edit_cb_ctx;
static void (*edit_cmd_cb)(void *ctx, char *cmd);
static void (*edit_eof_cb)(void *ctx);
static char ** (*edit_completion_cb)(void *ctx, const char *cmd, int pos) = NULL;

typedef unsigned char uint8_t;

//static struct termios prevt, newt;

//#define CLEAR_END_LINE "\e[K"

#define CLEAR_END_LINE "\x1b[K"

#define uart_rev_a_char getchar

char * os_strdup(const char *s)
{
    size_t len;
    char *d;
    len = os_strlen(s);
    d = os_malloc(len + 1);
    if (d == NULL)
        return NULL;
    os_memcpy(d, s, len);
    d[len] = '\0';
    return d;
}

//os_strlcpy(h->str, str, len + 1);
//os_strlcpy

void * os_zalloc(size_t size)
{
    void *n = (void *)os_malloc(size);
    if (n)
        os_memset(n, 0, size);
    return n;
}

void edit_clear_line(void)
{
    int i;
    putchar('\r');
    for (i = 0; i < cmdbuf_len + 2 + (ps2 ? (int)os_strlen(ps2) : 0); i++){
        putchar(' ');
    }
    for( i=0x00; i<32; i++ ){
         putchar(' '); 
    }
}

static void move_start(void)
{
    cmdbuf_pos = 0;
    edit_redraw();
}

static void move_end(void)
{
    cmdbuf_pos = cmdbuf_len;
    edit_redraw();
}

static void move_left(void)
{
    if (cmdbuf_pos > 0) {
        cmdbuf_pos--;
        edit_redraw();
    }
}

static void move_right(void)
{
    if (cmdbuf_pos < cmdbuf_len) {
        cmdbuf_pos++;
        edit_redraw();
    }
}

static void move_word_left(void)
{
    while (cmdbuf_pos > 0 && cmdbuf[cmdbuf_pos - 1] == ' ')
        cmdbuf_pos--;
    while (cmdbuf_pos > 0 && cmdbuf[cmdbuf_pos - 1] != ' ')
        cmdbuf_pos--;
    edit_redraw();
}

static void move_word_right(void)
{
    while (cmdbuf_pos < cmdbuf_len && cmdbuf[cmdbuf_pos] == ' ')
        cmdbuf_pos++;
    while (cmdbuf_pos < cmdbuf_len && cmdbuf[cmdbuf_pos] != ' ')
        cmdbuf_pos++;
    edit_redraw();
}

static void delete_left(void)
{

    //printf( " cmdbuf_pos = %d\n", cmdbuf_pos);
    

    if (cmdbuf_pos == 0){
        printf("\r%s#", ps2 ? ps2 : "");
        return;
    }

    edit_clear_line();
    os_memmove(cmdbuf + cmdbuf_pos - 1, cmdbuf + cmdbuf_pos,
           cmdbuf_len - cmdbuf_pos);
    cmdbuf_pos--;
    cmdbuf_len--;
    edit_redraw();
}

static void delete_current(void)
{
    if (cmdbuf_pos == cmdbuf_len)
        return;

    edit_clear_line();
    os_memmove(cmdbuf + cmdbuf_pos, cmdbuf + cmdbuf_pos + 1,
           cmdbuf_len - cmdbuf_pos);
    cmdbuf_len--;
    edit_redraw();
}

static void delete_word(void)
{
    int pos;

    edit_clear_line();
    pos = cmdbuf_pos;
    while (pos > 0 && cmdbuf[pos - 1] == ' ')
        pos--;
    while (pos > 0 && cmdbuf[pos - 1] != ' ')
        pos--;
    os_memmove(cmdbuf + pos, cmdbuf + cmdbuf_pos, cmdbuf_len - cmdbuf_pos);
    cmdbuf_len -= cmdbuf_pos - pos;
    cmdbuf_pos = pos;
    edit_redraw();
}

static void clear_left(void)
{
    if (cmdbuf_pos == 0)
        return;

    edit_clear_line();
    os_memmove(cmdbuf, cmdbuf + cmdbuf_pos, cmdbuf_len - cmdbuf_pos);
    cmdbuf_len -= cmdbuf_pos;
    cmdbuf_pos = 0;
    edit_redraw();
}

static void clear_right(void)
{
    if (cmdbuf_pos == cmdbuf_len)
        return;

    edit_clear_line();
    cmdbuf_len = cmdbuf_pos;
    edit_redraw();
}

static void history_add(const char *str)
{
    struct edit_history *h, *match = NULL, *last = NULL;
    size_t len, count = 0;

    if (str[0] == '\0')
        return;

    dl_list_for_each(h, &history_list, struct edit_history, list) {
        if (os_strcmp(str, h->str) == 0) {
            match = h;
            break;
        }
        last = h;
        count++;
    }

    if (match) {
        dl_list_del(&h->list);
        dl_list_add(&history_list, &h->list);
        history_curr = h;
        return;
    }

    if (count >= HISTORY_MAX && last) {
        dl_list_del(&last->list);
        os_free(last);
    }

    len = os_strlen(str);
    h = os_zalloc(sizeof(*h) + len);
    if (h == NULL)
        return;
    dl_list_add(&history_list, &h->list);
    os_strlcpy(h->str, str, len + 1);
    history_curr = h;
}

static void history_use(void)
{
    edit_clear_line();
    cmdbuf_len = cmdbuf_pos = os_strlen(history_curr->str);
    os_memcpy(cmdbuf, history_curr->str, cmdbuf_len);
    edit_redraw();
}

static void history_prev(void)
{
    if (history_curr == NULL)
        return;

    if (history_curr ==
        dl_list_first(&history_list, struct edit_history, list)) {
        if (!currbuf_valid) {
            cmdbuf[cmdbuf_len] = '\0';
            os_memcpy(currbuf, cmdbuf, cmdbuf_len + 1);
            currbuf_valid = 1;
            history_use();
            return;
        }
    }

    if (history_curr ==
        dl_list_last(&history_list, struct edit_history, list))
        return;

    history_curr = dl_list_entry(history_curr->list.next,
                     struct edit_history, list);
    history_use();
}

static void history_next(void)
{
    if (history_curr == NULL ||
        history_curr ==
        dl_list_first(&history_list, struct edit_history, list)) {
        if (currbuf_valid) {
            currbuf_valid = 0;
            edit_clear_line();
            cmdbuf_len = cmdbuf_pos = os_strlen(currbuf);
            os_memcpy(cmdbuf, currbuf, cmdbuf_len);
            edit_redraw();
        }
        return;
    }

    history_curr = dl_list_entry(history_curr->list.prev,
                     struct edit_history, list);
    history_use();
}

#if 0
static void history_read(const char *fname)
{
    FILE *f;
    char buf[CMD_BUF_LEN], *pos;
    //printf( "fname = %s\n", fname );

    f = fopen(fname, "r");
    //printf( "f = %p\n", f );
    if (f == NULL)
        return;

    while (fgets(buf, CMD_BUF_LEN, f)) {
        for (pos = buf; *pos; pos++) {
            if (*pos == '\r' || *pos == '\n') {
                *pos = '\0';
                break;
            }
        }
        history_add(buf);
    }

    fclose(f);
}

static void history_write(const char *fname,
              int (*filter_cb)(void *ctx, const char *cmd))
{
    FILE *f;
    struct edit_history *h;

    f = fopen(fname, "w");
    //printf( "f end= %p\n", f );
    if (f == NULL)
        return;

    dl_list_for_each_reverse(h, &history_list, struct edit_history, list) {
        if (filter_cb && filter_cb(edit_cb_ctx, h->str))
            continue;
        fprintf(f, "%s\n", h->str);
    }

    fclose(f);
}
#endif

static void history_debug_dump(void)
{
    struct edit_history *h;
    edit_clear_line();
    printf("\r");
    dl_list_for_each_reverse(h, &history_list, struct edit_history, list)
        printf("%s%s\n", h == history_curr ? "[C]" : "", h->str);
    if (currbuf_valid)
        printf("{%s}\n", currbuf);
    edit_redraw();
}

static void insert_char( int c )
{

    
    
    if( cmdbuf_len >= (int)sizeof(cmdbuf)-1 ){
        return;
    }

    //printf("\ncmdbuf_len = %d\n", cmdbuf_len);
    //printf("cmdbuf_pos = %d\n", cmdbuf_pos);
    
    
    if (cmdbuf_len == cmdbuf_pos) {
        cmdbuf[cmdbuf_pos++] = c;
        cmdbuf_len++;
        //putchar(c);
        //fflush(stdout);
    } else {
        os_memmove(cmdbuf + cmdbuf_pos + 1, cmdbuf + cmdbuf_pos,
               cmdbuf_len - cmdbuf_pos);
        cmdbuf[cmdbuf_pos++] = c;
        cmdbuf_len++;
        edit_redraw();
    }
}

static void process_cmd(void)
{      
    currbuf_valid = 0;
    if( cmdbuf_len == 0 ){
        printf("\r%s#", ps2 ? ps2 : "");
        //fflush(stdout);
        //history_debug_dump();
        //history_use();
        return;                     
    }
    printf("\n");
    cmdbuf[cmdbuf_len] = '\0';
    history_add(cmdbuf);
    cmdbuf_pos = 0;
    cmdbuf_len = 0;
    edit_cmd_cb(edit_cb_ctx, cmdbuf);
    printf("\r%s#", ps2 ? ps2 : "");
    //fflush(stdout);
}

static void free_completions(char **c)
{
    int i;
    if (c == NULL)
        return;
    for (i = 0; c[i]; i++)
        os_free(c[i]);
    os_free(c);
}

static int filter_strings(char **c, char *str, size_t len)
{
    int i, j;

    for (i = 0, j = 0; c[j]; j++) {
        if (os_strncasecmp(c[j], str, len) == 0) {
            if (i != j) {
                c[i] = c[j];
                c[j] = NULL;
            }
            i++;
        } else {
            os_free(c[j]);
            c[j] = NULL;
        }
    }
    c[i] = NULL;
    return i;
}

static int common_len(const char *a, const char *b)
{
    int len = 0;
    while (a[len] && a[len] == b[len])
        len++;
    return len;
}

static int max_common_length(char **c)
{
    int len, i;

    len = os_strlen(c[0]);
    for (i = 1; c[i]; i++) {
        int same = common_len(c[0], c[i]);
        if (same < len)
            len = same;
    }

    return len;
}

static int cmp_str(const void *a, const void *b)
{
    return os_strcmp(* (const char **) a, * (const char **) b);
}

static void complete(int list)
{
    char **c;
    int i, len, count;
    int start, end;
    int room, plen, add_space;

    if (edit_completion_cb == NULL)
        return;

    cmdbuf[cmdbuf_len] = '\0';
    c = edit_completion_cb(edit_cb_ctx, cmdbuf, cmdbuf_pos);
    if (c == NULL)
        return;

    end = cmdbuf_pos;
    start = end;
    while (start > 0 && cmdbuf[start - 1] != ' ')
        start--;
    plen = end - start;

    count = filter_strings(c, &cmdbuf[start], plen);
    if (count == 0) {
        free_completions(c);
        return;
    }

    len = max_common_length(c);
    if (len <= plen && count > 1) {
        if (list) {
            qsort(c, count, sizeof(char *), cmp_str);
            edit_clear_line();
            printf("\r");
            for (i = 0; c[i]; i++)
                printf("%s%s", i > 0 ? " " : "", c[i]);
            printf("\n");
            edit_redraw();
        }
        free_completions(c);
        return;
    }
    len -= plen;

    room = sizeof(cmdbuf) - 1 - cmdbuf_len;
    if (room < len)
        len = room;
    add_space = count == 1 && len < room;

    os_memmove(cmdbuf + cmdbuf_pos + len + add_space, cmdbuf + cmdbuf_pos,
           cmdbuf_len - cmdbuf_pos);
    os_memcpy(&cmdbuf[cmdbuf_pos - plen], c[0], plen + len);
    if (add_space)
        cmdbuf[cmdbuf_pos + len] = ' ';

    cmdbuf_pos += len + add_space;
    cmdbuf_len += len + add_space;

    edit_redraw();

    free_completions(c);
}

enum edit_key_code {
    EDIT_KEY_NONE = 256,
    EDIT_KEY_TAB,
    EDIT_KEY_UP,
    EDIT_KEY_DOWN,
    EDIT_KEY_RIGHT,
    EDIT_KEY_LEFT,
    EDIT_KEY_ENTER,
    EDIT_KEY_BACKSPACE,
    EDIT_KEY_INSERT,
    EDIT_KEY_DELETE,
    EDIT_KEY_HOME,
    EDIT_KEY_END,
    EDIT_KEY_PAGE_UP,
    EDIT_KEY_PAGE_DOWN,
    EDIT_KEY_F1,
    EDIT_KEY_F2,
    EDIT_KEY_F3,
    EDIT_KEY_F4,
    EDIT_KEY_F5,
    EDIT_KEY_F6,
    EDIT_KEY_F7,
    EDIT_KEY_F8,
    EDIT_KEY_F9,
    EDIT_KEY_F10,
    EDIT_KEY_F11,
    EDIT_KEY_F12,
    EDIT_KEY_CTRL_UP,
    EDIT_KEY_CTRL_DOWN,
    EDIT_KEY_CTRL_RIGHT,
    EDIT_KEY_CTRL_LEFT,
    EDIT_KEY_CTRL_A,
    EDIT_KEY_CTRL_B,
    EDIT_KEY_CTRL_D,
    EDIT_KEY_CTRL_E,
    EDIT_KEY_CTRL_F,
    EDIT_KEY_CTRL_G,
    EDIT_KEY_CTRL_H,
    EDIT_KEY_CTRL_J,
    EDIT_KEY_CTRL_K,
    EDIT_KEY_CTRL_L,
    EDIT_KEY_CTRL_N,
    EDIT_KEY_CTRL_O,
    EDIT_KEY_CTRL_P,
    EDIT_KEY_CTRL_R,
    EDIT_KEY_CTRL_T,
    EDIT_KEY_CTRL_U,
    EDIT_KEY_CTRL_V,
    EDIT_KEY_CTRL_W,
    EDIT_KEY_ALT_UP,
    EDIT_KEY_ALT_DOWN,
    EDIT_KEY_ALT_RIGHT,
    EDIT_KEY_ALT_LEFT,
    EDIT_KEY_SHIFT_UP,
    EDIT_KEY_SHIFT_DOWN,
    EDIT_KEY_SHIFT_RIGHT,
    EDIT_KEY_SHIFT_LEFT,
    EDIT_KEY_ALT_SHIFT_UP,
    EDIT_KEY_ALT_SHIFT_DOWN,
    EDIT_KEY_ALT_SHIFT_RIGHT,
    EDIT_KEY_ALT_SHIFT_LEFT,
    EDIT_KEY_EOF
};

static void show_esc_buf(const char *esc_buf, char c, int i)
{
    edit_clear_line();
    printf("\rESC buffer '%s' c='%c' [%d]\n", esc_buf, c, i);
    edit_redraw();
}

static enum edit_key_code esc_seq_to_key1_no(char last)
{
    switch (last) {
    case 'A':
        return EDIT_KEY_UP;
    case 'B':
        return EDIT_KEY_DOWN;
    case 'C':
        return EDIT_KEY_RIGHT;
    case 'D':
        return EDIT_KEY_LEFT;
    default:
        return EDIT_KEY_NONE;
    }
}

static enum edit_key_code esc_seq_to_key1_shift(char last)
{
    switch (last) {
    case 'A':
        return EDIT_KEY_SHIFT_UP;
    case 'B':
        return EDIT_KEY_SHIFT_DOWN;
    case 'C':
        return EDIT_KEY_SHIFT_RIGHT;
    case 'D':
        return EDIT_KEY_SHIFT_LEFT;
    default:
        return EDIT_KEY_NONE;
    }
}

static enum edit_key_code esc_seq_to_key1_alt(char last)
{
    switch (last) {
    case 'A':
        return EDIT_KEY_ALT_UP;
    case 'B':
        return EDIT_KEY_ALT_DOWN;
    case 'C':
        return EDIT_KEY_ALT_RIGHT;
    case 'D':
        return EDIT_KEY_ALT_LEFT;
    default:
        return EDIT_KEY_NONE;
    }
}

static enum edit_key_code esc_seq_to_key1_alt_shift(char last)
{
    switch (last) {
    case 'A':
        return EDIT_KEY_ALT_SHIFT_UP;
    case 'B':
        return EDIT_KEY_ALT_SHIFT_DOWN;
    case 'C':
        return EDIT_KEY_ALT_SHIFT_RIGHT;
    case 'D':
        return EDIT_KEY_ALT_SHIFT_LEFT;
    default:
        return EDIT_KEY_NONE;
    }
}

static enum edit_key_code esc_seq_to_key1_ctrl(char last)
{
    switch (last) {
    case 'A':
        return EDIT_KEY_CTRL_UP;
    case 'B':
        return EDIT_KEY_CTRL_DOWN;
    case 'C':
        return EDIT_KEY_CTRL_RIGHT;
    case 'D':
        return EDIT_KEY_CTRL_LEFT;
    default:
        return EDIT_KEY_NONE;
    }
}

static enum edit_key_code esc_seq_to_key1(int param1, int param2, char last)
{
    /* ESC-[<param1>;<param2><last> */

    if (param1 < 0 && param2 < 0)
        return esc_seq_to_key1_no(last);

    if (param1 == 1 && param2 == 2)
        return esc_seq_to_key1_shift(last);

    if (param1 == 1 && param2 == 3)
        return esc_seq_to_key1_alt(last);

    if (param1 == 1 && param2 == 4)
        return esc_seq_to_key1_alt_shift(last);

    if (param1 == 1 && param2 == 5)
        return esc_seq_to_key1_ctrl(last);

    if (param2 < 0) {
        if (last != '~')
            return EDIT_KEY_NONE;
        switch (param1) {
        case 2:
            return EDIT_KEY_INSERT;
        case 3:
            return EDIT_KEY_DELETE;
        case 5:
            return EDIT_KEY_PAGE_UP;
        case 6:
            return EDIT_KEY_PAGE_DOWN;
        case 15:
            return EDIT_KEY_F5;
        case 17:
            return EDIT_KEY_F6;
        case 18:
            return EDIT_KEY_F7;
        case 19:
            return EDIT_KEY_F8;
        case 20:
            return EDIT_KEY_F9;
        case 21:
            return EDIT_KEY_F10;
        case 23:
            return EDIT_KEY_F11;
        case 24:
            return EDIT_KEY_F12;
        }
    }

    return EDIT_KEY_NONE;
}

static enum edit_key_code esc_seq_to_key2(int param1, int param2, char last)
{
    /* ESC-O<param1>;<param2><last> */

    if (param1 >= 0 || param2 >= 0)
        return EDIT_KEY_NONE;

    switch (last) {
    case 'F':
        return EDIT_KEY_END;
    case 'H':
        return EDIT_KEY_HOME;
    case 'P':
        return EDIT_KEY_F1;
    case 'Q':
        return EDIT_KEY_F2;
    case 'R':
        return EDIT_KEY_F3;
    case 'S':
        return EDIT_KEY_F4;
    default:
        return EDIT_KEY_NONE;
    }
}

static enum edit_key_code esc_seq_to_key(char *seq)
{
    char last, *pos;
    int param1 = -1, param2 = -1;
    enum edit_key_code ret = EDIT_KEY_NONE;

    last = '\0';
    for (pos = seq; *pos; pos++)
        last = *pos;

    if (seq[1] >= '0' && seq[1] <= '9') {
        param1 = atoi(&seq[1]);
        pos = (char *)os_strchr(seq, ';');
        if (pos)
            param2 = atoi(pos + 1);
    }

    if (seq[0] == '[')
        ret = esc_seq_to_key1(param1, param2, last);
    else if (seq[0] == 'O')
        ret = esc_seq_to_key2(param1, param2, last);

    if (ret != EDIT_KEY_NONE)
        return ret;

    edit_clear_line();
    printf("\rUnknown escape sequence '%s'\n", seq);
    edit_redraw();
    return EDIT_KEY_NONE;
}
int secureCRT_mode = 0x00;

static enum edit_key_code edit_read_key(int sock)
{
    int c;
    static int esc = -1;
    static char esc_buf[7];
    char buffer[128] = {0x00};
                       
    c = getchar();
    //printf( "\n getchar = %#x, %c, esc=%d.\n", c, c, esc );
    

    if (esc >= 0) {
        if (c == 27 /* ESC */) {
            esc = 0;
            return EDIT_KEY_NONE;
        }

        if (esc == 6) {
            show_esc_buf(esc_buf, c, 0);
            esc = -1;
        } else {
            esc_buf[esc++] = c;
            esc_buf[esc] = '\0';
        }
    }

    //printf( "\nesc1=%d.\n", esc );

    if (esc == 1) {
        if (esc_buf[0] != '[' && esc_buf[0] != 'O') {
            show_esc_buf(esc_buf, c, 1);
            esc = -1;
            return EDIT_KEY_NONE;
        } else
            return EDIT_KEY_NONE; /* Escape sequence continues */
    }

    //printf( "\nesc2=%d.\n", esc );

    if (esc > 1) {
        if ((c >= '0' && c <= '9') || c == ';'){
            return EDIT_KEY_NONE; /* Escape sequence continues */
        }
        if (c == '~' || (c >= 'A' && c <= 'Z')) {

            if( secureCRT_mode == 0x00 ){   
                esc = -1;
                return esc_seq_to_key(esc_buf);
            }else{
                esc = esc - 1;  
                secureCRT_mode = 0x00;
                return EDIT_KEY_NONE;
            }
        }

        show_esc_buf(esc_buf, c, 2);
        esc = -1;
        return EDIT_KEY_NONE;
    }

    switch (c) {
    case 1:
        return EDIT_KEY_CTRL_A;
    case 2:
        return EDIT_KEY_CTRL_B;
    case 4:
        return EDIT_KEY_CTRL_D;
    case 5:
        return EDIT_KEY_CTRL_E;
    case 6:
        return EDIT_KEY_CTRL_F;
    case 7:
        return EDIT_KEY_CTRL_G;
    case 8:
        return EDIT_KEY_CTRL_H;
    case 9:
        return EDIT_KEY_TAB;
    case 10:
        return EDIT_KEY_CTRL_J;
    case 13: /* CR */
        return EDIT_KEY_ENTER;
    case 11:
        return EDIT_KEY_CTRL_K;
    case 12:
        return EDIT_KEY_CTRL_L;
    case 14:
        return EDIT_KEY_CTRL_N;
    case 15:
        return EDIT_KEY_CTRL_O;
    case 16:
        return EDIT_KEY_CTRL_P;
    case 18:
        return EDIT_KEY_CTRL_R;
    case 20:
        return EDIT_KEY_CTRL_T;
    case 21:
        return EDIT_KEY_CTRL_U;
    case 22:
        return EDIT_KEY_CTRL_V;
    case 23:
        return EDIT_KEY_CTRL_W;
    case 27: /* ESC */
        esc = 0;
        return EDIT_KEY_NONE;

    case 0x5B: /* ESC */
        esc = 1;
        esc_buf[0x00] = 0x5b; 
        secureCRT_mode = 0x01;
        return EDIT_KEY_NONE;
        
    case 127:
        return EDIT_KEY_BACKSPACE;
    default:
        return (enum edit_key_code)c;
    }
}

static char search_buf[21];
static int search_skip;

static char * search_find(void)
{
    struct edit_history *h;
    size_t len = os_strlen(search_buf);
    int skip = search_skip;

    if (len == 0)
        return NULL;

    dl_list_for_each(h, &history_list, struct edit_history, list) {
        if (os_strstr(h->str, search_buf)) {
            if (skip == 0)
                return h->str;
            skip--;
        }
    }

    search_skip = 0;
    return NULL;
}

static void search_redraw(void)
{
    char *match = search_find();
    printf("\rsearch '%s': %s" CLEAR_END_LINE, search_buf, match ? match : "");
    printf("\rsearch '%s", search_buf);
    //fflush(stdout);
}

static void search_start(void)
{
    edit_clear_line();
    search_buf[0] = '\0';
    search_skip = 0;
    search_redraw();
}

static void search_clear(void)
{
    search_redraw();
    //printf("\r" CLEAR_END_LINE);
    printf("\r\x1b[K");
}

static void search_stop(void)
{
    char *match = search_find();
    search_buf[0] = '\0';
    search_clear();
    if (match) {
        os_strlcpy(cmdbuf, match, CMD_BUF_LEN);
        cmdbuf_len = os_strlen(cmdbuf);
        cmdbuf_pos = cmdbuf_len;
    }
    edit_redraw();
}

static void search_cancel(void)
{
    search_buf[0] = '\0';
    search_clear();
    edit_redraw();
}

static void search_backspace(void)
{
    size_t len;
    len = os_strlen(search_buf);
    if (len == 0)
        return;
    search_buf[len - 1] = '\0';
    search_skip = 0;
    search_redraw();
}

static void search_next(void)
{
    search_skip++;
    search_find();
    search_redraw();
}

static void search_char(char c)
{
    size_t len;
    len = os_strlen(search_buf);
    if (len == sizeof(search_buf) - 1)
        return;
    search_buf[len] = c;
    search_buf[len + 1] = '\0';
    search_skip = 0;
    search_redraw();
}

static enum edit_key_code search_key(enum edit_key_code c)
{
    switch (c) {
    case EDIT_KEY_ENTER:
    case EDIT_KEY_CTRL_J:
    case EDIT_KEY_LEFT:
    case EDIT_KEY_RIGHT:
    case EDIT_KEY_HOME:
    case EDIT_KEY_END:
    case EDIT_KEY_CTRL_A:
    case EDIT_KEY_CTRL_E:
        search_stop();
        return c;
    case EDIT_KEY_DOWN:
    case EDIT_KEY_UP:
        search_cancel();
        return EDIT_KEY_EOF;
    case EDIT_KEY_CTRL_H:
    case EDIT_KEY_BACKSPACE:
        search_backspace();
        break;
    case EDIT_KEY_CTRL_R:
        search_next();
        break;
    default:
        if (c >= 32 && c <= 255)
            search_char(c);
        break;
    }

    return EDIT_KEY_NONE;
}

static void edit_read_char(int sock, void *eloop_ctx, void *sock_ctx)
{
    static int last_tab = 0;
    static int search = 0;
    enum edit_key_code c;

    c = edit_read_key(sock);
    //printf( " c1 = %d\n", c);

    
    //EDIT_KEY_CTRL_H 292

    

    if (search) {
        c = search_key(c);
        if (c == EDIT_KEY_NONE)
            return;
        search = 0;
        if (c == EDIT_KEY_EOF)
            return;
    }

    if (c != EDIT_KEY_TAB && c != EDIT_KEY_NONE)
        last_tab = 0;
    //printf( " c2 = %#x\n", c);

    switch (c) {
    case EDIT_KEY_NONE:
        break;
    case EDIT_KEY_EOF:
        edit_eof_cb(edit_cb_ctx);
        break;
    case EDIT_KEY_TAB:
        complete(last_tab);
        last_tab = 1;
        break;
    case EDIT_KEY_UP:
    case EDIT_KEY_CTRL_P:
        history_prev();
        break;
    case EDIT_KEY_DOWN:
    case EDIT_KEY_CTRL_N:
        history_next();
        break;
    case EDIT_KEY_RIGHT:
    case EDIT_KEY_CTRL_F:
        move_right();
        break;
    case EDIT_KEY_LEFT:
    case EDIT_KEY_CTRL_B:
        move_left();
        break;
    case EDIT_KEY_CTRL_RIGHT:
        move_word_right();
        break;
    case EDIT_KEY_CTRL_LEFT:
        move_word_left();
        break;
    case EDIT_KEY_DELETE:
        delete_current();
        break;
    case EDIT_KEY_END:
        move_end();
        break;
    case EDIT_KEY_HOME:
    case EDIT_KEY_CTRL_A:
        move_start();
        break;
    case EDIT_KEY_F2:
        history_debug_dump();
        break;
    case EDIT_KEY_CTRL_D:
        if (cmdbuf_len > 0) {
            delete_current();
            return;
        }
        printf("\n");
        edit_eof_cb(edit_cb_ctx);
        break;
    case EDIT_KEY_CTRL_E:
        move_end();
        break;
    case EDIT_KEY_CTRL_H:
    case EDIT_KEY_BACKSPACE:
        delete_left();
        break;
    case EDIT_KEY_ENTER:
    case EDIT_KEY_CTRL_J:
        process_cmd();
        break;
    case EDIT_KEY_CTRL_K:
        clear_right();
        break;
    case EDIT_KEY_CTRL_L:
        edit_clear_line();
        edit_redraw();
        break;
    case EDIT_KEY_CTRL_R:
        search = 1;
        search_start();
        break;
    case EDIT_KEY_CTRL_U:
        clear_left();
        break;
    case EDIT_KEY_CTRL_W:
        delete_word();
        break;
    default:
        if (c >= 32 && c <= 255);
            insert_char(c);
        break;
    }
}

int edit_init(void (*cmd_cb)(void *ctx, char *cmd),
          void (*eof_cb)(void *ctx),
          char ** (*completion_cb)(void *ctx, const char *cmd, int pos),
          void *ctx, const char *history_file, const char *ps)
{
    currbuf[0] = '\0';
    dl_list_init(&history_list);
    history_curr = NULL;
    

    edit_cb_ctx = ctx;
    edit_cmd_cb = cmd_cb;
    edit_eof_cb = eof_cb;
    edit_completion_cb = completion_cb;

    

    //eloop_register_read_sock( STDIN_FILENO, edit_read_char, NULL, NULL );        

    ps2 = ps;
    printf("%s#", ps2 ? ps2 : "");

    g_edit_exit = 0x00;
    while( g_edit_exit == 0x00 ){   
      edit_read_char( 0, NULL, NULL );
    }

    //return 0;
}

void edit_deinit(const char *history_file,
         int (*filter_cb)(void *ctx, const char *cmd))
{
    struct edit_history *h;
    //if (history_file)
    //    history_write(history_file, filter_cb);
    while ((h = dl_list_first(&history_list, struct edit_history, list))) {
        dl_list_del(&h->list);
        os_free(h);
    }
    edit_clear_line();
    putchar('\r');
    //fflush(stdout);
    //eloop_unregister_read_sock(STDIN_FILENO);
    //tcsetattr(STDIN_FILENO, TCSANOW, &prevt);
}

void edit_redraw( void )     
{    
    char tmp;
    cmdbuf[cmdbuf_len] = '\0';

    //printf("cmdbuf_len = %d\n", cmdbuf_len);
    //printf("cmdbuf = %s\n", cmdbuf);
    

    
    printf( "\r%s#%s", ps2 ? ps2 : "", cmdbuf );      
    if( cmdbuf_pos != cmdbuf_len ){    
        tmp = cmdbuf[cmdbuf_pos];
        cmdbuf[cmdbuf_pos] = '\0';
        printf("\r%s#%s", ps2 ? ps2 : "", cmdbuf);
        cmdbuf[cmdbuf_pos] = tmp;
    }
    //fflush(stdout);
}                                   

/*
 * Command line editing and history
 * Copyright (c) 2010, Jouni Malinen <j@w1.fi>
 *
 * This software may be distributed under the terms of the BSD license.
 * See README for more details.
 */

#ifndef EDIT_H
#define EDIT_H

int edit_init(void (*cmd_cb)(void *ctx, char *cmd),
          void (*eof_cb)(void *ctx),
          char ** (*completion_cb)(void *ctx, const char *cmd, int pos),
          void *ctx, const char *history_file, const char *ps);
void edit_deinit(const char *history_file,
         int (*filter_cb)(void *ctx, const char *cmd));
void edit_clear_line(void);
void edit_redraw(void);

#define os_strlen(s) strlen(s)
#define os_malloc(s) malloc((s))
#define os_free(p) free((p))
#define os_memset(s, c, n) memset(s, c, n)
#define os_memcpy(d, s, n) memcpy((d), (s), (n))
#define os_memmove(d, s, n) memmove((d), (s), (n))
#define os_strchr(s, c) strchr((s), (c))
#define os_strcmp(s1, s2) strcmp((s1), (s2))

#define os_strlcpy(s1, s2, len) strlcpy((s1), (s2), (len))
#define os_strncasecmp(s1, s2, n) strncasecmp((s1), (s2), (n))
#define os_strcasecmp(s1, s2) strcasecmp((s1), (s2))

#define os_strstr(h, n) strstr((h), (n))

#define os_strrchr(s, c) strrchr((s), (c))

extern int Ser_Printf (const char *format, ...);

//#undef putchar 
#define uart_send_a_char putchar 

#endif /* EDIT_H */