shcmd.c 文件参考

浏览源代码.

函数
	LOS_HAL_TABLE_BEGIN (g_shellcmd, shellcmd)
	LOS_HAL_TABLE_END (g_shellcmdEnd, shellcmd)
CmdModInfo *	OsCmdInfoGet (VOID)
	获取全局变量 更多...
STATIC VOID	OsFreeCmdPara (CmdParsed *cmdParsed)
	释放命令行参数所占内存 更多...
STATIC INT32	OsStrSeparateTabStrGet (CHAR **tabStr, CmdParsed *parsed, UINT32 tabStrLen)
STATIC INT32	OsStrSeparate (CHAR *tabStr, CHAR *strPath, CHAR *nameLooking, UINT32 tabStrLen)
STATIC INT32	OsShowPageInputControl (VOID)
	输出内容 更多...
STATIC INT32	OsShowPageControl (UINT32 timesPrint, UINT32 lineCap, UINT32 count)
	显示页内容控制器 更多...
STATIC INT32	OsSurePrintAll (UINT32 count)
	是否打印所有内容 更多...
STATIC INT32	OsPrintMatchList (UINT32 count, const CHAR *strPath, const CHAR *nameLooking, UINT32 printLen)
	打印匹配的列表数据 更多...
STATIC VOID	strncmp_cut (const CHAR *s1, CHAR *s2, size_t n)
STATIC INT32	OsExecNameMatch (const CHAR *strPath, const CHAR *nameLooking, CHAR *strObj, UINT32 *maxLen)
STATIC VOID	OsCompleteStr (const CHAR *result, const CHAR *target, CHAR *cmdKey, UINT32 *len)
STATIC INT32	OsTabMatchCmd (CHAR *cmdKey, UINT32 *len)
	使用tab键去匹配命令 更多...
STATIC INT32	OsTabMatchFile (CHAR *cmdKey, UINT32 *len)
	使用tab键去匹配关键字文件 更多...
LITE_OS_SEC_TEXT_MINOR UINT32	OsCmdKeyShift (const CHAR *cmdKey, CHAR *cmdOut, UINT32 size)
LITE_OS_SEC_TEXT_MINOR BOOL	OsCmdKeyCheck (const CHAR *cmdKey)
	类型变量命名,必须是数字字母下划线,首字母不能是数字 更多...
LITE_OS_SEC_TEXT_MINOR INT32	OsTabCompletion (CHAR *cmdKey, UINT32 *len)
	tab键 更多...
LITE_OS_SEC_TEXT_MINOR VOID	OsCmdAscendingInsert (CmdItemNode *cmd)
	按升序插入到链表中 更多...
LITE_OS_SEC_TEXT_MINOR UINT32	OsShellKeyInit (ShellCB *shellCB)
	shell 命令初始化 更多...
LITE_OS_SEC_TEXT_MINOR VOID	OsShellKeyDeInit (CmdKeyLink *cmdKeyLink)
	shell的析构函数 更多...
LITE_OS_SEC_TEXT_MINOR UINT32	OsShellSysCmdRegister (VOID)
	注册系统自带的shell命令 更多...
LITE_OS_SEC_TEXT_MINOR VOID	OsShellCmdPush (const CHAR *string, CmdKeyLink *cmdKeyLink)
	将shell命令 string 以 CmdKeyLink 方式加入链表 更多...
LITE_OS_SEC_TEXT_MINOR VOID	OsShellHistoryShow (UINT32 value, ShellCB *shellCB)
	显示shell命令历史记录,支持上下键方式 更多...
LITE_OS_SEC_TEXT_MINOR UINT32	OsCmdExec (CmdParsed *cmdParsed, CHAR *cmdStr)
	执行命令,shell是运行程序的程序. 更多...
LITE_OS_SEC_TEXT_MINOR UINT32	OsCmdInit (VOID)
STATIC UINT32	OsCmdItemCreate (CmdType cmdType, const CHAR *cmdKey, UINT32 paraNum, CmdCallBackFunc cmdProc)
	创建一个命令项,例如 chmod 更多...
LITE_OS_SEC_TEXT_MINOR UINT32	osCmdReg (CmdType cmdType, const CHAR *cmdKey, UINT32 paraNum, CmdCallBackFunc cmdProc)
	osCmdReg 以动态方式注册命令 更多...

变量
STATIC CmdModInfo	g_cmdInfo
	shell 命令模块信息,上面挂了所有的命令项(ls,cd ,cp ==) 更多...

函数说明

LOS_HAL_TABLE_BEGIN()

LOS_HAL_TABLE_BEGIN	(	g_shellcmd	,
		shellcmd
	)

LOS_HAL_TABLE_END()

LOS_HAL_TABLE_END	(	g_shellcmdEnd	,
		shellcmd
	)

OsCmdAscendingInsert()

LITE_OS_SEC_TEXT_MINOR VOID OsCmdAscendingInsert

(

CmdItemNode *

cmd

)

按升序插入到链表中

在文件 shcmd.c 第 572 行定义.

