pppmuxadapter.c

这是全套的PPP协议的源码

*/

LOCAL STATUS muxAdptrStackDataDestruct
    (
    PFW_OBJ * pfw,
    void * pStackData,	/* reference to this component's Stack data */
    void * profileData
    )
    {
    MUX_ADPTR_STACK_DATA * pMuxAdptrStackData =
		(MUX_ADPTR_STACK_DATA *)pStackData;

    if (pMuxAdptrStackData->destAddr != NULL)
	{
	pfwFree(pMuxAdptrStackData->destAddr);
	pMuxAdptrStackData->destAddr = NULL;
	}

    return OK;
    }

/*******************************************************************************
* muxAdptrStackInterfaceBind - bind our interfaces
*
* RETURNS: OK on success and ERROR otherwise
*/

LOCAL STATUS muxAdptrInterfaceBind
    (
    PFW_PLUGIN_OBJ * pluginObj
    )
    {
    int id;
    MUX_ADPTR_COMPONENT * pComponent = (MUX_ADPTR_COMPONENT *)pluginObj;

    if ((id = pfwInterfaceRegister(pluginObj->pfwObj,
		    "ADAPTER_DESTINATION_AND_PROTOCOL_SET_INTERFACE")) ==0)
	{
	printf("MUX ADAPTER: Failed to register %s \n",
		"ADAPTER_DESTINATION_AND_PROTOCOL_SET_INTERFACE");
	return ERROR;
	}

    pComponent->adapterInterface.interfaceObj.id = id;
    pComponent->adapterInterface.interfaceObj.pluginObj = pluginObj;
    pComponent->adapterInterface.destAddrAndProtocolSet =destAddrAndProtocolSet;

    pfwInterfaceBind(&pComponent->adapterInterface.interfaceObj);

    if ((id = pfwInterfaceRegister(pluginObj->pfwObj,
		    "ADAPTER_INFO_GET_INTERFACE")) ==0)
	{
	printf("MUX ADAPTER: Failed to register %s \n","ADAPTER_INFO_GET_INTERFACE");
	return ERROR;
	}

    pComponent->adapterInfoGetInterface.interfaceObj.id = id;
    pComponent->adapterInfoGetInterface.interfaceObj.pluginObj = pluginObj;
    pComponent->adapterInfoGetInterface.adapterPortIdGet = adapterPortIdGet;

    return (pfwInterfaceBind(&pComponent->adapterInfoGetInterface.interfaceObj));

    }
/*******************************************************************************
* muxAdptrStackDataConstruct - initialize component stack data
*
* This function is called by the framework at the time this component
* is included in a stack for the purpose of initializing the stack Data
*
* RETURNS: OK on success and ERROR otherwise
*/

LOCAL STATUS muxAdptrStackDataConstruct
    (
    PFW_OBJ * pfw,
    void * pStackData, 	/* reference to this component's Stack data */
    void * pProfileData 
    )
    {
    MUX_ADPTR_STACK_DATA * pMuxAdptrData = (MUX_ADPTR_STACK_DATA *)pStackData;

    /* start with a clean slate */

    bzero ((void *)pMuxAdptrData, sizeof(MUX_ADPTR_STACK_DATA));

    pMuxAdptrData->collectPppAttributesEvent = NULL;
    pMuxAdptrData->bindInfoCache = NULL;
    pMuxAdptrData->txBlocked = FALSE;
    pMuxAdptrData->txBlockedEvent = NULL;
    pMuxAdptrData->txUnblockedEvent = NULL;

    return OK;
    }

/*******************************************************************************
* muxAdptrStackAdd - initialize a stack via the MUX
*
* This is the first interface invoked by the framework to initialize a 
* stack which will use MUX. The profileData for this connection contained in
* the componentState parameter has the device name & unit number and
* protocol types that should be bound to the specified device
* 
*
* RETURNS: OK on success and ERROR otherwise
*/

