cli_cmdreg.c

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

/************************************************************************
Copyright 200X - 200X+1.

filename     : CLI_Cmdreg.c

description  : 命令行的命令树构造与命令注册接口的提供

author       : Woodhead

modification : Woodhead    create              2004-12-07
************************************************************************/

#include "Ros.h"
#include "ML.h"
#include "Sys_Ml.h"
#include "Cli_MlPriv.h"
#include "CLI_Private.inc"
#include "Cli_intp.inc"
#include "CLI_Io.h"
#include "Config\Cli_ConfigGlbVar.h"

extern _U32 RADIUS_AuthMode( _U32 ulTermId );

CT_MODE_T m_sCliSysModes[MAX_MODE_NUM];    /* 命令树 */
CT_USERTYPE_T m_sCliUserType[CT_MAX_USERTYPES]; /* 用户类型 */

/*********************************************************************/
/* 函数名称 : CT_RegModes()                                          */
/* 函数功能 : 命令行所有模式的注册                                   */
/* 输入参数 : 无                                                     */
/* 输出参数 : 无                                                     */
/* 返回     : 无                                                     */
/* 上层函数 : 初始化过程中调用                                       */
/* 修改记录 :                                                        */
/*********************************************************************/
_U32 CT_RegModes(_VOID)
{
    if(CT_SetMode(CTM_GENL,"Root Mode",">>", "enable",
                    CT_AL_QUERY, NULL_MODE, G_NULL) != G_SUCCESS)
    {
        return G_FAILURE;
    }

    if(CT_SetMode(CTM_CONFIG,"Config Mode",">>config>","configure",
                CT_AL_OPERATOR,CTM_GENL,G_NULL) != G_SUCCESS)
    {
        return G_FAILURE;
    }

    if(CT_SetMode(CTM_GLOBAL,"Global Mode",">>",
                "global",CT_AL_QUERY, NULL_MODE,G_NULL) != G_SUCCESS)
    {
        return G_FAILURE;
    }

    if(CT_SetMode(CTM_DIAG,"Diagnose Mode","%%",
                "diagnose",CT_AL_DEBUG, CTM_GENL,G_NULL) != G_SUCCESS)
    {
        return G_FAILURE;
    }

#if CLI_DEBUG_ON
    if(CT_SetMode(CTM_DBG, "Debug Mode",">>debug%%",
                "debug",CT_AL_SUPER,CTM_GENL,G_NULL) != G_SUCCESS)
    {
        return G_FAILURE;
    }
#endif

    /* 产品相关的命令行模式注册 */
    if( G_NULL != g_pfn_CFG_CT_ProdRegModes )
    {
        if( G_SUCCESS != g_pfn_CFG_CT_ProdRegModes() )
        {
            return G_FAILURE;
        }
    }

    return G_SUCCESS;

}

/*********************************************************************/
/* 函数名称 : CT_RegModeCmd()                                        */
/* 函数功能 : 所有模式的进入命令注册                                 */
/* 输入参数 : 无                                                     */
/* 输出参数 : 无                                                     */
/* 返回     : 无                                                     */
/* 上层函数 : 初始化过程中调用                                       */
/* 修改记录 :                                                        */
/*********************************************************************/
_U32 CT_RegModeCmd(_VOID)
{
    _U32 ulRet = 0;
    ulRet += CT_CmdAutoRegistEx(CMD_CM "configure",
                               CTM_GENL,
                               CT_AL_OPERATOR,
                               G_NULL,
                               CT_MC_NEW,
                               CTM_CONFIG,
                               CMDHELP_GLB_CM,
                               CMDHELP_GENL_CM_CONFIGURE,
                               CLI_ML_NULL);
    ulRet += CT_CmdAutoRegistEx(CMD_CM "diagnose",
                               CTM_GENL,
                               CT_AL_DEBUG,
                               CLI_EnterDiagMode,
                               CT_MC_NEW,
                               CTM_DIAG,
                               CMDHELP_GLB_CM,
                               CMDHELP_GENL_CM_DIAGNOSE,
                               CLI_ML_NULL);
#if CLI_DEBUG_ON
    ulRet += CT_CmdAutoRegistEx(CMD_CM "debug",
                               CTM_GENL,
                               CT_AL_SUPER,
                               G_NULL,
                               CT_MC_NEW,
                               CTM_DBG,
                               CMDHELP_GLB_CM,
                               CMDHELP_GENL_CM_DEBUG,
                               CLI_ML_NULL);
#endif

    if (ulRet != G_SUCCESS)
    {
        return G_FAILURE;
    }

    /* 产品相关的命令行模式注册 */
    if( G_NULL != g_pfn_CFG_CT_ProdRegModeCmd )
    {
        return g_pfn_CFG_CT_ProdRegModeCmd();
    }

    return G_SUCCESS;


}