{
    CmdItemNode *cmdItem = NULL;
    CmdItemNode *cmdNext = NULL;
 
    if (cmd == NULL) {
        return;
    }
    //遍历注册的命令项链表
    for (cmdItem = LOS_DL_LIST_ENTRY((&g_cmdInfo.cmdList.list)->pstPrev, CmdItemNode, list);
         &cmdItem->list != &(g_cmdInfo.cmdList.list);) {
        cmdNext = LOS_DL_LIST_ENTRY(cmdItem->list.pstPrev, CmdItemNode, list);//获取实体,一个个比较
        if (&cmdNext->list != &(g_cmdInfo.cmdList.list)) {
            if ((strncmp(cmdItem->cmd->cmdKey, cmd->cmd->cmdKey, strlen(cmd->cmd->cmdKey)) >= 0) &&
                (strncmp(cmdNext->cmd->cmdKey, cmd->cmd->cmdKey, strlen(cmd->cmd->cmdKey)) < 0)) {
                LOS_ListTailInsert(&(cmdItem->list), &(cmd->list));//从尾部插入
                return;
            }
            cmdItem = cmdNext;
        } else {
            if (strncmp(cmd->cmd->cmdKey, cmdItem->cmd->cmdKey, strlen(cmd->cmd->cmdKey)) > 0) {
                cmdItem = cmdNext;
            }
            break;
        }
    }
 
    LOS_ListTailInsert(&(cmdItem->list), &(cmd->list));
}

函数调用图:

这是这个函数的调用关系图:

OsCmdExec()

LITE_OS_SEC_TEXT_MINOR UINT32 OsCmdExec	(	CmdParsed *	cmdParsed,
		CHAR *	cmdStr
	)

执行命令,shell是运行程序的程序.

在文件 shcmd.c 第 744 行定义.

{
    UINT32 ret;
    CmdCallBackFunc cmdHook = NULL;
    CmdItemNode *curCmdItem = NULL;
    UINT32 i;
    const CHAR *cmdKey = NULL;
 
    if ((cmdParsed == NULL) || (cmdStr == NULL) || (strlen(cmdStr) == 0)) {
        return (UINT32)OS_ERROR;
    }
 
    ret = OsCmdParse(cmdStr, cmdParsed);//解析出命令关键字,参数
    if (ret != LOS_OK) {
        goto OUT;
    }
    //遍历命令注册全局链表
    LOS_DL_LIST_FOR_EACH_ENTRY(curCmdItem, &(g_cmdInfo.cmdList.list), CmdItemNode, list) {
        cmdKey = curCmdItem->cmd->cmdKey;
        if ((cmdParsed->cmdType == curCmdItem->cmd->cmdType) &&
            (strlen(cmdKey) == strlen(cmdParsed->cmdKeyword)) &&
            (strncmp(cmdKey, (CHAR *)(cmdParsed->cmdKeyword), strlen(cmdKey)) == 0)) {//找到命令的回调函数 例如: ls <-> osShellCmdLs
            cmdHook = curCmdItem->cmd->cmdHook;
            break;
        }
    }
 
    ret = OS_ERROR;
    if (cmdHook != NULL) {//执行命令,即回调函数
        ret = (cmdHook)(cmdParsed->paramCnt, (const CHAR **)cmdParsed->paramArray);
    }
 
OUT:
    for (i = 0; i < cmdParsed->paramCnt; i++) {//无效的命令要释放掉保存参数的内存
        if (cmdParsed->paramArray[i] != NULL) {
            (VOID)LOS_MemFree(m_aucSysMem0, cmdParsed->paramArray[i]);
            cmdParsed->paramArray[i] = NULL;
        }
    }
 
    return (UINT32)ret;
}

函数调用图:

这是这个函数的调用关系图:

OsCmdInfoGet()

CmdModInfo * OsCmdInfoGet

(

VOID

)

获取全局变量

在文件 shcmd.c 第 52 行定义.

{
    return &g_cmdInfo;
}

这是这个函数的调用关系图:

OsCmdInit()

LITE_OS_SEC_TEXT_MINOR UINT32 OsCmdInit

(

VOID

)

命令初始化,用于存放支持的命令,目前鸿蒙支持如下命令 arp cat cd chgrp chmod chown cp cpup
date dhclient dmesg dns format free help hwi
ifconfig ipdebug kill log ls lsfd memcheck mkdir
mount netstat oom partinfo partition ping ping6 pwd
reset rm rmdir sem statfs su swtmr sync
systeminfo task telnet test tftp touch umount uname
watch writeproc

在文件 shcmd.c 第 795 行定义.

{
    UINT32 ret;
    LOS_ListInit(&(g_cmdInfo.cmdList.list));//初始化双向链表
    g_cmdInfo.listNum = 0;  //命令数量
    g_cmdInfo.initMagicFlag = SHELL_INIT_MAGIC_FLAG;//魔法数字
    ret = LOS_MuxInit(&g_cmdInfo.muxLock, NULL);//初始化互斥量,确保链表安全访问
    if (ret != LOS_OK) {
        PRINT_ERR("Create mutex for shell cmd info failed\n");
        return OS_ERROR;
    }
    return LOS_OK;
}

函数调用图:

这是这个函数的调用关系图:

OsCmdItemCreate()

STATIC UINT32 OsCmdItemCreate	(	CmdType	cmdType,
		const CHAR *	cmdKey,
		UINT32	paraNum,
		CmdCallBackFunc	cmdProc
	)

创建一个命令项,例如 chmod

在文件 shcmd.c 第 809 行定义.