LOCAL STATUS muxAdptrStackAdd
    (
    PFW_PLUGIN_OBJ_STATE * pComponentState, /* our state for this connection */
    PFW_PLUGIN_OBJ_CALLBACKS * callbacks
    )
    {
    int i;
    int slot;
    void * cookie = NULL;

    UINT32 muxSvcType;
    char muxSvcName[25];
    int svcNameLen = strlen("PPP");
    MUX_ADPTR_COMPONENT * pComponent = 
		(MUX_ADPTR_COMPONENT *)pComponentState->pluginObj;

    MUX_ADPTR_PROFILE_DATA * pMuxAdptrProfileData =
		(MUX_ADPTR_PROFILE_DATA *)pComponentState->profileData;

    MUX_ADPTR_STACK_DATA * pMuxAdptrStackData =
		(MUX_ADPTR_STACK_DATA *)pComponentState->stackData;

    pMuxAdptrStackData->portId = 0;

    /* 
     * if we are going to send L2 frames simply add the provided L2 type
     * to the list of services that we'll bind to the device.
     */

    if (pMuxAdptrProfileData->muxL2SvcType != 0x0)
	{
	pMuxAdptrProfileData->muxSvcType[pMuxAdptrProfileData->muxNumSvcs++] = 
					pMuxAdptrProfileData->muxL2SvcType;
	}

    /* we must have atleast one protocol to bind to the MUX */

    if (pMuxAdptrProfileData->muxNumSvcs <= 0)
	{
	logMsg("MUX_ADAPTER: No protocols to bind\n", 1,2,3,4,5,6);
	return ERROR;
	}

    bzero((void *)muxSvcName,sizeof(muxSvcName));
    strcpy(muxSvcName,"PPP");

    if (pMuxAdptrStackData->collectPppAttributesEvent == NULL)
	{
	if ((pMuxAdptrStackData->collectPppAttributesEvent =
	     pfwEventObjGet(pComponentState->pluginObj->pfwObj,
	     "COLLECT_PPP_ATTRIBUTES_EVENT")) != NULL)
            {
	    pfwEventStackSubscribe(pComponentState,pMuxAdptrStackData->collectPppAttributesEvent,
	    muxPPPAttributesEventHandler);
	    }
        }

    /* get BLOCKED and UNBLOCKED events */

    if ((pMuxAdptrStackData->txBlockedEvent = 
			pfwEventObjGet(pComponentState->pluginObj->pfwObj,
					"PPP_SUB_LAYER_TX_BLOCKED")) == NULL)

	{
	logMsg("MUX_ADAPTER: Failed to get PPP_SUB_LAYER_TX_BLOCKED event\n",
	    1,2,3,4,5,6);
	}

    if ((pMuxAdptrStackData->txUnblockedEvent = 
			pfwEventObjGet(pComponentState->pluginObj->pfwObj,
					"PPP_SUB_LAYER_TX_UNBLOCKED")) == NULL)
	{
	logMsg("MUX_ADAPTER: Failed to get PPP_SUB_LAYER_TX_UNBLOCKED event\n",
	    1,2,3,4,5,6);
	}

    /* get stack resolve Interface from framing component */

    i = pfwInterfaceIdGet(pComponentState->pluginObj->pfwObj,
			    "FRAMING_COMPONENT_STACK_RESOLVE_INTERFACE");
    if (i == 0 ||
	pfwInterfaceObjAndStateGetViaStackObj(pComponentState->stackObj,
	    i,&pMuxAdptrStackData->resolverInterface) != OK)
	{
#ifdef CANNOT_PROCEED_WITHOUT_RESOLVER_INTERFACE
	printf ("MUX Adapter: could not find %s for this stack 0x%x\n",
		    "FRAMING_COMPONENT_STACK_RESOLVE_INTERFACE",
		    (UINT32)pComponentState->stackObj);
	return ERROR;
#else
	pMuxAdptrStackData->resolverInterface.interfaceObj = NULL;
	/*
	 * without this interface frames received will always be passed to
	 * the upper layers of this stackObj
	 */
	pMuxAdptrStackData->resolverInterface.state = pComponentState;
#endif /* CANNOT_PROCEED_WITHOUT_RESOLVER_INTERFACE */
	}

    for ( i = 0; i < pMuxAdptrProfileData->muxNumSvcs; i++)
	{
	muxSvcType = pMuxAdptrProfileData->muxSvcType[i];

        if (semTake(pComponent->muxAdptrMutex,WAIT_FOREVER) != OK)
            return ERROR;

	/* attempt to find binding information for this protocol */

	slot = muxAdptrBindInfoFind (pComponent,
				    pMuxAdptrProfileData->muxDevName,
				    pMuxAdptrProfileData->muxDevUnit,
				    muxSvcType);

	if (slot == pComponent->muxMaxBinds)
	    {
	    logMsg ("muxAdptrStackAdd: No more Binds\n",1,2,3,4,5,6);
            semGive (pComponent->muxAdptrMutex);
	    return ERROR;
	    }

	if (slot < 0)
            {
	    logMsg("MUX_ADPTR: Slot < 0\n",1,2,3,4,5,6);
            semGive (pComponent->muxAdptrMutex);
	    return ERROR;
            }
	    
	/* 
	 * check cookie and refCount to tell if this is already bound; 
	 * if so save bind entry reference in stack data
	 *
	 * NOTE: if this protocol is already bound to the named device
	 * on a different framework stack and if the interface
	 * FRAMING_COMPONENT_STACK_RESOLVE_INTERFACE was not provided
	 * we cannot continue.
	 */

	if ((pComponent->bindInfo[slot].cookie != NULL) &&
	    (pComponent->bindInfo[slot].refCount > 0))
	    {
	    if (pComponent->bindInfo[slot].stackObjResolver.interfaceObj == NULL)
		{
		logMsg("MUX_ADPTR: Protocol 0x%x already bound to Device %s,\
		Unit %d, on stackObj %p and did not supply\
		FRAMING_COMPONENT_STACK_RESOLVE_INTERFACE\n",
			muxSvcType,(int)pMuxAdptrProfileData->muxDevName,
			pMuxAdptrProfileData->muxDevUnit,
			(int)pComponentState->stackObj,5,6);

		MUX_ADPTR_STACK_ADD_ERROR(pComponentState);
                semGive (pComponent->muxAdptrMutex);
		return ERROR;
		}

	    pComponent->bindInfo[slot].refCount++;
	    pMuxAdptrStackData->bindInfoIndex[i] = slot;
            pMuxAdptrStackData->portId = pComponent->bindInfo[slot].portId;
            semGive (pComponent->muxAdptrMutex);
	    continue;
	    }

	/* need to bind */

	sprintf(&muxSvcName[svcNameLen],"-0x%lx", (long unsigned int) muxSvcType);

	if (muxTkDrvCheck(pMuxAdptrProfileData->muxDevName))
	    {
	    if (muxSvcType == pMuxAdptrProfileData->muxL2SvcType)
		{
		logMsg ("MUX_ADPTR: muxL2SvcType=0x%x cannot bind to NPT driver\
			%s%d\n", (int)pMuxAdptrProfileData->muxL2SvcType,
			(int)pMuxAdptrProfileData->muxDevName,
			pMuxAdptrProfileData->muxDevUnit,4,5,6);
		semGive (pComponent->muxAdptrMutex);
		return ERROR;
		}

	    cookie = muxTkBind ( pMuxAdptrProfileData->muxDevName,
			pMuxAdptrProfileData->muxDevUnit,
			muxAdptrRecvRtn,muxAdptrShutdownRtn,
			muxAdptrTxRestartRtn,
#if ((defined STACK_NAME) && (STACK_NAME == STACK_NAME_V4_V6))
			(FUNCPTR) muxAdptrErrorRtn,
#else
			muxAdptrErrorRtn,
#endif /* ((defined STACK_NAME) && (STACK_NAME == STACK_NAME_V4_V6)) */
			muxSvcType,muxSvcName, &pComponent->bindInfo[slot],
			NULL,NULL);
	    }
	else 
	    {
	    cookie = muxBind ( pMuxAdptrProfileData->muxDevName,
			pMuxAdptrProfileData->muxDevUnit,
			muxAdptrEndRecvRtn,muxAdptrEndShutdownRtn,
			muxAdptrEndTxRestartRtn, muxAdptrEndErrorRtn,
			muxSvcType,muxSvcName,&pComponent->bindInfo[slot]);
	    }

	if(cookie == NULL)
	    {
	    logMsg("MUX_ADAPTER: Failed to bind protocol 0x%x\n", muxSvcType
		    ,2,3,4,5,6);
            semGive (pComponent->muxAdptrMutex);
	    return ERROR;
	    }
	else
	    {

	    if (0 == pMuxAdptrStackData->portId)
	        {
	        pMuxAdptrStackData->portId = (ULONG) cookie;
	        }

	    /* save the bind information in the bindInfo table */

	    pMuxAdptrStackData->bindInfoIndex[i] = slot;

	    sllInit(&pComponent->bindInfo[slot].txBlockedList);
	    pComponent->bindInfo[slot].refCount = 1;
            semGive (pComponent->muxAdptrMutex);
	    pComponent->bindInfo[slot].stackObjResolver = 
					pMuxAdptrStackData->resolverInterface;
	    pComponent->bindInfo[slot].cookie = cookie;
	    pComponent->bindInfo[slot].pluginObj = (PFW_PLUGIN_OBJ *)pComponent;

	    pComponent->bindInfo[slot].portId = pMuxAdptrStackData->portId;
	    pComponent->bindInfo[slot].netSvcType = muxSvcType;
	    pComponent->bindInfo[slot].unitNo = pMuxAdptrProfileData->muxDevUnit;
	    strcpy (pComponent->bindInfo[slot].devName, 
	                   pMuxAdptrProfileData->muxDevName);

	    /* 
	     * when muxL2SvcType is set we always use the resulting bindCookie
	     * when sending frames. Also destAddrAndProtocolSet() is made
	     * inactive.
	     */
	    if (muxSvcType == pMuxAdptrProfileData->muxL2SvcType)
		pMuxAdptrStackData->bindInfoCache = &pComponent->bindInfo[slot];
	    }
	}

    /* save callbacks and state */

    pMuxAdptrStackData->callbacks = callbacks;
    pMuxAdptrStackData->state = pComponentState;

    /* DONE processing stack add request*/

    /* Get pfwRFC2233CountPair and set pfwRFC2233CountTest */

    RFC2233_COUNT_PAIR_GET(pComponentState, 
                           pMuxAdptrStackData->pfwAuxIfId, 
                           pMuxAdptrStackData->pfwRFC2233CountPair, 
			   pMuxAdptrStackData->pfwRFC2233CountTest);
    MUX_STACK_ADD_DONE(pComponentState);

    return OK;
    }

