pppbitsyncframing.c

这是全套的PPP协议的源码

/* pppBitSyncFraming.c - PPP Bit-Synchronous HDLC Framing */

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

/*
modification history
--------------------
01q,28may02,rvr fixed build warnings (teamf1)
01p,17dec01,mk  added macros to correct alignment problems
01o,12apr01,ijm First mbuf in the chain must have mBlkPktHdr info set. 
                Corrected convertNormalDataToSynchronousData to handle
                zero-length mbufs within an mbuf chain
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 collectPppAttributesEvent
01i,29jun00,md  subscribed COLLECT_PPP_ATTRIBUTES_EVENT
01h,17apr00,sj  use length of frame as size for decoded frame buffer
01g,07mar00,sj  use/generate mBuf chains on receive path
01f,02mar00,sj  On the send path no ACCompression for LCP packets and get 
                clusters on demand
01e,23feb00,sj  Pedantic ANSI fixes
01d,14feb00,sj  fixed 32 bit checksum on send path and added comments
01c,02dec99,sj  All new implementation of encoding and decoding
01b,29nov99,sgv Added comments
01a,06oct99,sgv Written
*/

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

/* includes */

#include "vxWorks.h"
#include "stdio.h"
#include "logLib.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 "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/kstart.h"
#include "ppp/kppp.h"
#include "ppp/pppLacStructures.h"
#include "ppp/pppChecksum.h"
#include "private/ppp/vpppstr.h"
#include "ppp/interfaces/lcpInterfaces.h"
#include "ppp/interfaces/pppInterfacesGroupInterfaces.h"


/* defines */

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

/* typedefs */

typedef struct bsyncFramingStackData
    {
    unsigned long localToPeerACCompression;
    unsigned long peerToLocalACCompression;
    unsigned long localToPeerProtocolCompression;
    unsigned long peerToLocalProtocolCompression;
    unsigned  int localMru;
    unsigned  int remoteMru;
    unsigned  int transmitFcsSize;
    unsigned  int receiveFcsSize;
    NET_POOL_ID   netPoolId;
    u_int bytesSent;
    u_int bytesRcvd;
    u_int inputBytes;
    u_int inputErrors;
    u_int mru;
    u_int flags;
    PFW_PLUGIN_OBJ_CALLBACKS    * callbacks;
    PFW_EVENT_OBJ * lcpUpEvent;
    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;
    } BSYNC_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;


/* LOCAL */

LOCAL STATUS pppBitSyncSend (PFW_PLUGIN_OBJ_STATE *, M_BLK_ID *);
LOCAL STATUS pppBitSyncReceive (PFW_PLUGIN_OBJ_STATE *, M_BLK_ID *);
LOCAL STATUS pppBitSyncStackAdd (PFW_PLUGIN_OBJ_STATE *state,
					PFW_PLUGIN_OBJ_CALLBACKS * callbacks);
LOCAL STATUS pppBitSyncStackDelete (PFW_PLUGIN_OBJ_STATE *);
LOCAL STATUS pppBitSyncStackDataConstruct ( PFW_OBJ *, void * stackData,
							 void * profileData);
LOCAL STATUS convertNormalDataToSynchronousData (PFW_PLUGIN_OBJ_STATE *,
						    M_BLK_ID src, M_BLK_ID dst);
LOCAL int convertSynchronousDataToNormalData (PFW_PLUGIN_OBJ_STATE *,
						    M_BLK_ID src, M_BLK_ID dst);
LOCAL STATUS lcpUpEventHandler (PFW_PLUGIN_OBJ_STATE *, void *eventData);
LOCAL STATUS decompress_ppp_header ( PFW_PLUGIN_OBJ_STATE *state, M_BLK_ID);
LOCAL STATUS BitSyncFrameEventHandler
    (
    PFW_PLUGIN_OBJ_STATE * state,
    void *eventData
    );

/*******************************************************************************
* pppBitSyncFramingComponentCreate - create bit synchronous component
*
* This routine creates the bit synchronous HDLC framing component plug-in
* object and adds it to the framework.
*
* RETURNS: OK or ERROR
*/

