pppsioadapter.c

这是全套的PPP协议的源码

    if (pfwPluginObjStateLock (pComponentState) == ERROR)
	return;
    pStackData = (SIO_ADPTR_STACK_DATA * )pComponentState->stackData;

#ifdef PPP_DEBUG
    logMsg ("SIO_ADPTER SendQ Open: sendQSize %d\n",pStackData->sendQSize,
	    2,3,4,5,6);
#endif /* PPP_DEBUG */

    pfwEventRaise(pComponentState->stackObj,pStackData->txUnblockedEvent,NULL);
    pfwPluginObjStateRelease(pComponentState);

    return;
    }
/*******************************************************************************
* sioAdptrFrameReceive - send received frame up in Data task context
*
* This routine forwards the received frame to the framing layers allocates
* a new buffer for the next frame
* 
*/

LOCAL void sioAdptrFrameReceive
    (
    void * data
    )
    {
    SIO_RECEIVE_JOB * jobData = (SIO_RECEIVE_JOB *)data;

    SIO_ADPTR_STACK_DATA * pStackData; 

    if (jobData == NULL)
	return;

    pStackData = (SIO_ADPTR_STACK_DATA * )jobData->state->stackData;

    if (pStackData->channelState != SIO_CHANNEL_UP)
	{
	SIO_FREE_PKT_CHAIN (jobData->pMblk);
	return;
	}

    pStackData->inputPackets ++;
    pStackData->inputOctets += jobData->pMblk->mBlkPktHdr.len;

    /* forward frame */

    if (pfwReceive (jobData->state,jobData->pMblk) != OK)
        netMblkClChainFree (jobData->pMblk);
    }

/*******************************************************************************
* lcpOpenHandler - lcp open 
*/
LOCAL STATUS lcpOpenHandler
    (
    PFW_PLUGIN_OBJ_STATE * state,
    void *eventData
    )
    {
    SIO_ADPTR_STACK_DATA *pStackData = state->stackData;
    SIO_ADPTR_PROFILE_DATA *pProfileData = state->profileData;
    int key;

    /* Flush send queue.  Set up for NT */

    flushSioTransmitQueue (state, eventData);
    
    ntSerialClientStringSetup(state, eventData); 

    bzero(pStackData->channelBuf, sizeof(pStackData->channelBuf));

    key = intLock();
    pStackData->nextSendIndex = 0;
    pStackData->nextReceiveIndex = 0;
    pStackData->lcpIsOpen = TRUE;
    intUnlock(key);

    if (pProfileData->peerType == SIO_PEER_NT_SERVER)
	{
	strcpy(pStackData->channelBuf, SIO_NT_CLIENT_STRING);

#ifdef PPP_DEBUG
	logMsg("sioAdptr: sending CLIENT string: stackObj = 0x%x\n",
					(int)state->stackObj,2,3,4,5,6);
#endif /* PPP_DEBUG */
	/* start transmission of CLIENT string */

	sioTxStartup(pStackData->pSioChan);
	}
	
#ifdef PPP_DEBUG
	logMsg("sioAdptr: LCP OPEN EVENT: stackObj = 0x%x\n",
					(int)state->stackObj,2,3,4,5,6);
#endif /* PPP_DEBUG */
    return OK;
    }


/*******************************************************************************
* lcpDownHandler - handle lcp down event
*
*/
LOCAL STATUS lcpDownHandler
    (
    PFW_PLUGIN_OBJ_STATE * state,
    void *eventData
    )
    {
#ifdef PPP_DEBUG
    SIO_ADPTR_STACK_DATA *pStackData = state->stackData;
    SIO_ADPTR_PROFILE_DATA *pProfileData = state->profileData;
#endif /* PPP_DEBUG */

#ifdef PPP_DEBUG
    logMsg("sioAdptr: LCP DOWN EVENT: stackObj = 0x%x\n",
                                        (int)state->stackObj,2,3,4,5,6);
#endif /* PPP_DEBUG */

    flushSioTransmitQueue (state, eventData);

    if (ntSerialClientStringSetup(state, eventData) != OK)
        return ERROR;
    
#ifdef PPP_DEBUG
    if (pProfileData->peerType != SIO_PEER_REGULAR &&
        pStackData->channelState != SIO_CHANNEL_DOWN)
        logMsg("sioAdptr: CHANNEL %d DOWN: stackObj = 0x%x\n",
               pProfileData->channelNum,(int)state->stackObj,3,4,5,6);
#endif

    return OK;
        
    }


