pppasyncframing.c

这是全套的PPP协议的源码

/* pppAsyncFraming.c - PPP Asynchronous HDLC Framing */

/* Copyright 1999 Wind River Systems, Inc. */
#include "copyright_wrs.h"

/*
modification history
--------------------
01w,07oct02,ijm increment bad address,bad control and packet too long counters,
                SPR#81713
01v,04oct02,ijm subscribe to PPP_LINK_RESET_EVENT, SPR# 82369
01u,25jun02,rp  adding missed multilink patch 2 changes
01t,28may02,rvr fixed build warnings 
01s,01may02,as  avoided memcopy in the decompress_ppp_header to access the 
                protocol id for arm fixes
01r,17dec01,mk  added macros to correct alignment problems
01q,16apr01,ijm corrected mBlkPktHdr settings
01p,17dec00,ihw support checksum bytes across cluster boundaries on recvd frames
01o,20nov00,ihw when looking at previous bytes for detecting occurences of
             	duplicate escape sequences, mind cluster boundaries-Ian Willats
01n,29sep00,sj  Merging in and reorganizing RFC2233 instrumentation
01m,29sep00,sj  merging with TOR2_0-WINDNET_PPP-CUM_PATCH_2
01l,02aug00,adb  Merging in LAC modifications
01k,01aug00,adb  Merging with openstack view except RFC 2233
01j,31jul00,md  initializes collectPppAttributesEvent01j,30jun00,md  
                fix prototype error
01i,29jun00,md  subscribed COLLECT_PPP_ATTRIBUTES_EVENT
01h,17apr00,sj  use length of frame as size for decoded frame buffer
01g,16mar00,cn  updated documentation.
01f,07mar00,sj  use/generate mBuf chains on receive path
01e,02mar00,sj  On the send path no ACCompression for LCP packets and get 
             	clusters on demand
01d,23feb00,sj  Pedandic ANSI fixes
01c,15feb00,cn  Modified send and receive routines to allow for chained
		mBlks, also defaulted to 16-bit checksum in 
		pppAsyncFramingStackDataConstruct ().
01b,11nov99,sgv Modified to the latest framework
01a,12sep99.sgv Derived from routerware PPP codebase
*/

/*
DESCRIPTION
This component implements PPP Asynchronous HDLC framing 
as specified in RFC 1662. It resides in the framing layer of the framing plane.
*/

#include "vxWorks.h"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "ctype.h"
#include "memLib.h"
#include "inetLib.h"
#include "hostLib.h"
#include "netBufLib.h"
#include "ioLib.h"
#include "logLib.h"
#include "pfw/pfw.h"
#include "pfw/pfwStack.h"
#include "pfw/pfwComponent.h"
#include "pfw/pfwTimer.h"
#include "pfw/pfwLayer.h"
#include "pfw/pfwEvent.h"
#include "pfw/pfwInterface.h"
#include "pfw/pfwMemory.h"
#include "ppp/kppp.h"
#include "ppp/pppLacStructures.h"
#include "private/ppp/vpppstr.h"
#include "ppp/pppAsyncFramingComponent.h"
#include "ppp/interfaces/lcpInterfaces.h"
#include "ppp/interfaces/pppInterfacesGroupInterfaces.h"
#include "ppp/pppChecksum.h"


/* defines */

#define PPP_ALLSTATIONS 0xFF
#define PPP_UI          0x03    /* Unnumbered Information */

#define PPP_HDRLEN      4       /* sizeof(struct ppp_header) must be 4 */

/* typedefs */