{
    CmdItem *cmdItem = NULL;
    CmdItemNode *cmdItemNode = NULL;
    //1.构造命令节点过程
    cmdItem = (CmdItem *)LOS_MemAlloc(m_aucSysMem0, sizeof(CmdItem));
    if (cmdItem == NULL) {
        return OS_ERRNO_SHELL_CMDREG_MEMALLOC_ERROR;
    }
    (VOID)memset_s(cmdItem, sizeof(CmdItem), '\0', sizeof(CmdItem));
 
    cmdItemNode = (CmdItemNode *)LOS_MemAlloc(m_aucSysMem0, sizeof(CmdItemNode));
    if (cmdItemNode == NULL) {
        (VOID)LOS_MemFree(m_aucSysMem0, cmdItem);
        return OS_ERRNO_SHELL_CMDREG_MEMALLOC_ERROR;
    }
    (VOID)memset_s(cmdItemNode, sizeof(CmdItemNode), '\0', sizeof(CmdItemNode));
    cmdItemNode->cmd = cmdItem;         //命令项 
    cmdItemNode->cmd->cmdHook = cmdProc;//回调函数 osShellCmdLs
    cmdItemNode->cmd->paraNum = paraNum;//`777`,'/home'
    cmdItemNode->cmd->cmdType = cmdType;//关键字类型
    cmdItemNode->cmd->cmdKey = cmdKey;  //`chmod`
    //2.完成构造后挂入全局链表
    (VOID)LOS_MuxLock(&g_cmdInfo.muxLock, LOS_WAIT_FOREVER);
    OsCmdAscendingInsert(cmdItemNode);//按升序方式插入
    g_cmdInfo.listNum++;//命令总数增加
    (VOID)LOS_MuxUnlock(&g_cmdInfo.muxLock);
 
    return LOS_OK;
}

函数调用图:

这是这个函数的调用关系图:

OsCmdKeyCheck()

LITE_OS_SEC_TEXT_MINOR BOOL OsCmdKeyCheck

(

const CHAR *

cmdKey

)

类型变量命名,必须是数字字母下划线,首字母不能是数字

在文件 shcmd.c 第 505 行定义.

{
    const CHAR *temp = cmdKey;
    enum Stat {
        STAT_NONE,  //普通
        STAT_DIGIT, //数字
        STAT_OTHER  //其余
    } state = STAT_NONE;
 
    if (strlen(cmdKey) >= CMD_KEY_LEN) {//长度不能超 16个字符
        return FALSE;
    }
    //命令只支持数字,字母,下划线,中划线
    while (*temp != '\0') {
        if (!((*temp <= '9') && (*temp >= '0')) &&
            !((*temp <= 'z') && (*temp >= 'a')) &&
            !((*temp <= 'Z') && (*temp >= 'A')) &&
            (*temp != '_') && (*temp != '-')) {
            return FALSE;
        }
        //数字
        if ((*temp >= '0') && (*temp <= '9')) {
            if (state == STAT_NONE) {
                state = STAT_DIGIT;
            }
        } else {
            state = STAT_OTHER;
        }
 
        temp++;
    }
 
    if (state == STAT_DIGIT) {
        return FALSE;
    }
 
    return TRUE;
}

这是这个函数的调用关系图:

OsCmdKeyShift()

LITE_OS_SEC_TEXT_MINOR UINT32 OsCmdKeyShift	(	const CHAR *	cmdKey,
		CHAR *	cmdOut,
		UINT32	size
	)

在文件 shcmd.c 第 439 行定义.

{
    CHAR *output = NULL;
    CHAR *outputBak = NULL;
    UINT32 len;
    INT32 ret;
    BOOL quotes = FALSE;
 
    if ((cmdKey == NULL) || (cmdOut == NULL)) {
        return (UINT32)OS_ERROR;
    }
 
    len = strlen(cmdKey);
    if (len >= size) {
        return (UINT32)OS_ERROR;
    }
    output = (CHAR*)LOS_MemAlloc(m_aucSysMem0, len + 1);
    if (output == NULL) {
        PRINTK("malloc failure in %s[%d]", __FUNCTION__, __LINE__);
        return (UINT32)OS_ERROR;
    }
    /* Backup the 'output' start address */
    outputBak = output;
    /* Scan each charactor in 'cmdKey',and squeeze the overmuch space and ignore invaild charactor */
    for (; *cmdKey != '\0'; cmdKey++) {
        /* Detected a Double Quotes, switch the matching status */
        if (*(cmdKey) == '\"') {
            SWITCH_QUOTES_STATUS(quotes);
        }
        /* Ignore the current charactor in following situation */
        /* 1) Quotes matching status is FALSE (which said that the space is not been marked by double quotes) */
        /* 2) Current charactor is a space */
        /* 3) Next charactor is a space too, or the string is been seeked to the end already(\0) */
        /* 4) Invaild charactor, such as single quotes */
        if ((*cmdKey == ' ') && ((*(cmdKey + 1) == ' ') || (*(cmdKey + 1) == '\0')) && QUOTES_STATUS_CLOSE(quotes)) {
            continue;
        }
        if (*cmdKey == '\'') {
            continue;
        }
        *output = *cmdKey;
        output++;
    }
    *output = '\0';
    /* Restore the 'output' start address */
    output = outputBak;
    len = strlen(output);
    /* Clear the space which is located at the first charactor in buffer */
    if (*outputBak == ' ') {
        output++;
        len--;
    }
    /* Copy out the buffer which is been operated already */
    ret = strncpy_s(cmdOut, size, output, len);
    if (ret != EOK) {
        PRINT_ERR("%s,%d strncpy_s failed, err:%d!\n", __FUNCTION__, __LINE__, ret);
        (VOID)LOS_MemFree(m_aucSysMem0, output);
        return OS_ERROR;
    }
    cmdOut[len] = '\0';
 
    (VOID)LOS_MemFree(m_aucSysMem0, output);
 
    return LOS_OK;
}

函数调用图:

这是这个函数的调用关系图:

osCmdReg()

LITE_OS_SEC_TEXT_MINOR UINT32 osCmdReg	(	CmdType	cmdType,
		const CHAR *	cmdKey,
		UINT32	paraNum,
		CmdCallBackFunc	cmdProc
	)

osCmdReg 以动态方式注册命令

以动态方式注册命令

参数