/*******************************************************************************
* muxAdptrStackDel - detach this component from the stack 
*
* This interface is invoked as part of a pfwStackDelete() call. In here
* we unbind the protocols bound to the mux as part of this stack instance.
*
* RETURNS: OK on success and ERROR otherwise
*/

LOCAL STATUS muxAdptrStackDel
    (
    PFW_PLUGIN_OBJ_STATE * pComponentState   /* our state for this connection */
    )
    {
    int i;
    MUX_ADPTR_BIND_INFO * pBindInfo = NULL;
    MUX_ADPTR_COMPONENT * pComponent = 
		    (MUX_ADPTR_COMPONENT *)pComponentState->pluginObj;

    MUX_ADPTR_PROFILE_DATA * pMuxAdptrProfileData =
		(MUX_ADPTR_PROFILE_DATA *)pComponentState->profileData;

    MUX_ADPTR_STACK_DATA * pMuxAdptrStackData =
		(MUX_ADPTR_STACK_DATA *)pComponentState->stackData;

    for ( i = 0; i < pMuxAdptrProfileData->muxNumSvcs; i++)
	{
	pBindInfo = &pComponent->bindInfo[pMuxAdptrStackData->bindInfoIndex[i]];
        if (semTake (pComponent->muxAdptrMutex,WAIT_FOREVER) != OK)
            return ERROR;

	muxAdptrBindInfoClear(pBindInfo,pMuxAdptrStackData);
        semGive (pComponent->muxAdptrMutex);
	}

    if (pMuxAdptrStackData->resolverInterface.interfaceObj != NULL)
	pfwInterfaceReferenceDelete(
			pMuxAdptrStackData->resolverInterface.interfaceObj);

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

    /* DONE processing stack Delete request*/

    MUX_STACK_DELETE_DONE(pComponentState);

    return OK;
    }