typedef struct asyncFramingStackData
    {
    unsigned long localToPeerACCompression;
    unsigned long peerToLocalACCompression;
    unsigned long localToPeerProtocolCompression;
    unsigned long peerToLocalProtocolCompression;
    unsigned long localToPeerACCMap;
    unsigned long peerToLocalACCMap;
    unsigned  int localMru;
    unsigned  int remoteMru;
    unsigned  int transmitFcsSize;
    unsigned  int receiveFcsSize;
    BOOL          frameCheckSequenceEnabled;
    NET_POOL_ID   netPoolId;
    unsigned  int bytesSent;
    unsigned  int bytesRcvd;
    unsigned  int inputBytes;
    unsigned  int inputErrors;
    unsigned  int mru;
    unsigned  int flags;
    PFW_PLUGIN_OBJ_CALLBACKS    * callbacks;
    PFW_EVENT_OBJ * lcpUpEvent;
    PFW_EVENT_OBJ * pppLinkResetEvent;
    PFW_INTERFACE_STATE_PAIR pppLinkStatusInterface;
    PFW_INTERFACE_STATE_PAIR pppLinkCounterInterface;
    PFW_EVENT_OBJ *collectPppAttributesEvent;

    /* auxiliary variables aiding RFC 2233 counters's implementation */

    int            pfwAuxIfId;
    PFW_INTERFACE_STATE_PAIR pfwRFC2233CountPair;
    BOOL           pfwRFC2233CountTest;

    } ASYNC_FRAMING_STACK_DATA;

typedef struct _PPP_HEADER
    {
    BYTE                             hdlc_address;
    BYTE_ENUM (LLC_FRAME_TYPE)       hdlc_control;
    USHORT_ENUM (PPP_PROTOCOL_TYPE)  protocol_type;
    }_WRS_PACK_ALIGN(1) _PPP_HEADER;

typedef struct _PPP_PACKET
    {
    _PPP_HEADER                   header;
    BYTE_ENUM (PPP_CONTROL_CODE)  code;
    BYTE                          id;
    USHORT                        length;
    BYTE                          data[VARIABLE_NUMBER_OF_BYTES];
    }_WRS_PACK_ALIGN(1) _PPP_PACKET;

#if     _BYTE_ORDER==_BIG_ENDIAN
#define BIG_ENDIAN_CONSTANT(ushort) ushort
#else   /* Little Endian */
#define BIG_ENDIAN_CONSTANT(ushort) (((0x00ff & ushort) << 8) | (ushort >> 8))
#endif  /* _BYTE_ORDER==_BIG_ENDIAN */

/* defines */

#define PARAMETER_NUMBER_SERIAL 1
LOCAL STATUS pppAsyncFramingSend (PFW_PLUGIN_OBJ_STATE *, M_BLK_ID *);
LOCAL STATUS pppAsyncFramingReceive (PFW_PLUGIN_OBJ_STATE *, M_BLK_ID *);
LOCAL STATUS pppAsyncFramingStackAdd (PFW_PLUGIN_OBJ_STATE *, 
	PFW_PLUGIN_OBJ_CALLBACKS * callbacks);
LOCAL STATUS pppAsyncFramingStackDelete (PFW_PLUGIN_OBJ_STATE *);
LOCAL BOOL encode_byte (ULONG *async_control_character_map, 
	BYTE byte_to_encode);
LOCAL STATUS convertNormalDataToAsynchronousData (PFW_PLUGIN_OBJ_STATE *state,
						 M_BLK_ID srcPacket,
						 M_BLK_ID destPacket);
LOCAL STATUS convertAsynchronousDataToNormalData (PFW_PLUGIN_OBJ_STATE *state,
						 M_BLK_ID inFrame,
						 M_BLK_ID outPacket);

LOCAL STATUS decompress_ppp_header (PFW_PLUGIN_OBJ_STATE *state,
    	M_BLK_ID packet);
LOCAL STATUS pppAsyncFramingStackDataConstruct (PFW_OBJ *,void * stackData,void * profileData);

LOCAL STATUS pppAsyncFramingLcpUpEventHandler (PFW_PLUGIN_OBJ_STATE *, void *eventData); 

LOCAL STATUS pppAsyncFramingLinkResetEventHandler (PFW_PLUGIN_OBJ_STATE *, void *eventData);

