pppmuxadapter.c

这是全套的PPP协议的源码

/* pppMuxAdapter.c - MUX Adapter component for PPP over END devices */

/* Copyright 2003 Wind River Systems, Inc. */

#include "copyright_wrs.h"

/*
modification history
--------------------
02e,10jun03,ijm use STACK_NAME to distinguish network stacks
02d,14may03,ijm fixed diab compiler warning
02c,29oct02,ijm use PPP_MUX_ADAPTER_MAX_BINDS, instead of muxMaxBinds,
                for IPv4/IPv6 stack
02b,27aug02,ijm fixed gnu warnings
02a,20aug02,ijm fixed diab compiler warnings
01z,15jul02,rp  rfc2233 counters not getting correctly updated SPR 73746
01y,17jul02,ijm discontinue use of NET_PROTOCOL
01x,15jul02,rp  multi-service support and muxCookie changes
01w,12apr01,sj  added muxL2SvcType parameter
01v,12mar01,ijm added mutual exclusion to slot selection in muxAdptrStackAdd
                and muxAdptrStackDel
01u,07mar01,ijm muxAdptrBindInfoFind should not increase bindInfo reference count
01t,30jan01,sj  protocol may bind only once across all framework stacks
              	if FRAMING_COMPONENT_STACK_RESOLVE interface is not provided
01s,21dec00,sj  release state only if locked
01r,20dec00,sj  on failure to lock state in RestartRtn delete node from list
01q,17dec00,sj  add stacks to txBlockedList on END_ERR_BLOCKED
01p,17dec00,sj  raise PPP_SUB_LAYER_TX_BLOCKED event on END_ERR_BLOCKED and
                 undo blocked condition by raising PPP_SUB_LAYER_TX_UNBLOCKED
01o,29sep00,sj  Merging in and reorganizing RFC2233 instrumentation
01n,29sep00,sj  merging with TOR2_0-WINDNET_PPP-CUM_PATCH_2
01m,06sep00,cn   free dstAddr string in muxAdptrStackDataDestruct () SPR# 34219.
01l,02aug00,adb  Merging in LAC modifications
01k,01aug00,adb  Merging with openstack view except RFC 2233
01j,31jul00,md  initializes collectPppAttributesEvent
01i,28jul00,md  initialize ppp attributes to a default value
01h,11jul00,md  subscribed COLLECT_PPP_ATTRIBUTES_EVENT
01g,10mar00,sj  interfaceReferenceDelete needs to be done only once
01f,16nov99,sj  increment bindInfo refCount for each attempt to bind
01e,14sep99,sj  adding events
01d,12aug99,sj  reworked for generic framework; 
01c,19jul99,sj  disabled loopback mode added macros for freeing packets
01b,19jul99,sj  successfully tested PPPOE under loopback mode
01a,02jul99,sj 	created
*/

/*
DESCRIPTION
This component enables PPP sessions over END/NPT devices via the MUX. Before
PPP sessions over the END/NPT devices can be established, this adapter component
must be added to the PPP framework.

This component provides a generic interface to the MUX for the PPP framework
to communicate via END/NPT devices in the system.

INCLUDE FILES:  muxLib.h muxTkLib.h
*/

#include "vxWorks.h"
#include "pfw/pfw.h"
#include "logLib.h"
#include "errnoLib.h"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "ctype.h"
#include "memLib.h"
#include "semLib.h"
#include "sllLib.h"
#include "inetLib.h"
#include "hostLib.h"
#include "end.h"
#include "muxLib.h"
#include "netBufLib.h"
#include "private/muxLibP.h"
#include "muxTkLib.h"
#include "pfw/pfwStack.h"
#include "pfw/pfwProfile.h"
#include "pfw/pfwComponent.h"
#include "pfw/pfwEvent.h"
#include "pfw/pfwLayer.h"
#include "pfw/pfwInterface.h"
#include "pfw/pfwMemory.h"
#include "ppp/kppp.h"
#include "ppp/pppLacStructures.h"
#include "ppp/pppMuxAdapter.h"
#include "ppp/interfaces/framingComponentInterfaces.h"
#include "ppp/interfaces/adapterComponentInterfaces.h"
#include "ppp/interfaces/pppInterfacesGroupInterfaces.h"