/*******************************************************************************
* muxAdptrSend - MUX adapter send interface
*
* This interface is invoked by the framework when a packet has to be sent 
* out to the network through us. In here we strip the destination address
* protocol information from the incoming packet and call muxSend()/muxTkSend()
* with the stripped out information to send the packet to the driver
*
* RETURNS: OK on success and ERROR otherwise
*/

LOCAL STATUS muxAdptrSend
    (
    PFW_PLUGIN_OBJ_STATE * pComponentState, /* our state for this stack */
    M_BLK_ID * pMblkId			/* packet to send */
    )
    {
    MUX_ADPTR_PROFILE_DATA * pMuxAdptrProfileData =
		(MUX_ADPTR_PROFILE_DATA *)pComponentState->profileData;

    MUX_ADPTR_STACK_DATA * pMuxAdptrStackData =
		(MUX_ADPTR_STACK_DATA *)pComponentState->stackData;

    void * cookie = NULL;
    M_BLK_ID pMblk = NULL;
    STATUS status;
    UINT pktLength;
    M_BLK_ID auxMblkId;

    pktLength = 0;

    if ((pMblkId == NULL) || ((pMblk = *pMblkId) == NULL))
	{
        RFC2233_COUNTER_UPDATE(pMuxAdptrStackData->pfwRFC2233CountTest, 
				pMuxAdptrStackData->pfwRFC2233CountPair,
                               M2_ctrId_ifOutErrors, 1);
	return ERROR;
	}

    auxMblkId = pMblk;
    while (auxMblkId != NULL)
        {
        pktLength += auxMblkId->mBlkHdr.mLen;
        auxMblkId = auxMblkId->mBlkHdr.mNext;
        }

    /* we must be bound to atleast one protocol for this connection */

    if (pMuxAdptrProfileData->muxNumSvcs <= 0)
	{
	MUX_FREE_PKT(pMblk);
        RFC2233_COUNTER_UPDATE(pMuxAdptrStackData->pfwRFC2233CountTest, 
				pMuxAdptrStackData->pfwRFC2233CountPair,
                               M2_ctrId_ifOutDiscards, 1);
	return ERROR;
	}

    /* cant proceed with a NULL cookie */