LOCAL STATUS AsyncFrameEventHandler
    (
    PFW_PLUGIN_OBJ_STATE * state,
    void *eventData
    );


/*******************************************************************************
* pppAsyncFramingComponentCreate - create the asynchronous framing component 
*
* This routine creates the asynchronous HDLC framing component plugin object
* and adds it to the specified framework.
*
* RETURNS: OK or ERROR
*/

STATUS pppAsyncFramingComponentCreate
    (
    PFW_OBJ *pfw
    )
    {
    PFW_COMPONENT_OBJ *pAsyncFramingComponent;
    pAsyncFramingComponent = (PFW_COMPONENT_OBJ *) pfwMalloc (pfw,
                                                sizeof (PFW_COMPONENT_OBJ));

    if (pAsyncFramingComponent == NULL)
        {
        printf ("pppAsyncFramingInit - Unable to allocate memory of size %d \
		 bytes\n", (int) sizeof (PFW_COMPONENT_OBJ));
        return (ERROR);
        }

    bzero ((void *)pAsyncFramingComponent, sizeof (PFW_COMPONENT_OBJ));

    strcpy (pAsyncFramingComponent->pluginObj.name, "ASYNC_FRAMING");
    pAsyncFramingComponent->pluginObj.pfwObj = pfw;
    pAsyncFramingComponent->layerObj = pfwLayerObjGet (pfw, "FRAMING_LAYER");
    pAsyncFramingComponent->pluginObj.profileDataSize =  0;
    pAsyncFramingComponent->pluginObj.stackDataSize = 
					sizeof (ASYNC_FRAMING_STACK_DATA);

    pAsyncFramingComponent->protocol = 0;
    pAsyncFramingComponent->pluginObj.profileDataConstruct  = NULL;
    pAsyncFramingComponent->pluginObj.profileDataCopy = NULL;
    pAsyncFramingComponent->pluginObj.profileDataDestruct = NULL;
    pAsyncFramingComponent->pluginObj.receive = pppAsyncFramingReceive;
    pAsyncFramingComponent->pluginObj.send = pppAsyncFramingSend;
    pAsyncFramingComponent->pluginObj.stackAdd = pppAsyncFramingStackAdd;
    pAsyncFramingComponent->pluginObj.stackDelete = pppAsyncFramingStackDelete;
    pAsyncFramingComponent->pluginObj.stackDataConstruct = 
				      pppAsyncFramingStackDataConstruct;
    pAsyncFramingComponent->pluginObj.stackDataDestruct = NULL;
    pAsyncFramingComponent->pluginObj.stackDataShow = NULL;

    if (pfwComponentAdd (pAsyncFramingComponent) == ERROR)
        {
        printf("pppAsyncInit  Async Driver cannot be added to the framework\n");
        return (ERROR);
        }

    return (OK);
    }

/*******************************************************************************
*
* pppAsyncFramingComponentDelete - delete the asynchronous framing component 
*
* The asynchronous framing plug-in component object allocated by 
* pppAsyncFramingComponentCreate(), is freed if there are no references 
* to this object from a stack or profile object in the specified framework.
*
* RETURNS: OK or ERROR
*/

STATUS pppAsyncFramingComponentDelete
    (
    PFW_OBJ *pfw
    )
    {
    PFW_COMPONENT_OBJ *pComponent;

    pComponent = pfwComponentObjGetByName (pfw, "ASYNC_FRAMING");

    if (pComponent == NULL)
        return ERROR;

    if (pfwComponentDelete (pComponent) == OK)
        {
        pfwFree (pComponent);
        return OK;
        }

    return (ERROR);
    }

/*******************************************************************************
*
* pppAsyncFramingStackDataConstruct - construct the stack data for the framework
*
* RETURNS: OK or ERROR
*/

