first

rt-thread/components/finsh/Kconfig

@@ -0,0 +1,84 @@
+menuconfig RT_USING_MSH
+    bool "MSH: command shell"
+    default n if RT_USING_NANO
+    default y
+
+if RT_USING_MSH
+
+    config RT_USING_FINSH
+        bool
+        default y
+
+    config FINSH_USING_MSH
+        bool
+        default y
+
+    config FINSH_THREAD_NAME
+        string "The msh thread name"
+        default "tshell"
+
+    config FINSH_THREAD_PRIORITY
+        int "The priority level value of thread"
+        default 20
+
+    config FINSH_THREAD_STACK_SIZE
+        int "The stack size for thread"
+        default 4096
+
+    config FINSH_USING_HISTORY
+        bool "Enable command history feature"
+        default y
+
+    if FINSH_USING_HISTORY
+        config FINSH_HISTORY_LINES
+            int "The command history line number"
+            default 5
+    endif
+
+    config FINSH_USING_SYMTAB
+        bool "Using symbol table for commands"
+        default y
+
+    config FINSH_CMD_SIZE
+        int "The command line size for shell"
+        default 80
+
+    config MSH_USING_BUILT_IN_COMMANDS
+        bool "Enable built-in commands, such as list_thread"
+        default y
+
+    config FINSH_USING_DESCRIPTION
+        bool "Keeping description in symbol table"
+        default y
+
+    config FINSH_ECHO_DISABLE_DEFAULT
+        bool "Disable the echo mode in default"
+        default n
+
+    config FINSH_USING_AUTH
+        bool "shell support authentication"
+        default n
+
+    if FINSH_USING_AUTH
+        config FINSH_DEFAULT_PASSWORD
+            string "The default password for shell authentication"
+            default "rtthread"
+
+        config FINSH_PASSWORD_MIN
+            int "The password min length"
+            default 6
+
+        config FINSH_PASSWORD_MAX
+            int "The password max length"
+            default RT_NAME_MAX
+    endif
+
+    config FINSH_ARG_MAX
+        int "The number of arguments for a shell command"
+        default 10
+
+    config FINSH_USING_OPTION_COMPLETION
+        bool "command option completion enable"
+        default y
+
+endif

rt-thread/components/finsh/SConscript

@@ -0,0 +1,26 @@
+from building import *
+from gcc import GetGCCLikePLATFORM
+
+cwd     = GetCurrentDir()
+src     = Split('''
+shell.c
+msh.c
+msh_parse.c
+''')
+
+CPPPATH = [cwd]
+LOCAL_CFLAGS = ''
+
+if rtconfig.PLATFORM in ['gcc']: # only for GCC
+    LOCAL_CFLAGS += ' -Wstack-usage=' + str(GetConfigValue('FINSH_THREAD_STACK_SIZE')) # check finsh thread stack size
+
+if GetDepend('MSH_USING_BUILT_IN_COMMANDS'):
+    src += ['cmd.c']
+
+if GetDepend('DFS_USING_POSIX'):
+    src += ['msh_file.c']
+
+group = DefineGroup('Finsh', src, depend = ['RT_USING_FINSH'], CPPPATH = CPPPATH,
+                    LOCAL_CFLAGS = LOCAL_CFLAGS)
+
+Return('group')

rt-thread/components/finsh/finsh.h