cmdKey	命令关键字，函数在Shell中访问的名称。
cmdProc	命令执行函数地址，即命令实际执行函数。
cmdType	CMD_TYPE_EX：不支持标准命令参数输入，会把用户填写的命令关键字屏蔽掉， 例如：输入ls /ramfs，传入给注册函数的参数只有/ramfs，而ls命令关键字并不会被传入。 CMD_TYPE_STD：支持的标准命令参数输入，所有输入的字符都会通过命令解析后被传入。
paraNum	调用的执行函数的入参最大个数，暂不支持该参数；当前为默认值XARGS(0xFFFFFFFF)。

注意

命令关键字必须是唯一的，也即两个不同的命令项不能拥有相同的命令关键字，否则只会执行其中一个。 Shell在执行用户命令时，如果存在多个命令关键字相同的命令，只会执行其中在"help"命令中排序在最前面的一个。

返回

参见

在文件 shcmd.c 第 856 行定义.

{
    CmdItemNode *cmdItemNode = NULL;
    //1.确保先拿到锁,魔法数字检查
    (VOID)LOS_MuxLock(&g_cmdInfo.muxLock, LOS_WAIT_FOREVER);
    if (g_cmdInfo.initMagicFlag != SHELL_INIT_MAGIC_FLAG) { //验证全局变量的有效性
        (VOID)LOS_MuxUnlock(&g_cmdInfo.muxLock);
        PRINT_ERR("[%s] shell is not yet initialized!\n", __FUNCTION__);
        return OS_ERRNO_SHELL_NOT_INIT;
    }
    (VOID)LOS_MuxUnlock(&g_cmdInfo.muxLock);
    //2.参数检查
    if ((cmdProc == NULL) || (cmdKey == NULL) ||
        (cmdType >= CMD_TYPE_BUTT) || (strlen(cmdKey) >= CMD_KEY_LEN) || !strlen(cmdKey)) {
        return OS_ERRNO_SHELL_CMDREG_PARA_ERROR;
    }
 
    if (paraNum > CMD_MAX_PARAS) {
        if (paraNum != XARGS) {
            return OS_ERRNO_SHELL_CMDREG_PARA_ERROR;
        }
    }
    //3.关键字检查 ;例如:'chmod 777 /home' ,此处检查 'chmod'的合法性
    if (OsCmdKeyCheck(cmdKey) != TRUE) {
        return OS_ERRNO_SHELL_CMDREG_CMD_ERROR;
    }
    //4.遍历链表节点,验证是否命令存在
    (VOID)LOS_MuxLock(&g_cmdInfo.muxLock, LOS_WAIT_FOREVER);
    LOS_DL_LIST_FOR_EACH_ENTRY(cmdItemNode, &(g_cmdInfo.cmdList.list), CmdItemNode, list) {
        if ((cmdType == cmdItemNode->cmd->cmdType) &&
            ((strlen(cmdKey) == strlen(cmdItemNode->cmd->cmdKey)) &&
            (strncmp((CHAR *)(cmdItemNode->cmd->cmdKey), cmdKey, strlen(cmdKey)) == 0))) {
            (VOID)LOS_MuxUnlock(&g_cmdInfo.muxLock);
            return OS_ERRNO_SHELL_CMDREG_CMD_EXIST;//已存在就退出
        }
    }
    (VOID)LOS_MuxUnlock(&g_cmdInfo.muxLock);
    //5.正式创建命令,挂入链表
    return OsCmdItemCreate(cmdType, cmdKey, paraNum, cmdProc);
}

函数调用图:

OsCompleteStr()

STATIC VOID OsCompleteStr	(	const CHAR *	result,
		const CHAR *	target,
		CHAR *	cmdKey,
		UINT32 *	len
	)

在文件 shcmd.c 第 313 行定义.

{
    UINT32 size = strlen(result) - strlen(target);
    CHAR *des = cmdKey + *len;
    CHAR *src = (CHAR *)result + strlen(target);
 
    while (size-- > 0) {
        PRINTK("%c", *src);
        if (*len == (SHOW_MAX_LEN - 1)) {
            *des = '\0';
            break;
        }
        *des++ = *src++;
        (*len)++;
    }
}

这是这个函数的调用关系图:

OsExecNameMatch()

STATIC INT32 OsExecNameMatch	(	const CHAR *	strPath,
		const CHAR *	nameLooking,
		CHAR *	strObj,
		UINT32 *	maxLen
	)

在文件 shcmd.c 第 275 行定义.

{
    INT32 count = 0;
    DIR *openDir = NULL;
    struct dirent *readDir = NULL;
 
    openDir = opendir(strPath);
    if (openDir == NULL) {
        return (INT32)OS_ERROR;
    }
    //遍历目录下的文件夹
    for (readDir = readdir(openDir); readDir != NULL; readDir = readdir(openDir)) {
        if (strncmp(nameLooking, readDir->d_name, strlen(nameLooking)) != 0) {//不存在字符,
            continue;
        }
        if (count == 0) {
            if (strncpy_s(strObj, CMD_MAX_PATH, readDir->d_name, CMD_MAX_PATH - 1)) {
                (VOID)closedir(openDir);
                return (INT32)OS_ERROR;
            }
            *maxLen = strlen(readDir->d_name);
        } else {
            /* strncmp&cut the same strings of name matched */
            strncmp_cut(readDir->d_name, strObj, strlen(strObj));
            if (strlen(readDir->d_name) > *maxLen) {
                *maxLen = strlen(readDir->d_name);
            }
        }
        count++;//找到一个
    }
 
    if (closedir(openDir) < 0) {
        return (INT32)OS_ERROR;
    }
 
    return count;
}

函数调用图:

这是这个函数的调用关系图:

OsFreeCmdPara()

STATIC VOID OsFreeCmdPara

(

CmdParsed *

cmdParsed

)

释放命令行参数所占内存

在文件 shcmd.c 第 57 行定义.