LOCAL STATUS pppAsyncFramingStackDataConstruct
    (
    PFW_OBJ * pfw,
    void * stackData,
    void * profileData
    )
    {
    ASYNC_FRAMING_STACK_DATA *pStackData = 
				(ASYNC_FRAMING_STACK_DATA *)stackData;

    if ((pStackData->netPoolId = pfwNetPoolIdGet(pfw)) == NULL)
        {
        printf("Async Framing:MUST have a valid NetPoolId;See pfwCreate()\n");
        return ERROR;
        }
    
    pStackData->collectPppAttributesEvent = NULL;
    pStackData->localMru = 1500;
    pStackData->remoteMru = 1500;
    pStackData->flags = 0;
    pStackData->inputBytes = 0;
    pStackData->frameCheckSequenceEnabled  =  TRUE;
    pStackData->localToPeerACCMap  = DEFAULT_ASYNC_CONTROL_CHARACTER_MAP;
    pStackData->peerToLocalACCMap  = DEFAULT_ASYNC_CONTROL_CHARACTER_MAP;

    /* Address control and protocol compression is disabled by default */

    pStackData->localToPeerACCompression = FALSE;
    pStackData->peerToLocalACCompression = FALSE;
    pStackData->localToPeerProtocolCompression = FALSE;
    pStackData->peerToLocalProtocolCompression = FALSE;

    pStackData->transmitFcsSize = PPP_16BIT_FCS;
    pStackData->receiveFcsSize = PPP_16BIT_FCS;
    return (OK);
    }

/*******************************************************************************
*
* pppAsyncFramingStackAdd - add the stack data to the framework
*
* RETURNS: OK or ERROR
*/

LOCAL STATUS pppAsyncFramingStackAdd
    (
    PFW_PLUGIN_OBJ_STATE *state,
    PFW_PLUGIN_OBJ_CALLBACKS * callbacks
    )
    {
    ASYNC_FRAMING_STACK_DATA *stackData = state->stackData;
    int id;

    stackData->callbacks = callbacks;

    if (stackData->collectPppAttributesEvent == NULL)
	{
	if ((stackData->collectPppAttributesEvent =
	    pfwEventObjGet(state->pluginObj->pfwObj,
                           "COLLECT_PPP_ATTRIBUTES_EVENT")) != NULL)
            {
	    pfwEventStackSubscribe(state,stackData->collectPppAttributesEvent,
                                   AsyncFrameEventHandler);
	    }
        }

    /* get LCP UP event object and subcribe to it*/

    if ((stackData->lcpUpEvent = 
	    pfwEventObjGet(state->pluginObj->pfwObj,"LCP_UP_EVENT")) != NULL)
	{
	pfwEventStackSubscribe(state,stackData->lcpUpEvent, 
			       pppAsyncFramingLcpUpEventHandler);
	}
    else
	return ERROR;

    /* get PPP LINK_RESET event object and subcribe to it*/

    if ((stackData->pppLinkResetEvent =
            pfwEventObjGet(state->pluginObj->pfwObj,"PPP_LINK_RESET_EVENT")) != NULL)
        {
        pfwEventStackSubscribe(state,stackData->pppLinkResetEvent,
                               pppAsyncFramingLinkResetEventHandler);
        }
    else
        return ERROR;


    /* get LCP interfaces */

    if ((id = pfwInterfaceIdGet(state->pluginObj->pfwObj,
			"PPP_LINK_STATUS_ENTRY_INTERFACE")) > 0)
	{
	if (pfwInterfaceObjAndStateGetViaStackObj(state->stackObj,
				id, &stackData->pppLinkStatusInterface) != OK)
	    return ERROR;
	}
    else
	return ERROR;

    if ((id = pfwInterfaceIdGet(state->pluginObj->pfwObj,
			"PPP_LINK_STATUS_COUNTER_INCREMENT_INTERFACE")) > 0)
	{
	if (pfwInterfaceObjAndStateGetViaStackObj(state->stackObj,
				id, &stackData->pppLinkCounterInterface) != OK)
	    return ERROR;
	}

    /* Get pfwRFC2233CountPair and set pfwRFC2233CountTest */

    RFC2233_COUNT_PAIR_GET(state, 
                           stackData->pfwAuxIfId, 
                           stackData->pfwRFC2233CountPair, 
			   stackData->pfwRFC2233CountTest);

    /* Allocate a buffer for input processing */
  
    if (stackData->callbacks && stackData->callbacks->stackAddComplete)
        {
        (*stackData->callbacks->stackAddComplete) (stackData->callbacks, state);
	return OK;
        }
    else
        return ERROR;
    }