@@ -0,0 +1,247 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2010-03-22     Bernard      first version
+ */
+#ifndef __FINSH_H__
+#define __FINSH_H__
+
+#include <rtdef.h>
+
+#ifdef _MSC_VER
+#pragma section("FSymTab$f",read)
+#endif /* _MSC_VER */
+
+#ifdef FINSH_USING_OPTION_COMPLETION
+#define FINSH_COND(opt) opt,
+#else
+#define FINSH_COND(opt)
+#endif
+
+#ifdef FINSH_USING_DESCRIPTION
+#define FINSH_DESC(cmd, desc) __fsym_##cmd##_desc,
+#else
+#define FINSH_DESC(cmd, desc)
+#endif
+
+typedef long (*syscall_func)(void);
+#ifdef FINSH_USING_SYMTAB
+
+#ifdef __TI_COMPILER_VERSION__
+#define __TI_FINSH_EXPORT_FUNCTION(f)  PRAGMA(DATA_SECTION(f,"FSymTab"))
+#endif /* __TI_COMPILER_VERSION__ */
+
+/**
+ * Macro to export a command along with its name, description, and options to the symbol table in MSVC.
+ * @param name The function name associated with the command.
+ * @param cmd The command name.
+ * @param desc The description of the command.
+ * @param opt The options associated with the command, used for option completion.
+ */
+#ifdef _MSC_VER
+#define MSH_FUNCTION_EXPORT_CMD(name, cmd, desc, opt)               \
+                const char __fsym_##cmd##_name[] = #cmd;            \
+                const char __fsym_##cmd##_desc[] = #desc;           \
+                __declspec(allocate("FSymTab$f"))                   \
+                const struct finsh_syscall __fsym_##cmd =           \
+                {                           \
+                    __fsym_##cmd##_name,    \
+                    FINSH_DESC(cmd, desc)   \
+                    FINSH_COND(opt)         \
+                    (syscall_func)&name     \
+                };
+#pragma comment(linker, "/merge:FSymTab=mytext")
+
+#elif defined(__TI_COMPILER_VERSION__)
+#ifdef __TMS320C28XX__
+#define RT_NOBLOCKED __attribute__((noblocked))
+#else
+#define RT_NOBLOCKED
+#endif
+#define MSH_FUNCTION_EXPORT_CMD(name, cmd, desc, opt)                           \
+                __TI_FINSH_EXPORT_FUNCTION(__fsym_##cmd);                       \
+                const char __fsym_##cmd##_name[] = #cmd;                        \
+                const char __fsym_##cmd##_desc[] = #desc;                       \
+                rt_used RT_NOBLOCKED const struct finsh_syscall __fsym_##cmd =  \
+                {                           \
+                    __fsym_##cmd##_name,    \
+                    FINSH_DESC(cmd, desc)   \
+                    FINSH_COND(opt)         \
+                    (syscall_func)&name     \
+                };
+
+#else
+#define MSH_FUNCTION_EXPORT_CMD(name, cmd, desc, opt)                                  \
+                const char __fsym_##cmd##_name[] rt_section(".rodata.name") = #cmd;    \
+                const char __fsym_##cmd##_desc[] rt_section(".rodata.name") = #desc;   \
+                rt_used const struct finsh_syscall __fsym_##cmd rt_section("FSymTab")= \
+                {                           \
+                    __fsym_##cmd##_name,    \
+                    FINSH_DESC(cmd, desc)   \
+                    FINSH_COND(opt)         \
+                    (syscall_func)&name     \
+                };
+
+#endif  /* _MSC_VER */
+#endif /* FINSH_USING_SYMTAB */
+
+/**
+ * Macro definitions to simplify the declaration of exported functions or commands.
+ */
+#define __MSH_GET_MACRO(_1, _2, _3, _FUN, ...)  _FUN
+#define __MSH_GET_EXPORT_MACRO(_1, _2, _3, _4, _FUN, ...) _FUN
+
+#define _MSH_FUNCTION_CMD2(a0, a1)       \
+        MSH_FUNCTION_EXPORT_CMD(a0, a0, a1, 0)
+
+#define _MSH_FUNCTION_CMD2_OPT(a0, a1, a2)       \
+        MSH_FUNCTION_EXPORT_CMD(a0, a0, a1, a0##_msh_options)
+
+#define _MSH_FUNCTION_EXPORT_CMD3(a0, a1, a2)       \
+        MSH_FUNCTION_EXPORT_CMD(a0, a1, a2, 0)
+
+#define _MSH_FUNCTION_EXPORT_CMD3_OPT(a0, a1, a2, a3)   \
+        MSH_FUNCTION_EXPORT_CMD(a0, a1, a2, a0##_msh_options)
+
+
+/**
+ * @ingroup finsh
+ *
+ * This macro exports a system function to finsh shell.
+ *
+ * @param name the name of function.
+ * @param desc the description of function, which will show in help.
+ */
+#define FINSH_FUNCTION_EXPORT(name, desc)
+
+/**
+ * @ingroup finsh
+ *
+ * This macro exports a system function with an alias name to finsh shell.
+ *
+ * @param name the name of function.
+ * @param alias the alias name of function.
+ * @param desc the description of function, which will show in help.
+ */
+#define FINSH_FUNCTION_EXPORT_ALIAS(name, alias, desc)
+
+/**
+ * @ingroup msh
+ *
+ * This macro exports a command to module shell.
+ *
+ * @param command is the name of the command.
+ * @param desc is the description of the command, which will show in help list.
+ * @param opt This is an option, enter any content to enable option completion
+ */
+/* MSH_CMD_EXPORT(command, desc) or MSH_CMD_EXPORT(command, desc, opt) */
+#define MSH_CMD_EXPORT(...)                                 \
+    __MSH_GET_MACRO(__VA_ARGS__, _MSH_FUNCTION_CMD2_OPT,    \
+        _MSH_FUNCTION_CMD2)(__VA_ARGS__)
+
+/**
+ * @ingroup msh
+ *
+ * This macro exports a command with alias to module shell.
+ *
+ * @param command is the name of the command.
+ * @param alias is the alias of the command.
+ * @param desc is the description of the command, which will show in help list.
+ * @param opt This is an option, enter any content to enable option completion
+ * @note
+ *      #define MSH_CMD_EXPORT_ALIAS(command, alias, desc) or
+ *      #define MSH_CMD_EXPORT_ALIAS(command, alias, desc, opt)
+ */
+#define MSH_CMD_EXPORT_ALIAS(...)                                           \
+    __MSH_GET_EXPORT_MACRO(__VA_ARGS__, _MSH_FUNCTION_EXPORT_CMD3_OPT,      \
+            _MSH_FUNCTION_EXPORT_CMD3)(__VA_ARGS__)
+
+/* system call table */
+struct finsh_syscall
+{
+    const char     *name;       /* the name of system call */
+#if defined(FINSH_USING_DESCRIPTION) && defined(FINSH_USING_SYMTAB)
+    const char     *desc;       /* description of system call */
+#endif
+
+#ifdef FINSH_USING_OPTION_COMPLETION
+    struct msh_cmd_opt *opt;
+#endif
+    syscall_func func;      /* the function address of system call */
+};
+
+/* system call item */
+struct finsh_syscall_item
+{
+    struct finsh_syscall_item *next;    /* next item */
+    struct finsh_syscall syscall;       /* syscall */
+};
+
+#ifdef FINSH_USING_OPTION_COMPLETION
+typedef struct msh_cmd_opt
+{
+    rt_uint32_t     id;
+    const char      *name;
+    const char      *des;
+} msh_cmd_opt_t;
+
+/* Command options declaration and definition macros */
+
+/**
+ * Declares a static array of command options for a specific command.
+ * @param command The command associated with these options.
+ */
+#define CMD_OPTIONS_STATEMENT(command) static struct msh_cmd_opt command##_msh_options[];
+
+/**
+ * Starts the definition of command options for a specific command.
+ * @param command The command these options are associated with.
+ */
+#define CMD_OPTIONS_NODE_START(command) static struct msh_cmd_opt command##_msh_options[] = {
+
+/**
+ * Defines a single command option.
+ * @param _id Unique identifier for the option.
+ * @param _name The name of the option.
+ * @param _des Description of the option.
+ */
+#define CMD_OPTIONS_NODE(_id, _name, _des) {.id = _id, .name = #_name, .des = #_des},
+
+/**
+ * Marks the end of command options definition.
+ */
+#define CMD_OPTIONS_NODE_END    {0},};
+
+void msh_opt_list_dump(void *options);
+int msh_cmd_opt_id_get(int argc, char *argv[], void *options);
+#define MSH_OPT_ID_GET(fun) msh_cmd_opt_id_get(argc, argv, (void*) fun##_msh_options)
+#define MSH_OPT_DUMP(fun)   msh_opt_list_dump((void*) fun##_msh_options)
+
+#else
+#define CMD_OPTIONS_STATEMENT(command)
+#define CMD_OPTIONS_NODE_START(command)
+#define CMD_OPTIONS_NODE(_id, _name, _des)
+#define CMD_OPTIONS_NODE_END
+#define MSH_OPT_ID_GET(fun) ((int)(-1UL))
+#define MSH_OPT_DUMP(fun)   do{}while(0)
+#endif
+
+extern struct finsh_syscall_item *global_syscall_list;
+extern struct finsh_syscall *_syscall_table_begin, *_syscall_table_end;
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && defined(__x86_64__))
+    struct finsh_syscall *finsh_syscall_next(struct finsh_syscall *call);
+    #define FINSH_NEXT_SYSCALL(index)  index=finsh_syscall_next(index)
+#else
+    #define FINSH_NEXT_SYSCALL(index)  index++
+#endif
+
+#if !defined(RT_USING_POSIX_STDIO) && defined(RT_USING_DEVICE)
+void finsh_set_device(const char *device_name);
+#endif
+
+#endif

rt-thread/components/finsh/msh.h

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2013-03-30     Bernard      the first verion for FinSH
+ */
+
+#ifndef __M_SHELL__
+#define __M_SHELL__
+
+#include <rtthread.h>
+
+int msh_exec(char *cmd, rt_size_t length);
+void msh_auto_complete(char *prefix);
+
+int msh_exec_module(const char *cmd_line, int size);
+int msh_exec_script(const char *cmd_line, int size);
+
+#ifdef FINSH_USING_OPTION_COMPLETION
+void msh_opt_auto_complete(char *prefix);
+
+#endif /* FINSH_USING_OPTION_COMPLETION */
+#endif

rt-thread/components/finsh/msh_parse.c

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2022-05-25     WangQiang    the first verion for msh parse
+ */
+
+#include <rtthread.h>
+#include <ctype.h>
+
+#define forstrloop(str) for (; '\0' != *(str); (str)++)
+
+/**
+ * This function will check integer.
+ *
+ * @param strvalue string
+ *
+ * @return true or false
+ */
+rt_bool_t msh_isint(char *strvalue)
+{
+    if ((RT_NULL == strvalue) || ('\0' == strvalue[0]))
+    {
+        return RT_FALSE;
+    }
+    if (('+' == *strvalue) || ('-' == *strvalue))
+    {
+        strvalue++;
+    }
+    forstrloop(strvalue)
+    {
+        if (!isdigit((int)(*strvalue)))
+        {
+            return RT_FALSE;
+        }
+    }
+    return RT_TRUE;
+}
+
+/**
+ * This function will check hex.
+ *
+ * @param strvalue string
+ *
+ * @return true or false
+ */
+rt_bool_t msh_ishex(char *strvalue)
+{
+    int c;
+    if ((RT_NULL == strvalue) || ('\0' == strvalue[0]))
+    {
+        return RT_FALSE;
+    }
+    if ('0' != *(strvalue++))
+    {
+        return RT_FALSE;
+    }
+    if ('x' != *(strvalue++))
+    {
+        return RT_FALSE;
+    }
+
+    forstrloop(strvalue)
+    {
+        c = tolower(*strvalue);
+        if (!isxdigit(c))
+        {
+            return RT_FALSE;
+        }
+    }
+    return RT_TRUE;
+}
+
+/**
+ * This function will transform for string to hex.
+ *
+ * @param strvalue string
+ *
+ * @return integer transformed from string
+ */
+int msh_strtohex(char *strvalue)
+{
+    char c = 0;
+    int value = 0;
+    strvalue += 2;
+    forstrloop(strvalue)
+    {
+        value *= 16;
+        c = tolower(*strvalue);
+        value += isdigit(c) ? c - '0' : c - 'a' + 10;
+    }
+    return value;
+}

rt-thread/components/finsh/msh_parse.h

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2022-05-25     WangQiang    the first verion for msh parse
+ */
+
+#ifndef MSH_PARSE_H
+#define MSH_PARSE_H
+
+#include <rtdef.h>
+
+rt_bool_t msh_isint(char *strvalue);
+rt_bool_t msh_ishex(char *strvalue);
+int msh_strtohex(char *strvalue);
+
+#endif /* MSH_PARSE_H */

rt-thread/components/finsh/shell.c

@@ -0,0 +1,829 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2006-04-30     Bernard      the first version for FinSH
+ * 2006-05-08     Bernard      change finsh thread stack to 2048
+ * 2006-06-03     Bernard      add support for skyeye
+ * 2006-09-24     Bernard      remove the code related with hardware
+ * 2010-01-18     Bernard      fix down then up key bug.
+ * 2010-03-19     Bernard      fix backspace issue and fix device read in shell.
+ * 2010-04-01     Bernard      add prompt output when start and remove the empty history
+ * 2011-02-23     Bernard      fix variable section end issue of finsh shell
+ *                             initialization when use GNU GCC compiler.
+ * 2016-11-26     armink       add password authentication
+ * 2018-07-02     aozima       add custom prompt support.
+ */
+
+#include <rthw.h>
+#include <string.h>
+#include <stdio.h>
+
+#ifdef RT_USING_FINSH
+
+#include "shell.h"
+#include "msh.h"
+
+#ifdef DFS_USING_POSIX
+#include <unistd.h>
+#include <fcntl.h>
+#endif /* DFS_USING_POSIX */
+
+/* finsh thread */
+#ifndef RT_USING_HEAP
+    static struct rt_thread finsh_thread;
+    rt_align(RT_ALIGN_SIZE)
+    static char finsh_thread_stack[FINSH_THREAD_STACK_SIZE];
+    struct finsh_shell _shell;
+#endif
+
+/* finsh symtab */
+#ifdef FINSH_USING_SYMTAB
+    struct finsh_syscall *_syscall_table_begin  = NULL;
+    struct finsh_syscall *_syscall_table_end    = NULL;
+#endif
+
+struct finsh_shell *shell;
+static char *finsh_prompt_custom = RT_NULL;
+
+#if defined(_MSC_VER) || (defined(__GNUC__) && defined(__x86_64__))
+struct finsh_syscall *finsh_syscall_next(struct finsh_syscall *call)
+{
+    unsigned int *ptr;
+    ptr = (unsigned int *)(call + 1);
+    while ((*ptr == 0) && ((unsigned int *)ptr < (unsigned int *) _syscall_table_end))
+        ptr ++;
+
+    return (struct finsh_syscall *)ptr;
+}
+
+#endif /* defined(_MSC_VER) || (defined(__GNUC__) && defined(__x86_64__)) */
+
+#ifdef RT_USING_HEAP
+int finsh_set_prompt(const char *prompt)
+{
+    if (finsh_prompt_custom)
+    {
+        rt_free(finsh_prompt_custom);
+        finsh_prompt_custom = RT_NULL;
+    }
+
+    /* strdup */
+    if (prompt)
+    {
+        finsh_prompt_custom = (char *)rt_malloc(strlen(prompt) + 1);
+        if (finsh_prompt_custom)
+        {
+            strcpy(finsh_prompt_custom, prompt);
+        }
+    }
+
+    return 0;
+}
+#endif /* RT_USING_HEAP */
+
+#define _MSH_PROMPT "msh "
+
+const char *finsh_get_prompt(void)
+{
+    static char finsh_prompt[RT_CONSOLEBUF_SIZE + 1] = {0};
+
+    /* check prompt mode */
+    if (!shell->prompt_mode)
+    {
+        finsh_prompt[0] = '\0';
+        return finsh_prompt;
+    }
+
+    if (finsh_prompt_custom)
+    {
+        strncpy(finsh_prompt, finsh_prompt_custom, sizeof(finsh_prompt) - 1);
+    }
+    else
+    {
+        strcpy(finsh_prompt, _MSH_PROMPT);
+    }
+
+#if defined(DFS_USING_POSIX) && defined(DFS_USING_WORKDIR)
+    /* get current working directory */
+    getcwd(&finsh_prompt[rt_strlen(finsh_prompt)], RT_CONSOLEBUF_SIZE - rt_strlen(finsh_prompt));
+#endif
+
+    if (rt_strlen(finsh_prompt) + 2 < RT_CONSOLEBUF_SIZE)
+    {
+        finsh_prompt[rt_strlen(finsh_prompt)] = '>';
+        finsh_prompt[rt_strlen(finsh_prompt) + 1] = '\0';
+    }
+
+    return finsh_prompt;
+}
+
+/**
+ * @ingroup finsh
+ *
+ * This function get the prompt mode of finsh shell.
+ *
+ * @return prompt the prompt mode, 0 disable prompt mode, other values enable prompt mode.
+ */
+rt_uint32_t finsh_get_prompt_mode(void)
+{
+    RT_ASSERT(shell != RT_NULL);
+    return shell->prompt_mode;
+}
+
+/**
+ * @ingroup finsh
+ *
+ * This function set the prompt mode of finsh shell.
+ *
+ * The parameter 0 disable prompt mode, other values enable prompt mode.
+ *
+ * @param prompt_mode the prompt mode
+ */
+void finsh_set_prompt_mode(rt_uint32_t prompt_mode)
+{
+    RT_ASSERT(shell != RT_NULL);
+    shell->prompt_mode = prompt_mode;
+}
+
+int finsh_getchar(void)
+{
+#ifdef RT_USING_DEVICE
+    char ch = 0;
+#ifdef RT_USING_POSIX_STDIO
+    if(read(STDIN_FILENO, &ch, 1) > 0)
+    {
+        return ch;
+    }
+    else
+    {
+        return -1; /* EOF */
+    }
+#else
+    rt_device_t device;
+
+    RT_ASSERT(shell != RT_NULL);
+
+    device = shell->device;
+    if (device == RT_NULL)
+    {
+        return -1; /* EOF */
+    }
+
+    while (rt_device_read(device, -1, &ch, 1) != 1)
+    {
+        rt_sem_take(&shell->rx_sem, RT_WAITING_FOREVER);
+        if (shell->device != device)
+        {
+            device = shell->device;
+            if (device == RT_NULL)
+            {
+                return -1;
+            }
+        }
+    }
+    return ch;
+#endif /* RT_USING_POSIX_STDIO */
+#else
+    extern char rt_hw_console_getchar(void);
+    return rt_hw_console_getchar();
+#endif /* RT_USING_DEVICE */
+}
+
+#if !defined(RT_USING_POSIX_STDIO) && defined(RT_USING_DEVICE)
+static rt_err_t finsh_rx_ind(rt_device_t dev, rt_size_t size)
+{
+    RT_ASSERT(shell != RT_NULL);
+
+    /* release semaphore to let finsh thread rx data */
+    rt_sem_release(&shell->rx_sem);
+
+    return RT_EOK;
+}
+
+/**
+ * @ingroup finsh
+ *
+ * This function sets the input device of finsh shell.
+ *
+ * @param device_name the name of new input device.
+ */
+void finsh_set_device(const char *device_name)
+{
+    rt_device_t dev = RT_NULL;
+
+    RT_ASSERT(shell != RT_NULL);
+    dev = rt_device_find(device_name);
+    if (dev == RT_NULL)
+    {
+        rt_kprintf("finsh: can not find device: %s\n", device_name);
+        return;
+    }
+
+    /* check whether it's a same device */
+    if (dev == shell->device) return;
+    /* open this device and set the new device in finsh shell */
+    if (rt_device_open(dev, RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX | \
+                       RT_DEVICE_FLAG_STREAM) == RT_EOK)
+    {
+        if (shell->device != RT_NULL)
+        {
+            /* close old finsh device */
+            rt_device_close(shell->device);
+            rt_device_set_rx_indicate(shell->device, RT_NULL);
+        }
+
+        /* clear line buffer before switch to new device */
+        rt_memset(shell->line, 0, sizeof(shell->line));
+        shell->line_curpos = shell->line_position = 0;
+
+        shell->device = dev;
+        rt_device_set_rx_indicate(dev, finsh_rx_ind);
+    }
+}
+
+/**
+ * @ingroup finsh
+ *
+ * This function returns current finsh shell input device.
+ *
+ * @return the finsh shell input device name is returned.
+ */
+const char *finsh_get_device()
+{
+    RT_ASSERT(shell != RT_NULL);
+    return shell->device->parent.name;
+}
+#endif /* !defined(RT_USING_POSIX_STDIO) && defined(RT_USING_DEVICE) */
+
+/**
+ * @ingroup finsh
+ *
+ * This function set the echo mode of finsh shell.
+ *
+ * FINSH_OPTION_ECHO=0x01 is echo mode, other values are none-echo mode.
+ *
+ * @param echo the echo mode
+ */
+void finsh_set_echo(rt_uint32_t echo)
+{
+    RT_ASSERT(shell != RT_NULL);
+    shell->echo_mode = (rt_uint8_t)echo;
+}
+
+/**
+ * @ingroup finsh
+ *
+ * This function gets the echo mode of finsh shell.
+ *
+ * @return the echo mode
+ */
+rt_uint32_t finsh_get_echo()
+{
+    RT_ASSERT(shell != RT_NULL);
+
+    return shell->echo_mode;
+}
+
+#ifdef FINSH_USING_AUTH
+/**
+ * set a new password for finsh
+ *
+ * @param password new password
+ *
+ * @return result, RT_EOK on OK, -RT_ERROR on the new password length is less than
+ *  FINSH_PASSWORD_MIN or greater than FINSH_PASSWORD_MAX
+ */
+rt_err_t finsh_set_password(const char *password)
+{
+    rt_base_t level;
+    rt_size_t pw_len = rt_strlen(password);
+
+    if (pw_len < FINSH_PASSWORD_MIN || pw_len > FINSH_PASSWORD_MAX)
+        return -RT_ERROR;
+
+    level = rt_hw_interrupt_disable();
+    rt_strncpy(shell->password, password, FINSH_PASSWORD_MAX);
+    rt_hw_interrupt_enable(level);
+
+    return RT_EOK;
+}
+
+/**
+ * get the finsh password
+ *
+ * @return password
+ */
+const char *finsh_get_password(void)
+{
+    return shell->password;
+}
+
+static void finsh_wait_auth(void)
+{
+    int ch;
+    rt_bool_t input_finish = RT_FALSE;
+    char password[FINSH_PASSWORD_MAX] = { 0 };
+    rt_size_t cur_pos = 0;
+    /* password not set */
+    if (rt_strlen(finsh_get_password()) == 0) return;
+
+    while (1)
+    {
+        rt_kprintf("Password for login: ");
+        while (!input_finish)
+        {
+            while (1)
+            {
+                /* read one character from device */
+                ch = (int)finsh_getchar();
+                if (ch < 0)
+                {
+                    continue;
+                }
+
+                if (ch >= ' ' && ch <= '~' && cur_pos < FINSH_PASSWORD_MAX)
+                {
+                    /* change the printable characters to '*' */
+                    rt_kprintf("*");
+                    password[cur_pos++] = ch;
+                }
+                else if (ch == '\b' && cur_pos > 0)
+                {
+                    /* backspace */
+                    cur_pos--;
+                    password[cur_pos] = '\0';
+                    rt_kprintf("\b \b");
+                }
+                else if (ch == '\r' || ch == '\n')
+                {
+                    rt_kprintf("\n");
+                    input_finish = RT_TRUE;
+                    break;
+                }
+            }
+        }
+        if (!rt_strncmp(shell->password, password, FINSH_PASSWORD_MAX)) return;
+        else
+        {
+            /* authentication failed, delay 2S for retry */
+            rt_thread_delay(2 * RT_TICK_PER_SECOND);
+            rt_kprintf("Sorry, try again.\n");
+            cur_pos = 0;
+            input_finish = RT_FALSE;
+            rt_memset(password, '\0', FINSH_PASSWORD_MAX);
+        }
+    }
+}
+#endif /* FINSH_USING_AUTH */
+
+static void shell_auto_complete(char *prefix)
+{
+    rt_kprintf("\n");
+    msh_auto_complete(prefix);
+
+#ifdef FINSH_USING_OPTION_COMPLETION
+    msh_opt_auto_complete(prefix);
+#endif
+
+    rt_kprintf("%s%s", FINSH_PROMPT, prefix);
+}
+
+#ifdef FINSH_USING_HISTORY
+static rt_bool_t shell_handle_history(struct finsh_shell *shell)
+{
+#if defined(_WIN32)
+    int i;
+    rt_kprintf("\r");
+
+    for (i = 0; i <= 60; i++)
+        putchar(' ');
+    rt_kprintf("\r");
+
+#else
+    rt_kprintf("\033[2K\r");
+#endif
+    rt_kprintf("%s%s", FINSH_PROMPT, shell->line);
+    return RT_FALSE;
+}
+
+static void shell_push_history(struct finsh_shell *shell)
+{
+    if (shell->line_position != 0)
+    {
+        /* push history */
+        if (shell->history_count >= FINSH_HISTORY_LINES)
+        {
+            /* if current cmd is same as last cmd, don't push */
+            if (memcmp(&shell->cmd_history[FINSH_HISTORY_LINES - 1], shell->line, FINSH_CMD_SIZE))
+            {
+                /* move history */
+                int index;
+                for (index = 0; index < FINSH_HISTORY_LINES - 1; index ++)
+                {
+                    rt_memcpy(&shell->cmd_history[index][0],
+                           &shell->cmd_history[index + 1][0], FINSH_CMD_SIZE);
+                }
+                rt_memset(&shell->cmd_history[index][0], 0, FINSH_CMD_SIZE);
+                rt_memcpy(&shell->cmd_history[index][0], shell->line, shell->line_position);
+
+                /* it's the maximum history */
+                shell->history_count = FINSH_HISTORY_LINES;
+            }
+        }
+        else
+        {
+            /* if current cmd is same as last cmd, don't push */
+            if (shell->history_count == 0 || memcmp(&shell->cmd_history[shell->history_count - 1], shell->line, FINSH_CMD_SIZE))
+            {
+                shell->current_history = shell->history_count;
+                rt_memset(&shell->cmd_history[shell->history_count][0], 0, FINSH_CMD_SIZE);
+                rt_memcpy(&shell->cmd_history[shell->history_count][0], shell->line, shell->line_position);
+
+                /* increase count and set current history position */
+                shell->history_count ++;
+            }
+        }
+    }
+    shell->current_history = shell->history_count;
+}
+#endif
+
+#ifdef RT_USING_HOOK
+static void (*_finsh_thread_entry_hook)(void);
+
+/**
+ * @ingroup finsh
+ *
+ * @brief This function set a hook function at the entry of finsh thread
+ *
+ * @param hook the function point to be called
+ */
+void finsh_thread_entry_sethook(void (*hook)(void))
+{
+    _finsh_thread_entry_hook = hook;
+}
+#endif /* RT_USING_HOOK */
+
+static void finsh_thread_entry(void *parameter)
+{
+    int ch;
+
+    RT_OBJECT_HOOK_CALL(_finsh_thread_entry_hook, ());
+
+    /* normal is echo mode */
+#ifndef FINSH_ECHO_DISABLE_DEFAULT
+    shell->echo_mode = 1;
+#else
+    shell->echo_mode = 0;
+#endif
+
+#if !defined(RT_USING_POSIX_STDIO) && defined(RT_USING_DEVICE)
+    /* set console device as shell device */
+    if (shell->device == RT_NULL)
+    {
+        rt_device_t console = rt_console_get_device();
+        if (console)
+        {
+            finsh_set_device(console->parent.name);
+        }
+    }
+#endif /* !defined(RT_USING_POSIX_STDIO) && defined(RT_USING_DEVICE) */
+
+#ifdef FINSH_USING_AUTH
+    /* set the default password when the password isn't setting */
+    if (rt_strlen(finsh_get_password()) == 0)
+    {
+        if (finsh_set_password(FINSH_DEFAULT_PASSWORD) != RT_EOK)
+        {
+            rt_kprintf("Finsh password set failed.\n");
+        }
+    }
+    /* waiting authenticate success */
+    finsh_wait_auth();
+#endif
+
+    rt_kprintf(FINSH_PROMPT);
+
+    while (1)
+    {
+        ch = (int)finsh_getchar();
+        if (ch < 0)
+        {
+            continue;
+        }
+
+        /*
+         * handle control key
+         * up key  : 0x1b 0x5b 0x41
+         * down key: 0x1b 0x5b 0x42
+         * right key:0x1b 0x5b 0x43
+         * left key: 0x1b 0x5b 0x44
+         */
+        if (ch == 0x1b)
+        {
+            shell->stat = WAIT_SPEC_KEY;
+            continue;
+        }
+        else if (shell->stat == WAIT_SPEC_KEY)
+        {
+            if (ch == 0x5b)
+            {
+                shell->stat = WAIT_FUNC_KEY;
+                continue;
+            }
+
+            shell->stat = WAIT_NORMAL;
+        }
+        else if (shell->stat == WAIT_FUNC_KEY)
+        {
+            shell->stat = WAIT_NORMAL;
+
+            if (ch == 0x41) /* up key */
+            {
+#ifdef FINSH_USING_HISTORY
+                /* prev history */
+                if (shell->current_history > 0)
+                    shell->current_history --;
+                else
+                {
+                    shell->current_history = 0;
+                    continue;
+                }
+
+                /* copy the history command */
+                rt_memcpy(shell->line, &shell->cmd_history[shell->current_history][0],
+                       FINSH_CMD_SIZE);
+                shell->line_curpos = shell->line_position = (rt_uint16_t)strlen(shell->line);
+                shell_handle_history(shell);
+#endif
+                continue;
+            }
+            else if (ch == 0x42) /* down key */
+            {
+#ifdef FINSH_USING_HISTORY
+                /* next history */
+                if (shell->current_history < shell->history_count - 1)
+                    shell->current_history ++;
+                else
+                {
+                    /* set to the end of history */
+                    if (shell->history_count != 0)
+                        shell->current_history = shell->history_count - 1;
+                    else
+                        continue;
+                }
+
+                rt_memcpy(shell->line, &shell->cmd_history[shell->current_history][0],
+                       FINSH_CMD_SIZE);
+                shell->line_curpos = shell->line_position = (rt_uint16_t)strlen(shell->line);
+                shell_handle_history(shell);
+#endif
+                continue;
+            }
+            else if (ch == 0x44) /* left key */
+            {
+                if (shell->line_curpos)
+                {
+                    rt_kprintf("\b");
+                    shell->line_curpos --;
+                }
+
+                continue;
+            }
+            else if (ch == 0x43) /* right key */
+            {
+                if (shell->line_curpos < shell->line_position)
+                {
+                    rt_kprintf("%c", shell->line[shell->line_curpos]);
+                    shell->line_curpos ++;
+                }
+
+                continue;
+            }
+        }
+
+        /* received null or error */
+        if (ch == '\0' || ch == 0xFF) continue;
+        /* handle tab key */
+        else if (ch == '\t')
+        {
+            int i;
+            /* move the cursor to the beginning of line */
+            for (i = 0; i < shell->line_curpos; i++)
+                rt_kprintf("\b");
+
+            /* auto complete */
+            shell_auto_complete(&shell->line[0]);
+            /* re-calculate position */
+            shell->line_curpos = shell->line_position = (rt_uint16_t)strlen(shell->line);
+
+            continue;
+        }
+        /* handle backspace key */
+        else if (ch == 0x7f || ch == 0x08)
+        {
+            /* note that shell->line_curpos >= 0 */
+            if (shell->line_curpos == 0)
+                continue;
+
+            shell->line_position--;
+            shell->line_curpos--;
+
+            if (shell->line_position > shell->line_curpos)
+            {
+                int i;
+
+                rt_memmove(&shell->line[shell->line_curpos],
+                           &shell->line[shell->line_curpos + 1],
+                           shell->line_position - shell->line_curpos);
+                shell->line[shell->line_position] = 0;
+
+                rt_kprintf("\b%s  \b", &shell->line[shell->line_curpos]);
+
+                /* move the cursor to the origin position */
+                for (i = shell->line_curpos; i <= shell->line_position; i++)
+                    rt_kprintf("\b");
+            }
+            else
+            {
+                rt_kprintf("\b \b");
+                shell->line[shell->line_position] = 0;
+            }
+
+            continue;
+        }
+
+        /* handle end of line, break */
+        if (ch == '\r' || ch == '\n')
+        {
+#ifdef FINSH_USING_HISTORY
+            shell_push_history(shell);
+#endif
+            if (shell->echo_mode)
+                rt_kprintf("\n");
+            msh_exec(shell->line, shell->line_position);
+
+            rt_kprintf(FINSH_PROMPT);
+            rt_memset(shell->line, 0, sizeof(shell->line));
+            shell->line_curpos = shell->line_position = 0;
+            continue;
+        }
+
+        /* it's a large line, discard it */
+        if (shell->line_position >= FINSH_CMD_SIZE)
+            shell->line_position = 0;
+
+        /* normal character */
+        if (shell->line_curpos < shell->line_position)
+        {
+            int i;
+
+            rt_memmove(&shell->line[shell->line_curpos + 1],
+                       &shell->line[shell->line_curpos],
+                       shell->line_position - shell->line_curpos);
+            shell->line[shell->line_curpos] = ch;
+            if (shell->echo_mode)
+                rt_kprintf("%s", &shell->line[shell->line_curpos]);
+
+            /* move the cursor to new position */
+            for (i = shell->line_curpos; i < shell->line_position; i++)
+                rt_kprintf("\b");
+        }
+        else
+        {
+            shell->line[shell->line_position] = ch;
+            if (shell->echo_mode)
+                rt_kprintf("%c", ch);
+        }
+
+        ch = 0;
+        shell->line_position ++;
+        shell->line_curpos++;
+        if (shell->line_position >= FINSH_CMD_SIZE)
+        {
+            /* clear command line */
+            shell->line_position = 0;
+            shell->line_curpos = 0;
+        }
+    } /* end of device read */
+}
+
+static void finsh_system_function_init(const void *begin, const void *end)
+{
+    _syscall_table_begin = (struct finsh_syscall *) begin;
+    _syscall_table_end = (struct finsh_syscall *) end;
+}
+
+#if defined(__ICCARM__) || defined(__ICCRX__)               /* for IAR compiler */
+#ifdef FINSH_USING_SYMTAB
+    #pragma section="FSymTab"
+#endif
+#elif defined(__ADSPBLACKFIN__) /* for VisaulDSP++ Compiler*/
+#ifdef FINSH_USING_SYMTAB
+    extern "asm" int __fsymtab_start;
+    extern "asm" int __fsymtab_end;
+#endif
+#elif defined(_MSC_VER)
+#pragma section("FSymTab$a", read)
+const char __fsym_begin_name[] = "__start";
+const char __fsym_begin_desc[] = "begin of finsh";
+__declspec(allocate("FSymTab$a")) const struct finsh_syscall __fsym_begin =
+{
+    __fsym_begin_name,
+    __fsym_begin_desc,
+    NULL
+};
+
+#pragma section("FSymTab$z", read)
+const char __fsym_end_name[] = "__end";
+const char __fsym_end_desc[] = "end of finsh";
+__declspec(allocate("FSymTab$z")) const struct finsh_syscall __fsym_end =
+{
+    __fsym_end_name,
+    __fsym_end_desc,
+    NULL
+};
+#endif
+
+/*
+ * @ingroup finsh
+ *
+ * This function will initialize finsh shell
+ */
+int finsh_system_init(void)
+{
+    rt_err_t result = RT_EOK;
+    rt_thread_t tid;
+
+#ifdef FINSH_USING_SYMTAB
+#ifdef __ARMCC_VERSION  /* ARM C Compiler */
+    extern const int FSymTab$$Base;
+    extern const int FSymTab$$Limit;
+    finsh_system_function_init(&FSymTab$$Base, &FSymTab$$Limit);
+#elif defined (__ICCARM__) || defined(__ICCRX__)      /* for IAR Compiler */
+    finsh_system_function_init(__section_begin("FSymTab"),
+                               __section_end("FSymTab"));
+#elif defined (__GNUC__) || defined(__TI_COMPILER_VERSION__) || defined(__TASKING__)
+    /* GNU GCC Compiler and TI CCS */
+    extern const int __fsymtab_start;
+    extern const int __fsymtab_end;
+    finsh_system_function_init(&__fsymtab_start, &__fsymtab_end);
+#elif defined(__ADSPBLACKFIN__) /* for VisualDSP++ Compiler */
+    finsh_system_function_init(&__fsymtab_start, &__fsymtab_end);
+#elif defined(_MSC_VER)
+    unsigned int *ptr_begin, *ptr_end;
+
+    if (shell)
+    {
+        rt_kprintf("finsh shell already init.\n");
+        return RT_EOK;
+    }
+
+    ptr_begin = (unsigned int *)&__fsym_begin;
+    ptr_begin += (sizeof(struct finsh_syscall) / sizeof(unsigned int));
+    while (*ptr_begin == 0) ptr_begin ++;
+
+    ptr_end = (unsigned int *) &__fsym_end;
+    ptr_end --;
+    while (*ptr_end == 0) ptr_end --;
+
+    finsh_system_function_init(ptr_begin, ptr_end);
+#endif
+#endif
+
+#ifdef RT_USING_HEAP
+    /* create or set shell structure */
+    shell = (struct finsh_shell *)rt_calloc(1, sizeof(struct finsh_shell));
+    if (shell == RT_NULL)
+    {
+        rt_kprintf("no memory for shell\n");
+        return -1;
+    }
+    tid = rt_thread_create(FINSH_THREAD_NAME,
+                           finsh_thread_entry, RT_NULL,
+                           FINSH_THREAD_STACK_SIZE, FINSH_THREAD_PRIORITY, 10);
+#else
+    shell = &_shell;
+    tid = &finsh_thread;
+    result = rt_thread_init(&finsh_thread,
+                            FINSH_THREAD_NAME,
+                            finsh_thread_entry, RT_NULL,
+                            &finsh_thread_stack[0], sizeof(finsh_thread_stack),
+                            FINSH_THREAD_PRIORITY, 10);
+#endif /* RT_USING_HEAP */
+
+    rt_sem_init(&(shell->rx_sem), "shrx", 0, 0);
+    finsh_set_prompt_mode(1);
+
+    if (tid != NULL && result == RT_EOK)
+        rt_thread_startup(tid);
+    return 0;
+}
+INIT_APP_EXPORT(finsh_system_init);
+
+#endif /* RT_USING_FINSH */
+

rt-thread/components/finsh/shell.h

@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2011-06-02     Bernard      Add finsh_get_prompt function declaration
+ */
+
+#ifndef __SHELL_H__
+#define __SHELL_H__
+
+#include <rtthread.h>
+#include "finsh.h"
+
+#ifndef FINSH_THREAD_PRIORITY
+    #define FINSH_THREAD_PRIORITY 20
+#endif
+#ifndef FINSH_THREAD_STACK_SIZE
+    #define FINSH_THREAD_STACK_SIZE 2048
+#endif
+#ifndef FINSH_CMD_SIZE
+    #define FINSH_CMD_SIZE      80
+#endif
+
+#define FINSH_OPTION_ECHO   0x01
+
+#define FINSH_PROMPT        finsh_get_prompt()
+const char *finsh_get_prompt(void);
+int finsh_set_prompt(const char *prompt);
+
+#ifdef FINSH_USING_HISTORY
+    #ifndef FINSH_HISTORY_LINES
+        #define FINSH_HISTORY_LINES 5
+    #endif
+#endif
+
+#ifdef FINSH_USING_AUTH
+    #ifndef FINSH_PASSWORD_MAX
+        #define FINSH_PASSWORD_MAX RT_NAME_MAX
+    #endif
+    #ifndef FINSH_PASSWORD_MIN
+        #define FINSH_PASSWORD_MIN 6
+    #endif
+    #ifndef FINSH_DEFAULT_PASSWORD
+        #define FINSH_DEFAULT_PASSWORD "rtthread"
+    #endif
+#endif /* FINSH_USING_AUTH */
+
+#ifndef FINSH_THREAD_NAME
+    #define FINSH_THREAD_NAME   "tshell"
+#endif
+
+enum input_stat
+{
+    WAIT_NORMAL,
+    WAIT_SPEC_KEY,
+    WAIT_FUNC_KEY,
+};
+struct finsh_shell
+{
+    struct rt_semaphore rx_sem;
+
+    enum input_stat stat;
+
+    rt_uint8_t echo_mode: 1;
+    rt_uint8_t prompt_mode: 1;
+
+#ifdef FINSH_USING_HISTORY
+    rt_uint16_t current_history;
+    rt_uint16_t history_count;
+
+    char cmd_history[FINSH_HISTORY_LINES][FINSH_CMD_SIZE];
+#endif
+
+    char line[FINSH_CMD_SIZE + 1];
+    rt_uint16_t line_position;
+    rt_uint16_t line_curpos;
+
+#if !defined(RT_USING_POSIX_STDIO) && defined(RT_USING_DEVICE)
+    rt_device_t device;
+#endif
+
+#ifdef FINSH_USING_AUTH
+    char password[FINSH_PASSWORD_MAX];
+#endif
+};
+
+void finsh_set_echo(rt_uint32_t echo);
+rt_uint32_t finsh_get_echo(void);
+
+int finsh_system_init(void);
+const char *finsh_get_device(void);
+int finsh_getchar(void);
+
+rt_uint32_t finsh_get_prompt_mode(void);
+void finsh_set_prompt_mode(rt_uint32_t prompt_mode);
+
+#ifdef FINSH_USING_AUTH
+    rt_err_t finsh_set_password(const char *password);
+    const char *finsh_get_password(void);
+#endif
+
+#ifdef RT_USING_HOOK
+void finsh_thread_entry_sethook(void (*hook)(void));
+#endif /* RT_USING_HOOK */
+
+#endif