{
    UINT32 i;
    for (i = 0; i < cmdParsed->paramCnt; i++) {//遍历参数个数
        if ((cmdParsed->paramArray[i]) != NULL) {//一个个释放内存
            (VOID)LOS_MemFree(m_aucSysMem0, (cmdParsed->paramArray[i]));
            cmdParsed->paramArray[i] = NULL;//重新初始化
        }
    }
}

函数调用图:

这是这个函数的调用关系图:

OsPrintMatchList()

STATIC INT32 OsPrintMatchList	(	UINT32	count,
		const CHAR *	strPath,
		const CHAR *	nameLooking,
		UINT32	printLen
	)

打印匹配的列表数据

在文件 shcmd.c 第 203 行定义.

{
    UINT32 timesPrint = 0;
    UINT32 lineCap;
    INT32 ret;
    DIR *openDir = NULL;
    struct dirent *readDir = NULL;
    CHAR formatChar[10] = {0}; /* 10:for formatChar length */
 
    printLen = (printLen > (DEFAULT_SCREEN_WIDTH - 2)) ? (DEFAULT_SCREEN_WIDTH - 2) : printLen; /* 2:revered 2 bytes */
    lineCap = DEFAULT_SCREEN_WIDTH / (printLen + 2); /* 2:DEFAULT_SCREEN_WIDTH revered 2 bytes */
    if (snprintf_s(formatChar, sizeof(formatChar) - 1, 7, "%%-%us  ", printLen) < 0) { /* 7:format-len */
        return (INT32)OS_ERROR;
    }
 
    if (count > (lineCap * DEFAULT_SCREEN_HEIGHT)) {
        ret = OsSurePrintAll(count);//确认打印内容,等待用户输入 N/Y
        if (ret != 1) {
            return ret;
        }
    }
    openDir = opendir(strPath);//打开目录
    if (openDir == NULL) {
        return (INT32)OS_ERROR;
    }
 
    PRINTK("\n");
    for (readDir = readdir(openDir); readDir != NULL; readDir = readdir(openDir)) {
        if (strncmp(nameLooking, readDir->d_name, strlen(nameLooking)) != 0) {
            continue;
        }
        PRINTK(formatChar, readDir->d_name);
        timesPrint++;
        ret = OsShowPageControl(timesPrint, lineCap, count);
        if (ret != 1) {
            if (closedir(openDir) < 0) {
                return (INT32)OS_ERROR;
            }
            return ret;
        }
    }
 
    PRINTK("\n");
    if (closedir(openDir) < 0) {
        return (INT32)OS_ERROR;
    }
 
    return LOS_OK;
}

函数调用图:

这是这个函数的调用关系图:

OsShellCmdPush()

LITE_OS_SEC_TEXT_MINOR VOID OsShellCmdPush	(	const CHAR *	string,
		CmdKeyLink *	cmdKeyLink
	)

将shell命令 string 以 CmdKeyLink 方式加入链表

在文件 shcmd.c 第 672 行定义.

{
    CmdKeyLink *cmdNewNode = NULL;
    UINT32 len;
 
    if ((string == NULL) || (strlen(string) == 0)) {
        return;
    }
 
    len = strlen(string);//获取string的长度,注意CmdKeyLink结构体中,cmdString[0],可变数组的实现.
    cmdNewNode = (CmdKeyLink *)LOS_MemAlloc(m_aucSysMem0, sizeof(CmdKeyLink) + len + 1);//申请内核内存
    if (cmdNewNode == NULL) {
        return;
    }
 
    (VOID)memset_s(cmdNewNode, sizeof(CmdKeyLink) + len + 1, 0, sizeof(CmdKeyLink) + len + 1);
    if (strncpy_s(cmdNewNode->cmdString, len + 1, string, len)) {//将string拷贝至cmdString中
        (VOID)LOS_MemFree(m_aucSysMem0, cmdNewNode);
        return;
    }
 
    LOS_ListTailInsert(&(cmdKeyLink->list), &(cmdNewNode->list));//从尾部插入链表
 
    return;
}

函数调用图:

这是这个函数的调用关系图:

OsShellHistoryShow()

LITE_OS_SEC_TEXT_MINOR VOID OsShellHistoryShow	(	UINT32	value,
		ShellCB *	shellCB
	)

显示shell命令历史记录,支持上下键方式

在文件 shcmd.c 第 698 行定义.

{
    CmdKeyLink *cmdtmp = NULL;
    CmdKeyLink *cmdNode = shellCB->cmdHistoryKeyLink;
    CmdKeyLink *cmdMask = shellCB->cmdMaskKeyLink;
    errno_t ret;
 
    (VOID)pthread_mutex_lock(&shellCB->historyMutex);
    if (value == CMD_KEY_DOWN) {//方向下键切换下一条历史
        if (cmdMask == cmdNode) {
            goto END;
        }
 
        cmdtmp = LOS_DL_LIST_ENTRY(cmdMask->list.pstNext, CmdKeyLink, list);//下一条命令
        if (cmdtmp != cmdNode) {
            cmdMask = cmdtmp;
        } else {
            goto END;
        }
    } else if (value == CMD_KEY_UP) {
        cmdtmp = LOS_DL_LIST_ENTRY(cmdMask->list.pstPrev, CmdKeyLink, list);//上一条命令
        if (cmdtmp != cmdNode) {
            cmdMask = cmdtmp;
        } else {
            goto END;
        }
    }
 
    while (shellCB->shellBufOffset--) {//@note_why 这段代码不知道啥意思
        PRINTK("\b \b");
    }
    PRINTK("%s", cmdMask->cmdString);//打印命令
    shellCB->shellBufOffset = strlen(cmdMask->cmdString);//获取命令长度
    (VOID)memset_s(shellCB->shellBuf, SHOW_MAX_LEN, 0, SHOW_MAX_LEN);//整个buf进行重置,
    ret = memcpy_s(shellCB->shellBuf, SHOW_MAX_LEN, cmdMask->cmdString, shellCB->shellBufOffset);//将命令拷贝进buf,以便继续添加内容
    if (ret != EOK) {
        PRINT_ERR("%s, %d memcpy failed!\n", __FUNCTION__, __LINE__);
        goto END;
    }
    shellCB->cmdMaskKeyLink = (VOID *)cmdMask;//记录按上下键命令的位置
 
END:
    (VOID)pthread_mutex_unlock(&shellCB->historyMutex);
    return;
}

