cli_debug.c

命令行在嵌入式系统的实现

        default:
            break;

    }

    IO_OutToTerm(pTermStruct, szInfo);
    free (szInfo);

    DBG_Out(PID_CLI, CLI_DBGOUT_ERR, "\r\n  CLI: 测试完成，请观察串口终端输出结果");

    return G_SUCCESS;
}

/*--------------------命令行的日志管理测试函数-----------------------*/
/*===================================================================*/
/*       CmdWord = 6                       */
/* 说明  Param1: 1、执行成功的命令       */
/*               2、执行不成功的命令     */
/*       Param2: 增加的命令记录数目      */
/*  可以通过参数2来达到预置命令记录与日志记录是满与否的条件*/
_U32 CLI_CmdTestLog(_U32 Param1, _U32 Param2, _U32 Param3, _U32 Param4)
{
    static _U32 ulNum = 0;
    PTerm_Data_S pTermStruct;
    extern _U32 m_ulLogTag;
    (_VOID)Param3;
    (_VOID)Param4;

    if (Param1 ==0 && Param2 == 0 && Param3 == 0 && Param4 == 0)
    {
        DBG_Out(PID_CLI, CLI_DBGOUT_ERR,
            "\r\n Param1 -- 1、执行成功的命令       "
            "\r\n           2、执行不成功的命令     "
            "\r\n Param2 -- 增加的命令记录数目      "
            "\r\n  可以通过参数2来达到预置命令记录与日志记录是满与否的条件"
                    );
        return G_SUCCESS;
    }

    pTermStruct = m_TDTable[0].pTermStruct;

    for (ulNum = 0; ulNum < Param2; ulNum++)
    {
        EOS_Sprintf (pTermStruct->szCommandBuf, "test command %d", ulNum);
        EOS_StrCpy (pTermStruct->szCurUserName, "admin");
        if (Param1 == 1)
        {
            pTermStruct->ulCommandExecOk = COMMAND_ACCOMPLISHED;
            m_ulLogTag = 1;
        }
        else
            pTermStruct->ulCommandExecOk = COMMAND_UNFINISHED;

        CLI_CmdRecord(pTermStruct);
    }
    EOS_StrCpy(pTermStruct->szCurUserName, g_csz_CFG_CLI_DBG_USER_NAME);
    DBG_Out(PID_CLI, CLI_DBGOUT_ERR, "\r\n  CLI: 测试完成，请观察命令历史记录与日志记录");

    return G_SUCCESS;

}