STATUS pppBitSyncFramingComponentCreate
    (
    PFW_OBJ *pfw
    )
    {
    PFW_COMPONENT_OBJ *pBsyncFramingComponent;
    pBsyncFramingComponent = (PFW_COMPONENT_OBJ *) pfwMalloc (pfw,
                                                sizeof (PFW_COMPONENT_OBJ));

    if (pBsyncFramingComponent == NULL)
        {
        printf ("pppBsyncFramingInit - Unable to allocate memory of size %d \
		 byte s\n", (int) sizeof (PFW_COMPONENT_OBJ));
        return (ERROR);
        }

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

    strcpy (pBsyncFramingComponent->pluginObj.name, "BITSYNC_FRAMING");
    pBsyncFramingComponent->pluginObj.pfwObj = pfw;
    pBsyncFramingComponent->layerObj = pfwLayerObjGet (pfw, "FRAMING_LAYER");
    pBsyncFramingComponent->pluginObj.profileDataSize = 0;
    pBsyncFramingComponent->pluginObj.stackDataSize 
				= sizeof (BSYNC_FRAMING_STACK_DATA);

    pBsyncFramingComponent->protocol = 0;
    pBsyncFramingComponent->pluginObj.profileDataConstruct = NULL;
    pBsyncFramingComponent->pluginObj.profileDataCopy = NULL;
    pBsyncFramingComponent->pluginObj.profileDataDestruct = NULL;
    pBsyncFramingComponent->pluginObj.receive = pppBitSyncReceive;
    pBsyncFramingComponent->pluginObj.send = pppBitSyncSend;
    pBsyncFramingComponent->pluginObj.stackAdd = pppBitSyncStackAdd;
    pBsyncFramingComponent->pluginObj.stackDelete = pppBitSyncStackDelete;
    pBsyncFramingComponent->pluginObj.stackDataConstruct = pppBitSyncStackDataConstruct;
    pBsyncFramingComponent->pluginObj.stackDataDestruct = NULL;
    pBsyncFramingComponent->pluginObj.stackDataShow = NULL;

    if (pfwComponentAdd (pBsyncFramingComponent) == ERROR)
        {
        printf (
	"pppBitSyncFramingComponentCreate - BitSync Framing could not be added to the framework\n");
        return (ERROR);
        }

    return (OK);
    }

/*******************************************************************************
*
* pppBitSyncFramingComponentDelete - delete the bit synchronous component 
*
* The bit synchronous framing plug-in component object allocated by 
* pppBitSyncFramingComponentCreate() is freed if there are no references 
* to this object from a stack or profile object in the framework.
*
* RETURNS: OK or ERROR
*/

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

    pComponent = pfwComponentObjGetByName (pfw, "BITSYNC_FRAMING");

    if (pComponent == NULL)
        return ERROR;

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

    return (ERROR);
    }

/*******************************************************************************
* pppBitSyncStackDataConstruct -
*/
LOCAL STATUS pppBitSyncStackDataConstruct
    (
    PFW_OBJ * pfw,
    void * stackData,
    void * profileData
    )
    {
    BSYNC_FRAMING_STACK_DATA *pStackData =
                                (BSYNC_FRAMING_STACK_DATA *)stackData;

    if ((pStackData->netPoolId = pfwNetPoolIdGet(pfw)) == NULL)
	{
	printf("BitSync 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;

    /* default to 16 bit FCS */

    pStackData->transmitFcsSize = PPP_16BIT_FCS;
    pStackData->receiveFcsSize = PPP_16BIT_FCS;

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

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

    return (OK);
    }

/*******************************************************************************
* pppBitSyncStackAdd -
*/

LOCAL STATUS pppBitSyncStackAdd
    (
    PFW_PLUGIN_OBJ_STATE *state,
    PFW_PLUGIN_OBJ_CALLBACKS * callbacks
    )
    {
    BSYNC_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, BitSyncFrameEventHandler);
	    }
        }

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

    if ((stackData->lcpUpEvent =
            pfwEventObjGet(state->pluginObj->pfwObj,"LCP_UP_EVENT")) != NULL)
        {
        pfwEventStackSubscribe(state,stackData->lcpUpEvent, lcpUpEventHandler);
        }
    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);

    /* stackAdd done */

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

/*******************************************************************************
* pppBitSyncStackDelete -
*/
LOCAL STATUS pppBitSyncStackDelete
    (
    PFW_PLUGIN_OBJ_STATE *state
    )
    {
    BSYNC_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;
    }

/*******************************************************************************
* lcpUpEventHandler -
*/
LOCAL STATUS lcpUpEventHandler
    (
    PFW_PLUGIN_OBJ_STATE * state,
    void *eventData
    )
    {
    PFW_PLUGIN_OBJ_STATE * lcpState = (PFW_PLUGIN_OBJ_STATE * )eventData;
    BSYNC_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->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);

    return OK;