lcp.cpp

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

//---------------------------------------------------------------------------
//#include <vcl\vcl.h>
//#pragma hdrstop
#include <string>
#include <memory>
using namespace std;

#include "lcp.h"
#include "linkDefs.h"
//---------------------------------------------------------------------------
//unsigned char LCP::identifier=0;

LCP::LCP()
{
// 	memset(data, 0, 1024);
    code=0;
    identifier=0;
    length=0;
}
LCP::~LCP()
{
}
void LCP::GetMessageType(string &type)
{
	switch (code)
    {
    	case PPP_LCP_CONFIGURE_REQUEST:
        	type.assign("LCP Configure Request");
            break;
		case PPP_LCP_CONFIGURE_ACK:
        	type.assign("LCP Configure Ack");
            break;
    	case PPP_LCP_CONFIGURE_NAK:
        	type.assign("LCP Configure Nak");
            break;
    	case PPP_LCP_CONFIGURE_REJECT:
        	type.assign("LCP Configure Reject");
            break;
    	case PPP_LCP_TERMINATE_REQUEST:
        	type.assign("LCP Terminate Request");
            break;
    	case PPP_LCP_TERMINATE_ACK:
        	type.assign("LCP Terminate Ack");
        	break;
    	case PPP_LCP_CODE_REJECT:      // we're rejected, different version, so close the link
        	type.assign("LCP Code Reject");
            break;
    	case PPP_LCP_PROTOCOL_REJECT:   // don't handle this yet
        	type.assign("LCP Protocol Reject");
        	break;
    	case PPP_LCP_ECHO_REQUEST:
        	type.assign("LCP Echo Request");
            break;
    	case PPP_LCP_ECHO_REPLY:
        	type.assign("LCP Echo Reply ");
            break;
    	case PPP_LCP_DISCARD_REQUEST:
        	type.assign("LCP Discard Request");
            break;
        default:
        	type.assign("LCP Invalid Code");
        	break;
    }
}
void LCP::FillLCP(string &theData)
{
	code = theData.at(0);
    identifier = theData.at(1);
    length = theData.at(2) * 256 + theData.at(3);
/*    memset(data, 0, 1024);
    memcpy(data, &(theData[4]), length-4);*/
    data.assign(theData); //assign the rest of the message to the 'data' field
    data.erase(0,4);
    SetPacketTime();
}
unsigned char LCP::GetCode()
{
	return code;
}
unsigned char LCP::GetIdentifier()
{
	return identifier;
}
unsigned short LCP::GetLength()
{
	return length;
}
unsigned short LCP::GetData( string &dataArray)
{
 	//dataArray = new unsigned char [data.length()];
    //memcpy(dataArray, data.c_str(), data.length());
    dataArray.assign(data);
    return (data.length());
}
unsigned short LCP::GetPacket(string &packet)
{

    packet.assign("");
    packet.append(1, code);
   	packet.append(1, identifier);
    packet.append(1, (unsigned char)(length/256));
    packet.append(1, (unsigned char)(length%256));
    packet.append(data);

    return (packet.length());
}
//
// LCP.GenerateResponse takes an LCP argument as a received message, and
// populates the owning object with the response packet
//
long LCP::GetEvent(LCP lastSentLCP, long lastSentMagicNumber)
{
    char type;
    long ret;

	switch (code)
    {
    	case PPP_LCP_CONFIGURE_REQUEST:
            type = GetConfigureRequestOptionType();
            ret = HandleConfigureRequest(lastSentMagicNumber);
            if (ret == LCP_CONFIGURE_REQUEST_OPTION_REJECT)
                return PPP_EVENT_RECEIVE_CONFIGURE_REQUEST_MINUS_REJECT;
            else if (ret == LCP_CONFIGURE_REQUEST_OPTION_FORCE_DEFAULT)
                return PPP_EVENT_RECEIVE_CONFIGURE_REQUEST_MINUS_NAK;
            else if (ret == LCP_CONFIGURE_REQUEST_OPTION_ACCEPT)
                return PPP_EVENT_RECEIVE_CONFIGURE_REQUEST_PLUS;
            else
                return ret;
            break;
		case PPP_LCP_CONFIGURE_ACK:
        	if (lastSentLCP.GetCode() == PPP_LCP_CONFIGURE_REQUEST)
            	return PPP_EVENT_RECEIVE_CONFIGURE_ACK;
            break;
    	case PPP_LCP_CONFIGURE_NAK:
    	case PPP_LCP_CONFIGURE_REJECT:
        	if (lastSentLCP.GetCode() == PPP_LCP_CONFIGURE_REQUEST)
            	return PPP_EVENT_RECEIVE_CONFIGURE_NAK_REJ;
            break;
    	case PPP_LCP_TERMINATE_REQUEST:
			return PPP_EVENT_RECEIVE_TERMINATION_REQUEST;
            break;
    	case PPP_LCP_TERMINATE_ACK:
			return PPP_EVENT_RECEIVE_TERMINATE_ACK;
        	break;
    	case PPP_LCP_CODE_REJECT:      // we're rejected, different version, so close the link
            if (lastSentLCP.GetCode() == PPP_LCP_CONFIGURE_REQUEST)
        		return PPP_EVENT_RECEIVE_CODE_REJECT_MINUS;
            else
            	return PPP_EVENT_RECEIVE_CODE_REJECT_PLUS;
            break;
    	case PPP_LCP_PROTOCOL_REJECT:   // don't handle this yet
        	return PPP_EVENT_RECEIVE_CODE_REJECT_MINUS;
        	break;
    	case PPP_LCP_ECHO_REQUEST:
        	return PPP_EVENT_ECHO_REQUEST;
            break;
    	case PPP_LCP_ECHO_REPLY:
        	return PPP_EVENT_ECHO_REPLY;
            break;
    	case PPP_LCP_DISCARD_REQUEST:
        	return PPP_EVENT_DISCARD_REQUEST;
            break;
        default:
        	return LCP_INVALID_CODE;
        	break;
    }
}