/*--------------------命令行的终端管理测试函数-----------------------*/
/*===================================================================*/
/*       CmdWord = 7                      */
/* 说明  Param1: 1、注销终端 (尝试登录终端与为登录终端的注销) */
/*       Param2: 1、命令注销            */
/*               2、超时注销            */
/*               3、重复注销            */
/* 注意，为显示测试效果，除第一种情况外，*/
/*     请不要在被测试对象上进行测试操作  */
_U32 CLI_CmdTestTerm(_U32 Param1, _U32 Param2, _U32 Param3, _U32 Param4)
{
    _U32 ulTermID;
    PTerm_Data_S pTermStruct;
    (_VOID)Param3;
    (_VOID)Param4;

    if (Param1 ==0 && Param2 == 0 && Param3 == 0 && Param4 == 0)
    {

        DBG_Out(PID_CLI, CLI_DBGOUT_ERR,
            "\r\n Param1 -- 1. 注销终端 (尝试登录终端与为登录终端的注销) "
            "\r\n Param2 -- 1. 命令注销           "
            "\r\n           2. 超时注销            "
            "\r\n           3. 重复注销            "
            "\r\n 注意，为显示测试效果，除第一种情况外，"
            "\r\n     请不要在被测试对象上进行测试操作  "
                    );
        return G_SUCCESS;
    }

    ulTermID = Param1;
    if (!CLI_IS_TERMID_VALIDE(ulTermID))
    {
        DBG_Out(PID_CLI, CLI_DBGOUT_ERR, "\r\n  CLI: 测试错误，终端参数错误(%d)", ulTermID);
        return G_FAILURE;
    }
    pTermStruct = m_TDTable[ulTermID - 1].pTermStruct;

    switch (Param2)
    {
        /*命令注销, 在命令行直接使用*/
        case 1:
            break;
        /*超时注销*/
        case 2:
            if (!IS_TERM_NORMAL(pTermStruct))
            {
                DBG_Out(PID_CLI, CLI_DBGOUT_ERR, "\r\n  CLI: 测试提示，在非正常终端上尝试注销测试");
            }
            pTermStruct->ulTimeLeft = 1;
            break;

        /*重复注销*/
        case 3:
            if (!IS_TERM_NORMAL(pTermStruct))
            {
                DBG_Out(PID_CLI, CLI_DBGOUT_ERR, "\r\n  CLI: 测试提示，在非正常终端上尝试注销测试");
            }
            DBG_Out(PID_CLI, CLI_DBGOUT_ERR, "\r\n  CLI: 测试提示，第一次注销终端开始");
            CLI_TermLogout(pTermStruct);
            DBG_Out(PID_CLI, CLI_DBGOUT_ERR, "\r\n  CLI: 测试提示，第二次注销终端开始");
            CLI_TermLogout(pTermStruct);
            break;
        default:
            break;
    }

    DBG_Out(PID_CLI, CLI_DBGOUT_ERR, "\r\n  CLI: 注销测试完成，请观察终端%d的结果", ulTermID);
    return G_SUCCESS;

}


/*-------------------命令行的分布式管理测试函数----------------------*/
/*===================================================================*/
/*       CmdWord = 28                    */
/* 说明  Param1: 1、注销终端 (尝试登录终端与为登录终端的注销) */
/*       Param2: 1、命令注销             */
/*               2、超时注销             */
/*               3、重复注销             */
/* 注意，为显示测试效果，除第一种情况外，*/
/*     请不要在被测试对象上进行测试操作  */
_U32 CLI_CmdTestDisttr(_U32 Param1, _U32 Param2, _U32 Param3, _U32 Param4)
{
    _U32 ulTermID;

    #if MULTI_DEVICE_SUPPORT
    PTerm_Data_S    pTermStruct;
    ST_MSG  *pstMsg;
    #endif

    if (Param1 ==0 && Param2 == 0 && Param3 == 0 && Param4 == 0)
    {

        DBG_Out(PID_CLI, CLI_DBGOUT_ERR,
            "\r\n Param1 -- 终端ID"
            "\r\n Param2 -- 1、作为主设备测试"
            "\r\n           2、作为从设备测试"
            "\r\n Param3 -- 1、测试模拟从主设备下发的命令透传消息处理"
            "\r\n           2、测试模拟从从设备上报的信息输出消息处理"
            "\r\n           3、测试模拟从从设备上报的命令执行反馈处理"
        "\r\n\r\n 该测试命令只在支持主从设备时的分布式命令行有效"
            "\r\n 注意打开命令行调试通道2观察终端的状态变化与其它信息输出,"
            "\r\n 本测试命令需要修改终端属性，可能导致以外而必须复位，"
            "\r\n 如果模拟的是从设备，建议使用终端2，并请使用本测试命令及时恢复"
                    );
        return G_SUCCESS;
    }

    ulTermID = Param1;
    if (!CLI_IS_TERMID_VALIDE(ulTermID))
    {
        return G_FAILURE;
    }

#if MULTI_DEVICE_SUPPORT

    pTermStruct = m_TDTable[ulTermID - 1].pTermStruct;

    if (Param2 == 1)
        m_CliIsMainDevice = G_TRUE;
    else if (Param2 == 2)
        m_CliIsMainDevice = G_FALSE;

    switch (Param3)
    {
        case 1:
            pTermStruct->iSocket = SOCKET_FOR_MML;

            pstMsg = CLI_MSMsgCreat(0, ulTermID, MSG_CODE_CLI_TRANSCMD, "show log\r\n");
            if (pstMsg == G_NULL)
                return G_FAILURE;

            if (G_SUCCESS != BOARD_SEND_MSG(pstMsg))
            {
                ROS_MsgFree( pstMsg);
                return G_FAILURE;
            }
            break;

        case 2:
            CLI_SetTermStatus(pTermStruct , TERM_WAIT_RESPONSE);

            pstMsg = CLI_MSMsgCreat(0, ulTermID, MSG_CODE_CLI_FEEDBACK, "\r\n Feed back information");
            if (pstMsg == G_NULL)
                return G_FAILURE;

            if (G_SUCCESS != BOARD_SEND_MSG(pstMsg))
            {
                ROS_MsgFree( pstMsg);
                return G_FAILURE;
            }
            break;

        case 3:
            pstMsg = CLI_MSMsgCreat(0, ulTermID, MSG_CODE_CLI_EXECRESP, G_NULL);
            if (pstMsg == G_NULL)
                return G_FAILURE;

            pstMsg->ucData[0] = 0;

            if (G_SUCCESS != BOARD_SEND_MSG(pstMsg))
            {
                ROS_MsgFree( pstMsg);
                return G_FAILURE;
            }
            break;

        default:
            break;
    }
#endif

    return G_SUCCESS;
}