/* defines */

/* max number of protocols per stack that this adapter has to deal with*/

#define MAX_MUX_ADPTR_SERVICES 6

#define MUX_FREE_PKT netMblkClChainFree

#define MUX_STACK_ADD_DONE(state)\
	{\
	MUX_ADPTR_STACK_DATA * stack =(MUX_ADPTR_STACK_DATA *)state->stackData;\
	\
	if (stack->callbacks && stack->callbacks->stackAddComplete)\
	    (*stack->callbacks->stackAddComplete) (stack->callbacks,state);\
	}

#define MUX_STACK_DELETE_DONE(state)\
	{\
	MUX_ADPTR_STACK_DATA * stack =(MUX_ADPTR_STACK_DATA *)state->stackData;\
	\
	if (stack->callbacks && stack->callbacks->stackDeleteComplete)\
	    (*stack->callbacks->stackDeleteComplete) (stack->callbacks,state);\
	}


#define MUX_ADPTR_STACK_ADD_ERROR(state)\
	{\
	MUX_ADPTR_STACK_DATA * stack =(MUX_ADPTR_STACK_DATA *)state->stackData;\
	\
	if (stack->callbacks && stack->callbacks->stackAddError)\
	    (*stack->callbacks->stackAddError)\
				    (stack->callbacks,state);\
	}

/* typedefs */

typedef struct muxAdptrBindInfo
    {
    int refCount;                              /* number of stacks using this */
    void * cookie;		               /* binding instance handle */
    PFW_INTERFACE_STATE_PAIR stackObjResolver; /* stack resolver data */
    PFW_PLUGIN_OBJ * pluginObj;                /* reference to this component*/
    SL_LIST          txBlockedList;            /* stacks blocked for send */
    ULONG            portId;                   /* port id for adapterPortIdGet */
    long             netSvcType;               /* network service type */
    int              unitNo;                   /* unit number of the device */
    char             devName[END_NAME_MAX];    /* device name */
    } MUX_ADPTR_BIND_INFO;

/* MUX adapter profile data */

typedef struct muxAdptrProfileData
    {
    char muxDevName[END_NAME_MAX];
    int muxDevUnit;
    int muxNumSvcs;
    UINT32 muxL2SvcType;
    UINT32 muxSvcType[MAX_MUX_ADPTR_SERVICES];
    } MUX_ADPTR_PROFILE_DATA;

/* MUX adapter connection data */

typedef struct muxAdptrStackData
    {
    SL_NODE node;           /* this is how we stay on txBlocked List */
    MUX_ADPTR_BIND_INFO * bindInfoCache;/* bind info cache for currently */
                                        /* sending protocol */
    UINT32 nboProtocol;     /* protocol number in network byte order */
    char * destAddr;        /* current send destination */
    UINT32 destAddrLen;     /* current send destination add length*/
    PFW_INTERFACE_STATE_PAIR resolverInterface; /* stack resolver data */
    PFW_PLUGIN_OBJ_CALLBACKS * callbacks;
    PFW_PLUGIN_OBJ_STATE * state; /* back pointer to state */
    int bindInfoIndex[MAX_MUX_ADPTR_SERVICES]; /* bind info for each protocol */
    BOOL            txBlocked; /* set when muxTkSend returns END_ERR_BLOCKED */
    PFW_EVENT_OBJ *collectPppAttributesEvent;
    PFW_EVENT_OBJ * txBlockedEvent; 
    PFW_EVENT_OBJ * txUnblockedEvent; 
    ULONG           portId;

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

    int    pfwAuxIfId;
    PFW_INTERFACE_STATE_PAIR pfwRFC2233CountPair;
    BOOL   pfwRFC2233CountTest;
    } MUX_ADPTR_STACK_DATA;

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