函数调用图:

这是这个函数的调用关系图:

OsShellKeyDeInit()

LITE_OS_SEC_TEXT_MINOR VOID OsShellKeyDeInit

(

CmdKeyLink *

cmdKeyLink

)

shell的析构函数

在文件 shcmd.c 第 633 行定义.

{
    CmdKeyLink *cmdtmp = NULL;
    if (cmdKeyLink == NULL) {
        return;
    }
 
    while (!LOS_ListEmpty(&(cmdKeyLink->list))) {//清空待处理命令列表
        cmdtmp = LOS_DL_LIST_ENTRY(cmdKeyLink->list.pstNext, CmdKeyLink, list);
        LOS_ListDelete(&cmdtmp->list);//将自己从链表中摘出去
        (VOID)LOS_MemFree(m_aucSysMem0, cmdtmp);//释放内核内存空间
    }
 
    cmdKeyLink->count = 0;//链表为空,个数清0
    (VOID)LOS_MemFree(m_aucSysMem0, cmdKeyLink);
}

函数调用图:

这是这个函数的调用关系图:

OsShellKeyInit()

LITE_OS_SEC_TEXT_MINOR UINT32 OsShellKeyInit

(

ShellCB *

shellCB

)

shell 命令初始化

在文件 shcmd.c 第 602 行定义.

{
    CmdKeyLink *cmdKeyLink = NULL;
    CmdKeyLink *cmdHistoryLink = NULL;
 
    if (shellCB == NULL) {
        return OS_ERROR;
    }
    cmdKeyLink = (CmdKeyLink *)LOS_MemAlloc(m_aucSysMem0, sizeof(CmdKeyLink));
    if (cmdKeyLink == NULL) {
        PRINT_ERR("Shell CmdKeyLink memory alloc error!\n");
        return OS_ERROR;
    }
    cmdHistoryLink = (CmdKeyLink *)LOS_MemAlloc(m_aucSysMem0, sizeof(CmdKeyLink));
    if (cmdHistoryLink == NULL) {
        (VOID)LOS_MemFree(m_aucSysMem0, cmdKeyLink);
        PRINT_ERR("Shell CmdHistoryLink memory alloc error!\n");
        return OS_ERROR;
    }
 
    cmdKeyLink->count = 0;
    LOS_ListInit(&(cmdKeyLink->list));//待处理命令链表初始化
    shellCB->cmdKeyLink = (VOID *)cmdKeyLink;//链表源头
 
    cmdHistoryLink->count = 0;
    LOS_ListInit(&(cmdHistoryLink->list));//历史记录链表初始化
    shellCB->cmdHistoryKeyLink = (VOID *)cmdHistoryLink;//链表源头
    shellCB->cmdMaskKeyLink = (VOID *)cmdHistoryLink;//掩码命令链表同历史记录链表,标识上下键位置.
    return LOS_OK;
}

函数调用图:

这是这个函数的调用关系图:

OsShellSysCmdRegister()

LITE_OS_SEC_TEXT_MINOR UINT32 OsShellSysCmdRegister

(

VOID

)

注册系统自带的shell命令

在文件 shcmd.c 第 650 行定义.

{
    UINT32 i;
    UINT8 *cmdItemGroup = NULL;
    UINT32 index = ((UINTPTR)(&g_shellcmdEnd) - (UINTPTR)(&g_shellcmd[0])) / sizeof(CmdItem);//获取个数
    CmdItemNode *cmdItem = NULL;
 
    cmdItemGroup = (UINT8 *)LOS_MemAlloc(m_aucSysMem0, index * sizeof(CmdItemNode));//分配命令项
    if (cmdItemGroup == NULL) {
        PRINT_ERR("[%s]System memory allocation failure!\n", __FUNCTION__);
        return (UINT32)OS_ERROR;
    }
 
    for (i = 0; i < index; ++i) {//循环插入
        cmdItem = (CmdItemNode *)(cmdItemGroup + i * sizeof(CmdItemNode));
        cmdItem->cmd = &g_shellcmd[i];//一个个取
        OsCmdAscendingInsert(cmdItem);//按升序插入到链表中
    }
    g_cmdInfo.listNum += index;//命令数量叠加
    return LOS_OK;
}

函数调用图:

这是这个函数的调用关系图:

OsShowPageControl()

STATIC INT32 OsShowPageControl	(	UINT32	timesPrint,
		UINT32	lineCap,
		UINT32	count
	)

显示页内容控制器

在文件 shcmd.c 第 174 行定义.

{
    if (NEED_NEW_LINE(timesPrint, lineCap)) {//是否新开一行
        PRINTK("\n");
        if (SCREEN_IS_FULL(timesPrint, lineCap) && (timesPrint < count)) {
            PRINTK("--More--");
            return OsShowPageInputControl();//打印内容
        }
    }
    return 1;
}

函数调用图:

这是这个函数的调用关系图:

OsShowPageInputControl()

STATIC INT32 OsShowPageInputControl

(

VOID

)

输出内容

在文件 shcmd.c 第 155 行定义.