/*******************************************************************************
* flushSioTransmitQueue - flush transmit queue 
*
*/
LOCAL void flushSioTransmitQueue
    (
    PFW_PLUGIN_OBJ_STATE * state,
    void *eventData
    )
    {
    SIO_ADPTR_STACK_DATA *pStackData = state->stackData;
    M_BLK_ID sendQHead = NULL;
    M_BLK_ID pMblk = NULL;


    sendQHead = pStackData->sendMblk;
    if (sendQHead != NULL)
        sendQHead->mBlkHdr.mNextPkt = pStackData->sendQHead;
    pStackData->sendMblk = NULL;
    pStackData->sendQHead = NULL;
    pStackData->sendQTail = NULL;
    pStackData->sendQSize = 0;
    pStackData->sendQFull = FALSE;
    pStackData->nextSendIndex = 0;
    pStackData->nextReceiveIndex = 0;

    /* flush transmit Queue */
    while (sendQHead != NULL)
        {
        pMblk = sendQHead->mBlkHdr.mNextPkt;
        netMblkClChainFree(sendQHead);
        sendQHead = pMblk;
        }

    }


/*******************************************************************************
* ntSerialClientStringSetup - set up CLIENT/CLIENTSERVER string for NT 
*
*/
LOCAL STATUS ntSerialClientStringSetup
    (
    PFW_PLUGIN_OBJ_STATE * state,
    void *eventData
    )
    {
    SIO_ADPTR_STACK_DATA *pStackData = state->stackData;
    SIO_ADPTR_PROFILE_DATA *pProfileData = state->profileData;

    if (pProfileData->peerType == SIO_PEER_REGULAR ||
        pProfileData->peerType == SIO_PEER_MODEM)
        return OK;

    /* 
     * this forces re-negotiation of "CLIENT/CLIENTSERVER" string when LCP
     * re-opens when peer is a NT SERVER/CLIENT
     */

    if (pStackData->channelState != SIO_CHANNEL_DOWN)
	{
	if (semTake(pStackData->channelSem, WAIT_FOREVER) != OK)
	    return ERROR;

	pStackData->channelState = SIO_CHANNEL_DOWN;
	bzero(pStackData->channelBuf, sizeof(pStackData->channelBuf));
	pStackData->reTransmitClientString = 0x1;

	/* free captured receive buffer */

	if (pStackData->receiveChain != NULL )
	    {
	    SIO_FREE_PKT_CHAIN(pStackData->receiveChain);
	    pStackData->receiveChain = NULL;
	    }

    semGive(pStackData->channelSem);
	}

    return OK;
    }


/*******************************************************************************
* lcpCloseHandler - handle lcp administrative close event
*
*/
LOCAL STATUS lcpCloseHandler
    (
    PFW_PLUGIN_OBJ_STATE * state,
    void *eventData
    )
    {
    SIO_ADPTR_STACK_DATA *pStackData = state->stackData;
    int key;

#ifdef PPP_DEBUG
    logMsg("sioAdptr: LCP CLOSE EVENT: stackObj = 0x%x\n",
	    (int)state->stackObj,2,3,4,5,6);
#endif /* PPP_DEBUG */

    /* stop all sending and receiving */

    key = intLock();
    pStackData->lcpIsOpen = FALSE;
    intUnlock (key);

    return (OK);
    }


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

    return OK;
    }
/*******************************************************************************
* sio_channelNum - channelNum profile parameter
*
*
* RETURNS: OK on success and ERROR otherwise
*/

LOCAL STATUS sio_channelNum
    (
    PFW_OBJ * pfw,
    PFW_PARAMETER_OPERATION_TYPE operType,	/* operation type */
    void * pProfileData,                	/* profile data bucket */
    char * value	                 	/* value for this parameter */
    )
    {
    SIO_ADPTR_PROFILE_DATA * pSioProfileData =
					(SIO_ADPTR_PROFILE_DATA *)pProfileData;
    if (operType == PFW_PARAMETER_SET)
	{
	/* convert from ascii */

	pSioProfileData->channelNum = atoi((const char *)value);
	return OK;
	}
    else if (operType == PFW_PARAMETER_GET)
	{
	sprintf(value,"%d",pSioProfileData->channelNum);
	return OK;
	}

    return ERROR;
    }

/*******************************************************************************
* sio_baudRate - baud rate for channel
*
*
* RETURNS: OK on success and ERROR otherwise
*/