typedef struct muxAdptrParams
    {
    char * name;
    PFW_PARAMETER_HANDLER handler;
    } MUX_ADPTR_PARAMS;

typedef struct muxAdptrComponent
    {
    PFW_COMPONENT_OBJ component;
    int muxMaxBinds;
    SEM_ID muxAdptrMutex;   
    MUX_ADPTR_BIND_INFO * bindInfo;
    ADAPTER_DESTINATION_AND_PROTOCOL_SET_INTERFACE adapterInterface;
    ADAPTER_INFO_GET_INTERFACE adapterInfoGetInterface;
    }MUX_ADPTR_COMPONENT;

/* externs */

#if (!((defined STACK_NAME) && (STACK_NAME == STACK_NAME_V4_V6)))
IMPORT int muxMaxBinds; /* maximum number of binds configured in the system */
#endif /* (!((defined STACK_NAME) && (STACK_NAME == STACK_NAME_V4_V6))) */

/* globals */

/* forward declarations */

/* component interface */

LOCAL STATUS muxAdptrProfileDataConstruct (PFW_OBJ *,void *);
LOCAL STATUS muxAdptrStackDataConstruct (PFW_OBJ *,void *stackData,
							void * profileData);
LOCAL STATUS muxAdptrStackDataDestruct (PFW_OBJ *, void *stackData,
							void * profileData);

LOCAL STATUS muxAdptrStackAdd(PFW_PLUGIN_OBJ_STATE*,PFW_PLUGIN_OBJ_CALLBACKS *);
LOCAL STATUS muxAdptrStackDel (PFW_PLUGIN_OBJ_STATE *);
LOCAL STATUS muxAdptrSend (PFW_PLUGIN_OBJ_STATE *, M_BLK_ID *);
LOCAL STATUS muxAdptrStackDataShow (PFW_PLUGIN_OBJ_STATE *);
LOCAL STATUS muxAdptrInterfaceBind (PFW_PLUGIN_OBJ *);

/* paramter handlers */

LOCAL STATUS muxAdptr_muxDevName(PFW_OBJ *, PFW_PARAMETER_OPERATION_TYPE,
								void *, char *);
LOCAL STATUS muxAdptr_muxDevUnit(PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,
								void *, char *);
LOCAL STATUS muxAdptr_muxSvcType(PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,
								void *, char *);
LOCAL STATUS muxAdptr_muxL2SvcType(PFW_OBJ *,PFW_PARAMETER_OPERATION_TYPE,
								void *, char *);

/* MUX NPT callback routines */

LOCAL BOOL muxAdptrRecvRtn (void *, long, M_BLK_ID, void *);
LOCAL STATUS muxAdptrShutdownRtn (void *);
LOCAL STATUS muxAdptrTxRestartRtn (void *);
LOCAL void muxAdptrErrorRtn (void *, END_ERR *);

/* MUX END callback routines */

LOCAL BOOL muxAdptrEndRecvRtn (void * cookie, long, M_BLK_ID, LL_HDR_INFO *,
								void* pSpare);
LOCAL STATUS muxAdptrEndShutdownRtn (void* cookie, void * pSpare);
LOCAL STATUS muxAdptrEndTxRestartRtn  (void * cookie, void * pSpare);
LOCAL void muxAdptrEndErrorRtn (END_OBJ * cookie, END_ERR *, void * pSpare);

/* utilities */

LOCAL int muxAdptrBindInfoFind (MUX_ADPTR_COMPONENT *,
						char * devName, int unit,
						int protocol);
LOCAL STATUS muxAdptrBindInfoClear ( MUX_ADPTR_BIND_INFO *pBindInfo,
				     MUX_ADPTR_STACK_DATA *pStackData);

    /* interfaces */

LOCAL STATUS destAddrAndProtocolSet
			   (
			    PFW_PLUGIN_OBJ_STATE *adapterState,
			    char * destAddr,
			    UINT32 addrLength,
			    char * protocol,
			    UINT32 protocolLength
			   );