/*********************************************************************/
/* 函数名称 : CT_InitUserType()                                      */
/* 函数功能 : 可供用户自己扩展的参数值数据结构初始化                 */
/* 输入参数 : 无                                                     */
/* 输出参数 : 无                                                     */
/* 返回     : 无                                                     */
/* 上层函数 : 初始化过程中调用                                       */
/* 创建者   : Liuzequn                                               */
/* 修改记录 :                                                        */
/*********************************************************************/
_VOID  CT_InitUserType(_VOID)
{
    _U32 i;

    for(i = 0; i < CT_MAX_USERTYPES; i++)
    {
        m_sCliUserType[i].ucTypeID = 0;
        m_sCliUserType[i].szTypeName[0] = 0;
        m_sCliUserType[i].pCheckFunc = G_NULL;
    }

    return ;
}

/*  系统模式结构数组初始化  */
_VOID  CT_InitSysModes(_VOID)
{
    _U32 ulCountTemp;

    for(ulCountTemp = 0; ulCountTemp < MAX_MODE_NUM; ulCountTemp++)
    {
        m_sCliSysModes[ulCountTemp].ulMode          = NULL_MODE;
        m_sCliSysModes[ulCountTemp].szModeName[0]   = 0;
        m_sCliSysModes[ulCountTemp].szModePrompt[0] = 0;
        m_sCliSysModes[ulCountTemp].szModeVerb[0]   = 0;
        m_sCliSysModes[ulCountTemp].rightLevel      = CT_AL_QUERY;
        m_sCliSysModes[ulCountTemp].ulParent        = NULL_MODE;
        m_sCliSysModes[ulCountTemp].pObject         = G_NULL;
        m_sCliSysModes[ulCountTemp].ulHierarchy     = 0;
        m_sCliSysModes[ulCountTemp].ulParamCount    = 0;
    }

    return ;
}

_U32 CT_InitModeObject(_VOID)
{
    CT_OBJECT_P pObj;

    pObj = CT_CreateObject("GENERAL", CTM_GENL, CT_AL_QUERY,
                            G_NULL, G_FALSE, CT_MC_NULL, G_NULL);
    if(pObj == G_NULL)
        return G_FAILURE;

    if(CT_RegModeObject(ROOT_MODE,pObj,0) != G_SUCCESS)
    {
        return G_FAILURE;
    }

    pObj = CT_CreateObject("GLOBAL", CTM_GLOBAL, CT_AL_QUERY,
                            G_NULL, G_FALSE, CT_MC_NULL, G_NULL);
    if(pObj == G_NULL)
        return G_FAILURE;

    if (CT_RegModeObject(CTM_GLOBAL,pObj,0) != G_SUCCESS)
    {
        return G_FAILURE;
    }

    return G_SUCCESS;
}

_U32  CT_InitCmdTree(_VOID)
{
    if(CT_RegModes() != G_SUCCESS)
    {
        EOS_Printf("\r\n  Mode initial failed!");
        return G_FAILURE;
    }

    if(CT_InitModeObject() != G_SUCCESS)
    {
        EOS_Printf("\r\n  Root object register failed!");
        return G_FAILURE;
    }

    if(CT_RegModeCmd() != G_SUCCESS)
    {
        EOS_Printf("\r\n  Mode command register failed");
        return G_FAILURE;
    }

    return G_SUCCESS;
}

_U32 CT_RegisterUserType(_U32 *ulID,_S8 *szName,CT_TYPECHECK_FUNC_T pFunc)
{
    _U32 i;

    if((ulID == G_NULL) || (pFunc == G_NULL))
    {
        return G_FAILURE;
    }

    for(i = 0; i < CT_MAX_USERTYPES; i++)
    {
        if(m_sCliUserType[i].ucTypeID != (CT_DATA_USER+i))
        {
            if(m_sCliUserType[i].ucTypeID == 0)
            {
                m_sCliUserType[i].ucTypeID = (_U8)(CT_DATA_USER + i);
                if(szName != G_NULL)
                {
                    EOS_StrCpy(&m_sCliUserType[i].szTypeName[0],szName);
                }
                m_sCliUserType[i].pCheckFunc = pFunc;
                *ulID = m_sCliUserType[i].ucTypeID;
                return G_SUCCESS;
            }
            else
            {
                return G_FAILURE;
            }
        }
    }

    return G_FAILURE;
}