/*--------------------------------------------*/
/* 显示命令行统计信息                         */
/*--------------------------------------------*/
_U32 CLI_DispStatInfo(_U32 ulTermID)
{
    _S8 szStatInfo[CLI_STAT_BUTT][50] ={
                                "Tid get failed        :",//CLI_STAT_GET_TID_FAILD = 0,
                                "Received error        :",//CLI_STAT_RECEIVE_ERR,
                                "Sem P failed          :",//CLI_STAT_SEM_P,
                                "Sem V failed          :",//CLI_STAT_SEM_V,
                                "Telnet login failed   :",//CLI_STAT_TELNET_LOGIN,
                                "User be kicked off    :",//CLI_STAT_KICKOFF_OTHER,
                                "Log out many times    :",//CLI_STAT_LOGOUT_MANY_TIMES,
                                "Output too long       :",//CLI_STAT_OUTPUT_TOO_LONG,
                                "Asyn-out term error   :",//CLI_STAT_ASYNOUT_TERM_ERR,
                                "Receive abnormal      :",//CLI_STAT_RECEIVE_ABNORMAL,
                                "Get taskdata failed   :",//CLI_STAT_GETTASK_DATA,
                                "Received error msg    :",//CLI_STAT_RECEIVED_UNWANTED,
                                "Get time failed       :",
                                "Client closed times(s):",//CLI_STAT_CLIENT_SEND_CLOSED
                                "Client closed times(r):",//CLI_STAT_CLIENT_RECV_CLOSED
                                "Client receive timeout:",//CLI_STAT_CLIENT_RECV_TIMEOUT
                                "Client goto seclect(r):",//CLI_STAT_CLIENT_GOTO_SELECT
                                "Client over seclect(r):",//CLI_STAT_CLIENT_OVER_SELECT
                                "Client goto seclect(s):",//CLI_STAT_CLIENT_GOTO_SELECT_S
                                "Client over seclect(s):",//CLI_STAT_CLIENT_OVER_SELECT_S
                                "Client goto receive   :",//CLI_STAT_CLIENT_GOTO_SELECT
                                "Client over receive   :",//CLI_STAT_CLIENT_OVER_SELECT
                                "Client goto send      :",//CLI_STAT_CLIENT_GOTO_SELECT_S
                                "Client over send      :",//CLI_STAT_CLIENT_OVER_SELECT_S
                                };
    _U32 i;
    (_VOID)ulTermID;

    for (i = 0; i < CLI_STAT_BUTT; i++)
    {
        DBG_Out(PID_CLI, CLI_DBGOUT_MUST,
              "\r\n %s %d", szStatInfo[i], m_ulCliStat[i]);
    }
    return G_SUCCESS;
}