LOCAL STATUS adapterPortIdGet
                          (
                          PFW_PLUGIN_OBJ_STATE * pAdapterState,
                          ULONG *                pPortId
                          );

/* locals */

LOCAL MUX_ADPTR_PARAMS muxAdptrParams[] = 
			{{"muxDevName",muxAdptr_muxDevName},
			 {"muxDevUnit",muxAdptr_muxDevUnit},
		     {"muxL2SvcType",muxAdptr_muxL2SvcType},
			 {"muxSvcType",muxAdptr_muxSvcType}};

LOCAL int numMuxAdptrParams = NELEMENTS (muxAdptrParams);

/*******************************************************************************
* muxAdapterCreate - add the MUX adapter component to the PPP framework
*
* This function should be called to add the MUX adapter to the PPP framework
* if PPP connections have to be established over END/NPT devices.
* This adapter is a generic component which interfaces the PPP framework with
* any END/NPT device in the system
*
* RETURNS: OK on success and ERROR otherwise
*/

STATUS muxAdapterCreate
    (
    PFW_OBJ * pfw	/* framework we are adding ourselves to */
    )
    {
    int i = 0;
    MUX_ADPTR_COMPONENT *pComponent;
    PFW_PLUGIN_OBJ * muxAdptrPluginObj = NULL;
    int pppMuxMaxBinds;

    if (pfw == NULL)
	{
        logMsg ("muAdapterCreate: Framework is NULL\n",
                 1,2,3,4,5,6);
	return ERROR;
	}

    /* allocate the component object */

    if ( (pComponent = pfwMalloc(pfw,sizeof(MUX_ADPTR_COMPONENT))) == NULL)
        {
        logMsg ("muxAptrCreate: Could not malloc memory for MUX ADAPTER component\n",
                 1,2,3,4,5,6);
	return ERROR;
        }

    bzero((void *)pComponent,sizeof(MUX_ADPTR_COMPONENT));

    if ((pComponent->muxAdptrMutex = semMCreate(SEM_Q_PRIORITY)) == NULL)
        {
        pfwFree (pComponent);
        logMsg ("muxAptrCreate: Could not create semaphore for MUX ADAPTER component\n",
                 1,2,3,4,5,6);
        return ERROR;
        }

    muxAdptrPluginObj = (PFW_PLUGIN_OBJ *)&(pComponent->component);

    /* initialize our component object */

    bzero(muxAdptrPluginObj->name, PFW_MAX_NAME_LENGTH);
    strncpy(muxAdptrPluginObj->name,"MUX_ADAPTER",
	    (PFW_MAX_NAME_LENGTH -1));

    muxAdptrPluginObj->pfwObj = pfw;
    muxAdptrPluginObj->profileDataSize = sizeof (MUX_ADPTR_PROFILE_DATA);
    muxAdptrPluginObj->stackDataSize = sizeof (MUX_ADPTR_STACK_DATA);
    muxAdptrPluginObj->profileDataConstruct = muxAdptrProfileDataConstruct;
    muxAdptrPluginObj->profileDataCopy = NULL;
    muxAdptrPluginObj->profileDataDestruct = NULL;
    muxAdptrPluginObj->stackDataConstruct = muxAdptrStackDataConstruct;
    muxAdptrPluginObj->stackDataDestruct = muxAdptrStackDataDestruct;
    muxAdptrPluginObj->interfaceBind = muxAdptrInterfaceBind;
    muxAdptrPluginObj->receive = NULL;
    muxAdptrPluginObj->send = muxAdptrSend;
    muxAdptrPluginObj->stackAdd = muxAdptrStackAdd;
    muxAdptrPluginObj->stackDelete = muxAdptrStackDel;
    muxAdptrPluginObj->stackDataShow = muxAdptrStackDataShow;

    pComponent->component.protocol = 0;
    pComponent->component.layerObj = pfwLayerObjGet(pfw, "ADAPTER_LAYER");

    /* register this component with the framework */

    if (pfwComponentAdd (&pComponent->component) == ERROR)
        {
        logMsg ("muxAdapterCreate: Could not add MUX ADAPTER component\n",
                 1,2,3,4,5,6);
        semDelete (pComponent->muxAdptrMutex);
        pfwFree (pComponent);
        return (ERROR);
        }

    /* add our parameters to the framework */

    for (i = 0; i < numMuxAdptrParams ; i++)
	{
        if (pfwParameterAdd ((PFW_PLUGIN_OBJ *)pComponent,
			muxAdptrParams[i].name, muxAdptrParams[i].handler)
			== ERROR)
	    {
	    logMsg ("muxAdapterCreate - Parameter %s could not be added\n",
	    (int)muxAdptrParams[i].name,2,3,4,5,6);
	    return (ERROR);
	    }
	}

    /* allocate memory for the bindInfo Array */

#if ((defined STACK_NAME) && (STACK_NAME == STACK_NAME_V4_V6))
    pppMuxMaxBinds = PPP_MUX_ADAPTER_MAX_BINDS;
#else
    pppMuxMaxBinds = muxMaxBinds;
#endif /* ((defined STACK_NAME) && (STACK_NAME == STACK_NAME_V4_V6)) */

    if ((pComponent->bindInfo = (MUX_ADPTR_BIND_INFO *) pfwMalloc
		(pfw,pppMuxMaxBinds * sizeof(MUX_ADPTR_BIND_INFO))) == NULL)
        {
        logMsg ("muxAdapterCreate: Could not malloc memory for bindInfo\n",
                 1,2,3,4,5,6);
	return ERROR;
        }

    bzero((void *)pComponent->bindInfo, 
		pppMuxMaxBinds * sizeof(MUX_ADPTR_BIND_INFO));

    pComponent->muxMaxBinds = pppMuxMaxBinds;

    return OK;
    }