_U32 CT_FreeValue( CT_VALUE_P pValue )
{
    CT_VALUE_P pTemp,pValueNext;

    if(pValue == G_NULL)
        return G_FAILURE;

    pTemp = pValue;

    while( pTemp != G_NULL )
    {
        pValueNext = pTemp->pNext;

        /* 1、释放名字 */
        if(pTemp->szName != G_NULL) ROS_MemFree(pTemp->szName);


        /* 2、释放关键字 */
        if(pTemp->keywords.pKeyword != G_NULL)
            if(CT_FreeKeyword(pTemp->keywords.pKeyword) != G_SUCCESS)
            {
                //统计
            }

        /* 3、释放自己 */
        ROS_MemFree(pTemp);
        pTemp = pValueNext;

    }

    return G_SUCCESS;
}


_U32 CT_FreeKeyword(CT_SERIAL_WORD_P pKW)
{
    CT_SERIAL_WORD_P pKeyW, pNextKW;

    if(pKW == G_NULL)
        return G_FAILURE;

    pKeyW = pKW;

    while(pKeyW != G_NULL)
    {
        pNextKW = pKeyW->pNext;

        if(pKeyW->pK != G_NULL)
        {
            ROS_MemFree(pKeyW->pK);
        }

        ROS_MemFree(pKeyW);

        pKeyW = pNextKW;

    }

    return G_SUCCESS;
}

CT_SERIAL_WORD_P CT_NewKeywords(_S8 *szKeys, _U32 *ulCount)
{
    CT_SERIAL_WORD_P pKeyWord = G_NULL, p1 = G_NULL, pReturn = G_NULL;
    _S8 *TmpKey, KeyStr[MAX_TOKEN_SIZE];
    _U32 i;

    if((szKeys == G_NULL) || (ulCount == G_NULL))
        return G_NULL;

    *ulCount = 0;

    TmpKey = szKeys;
    i = 0;
    KeyStr[0] = 0;
    while(*TmpKey != 0)
    {
        if(*TmpKey == KEY_SPACE)
        {
            TmpKey++;
            continue;
        }
        else if(*TmpKey == ',')
        {
            if(i == 0)
            {
                TmpKey++; continue;
            }

            pKeyWord = CT_NewKeyword();
            if(pKeyWord == G_NULL)
                return G_NULL;
            pKeyWord->pK = ROS_MemAlloc(i+1, ROS_MEM_ALLOC_OPT_NONE);
            if(pKeyWord->pK == G_NULL)
            {
                    if(CT_FreeKeyword(pKeyWord) != G_SUCCESS)
                    {
                        //统计
                    }
                return G_NULL;
            }
            KeyStr[i]=0;
            EOS_StrCpy(pKeyWord->pK,&KeyStr[0]);
            (*ulCount)++;

            if(p1 != G_NULL)
            {
                p1->pNext = pKeyWord;
                pKeyWord->pPrevious = p1;
            }
            else
            {
                if(pReturn == G_NULL)
                    pReturn = pKeyWord;
            }
            p1 = pKeyWord;
            TmpKey++;
            i = 0;
            KeyStr[0] = 0;
        }
        else
        {
            KeyStr[i++] = *TmpKey++;
            if(i > 79)
                return G_NULL;
        }
    }

    if(i > 0)
    {
        pKeyWord = CT_NewKeyword();
        if(pKeyWord == G_NULL)
            return G_NULL;
        pKeyWord->pK = ROS_MemAlloc(i+1, ROS_MEM_ALLOC_OPT_NONE);
        if(pKeyWord->pK == G_NULL)
        {
                if(CT_FreeKeyword(pKeyWord) != G_SUCCESS)
                {
                    //统计
                }

            return G_NULL;
        }
        KeyStr[i]=0;
        EOS_StrCpy(pKeyWord->pK,&KeyStr[0]);
        (*ulCount)++;

        if(p1 != G_NULL)
        {
            p1->pNext = pKeyWord;
            pKeyWord->pPrevious = p1;
        }
        else
        {
            if(pReturn == G_NULL)
                pReturn = pKeyWord;
        }