cli_lib.c

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

                    break;
                ucTmpMask = (_S8)(ucTmpMask << 1);
            }
            if((i == 8) && (ucByte != 0))
                return G_FAILURE;
            if((ucTmpMask != 0xff) && (ulAllOne == 1))
                ulAllOne = 0;
            else if((ucTmpMask != 0x00) && (ulAllOne == 0))
                return G_FAILURE;
            pTmp[0] = pTmp[1] = pTmp[2] = pTmp[3] = '\0';
            if(*pData == '\0')
            {
                if(ulCount < 4)
                    return G_FAILURE;
                return G_SUCCESS;
            }
        }
        else return G_FAILURE;
        pData ++;
        ulIpByte ++;
    }
}


_U32 _VerifyMACAddress(_S8 *szMACAdd)
{
    _S8 *pData;
    _U32 ulCount = 0, ulIpByte = 0;
    _S8 pTmp[3];

    pData = szMACAdd;
    pTmp[0] = pTmp[1] = pTmp[2] = '\0';
    if(pData == G_NULL)
    {
        MT_ERRLOG(0);
        return G_FAILURE;
    }

    for(;;)
    {
        if (((*pData >= '0') && (*pData <= '9'))
          ||((*pData >= 'a') && (*pData <= 'f'))
          ||((*pData >= 'A') && (*pData <= 'F')))
        {
            if(ulIpByte > 1)
                return G_FAILURE;
            pTmp[ulIpByte] = *pData;
        }
        else if((*pData == '-') || (*pData == '\0'))
        {
            ulCount ++;
            if(ulIpByte != 2)
                return G_FAILURE;
            ulIpByte = (_U32)-1;
            if((ulCount > 6) || (pTmp[0] == '\0'))
                return G_FAILURE;
            pTmp[0] = pTmp[1] = pTmp[2] = '\0';
            if(*pData == '\0')
            {
                if(ulCount < 6)
                    return G_FAILURE;
                return G_SUCCESS;
            }
        }
        else return G_FAILURE;
        pData ++;
        ulIpByte ++;
    }

}

_U32 _AffirmStrBeLower(_S8 *szStr)
{
    _U32 ulTail, ulCur;

    if (szStr == G_NULL)
    {
        MT_ERRLOG(0);
        return G_FAILURE;
    }

    ulTail = strlen(szStr);
    for(ulCur = 0; ulCur < ulTail; ulCur++)
    {
        if (*(szStr + ulCur) <= 'Z' && *(szStr + ulCur) >= 'A')
        {
            *(szStr + ulCur) += 'a' - 'A';
        }
    }
    return G_SUCCESS;
}

int _Split(_S8 **Sour,_S8 *Dest,_S8 flag,int Len)
{
  register _S8 *temp;
  register int i=0;

  temp=*Sour;
  for (; ;)
  {
      if (*temp==flag)
      {
          *Sour=temp+1;
          *Dest='\0';
          return 1;
      }
      else
      if (!(*temp))
      {
          *Sour=temp;
          *Dest='\0';
          return 0;
      }
      else
      if (i==Len)
      {
          *Sour=temp;
          *Dest='\0';
          return 2;
      }
      else
      {
          *Dest++=*temp++;
          i++;
      }
  }
}

_U32 _StrToIPAddr(_S8 *string, _U32 *ulRet)
{
    _S8 stemp[300];
    _U32 a,b,c,d;

    if (_Split(&string,stemp,'.',300)!=1)
        return G_FAILURE;

    if (!*stemp)
        return G_FAILURE;

    if (_atou(stemp,&a))
        return G_FAILURE;

    if (a>255)
        return G_FAILURE;

    if (_Split(&string,stemp,'.',300)!=1)
        return G_FAILURE;

    if (!*stemp)
        return G_FAILURE;

    if (_atou(stemp,&b))
        return G_FAILURE;

    if (b>255)
        return G_FAILURE;

    if (_Split(&string,stemp,'.',300)!=1)
        return G_FAILURE;

    if (!*stemp)
        return G_FAILURE;

    if (_atou(stemp,&c))
        return G_FAILURE;

    if (c>255)
        return G_FAILURE;

    if (_Split(&string,stemp,'\0',300)!=1)
        return G_FAILURE;

    if (!*stemp)
        return G_FAILURE;

    if (_atou(stemp,&d))
        return G_FAILURE;

    if (d>255)
        return G_FAILURE;

    *ulRet =htonl((a<<24)+(b<<16)+(c<<8)+d);

    return G_SUCCESS;
}

_S8 *_IPAddrToStr(_U32 ulIPAddr, _S8 *string)
{
    if (G_NULL == string)
    {
        MT_ERRLOG(0);
        return 0;//for 代码审查
    }
    /* IPAddr都是网络字节顺序 */
    ulIPAddr=ntohl(ulIPAddr);
    EOS_Sprintf((_S8 *)string,"%d.%d.%d.%d",
        ulIPAddr>>24,(ulIPAddr>>16)&0xff,
        (ulIPAddr>>8)&0xff,ulIPAddr&0xff);
    return string;
}