/*******************************************************************************
* muxAdapterDelete - delete the MUX adapter component from the framework
*
* The MUX_ADAPTER plug-in component object allocated by muxAdapterCreate() is 
* freed if there are no references to this object from a 
* Stack or Profile object in the framework.
*
* RETURNS: OK or ERROR
*/
STATUS muxAdapterDelete
    (
    PFW_OBJ * pfw	/* framework we are deleting this from */
    )
    {
    PFW_COMPONENT_OBJ *pComponent;
    MUX_ADPTR_COMPONENT * muxComponent;

    pComponent = pfwComponentObjGetByName(pfw,"MUX_ADAPTER");

    if (pComponent == NULL)
	return ERROR;

    if (pfwComponentDelete(pComponent) != OK)
	return ERROR;

    muxComponent = (MUX_ADPTR_COMPONENT *)pComponent;

    pfwFree(muxComponent->bindInfo);
    semDelete (muxComponent->muxAdptrMutex);
    pfwFree(pComponent);
    return OK;
    }


/*******************************************************************************
* muxAdptrProfileDataConstruct - initialize component parameter default values
*
* This function is called by the framework to get default values for the
* parameters managed and supported by this component
*
* RETURNS: OK on success and ERROR otherwise
*/

LOCAL STATUS muxAdptrProfileDataConstruct
    (
    PFW_OBJ *pfw,
    void * pProfileData 	/* reference to this component's profile data */
    )
    {
    MUX_ADPTR_PROFILE_DATA * pMuxAdptrData = 
					(MUX_ADPTR_PROFILE_DATA *)pProfileData;

    /* start with a clean slate */

    bzero ((void *)pMuxAdptrData, sizeof(MUX_ADPTR_PROFILE_DATA));
    return OK;
    }

/*******************************************************************************
* muxAdptrStackDataDestruct - clean up stack data
*
* This function is called by the framework at the time this component
* is being removed from a stack for the purpose of cleaning up the stack Data
* which includes freeing of any memory that may have been allocated
*
* RETURNS: OK on success and ERROR otherwise