_U32 CLI_DirIoTest(_U32 ulTermID)
{
    _U32 ulType;
    _U32 ulRet;
    _S8 *pOutput;
    _U32 i;

    if (CT_GetUlongByName("test-type", ulTermID, &ulType) != G_SUCCESS)
    {
        return G_FAILURE;
    }

    switch(ulType)
    {
        case 1:
            IO_OutString("\r\n Hello world!");
            break;
        case 2:
            pOutput = ROS_MemAlloc(100000, ROS_MEM_ALLOC_OPT_LEAK_CHECK);
            if (pOutput == G_NULL)
            {
                DBG_Out(PID_CLI, CLI_DBGOUT_ERR,
                    "\r\n  CLI: 系统资源不足，无法进行该测试!");
                return G_FAILURE;
            }
            while (EOS_StrLen(pOutput) < 90000)
                EOS_StrCat(pOutput, "\r\n 1111111111111111111111111111*");
            ulRet = IO_OutString(pOutput);
            ROS_MemFree(pOutput);
            return ulRet;
        case 3:
            for (i = 0; i < 200; i++)
            {
                IO_OutString("\r\n Hello word!");
            }
            break;
        case 4:
            return IO_OutString(G_NULL);
        case 5:
            return IO_OutString("");
        default:
            DBG_Out(PID_CLI, CLI_DBGOUT_ERR,
                "\r\n  CLI: 错误的测试操作");
            return G_FAILURE;
    }
    return G_SUCCESS;
}


_U32 CLI_DispSysStat(_U32 ulTermID)
{
    _U32 i;
    _S8* pModulename;

    pModulename = CT_GetParamByName("module", ulTermID);

    if (!EOS_StriCmp(pModulename, "all"))
    {
        for (i = 0; g_st_CFG_ModuleStatDisp[i].szModuleName[0] != '\0'; i++)
        {
            if (g_st_CFG_ModuleStatDisp[i].pDispFile != G_NULL)
            {
                IO_PrintToTerm(ulTermID, PUB_STRING_OUT, "\r\n\r\n ==== SHOW STATISTIC OF MODULE :");
                IO_PrintToTerm(ulTermID, PUB_STRING_OUT, g_st_CFG_ModuleStatDisp[i].szModuleName);
                g_st_CFG_ModuleStatDisp[i].pDispFile(ulTermID);
            }
        }
        return G_SUCCESS;
    }

    for (i = 0; g_st_CFG_ModuleStatDisp[i].szModuleName[0] != '\0'; i++)
    {
        if (!EOS_StriCmp(g_st_CFG_ModuleStatDisp[i].szModuleName, pModulename))
        {
            if (g_st_CFG_ModuleStatDisp[i].pDispFile != G_NULL)
            {
                IO_PrintToTerm(ulTermID, PUB_STRING_OUT, "\r\n\r\n ==== SHOW STATISTIC OF MODULE :");
                IO_PrintToTerm(ulTermID, PUB_STRING_OUT, g_st_CFG_ModuleStatDisp[i].szModuleName);
                g_st_CFG_ModuleStatDisp[i].pDispFile(ulTermID);
            }
            else
            {
                IO_PrintToTerm(ulTermID, PUB_STRING_OUT, "\r\n  There is no show statistic function of module " );
                IO_PrintToTerm(ulTermID, PUB_STRING_OUT, g_st_CFG_ModuleStatDisp[i].szModuleName );
            }
            return G_SUCCESS;
        }
    }

    return G_FAILURE;
}


_U32 CLI_ClearSysStat(_U32 ulTermID)
{
    _U32 i;
    _S8* pModulename;