LOCAL STATUS sio_baudRate
    (
    PFW_OBJ * pfw,
    PFW_PARAMETER_OPERATION_TYPE operType,	/* operation type */
    void * pProfileData,                	/* profile data bucket */
    char * value	                 	/* value for this parameter */
    )
    {
    SIO_ADPTR_PROFILE_DATA * pSioProfileData =
					(SIO_ADPTR_PROFILE_DATA *)pProfileData;
    if (operType == PFW_PARAMETER_SET)
	{
	/* convert from ascii */

	pSioProfileData->baudRate = atoi((const char *)value);
	return OK;
	}
    else if (operType == PFW_PARAMETER_GET)
	{
	sprintf(value,"%d",pSioProfileData->baudRate);
	return OK;
	}

    return ERROR;
    }

/*******************************************************************************
* sio_maxSendQSize - maximum send queue size
*
*
* RETURNS: OK on success and ERROR otherwise
*/

LOCAL STATUS sio_maxSendQSize
    (
    PFW_OBJ * pfw,
    PFW_PARAMETER_OPERATION_TYPE operType,	/* operation type */
    void * pProfileData,                	/* profile data bucket */
    char * value	                 	/* value for this parameter */
    )
    {
    SIO_ADPTR_PROFILE_DATA * pSioProfileData =
					(SIO_ADPTR_PROFILE_DATA *)pProfileData;
    if (operType == PFW_PARAMETER_SET)
	{
	/* convert from ascii */

	pSioProfileData->maxSendQSize = atoi((const char *)value);
	return OK;
	}
    else if (operType == PFW_PARAMETER_GET)
	{
	sprintf(value,"%d",pSioProfileData->maxSendQSize);
	return OK;
	}

    return ERROR;
    }
/*******************************************************************************
* sio_peerType - peer type parameter handler
*
*
* RETURNS: OK on success and ERROR otherwise
*/

LOCAL STATUS sio_peerType
    (
    PFW_OBJ * pfw,
    PFW_PARAMETER_OPERATION_TYPE operType,	/* operation type */
    void * pProfileData,                	/* profile data bucket */
    char * value	                 	/* value for this parameter */
    )
    {
    SIO_ADPTR_PROFILE_DATA * pSioProfileData =
					(SIO_ADPTR_PROFILE_DATA *)pProfileData;

    if (operType == PFW_PARAMETER_SET)
	{
	if (!strcmp(value, "NT_SERVER") || !strcmp(value, "WIN_SERVER"))
	    pSioProfileData->peerType = SIO_PEER_NT_SERVER;

	else if (!strcmp(value, "NT_CLIENT") || !strcmp(value, "WIN_CLIENT"))
	    pSioProfileData->peerType = SIO_PEER_NT_CLIENT;

	else if (!strcmp(value, "REGULAR"))
	    pSioProfileData->peerType = SIO_PEER_REGULAR;

	else if (!strcmp(value, "MODEM"))
	    pSioProfileData->peerType = SIO_PEER_MODEM;

	else 
	    return ERROR;

	return OK;
	}
    else if (operType == PFW_PARAMETER_GET)
	{
	if (pSioProfileData->peerType == SIO_PEER_NT_SERVER)
	    sprintf (value,"WIN_SERVER");

	else if (pSioProfileData->peerType == SIO_PEER_NT_CLIENT)
	    sprintf (value,"WIN_CLIENT");

	else if (pSioProfileData->peerType == SIO_PEER_REGULAR)
	    sprintf (value,"REGULAR");

	else if (pSioProfileData->peerType == SIO_PEER_MODEM)
	    sprintf (value,"MODEM");

	else
	    return ERROR;

	return OK;
	}
    return ERROR;
    }

/****************************************************************************
* sioChannelIDConnectSpeedEventHandler -
*
* This routine collect ppp attributes.
*
*/
LOCAL STATUS sioChannelIDConnectSpeedEventHandler
    (
    PFW_PLUGIN_OBJ_STATE * state,
    void *eventData
    )
    {
    int id;
    PFW_INTERFACE_STATE_PAIR phyPortStatePair;
    PHY_PORT_INTERFACE *phyPortInterface;
    SIO_ADPTR_PROFILE_DATA * pProfileData =
	(SIO_ADPTR_PROFILE_DATA * )state->profileData;

    PPP_ATTRIBUTES *pEventData = (PPP_ATTRIBUTES *) eventData;

    pEventData->txConnectSpeed = pProfileData->baudRate;