int _atoulx(register _S8 *Sour,unsigned long * pTemp)
{
  register unsigned long ulResult=0;
  register unsigned char ch;
  if (Sour == G_NULL || pTemp == G_NULL)
  {
      MT_ERRLOG(0);
      return 1;
  }

  if (*Sour == '0' && *(Sour + 1) == 'x')
    Sour += 2;

  while (*Sour)
  {
      /* count */
      ch=(_U8)toupper(*Sour);
      if (isdigit(ch) || ((ch>='A') && (ch<='F')))
      {
          if (ulResult<0x10000000)
              ulResult=ulResult*16+((ch<='9')?(ch-48):(ch-55));
          else
          {
              *pTemp=ulResult;
              return 1;
          }
      }
      else
      {
          *pTemp=ulResult;
          return 1;
      }
      Sour++;
  }
  *pTemp=ulResult;
  return 0;
}

int _atoul(register _S8 *Sour,_U32 * pTemp)
/* 0:success 1:failure */
{
    _U32 ulResult=0;

    if (Sour == G_NULL || pTemp == G_NULL)
    {
        MT_ERRLOG(0);
        return 1;
    }

    while (*Sour)
    {
        /* count */
        if (isdigit(*Sour))
        {
            if ((ulResult<429496729) || ((ulResult==429496729) && (*Sour<'6')))
                ulResult = (_U32)(ulResult*10 + (_U8)((*Sour)-48));
            else
            {
                *pTemp=ulResult;
                return 1;
            }
        }
        else
        {
            *pTemp=ulResult;
            return 1;
        }
        Sour++;
    }
    *pTemp=ulResult;
    return 0;
}

int _atol(_S8 *szSrc, _S32 *ulVal)
{
    _U32 ulFlag = 0;
    _U32 ulTmp;

    if (szSrc == G_NULL || ulVal == G_NULL)
    {
        MT_ERRLOG(0);
        return 1;
    }
    if (*szSrc == '-')
    {
        ulFlag = 1;
        szSrc++;
    }

    if (_atoul(szSrc, &ulTmp) != 0)
    {
        return 1;
    }

    if (ulFlag == 1)
        *ulVal = 0 - (_S8)ulTmp;
    else
        *ulVal = (_S8)ulTmp;
    return 0;
}

int _atou(_S8 *Sour,_U32 * pTemp)
/* 0:success 1:failure */
{
  _U32 uResult=0;

  if (Sour == G_NULL || pTemp == G_NULL)
  {
      MT_ERRLOG(0);
      return 1;
  }

  while (*Sour)
  {
      /* count */
      if (isdigit(*Sour))
      {
          if ((uResult<6553) || ((uResult==6553) && (*Sour<'6')))
              uResult = (_U32)(uResult * 10 + (_U8)(*Sour - 48));
          else
          {
              *pTemp=uResult;
              return 1;
          }
      }
      else
      {
          *pTemp=uResult;
          return 1;
      }
      Sour++;
  }
  *pTemp=uResult;
  return 0;
}

int _atoux(register _S8 *Sour,unsigned short * pTemp)
/* 0:success 1:failure */
{
  register unsigned short uResult=0;
  register unsigned char ch;

  if (Sour == G_NULL || pTemp == G_NULL)
  {
      MT_ERRLOG(0);
      return 1;
  }

  while (*Sour)
  {
      /* count */
      ch=(_U8)toupper(*Sour);
      if (isdigit(ch) || ((ch >= 'A') && (ch <= 'F')))
      {
          if (uResult<0x1000)
              uResult=(_U16)(uResult*16+((ch<='9')?(ch-48):(ch-55)));
          else
          {
              *pTemp=uResult;
              return 1;
          }
      }
      else
      {
          *pTemp=uResult;
          return 1;
      }
      Sour++;
  }
  *pTemp=uResult;
  return 0;
}


/*==================================================================*/
/*      函数名      : _strtol                                       */
/*      函数功能    : 串转换成长整数                                */
/*      输入参数    : _S8 *str 字符串                              */
/*                    ULONG base 基数                               */
/*      输出参数    : 无                                            */
/*      返回值      : ULONG  0: 失败                                */
/*                         > 0: 成功                                */
/*      调用函数    :                                               */
/*      被调函数    :                                               */
/*==================================================================*/
_U32 _strtol(const _S8 *str, _U32 base)
{
    _U32 val = 0 ;
    _S8 *ptr ;

    if (str == G_NULL || base == G_NULL)
    {
        MT_ERRLOG(0);
        return 1;
    }

    while (isspace(*str))
        str++ ;

    ptr = (_S8 *)str ;
    if ( (*ptr == '0') && (tolower(*(ptr+1)) == 'x') )
    {
        if (!base)
            base = 16 ;
        ptr += 2 ;
    }
    if (!base)
        base = 10 ;

    if (strlen(ptr) > 8)
        return 0 ;

    while (*ptr)
    {
        if ( (base == 16 && !isxdigit(*ptr)) || (base == 10 && !isdigit(*ptr)))
        {
            return 0 ;
        }

        val = val*base + (isdigit(*ptr) ? (ULONG)(int)(*ptr-'0') : \
                            (islower(*ptr) ? (ULONG)(int)(*ptr-'a'+10) : \
                            (ULONG)(int)(*ptr-'A'+10))) ;
        ptr++ ;
    }

    return val ;
} /* End of function _strtol() */

_U32 _IsChar(_S8 c)
{
    if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
        return 0;
    else
        return 1;
}

_U32 _IsCmdChar(_S8 c)
{
    if (_IsChar(c) == G_SUCCESS || c == '-' || isdigit(c))
        return G_SUCCESS;
    else
        return G_FAILURE;
}