lcp.cpp

基于单片机的 snmp协议解析的一些原代码 给有用的 同行

char LCP::GetConfigureRequestOptionType()
{
    return ((char) data[0]);
}
/**********************************************************************************
Check the Configure Request and scan the options list.  Currently, if any option is
unrecognizeable we reject it.  We scan, if we find an unacceptable value we will
return a NAK, but continue to scan to see if there is an unrecognizeable value for
which we return a REJECT.
**********************************************************************************/
long LCP::HandleConfigureRequest(long lastSentMagicNumber)
{
    char usedOptionLength=0;
    char optionType;
    char optionLength=0;
    unsigned char optionData[50];
    long magicNumber;
    long ret;
    long mru;
    long retVal = PPP_EVENT_RECEIVE_CONFIGURE_REQUEST_PLUS;

    memset(optionData, 0, 50);
    ret = GetOption(&usedOptionLength, &optionType, &optionLength, optionData);
    while (ret != END_OF_OPTION_LIST)
    {
        switch (optionType)
        {
            case PPP_OPTION_RESERVED:
                return LCP_CONFIGURE_REQUEST_OPTION_REJECT;
                break;
            case PPP_OPTION_MAXIMUM_RECEIVE_UNIT:
                mru = optionData[0]*256 + optionData[1];
                if (mru != 1500)
                    retVal = PPP_EVENT_RECEIVE_CONFIGURE_REQUEST_MINUS_NAK;

                break;
            case PPP_OPTION_ASYNC_CONTROL_CHARACTER_MAP:
             /*   if ((optionData[0] != 0xff) || (optionData[1] != 0xff) ||
                        (optionData[2] != 0xff) || (optionData[3] != 0x20))*/
                if ((optionData[0] != 0x0) || (optionData[1] != 0x0) ||
                        (optionData[2] != 0x0) || (optionData[3] != 0x0))
                    retVal = PPP_EVENT_RECEIVE_CONFIGURE_REQUEST_MINUS_NAK;
                break;
            case PPP_OPTION_AUTHENTICATION_PROTOCOL:
                if ((optionData[0] != 0xc2) || (optionData[1] != 0x23) ||
                    (optionData[2] != 0x05))
                    retVal = PPP_EVENT_RECEIVE_CONFIGURE_REQUEST_MINUS_NAK;
                break;
            case PPP_OPTION_MAGIC_NUMBER:
                magicNumber = GetMagicNumber();
                if (lastSentMagicNumber != 0) // if 0, then we never sent one
                {
                    if (magicNumber == lastSentMagicNumber)
                    {
                        PPP_EVENT_RECEIVE_CONFIGURE_REQUEST_MINUS_NAK;
                    }
                }
                break;
            case PPP_OPTION_QUALITY_PROTOCOL:
                retVal = PPP_EVENT_RECEIVE_CONFIGURE_REQUEST_MINUS_NAK;
                break;
            case PPP_OPTION_FCS_ALTERNATIVE:
            case PPP_OPTION_SELF_DESCRIBING_PAD:
            case PPP_OPTION_NUMBERED_MODE:
            case PPP_OPTION_CALLBACK:
            case PPP_OPTION_MULTILINK_OPTIONS:
            case PPP_OPTION_PROTOCOL_FIELD_COMPRESSION:
            case PPP_OPTION_ADDRESS_AND_CONTROL_FIELD_COMPRESSION:
            default:
                return LCP_CONFIGURE_REQUEST_OPTION_REJECT;
                break;
        }
        memset(optionData, 0, 50);
        ret = GetOption(&usedOptionLength, &optionType, &optionLength, optionData);
    };
    return retVal;
}
long LCP::FillOptionsList(LCP receivedMessage, string &newOptionsList, long newMessageType)
{
    char usedOptionLength=0;
    char optionType;
    char optionLength=0;
    char optionData[50];
    long ret;
    char temp[4];
    long magicNumber;
    long mru;

    memset(optionData, 0, 50);
    ret = receivedMessage.GetOption(&usedOptionLength, &optionType, &optionLength, optionData);
    while (ret != END_OF_OPTION_LIST)
    {
        if (newMessageType == PPP_LCP_CONFIGURE_NAK) // these are recognizeable, force to default
        {
            switch (optionType)
            {
                case PPP_OPTION_MAXIMUM_RECEIVE_UNIT:
                    mru = optionData[0]*256 + optionData[1];
                    if (mru != 1500)
                    {
                        newOptionsList.append(1, PPP_OPTION_MAXIMUM_RECEIVE_UNIT);
                        newOptionsList.append(1, (char)0x04);
                        newOptionsList.append(1, (char)0x05);
                        newOptionsList.append(1, (char)0xDC); // hardcode for now
                    }
                    break;
                case PPP_OPTION_ASYNC_CONTROL_CHARACTER_MAP:
                    if ((optionData[0] != 0x0) || (optionData[1] != 0x0) ||
                        (optionData[2] != 0x0) || (optionData[3] != 0x0))
                    {
                        newOptionsList.append(1,PPP_OPTION_ASYNC_CONTROL_CHARACTER_MAP);
                        newOptionsList.append(1, (char)0x06);
                        newOptionsList.append(1, (char)0x00);
                        newOptionsList.append(1, (char)0x00);
                        newOptionsList.append(1, (char)0x00);
                        newOptionsList.append(1, (char)0x00);
                    }
                    break;
                case PPP_OPTION_AUTHENTICATION_PROTOCOL:
                    if ((optionData[0] != 0xc2) || (optionData[1] != 0xc2) ||
                        (optionData[2] != 0x23) || (optionData[3] != 0x05))
                    {
                        newOptionsList.append(1, PPP_OPTION_AUTHENTICATION_PROTOCOL);
                        newOptionsList.append(1, (char)0x05); //length
                        newOptionsList.append(1, (char)0xc2); //CHAP protocol
                        newOptionsList.append(1, (char)0x23);
                        newOptionsList.append(1, (char)0x05); // MD5 algorithm
                    }
                    break;
                case PPP_OPTION_QUALITY_PROTOCOL:
                    newOptionsList.append(1, PPP_OPTION_QUALITY_PROTOCOL);
                    newOptionsList.append(1, (char)0x04);
                    newOptionsList.append(1, (char)0xc0);
                    newOptionsList.append(1, (char)0x25);
                    break;
                case PPP_OPTION_MAGIC_NUMBER:
                    if ((optionData[0] != 0x00) || (optionData[1] != 0x00) ||
                        (optionData[2] != 0x00) || (optionData[3] != 0x00))
                    {
                        newOptionsList.append(1, PPP_OPTION_MAGIC_NUMBER);
                        newOptionsList.append(1, (char)0x06);
                         /*magicNumber = receivedMessage.GetMagicNumber();
                            magicNumber++;
                            itoa(magicNumber, temp, 10);*/ // for VDOT, magic number = default = all 0
                        newOptionsList.append(1, (char)0x00);
                        newOptionsList.append(1, (char)0x00);
                        newOptionsList.append(1, (char)0x00);
                        newOptionsList.append(1, (char)0x00);
                    }
                    break;
                default:
                    return -1; // there must have been an internal error detecting the message type
            }
        }
        else if(newMessageType == PPP_LCP_CONFIGURE_REJECT) // these we reject
        {
            switch (optionType)
            {
                case PPP_OPTION_PROTOCOL_FIELD_COMPRESSION:
                    newOptionsList.append(1, PPP_OPTION_PROTOCOL_FIELD_COMPRESSION);
                    newOptionsList.append(1, (char)0x02);
                    break;
                case PPP_OPTION_ADDRESS_AND_CONTROL_FIELD_COMPRESSION:
                    newOptionsList.append(1, PPP_OPTION_ADDRESS_AND_CONTROL_FIELD_COMPRESSION);
                    newOptionsList.append(1, (char)0x02);
                    break;
                case PPP_OPTION_RESERVED:
                case PPP_OPTION_FCS_ALTERNATIVE:
                case PPP_OPTION_SELF_DESCRIBING_PAD:
                case PPP_OPTION_NUMBERED_MODE:
                case PPP_OPTION_CALLBACK:
                case PPP_OPTION_MULTILINK_OPTIONS:
                    newOptionsList.append(1, optionType);
                    newOptionsList.append(1, optionLength);
                    newOptionsList.append(optionData, optionLength);
                default:
                    break;
            }
        }
        else
            return 0;
        memset(optionData, 0, 50);
        ret = receivedMessage.GetOption(&usedOptionLength, &optionType, &optionLength, optionData);
    };
    return 0;
}
long LCP::GetMagicNumber()
{
    if (length!=6)
        return 0; //illegal magic number
    else
        return (long)((long)data.at(3) + 256 * ((long)data.at(2) + 256 * (long)(data.at(1) + 256 * (long)data.at(0))));
}
long LCP::GetOption(char *theUsedOptionLength, char *theOptionType, char *theOptionLength, char *theOptionData)
{
    if (data.length() >= (*theUsedOptionLength)+2) // need at least two bytes for the option
    {
        *theOptionType = data.at((*theUsedOptionLength)++);
        *theOptionLength = data.at((*theUsedOptionLength)++);
        for (int i=0; i < *theOptionLength-2; i++)  //should throw exception if *theOptionLength > data.size()
            theOptionData[i] = data[(*theUsedOptionLength)++];
        return *theOptionLength;
    }
    return END_OF_OPTION_LIST;
}
string LCP::GetOptionString(long theOptionType)
{
    string newOptionsList;
    char temp[1500];
    long magicNumber;

    memset(temp, 0, 1500);

    switch(theOptionType)
    {
        case PPP_OPTION_MAXIMUM_RECEIVE_UNIT:
            newOptionsList.assign(1,PPP_OPTION_MAXIMUM_RECEIVE_UNIT);
            newOptionsList.append(1, (char)0x04);
           // itoa(1500, temp, 10);
            newOptionsList.append(1, (char)0x05);
            newOptionsList.append(1, (char)0xDC);
            //newOptionsList.append(temp);
            break;
        case PPP_OPTION_ASYNC_CONTROL_CHARACTER_MAP:
            newOptionsList.assign(1, PPP_OPTION_ASYNC_CONTROL_CHARACTER_MAP);
            newOptionsList.append(1, (char)0x06);
            itoa(0xffffff20, temp, 16);               // does not support new ones
            newOptionsList.append(temp);
            break;
        case PPP_OPTION_AUTHENTICATION_PROTOCOL:
            newOptionsList.assign(1, PPP_OPTION_AUTHENTICATION_PROTOCOL);
            newOptionsList.append(1, (char)0x05);
            newOptionsList.append(1, (char)0xc2);
            newOptionsList.append(1, (char)0x23);
            newOptionsList.append(1, (char)0x05);
            break;
        case PPP_OPTION_QUALITY_PROTOCOL:
            newOptionsList.assign(1, PPP_OPTION_QUALITY_PROTOCOL);
            newOptionsList.append(1, (char)0x04);
            newOptionsList.append(1, (char)0xc0);
            newOptionsList.append(1, (char)0x25);
            break;
        case PPP_OPTION_MAGIC_NUMBER:
            newOptionsList.assign(1, PPP_OPTION_MAGIC_NUMBER);
            newOptionsList.append(1, (char)0x06);
//            magicNumber = receivedMessage.GetMagicNumber();  // does not support user input
            magicNumber=9876;
            //itoa(magicNumber, temp, 10);
            //newOptionsList.append(temp);
            newOptionsList.append(1, (char)0x0);
            newOptionsList.append(1, (char)0x0);
            newOptionsList.append(1, (char)0x87);
            newOptionsList.append(1, (char)0xFE);
            break;
        case PPP_OPTION_PROTOCOL_FIELD_COMPRESSION:
            newOptionsList.assign(1, PPP_OPTION_PROTOCOL_FIELD_COMPRESSION);
            newOptionsList.append(1, (char)0x02);
            break;
        case PPP_OPTION_ADDRESS_AND_CONTROL_FIELD_COMPRESSION:
            newOptionsList.assign(1, PPP_OPTION_ADDRESS_AND_CONTROL_FIELD_COMPRESSION);
            newOptionsList.append(1, (char)0x02);
            break;
        case PPP_OPTION_RESERVED:
        case PPP_OPTION_FCS_ALTERNATIVE:
        case PPP_OPTION_SELF_DESCRIBING_PAD:
        case PPP_OPTION_NUMBERED_MODE:
        case PPP_OPTION_CALLBACK:
        case PPP_OPTION_MULTILINK_OPTIONS:
        default:
            break;
    }
    return newOptionsList;
}
void LCP::GetSelectedOptions(long *numOptions, long *optionsList)
{
    options.GetSelectedOptions(numOptions, optionsList);
}
long LCP::GetAuthenticationProtocol()
{
    return(options.GetAuthenticationProtocol());
}