void LCP::AssignConfigureRequest()
{
	code = PPP_LCP_CONFIGURE_REQUEST;
    identifier = ++identifierCounter;
    length=4;
 	data.assign("");
    SetPacketTime();
}
void LCP::AppendConfigureRequestOption(unsigned long option, long optionType)
{
    AppendConfigureRequestOption(option, GetOptionString(optionType));
}
void LCP::AppendConfigureRequestOption(unsigned long option, string theOptionData)
{
 	data.append(theOptionData);
    length=length+theOptionData.length();
    SetPacketTime();
}
void LCP::AssignConfigureRequest(unsigned char ident)
{
	code = PPP_LCP_CONFIGURE_REQUEST;
    identifier = ident;
    length=4;
 	data.assign("");
    SetPacketTime();
}
void LCP::AssignConfigureAck(LCP receivedMessage)
{
    string theData;

	code = PPP_LCP_CONFIGURE_ACK;
	identifier = receivedMessage.GetIdentifier();
    length = receivedMessage.GetLength();
 	receivedMessage.GetData(theData);
    data.assign(theData);
    SetPacketTime();
}
void LCP::AssignConfigureNak(LCP receivedMessage)
{
    string optionsList;

	code = PPP_LCP_CONFIGURE_NAK;
   	identifier = receivedMessage.GetIdentifier();
        // first fill in the options, as we only use the unacceptable options, so
        // this message may be smaller than the received Configure Request
    FillOptionsList(receivedMessage, optionsList, PPP_LCP_CONFIGURE_NAK);
    length = 4 + optionsList.length();
 	data.assign(optionsList);
    SetPacketTime();
}
void LCP::AssignConfigureReject(LCP receivedMessage)
{
 	string optionsList;

  	code = PPP_LCP_CONFIGURE_REJECT;
	identifier = receivedMessage.GetIdentifier();
        // first fill in the options, as we only use the unrecognizeable options, so
        // this message may be smaller than the received Configure Request
    FillOptionsList(receivedMessage, optionsList, PPP_LCP_CONFIGURE_REJECT);
    length = 4 + optionsList.length();
 	data.assign(optionsList);
    SetPacketTime();
}
void LCP::AssignTerminateRequest()
{
	code = PPP_LCP_TERMINATE_REQUEST;
    identifier = identifierCounter;
    length = 4;
 	data.assign("");
    SetPacketTime();
}
void LCP::AssignTerminateRequest(unsigned char ident)
{
	code = PPP_LCP_TERMINATE_REQUEST;
    identifier = ident;
    length = 4;
 	data.assign("");
    SetPacketTime();
}
void LCP::AssignTerminateAck(unsigned char ident)
{
 	code = PPP_LCP_TERMINATE_ACK;
    identifier = ident;
    length = 4;
 	data.assign("");
    SetPacketTime();
}
void LCP::AssignCodeReject(LCP receivedLCP)
{
	string options;

 	code = PPP_LCP_CODE_REJECT;
    identifier = receivedLCP.GetIdentifier() + 1;
 	receivedLCP.GetData(options);
    length = 4 + options.length();
    data.assign(options);
    SetPacketTime();
}
void LCP::AssignProtocolReject(LCP receivedLCP)
{
	string options;

 	code = PPP_LCP_PROTOCOL_REJECT;
    identifier = receivedLCP.GetIdentifier() + 1;
 	receivedLCP.GetData(options);
    data.assign(options);
	length = 4 + options.length();
    SetPacketTime();
}
void LCP::AssignEchoRequest(unsigned char ident)
{
	code = PPP_LCP_ECHO_REQUEST;
    identifier = ident;
    length = 8;
 	data.assign("0000");    //magic number 0 for now
    SetPacketTime();
}
void LCP::AssignEchoReply(unsigned char ident)
{
	code = PPP_LCP_ECHO_REPLY;
    identifier = ident;
    length = 8;
 	data.assign("0000");    //magic number 0 for now
    SetPacketTime();
}
void LCP::AssignDiscardRequest(unsigned char ident)
{
    code = PPP_LCP_DISCARD_REQUEST;
    identifier = ident;
    length=8;
    data.assign("0000");
    SetPacketTime();
}
void LCP::SetPacketTime()
{
	timeOfPacket = GetTickCount();
}
unsigned long LCP::GetPacketTime()
{
	return timeOfPacket;
}