/*******************************************************************************
*
* pppAsyncFramingStackDelete - delete the stack data from the framework
*
* RETURNS: OK or ERROR
*/

LOCAL STATUS pppAsyncFramingStackDelete
    (
    PFW_PLUGIN_OBJ_STATE *state
    )
    {
    ASYNC_FRAMING_STACK_DATA *stackData = state->stackData;

    /* Delete the LCP LinkStatus Interface reference */
    pfwInterfaceReferenceDelete (
		stackData->pppLinkStatusInterface.interfaceObj);

    /* Delete the LCP LinkCounter Interface reference */
    pfwInterfaceReferenceDelete (
		stackData->pppLinkCounterInterface.interfaceObj);

    if (stackData->pfwRFC2233CountTest)
       pfwInterfaceReferenceDelete(stackData->pfwRFC2233CountPair.interfaceObj);

    if (stackData->callbacks && stackData->callbacks->stackDeleteComplete)
        {
        (*stackData->callbacks->stackDeleteComplete)
                                    (stackData->callbacks , state);
	return OK;
        }
    else
        return ERROR;
    }


/*******************************************************************************
*
* pppAsyncFramingLcpUpEventHandler - handle LCP events
*
* RETURNS: OK or ERROR
*/

LOCAL STATUS pppAsyncFramingLcpUpEventHandler
    (
    PFW_PLUGIN_OBJ_STATE * state,
    void *eventData
    )
    {
    PFW_PLUGIN_OBJ_STATE * lcpState = (PFW_PLUGIN_OBJ_STATE * )eventData;
    ASYNC_FRAMING_STACK_DATA *stackData = state->stackData;

    PPP_LINK_STATUS_ENTRY_INTERFACE * linkStatus = 
		    (PPP_LINK_STATUS_ENTRY_INTERFACE *)
				stackData->pppLinkStatusInterface.interfaceObj;

    stackData->localMru = (*linkStatus->pppLinkStatusLocalMRUGet)(lcpState);
    stackData->remoteMru = (*linkStatus->pppLinkStatusRemoteMRUGet)(lcpState);

    stackData->localToPeerACCMap =
		(*linkStatus->pppLinkStatusLocalToPeerACCMapGet)(lcpState);
    stackData->peerToLocalACCMap = 
		(*linkStatus->pppLinkStatusPeerToLocalACCMapGet)(lcpState);

    stackData->localToPeerProtocolCompression =
      (*linkStatus->pppLinkStatusLocalToRemoteProtocolCompressionGet)(lcpState);

    stackData->peerToLocalProtocolCompression = 
      (*linkStatus->pppLinkStatusRemoteToLocalProtocolCompressionGet)(lcpState);

    stackData->localToPeerACCompression = 
	   (*linkStatus->pppLinkStatusLocalToRemoteACCompressionGet) (lcpState);

    stackData->peerToLocalACCompression = 
	    (*linkStatus->pppLinkStatusRemoteToLocalACCompressionGet)(lcpState);

    stackData->transmitFcsSize = 
		(*linkStatus->pppLinkStatusTransmitFcsSizeGet)(lcpState);

    stackData->receiveFcsSize =
		(*linkStatus->pppLinkStatusReceiveFcsSizeGet) (lcpState);