void LCP::GetLCPOptions( long *maximumReceiveUnit, string *asyncControlCharacterMap,
    long *authenticationProtocol, long *qualityProtocol, long *magicNumber,
    bool *protocolFieldCompression, bool *addressControlFieldCompression,
    long *reserved, long *FCSAlternative, bool *selfDescribingPad, bool *numberedMode,
    bool *callback, bool *multilinkOptions)
{
    options.GetLCPOptions( maximumReceiveUnit, asyncControlCharacterMap,
        authenticationProtocol, qualityProtocol, magicNumber,
        protocolFieldCompression, addressControlFieldCompression,
        reserved, FCSAlternative, selfDescribingPad, numberedMode,
        callback, multilinkOptions);
}
void LCP::SetLCPOptions(long maximumReceiveUnit, string asyncControlCharacterMap,
    long authenticationProtocol, long qualityProtocol, long magicNumber,
    bool protocolFieldCompression, bool addressControlFieldCompression,
    long reserved, long FCSAlternative, bool selfDescribingPad, bool numberedMode,
    bool callback, bool multilinkOptions)
{
    options.SetLCPOptions(maximumReceiveUnit, asyncControlCharacterMap,
        authenticationProtocol, qualityProtocol, magicNumber,
        protocolFieldCompression, addressControlFieldCompression,
        reserved, FCSAlternative, selfDescribingPad, numberedMode,
        callback, multilinkOptions);
}