{
    CHAR readChar;
 
    while (1) {//从 stdin 中读取内容字符
        if (read(STDIN_FILENO, &readChar, 1) != 1) { /* get one CHAR from stdin */
            PRINTK("\n");
            return (INT32)OS_ERROR;
        }
        if ((readChar == 'q') || (readChar == 'Q') || (readChar == CTRL_C)) {
            PRINTK("\n");
            return 0;
        } else if (readChar == '\r') {
            PRINTK("\b \b\b \b\b \b\b \b\b \b\b \b\b \b\b \b");
            return 1;
        }
    }
}

这是这个函数的调用关系图:

OsStrSeparate()

STATIC INT32 OsStrSeparate	(	CHAR *	tabStr,
		CHAR *	strPath,
		CHAR *	nameLooking,
		UINT32	tabStrLen
	)

在文件 shcmd.c 第 108 行定义.

{
    CHAR *strEnd = NULL;
    CHAR *cutPos = NULL;
    CmdParsed parsed = {0};
    CHAR *shellWorkingDirectory = OsShellGetWorkingDirectory();
    INT32 ret;
 
    ret = OsStrSeparateTabStrGet(&tabStr, &parsed, tabStrLen);
    if (ret != LOS_OK) {
        return ret;
    }
 
    /* get fullpath str *///获取全路径
    if (*tabStr != '/') {
        if (strncpy_s(strPath, CMD_MAX_PATH, shellWorkingDirectory, CMD_MAX_PATH - 1)) {
            OsFreeCmdPara(&parsed);
            return (INT32)OS_ERROR;
        }
        if (strcmp(shellWorkingDirectory, "/")) {
            if (strncat_s(strPath, CMD_MAX_PATH, "/", CMD_MAX_PATH - strlen(strPath) - 1)) {
                OsFreeCmdPara(&parsed);
                return (INT32)OS_ERROR;
            }
        }
    }
 
    if (strncat_s(strPath, CMD_MAX_PATH, tabStr, CMD_MAX_PATH - strlen(strPath) - 1)) {
        OsFreeCmdPara(&parsed);//释放命令行中参数所占内存
        return (INT32)OS_ERROR;
    }
 
    /* split str by last '/' */
    strEnd = strrchr(strPath, '/');
    cutPos = strEnd;
    if (strEnd != NULL) {
        if (strncpy_s(nameLooking, CMD_MAX_PATH, strEnd + 1, CMD_MAX_PATH - 1)) { /* get cmp str */
            OsFreeCmdPara(&parsed);
            return (INT32)OS_ERROR;
        }
        *(cutPos + 1) = '\0';
    }
 
    OsFreeCmdPara(&parsed);
    return LOS_OK;
}

函数调用图:

这是这个函数的调用关系图:

OsStrSeparateTabStrGet()

STATIC INT32 OsStrSeparateTabStrGet	(	CHAR **	tabStr,
		CmdParsed *	parsed,
		UINT32	tabStrLen
	)

在文件 shcmd.c 第 68 行定义.

{
    CHAR *shiftStr = NULL;
    CHAR *tempStr = (CHAR *)LOS_MemAlloc(m_aucSysMem0, SHOW_MAX_LEN << 1);
    if (tempStr == NULL) {
        return (INT32)OS_ERROR;
    }
 
    (VOID)memset_s(tempStr, SHOW_MAX_LEN << 1, 0, SHOW_MAX_LEN << 1);
    shiftStr = tempStr + SHOW_MAX_LEN;
 
    if (strncpy_s(tempStr, SHOW_MAX_LEN - 1, *tabStr, tabStrLen)) {
        (VOID)LOS_MemFree(m_aucSysMem0, tempStr);
        return (INT32)OS_ERROR;
    }
 
    parsed->cmdType = CMD_TYPE_STD;
 
    /* cut useless or repeat space */
    if (OsCmdKeyShift(tempStr, shiftStr, SHOW_MAX_LEN - 1)) {
        (VOID)LOS_MemFree(m_aucSysMem0, tempStr);
        return (INT32)OS_ERROR;
    }
 
    /* get exact position of string to complete */
    /* situation different if end space lost or still exist */
    if ((strlen(shiftStr) == 0) || (tempStr[strlen(tempStr) - 1] != shiftStr[strlen(shiftStr) - 1])) {
        *tabStr = "";
    } else {
        if (OsCmdTokenSplit(shiftStr, ' ', parsed)) {
            (VOID)LOS_MemFree(m_aucSysMem0, tempStr);
            return (INT32)OS_ERROR;
        }
        *tabStr = parsed->paramArray[parsed->paramCnt - 1];
    }
 
    (VOID)LOS_MemFree(m_aucSysMem0, tempStr);
    return LOS_OK;
}

函数调用图:

这是这个函数的调用关系图:

OsSurePrintAll()

STATIC INT32 OsSurePrintAll

(

UINT32

count

)

是否打印所有内容

在文件 shcmd.c 第 186 行定义.

{
    CHAR readChar = 0;
    PRINTK("\nDisplay all %u possibilities?(y/n)", count);
    while (1) {//死循环等待输入
        if (read(0, &readChar, 1) != 1) {//从标准输入中 读取字符
            return (INT32)OS_ERROR;
        }
        if ((readChar == 'n') || (readChar == 'N') || (readChar == CTRL_C)) {//输入N
            PRINTK("\n");
            return 0;
        } else if ((readChar == 'y') || (readChar == 'Y') || (readChar == '\r')) {//输入 Y
            return 1;
        }
    }
}

这是这个函数的调用关系图:

OsTabCompletion()

LITE_OS_SEC_TEXT_MINOR INT32 OsTabCompletion	(	CHAR *	cmdKey,
		UINT32 *	len
	)

tab键

在文件 shcmd.c 第 544 行定义.

{
    INT32 count = 0;
    CHAR *space = NULL;
    CHAR *cmdMainStr = cmdKey;
 
    if ((cmdKey == NULL) || (len == NULL)) {
        return (INT32)OS_ERROR;
    }
 
    /* cut left space */
    while (*cmdMainStr == 0x20) {//空格键
        cmdMainStr++;
    }
 
    /* try to find space in remain */
    space = strrchr(cmdMainStr, 0x20);
    if ((space == NULL) && (*cmdMainStr != '\0')) {
        count = OsTabMatchCmd(cmdKey, len);
    }
 
    if (count == 0) {
        count = OsTabMatchFile(cmdKey, len);
    }
 
    return count;
}

函数调用图:

这是这个函数的调用关系图:

OsTabMatchCmd()

STATIC INT32 OsTabMatchCmd	(	CHAR *	cmdKey,
		UINT32 *	len
	)

使用tab键去匹配命令

在文件 shcmd.c 第 335 行定义.

{
    INT32 count = 0;
    INT32 ret;
    CmdItemNode *cmdItemGuard = NULL;
    CmdItemNode *curCmdItem = NULL;
    const CHAR *cmdMajor = (const CHAR *)cmdKey;
 
    while (*cmdMajor == 0x20) { /* cut left space */
        cmdMajor++;
    }
 
    if (LOS_ListEmpty(&(g_cmdInfo.cmdList.list))) {
        return (INT32)OS_ERROR;
    }
    //遍历现有命令
    LOS_DL_LIST_FOR_EACH_ENTRY(curCmdItem, &(g_cmdInfo.cmdList.list), CmdItemNode, list) {
        if ((curCmdItem == NULL) || (curCmdItem->cmd == NULL)) {
            return -1;
        }
        
        if (strncmp(cmdMajor, curCmdItem->cmd->cmdKey, strlen(cmdMajor)) > 0) {
            continue;
        }
 
        if (strncmp(cmdMajor, curCmdItem->cmd->cmdKey, strlen(cmdMajor)) != 0) {
            break;
        }
 
        if (count == 0) {
            cmdItemGuard = curCmdItem;
        }
        ++count;//匹配到一个
    }
 
    if (cmdItemGuard == NULL) {
        return 0;
    }
 
    if (count == 1) {//只有一个的情况,直接补充完整
        OsCompleteStr(cmdItemGuard->cmd->cmdKey, cmdMajor, cmdKey, len);
    }
 
    ret = count;
    if (count > 1) {
        PRINTK("\n");
        while (count--) {//打印已经匹配到的命令
            PRINTK("%s  ", cmdItemGuard->cmd->cmdKey);
            cmdItemGuard = LOS_DL_LIST_ENTRY(cmdItemGuard->list.pstNext, CmdItemNode, list);//取下一个
        }
        PRINTK("\n");
    }
 
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

OsTabMatchFile()

STATIC INT32 OsTabMatchFile	(	CHAR *	cmdKey,
		UINT32 *	len
	)

使用tab键去匹配关键字文件

在文件 shcmd.c 第 391 行定义.

{
    UINT32 maxLen = 0;
    INT32 count;
    CHAR *strOutput = NULL;
    CHAR *strCmp = NULL;
    CHAR *dirOpen = (CHAR *)LOS_MemAlloc(m_aucSysMem0, CMD_MAX_PATH * 3); /* 3:dirOpen\strOutput\strCmp */
    if (dirOpen == NULL) {
        return (INT32)OS_ERROR;
    }
 
    (VOID)memset_s(dirOpen, CMD_MAX_PATH * 3, 0, CMD_MAX_PATH * 3); /* 3:dirOpen\strOutput\strCmp */
    strOutput = dirOpen + CMD_MAX_PATH;
    strCmp = strOutput + CMD_MAX_PATH;
 
    if (OsStrSeparate(cmdKey, dirOpen, strCmp, *len)) {
        (VOID)LOS_MemFree(m_aucSysMem0, dirOpen);
        return (INT32)OS_ERROR;
    }
    //匹配名字
    count = OsExecNameMatch(dirOpen, strCmp, strOutput, &maxLen);
    /* one or more matched */
    if (count >= 1) {
        OsCompleteStr(strOutput, strCmp, cmdKey, len);
 
        if (count == 1) {
            (VOID)LOS_MemFree(m_aucSysMem0, dirOpen);
            return 1;
        }
        if (OsPrintMatchList((UINT32)count, dirOpen, strCmp, maxLen) == -1) {
            (VOID)LOS_MemFree(m_aucSysMem0, dirOpen);
            return (INT32)OS_ERROR;
        }
    }
 
    (VOID)LOS_MemFree(m_aucSysMem0, dirOpen);
    return count;
}

函数调用图:

这是这个函数的调用关系图:

strncmp_cut()

STATIC VOID strncmp_cut	(	const CHAR *	s1,
		CHAR *	s2,
		size_t	n
	)

在文件 shcmd.c 第 253 行定义.

{
    if ((n == 0) || (s1 == NULL) || (s2 == NULL)) {
        return;
    }
    do {
        if (*s1 && *s2 && (*s1 == *s2)) {
            s1++;
            s2++;
        } else {
            break;
        }
    } while (--n != 0);
    if (n > 0) {
        /* NULL pad the remaining n-1 bytes */
        while (n-- != 0)
            *s2++ = 0;
    }
    return;
}

这是这个函数的调用关系图:

变量说明

g_cmdInfo

STATIC CmdModInfo g_cmdInfo

shell 命令模块信息,上面挂了所有的命令项(ls,cd ,cp ==)

在文件 shcmd.c 第 47 行定义.