ppppapcomponent.c

这是全套的PPP协议的源码

		}

	    (*stackData->controlLayerInterface->pppAuthRefused)(pluginObjState);
	    return (OK);
	    }
	}

    if ((packet = stackData->lastSentAuthRequestPacket) == NULL)
            return OK;

    if ((dupPkt = papDupPkt(packet)) != NULL)
	{
	if (retry)
	    {
	    /* change the packet identifier */

	    sptr_authentication_request_packet = mtod (dupPkt, 
					   AUTHENTICATION_REQUEST_PACKET *);
	    sptr_authentication_request_packet->id = 
					    ++stackData->id_sequence_number;

	    stackData->lastSendAuthRequestPacketId = 
					stackData->id_sequence_number;
#ifdef PPP_DEBUG
	    printf ("PAP:Sending Auth request:ID %d, \n",
		   sptr_authentication_request_packet->id);
#endif /* PPP_DEBUG */
	    }
	stackData->lastSentAuthRequestPacket = dupPkt;
	pfwSend(pluginObjState,packet);
	}

#ifdef PPP_DEBUG
    printf ("PAP: sending Auth Request; Retry %d\n",(retry +1));
#endif /* PPP_DEBUG */

    pfwTimerStart(stackData->authRequestTimer, PFW_SECOND, 
			  profileData->authRequestInterval, 
			  sendAuthRequestRetry, ++retry);

    return OK;
    }
     
/*******************************************************************************
* papStateMachine -
*
* This state machine only handles UP,OPEN,DOWN and CLOSE events from the
* control layer
*/
LOCAL void papStateMachine
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    PPP_EVENT              ppp_event,
    M_BLK_ID               pMblk
    )
    {
    PAP_STACK_DATA *stackData = (PAP_STACK_DATA *)pluginState->stackData;

    LCP_NEGOTIATED_AUTH_PROTOCOL_INTERFACE * authProto =
                    (LCP_NEGOTIATED_AUTH_PROTOCOL_INTERFACE *)
                            stackData->lcpNegotiatedAuthProtocols.interfaceObj;

    PFW_PLUGIN_OBJ_STATE * lcpState = 
				stackData->lcpNegotiatedAuthProtocols.state;
    switch (ppp_event)
        {
        case PPP_UP_EVENT:
	    if (stackData->clientState == PPP_INITIAL_STATE &&
		stackData->serverState == PPP_INITIAL_STATE)
		{
		break;
		}
	    /* else FALL THROUGH */

        case PPP_OPEN_EVENT:
            pap_initialize_restart_counter(pluginState);

	    if (authProto->pppRemoteAuthenticationProtocolGet(lcpState)
		== PAP_PROTOCOL)
		{
		stackData->clientEnabled =  TRUE;

                send_pap_authentication_request (pluginState);
		stackData->clientState = PPP_ACK_SENT_STATE;
		stackData->state = PPP_ACK_SENT_STATE;
		}

	    if (authProto->pppLocalAuthenticationProtocolGet(lcpState)
		== PAP_PROTOCOL)
		{
		stackData->serverEnabled =  TRUE;

		stackData->serverState = PPP_ACK_RECEIVED_STATE;
		stackData->state = PPP_ACK_RECEIVED_STATE;
		}

	    if (stackData->clientEnabled && stackData->serverEnabled)
		stackData->state = PPP_REQUEST_SENT_STATE;

            break;

        case PPP_DOWN_EVENT:
        case PPP_CLOSE_EVENT:
            pfwTimerCancel(stackData->authRequestTimer);
	    if (stackData->lastSentAuthRequestPacket != NULL)
		{
		netMblkClChainFree(stackData->lastSentAuthRequestPacket);
		stackData->lastSentAuthRequestPacket = NULL;
		}

	    stackData->clientState = PPP_STARTING_STATE;
	    stackData->serverState = PPP_STARTING_STATE;
	    stackData->state = PPP_STARTING_STATE;

	    stackData->controlLayerInterface->protocolDown(pluginState,
							PPP_STARTING_STATE);
            break;

        default:
            printf ("PAP cannot handle event %d\n",ppp_event);
            break;
        }

    }

/*******************************************************************************
*
* pap_packet_received -
*/
LOCAL void pap_packet_received 
    (
    PFW_PLUGIN_OBJ_STATE * state,
    M_BLK_ID packet
    )
    {
    PAP_PACKET *sptr_pap_rx_packet;
    PAP_STACK_DATA *stackData = (PAP_STACK_DATA *)state->stackData;
    AUTHENTICATION_ACK_PACKET *sptr_authentication_ack_packet;
    AUTHENTICATION_NAK_PACKET *sptr_authentication_nak_packet;
    USHORT number_of_bytes_rxed;
    int pap_packet_length;
    BYTE messageLength;
    int receivedBytesLessHdr;
    int excessBytes;

    if (packet->mBlkHdr.mFlags & M_PKTHDR)
        {
        number_of_bytes_rxed = packet->mBlkPktHdr.len;
        }
    else
        number_of_bytes_rxed = packet->mBlkHdr.mLen;

    if (number_of_bytes_rxed < (sizeof (LCP_HEADER) + sizeof(PPP_HEADER)))
	{
	netMblkClChainFree(packet);
	return ;
	}

    sptr_pap_rx_packet = mtod(packet, PAP_PACKET *);
    sptr_authentication_ack_packet = mtod(packet,AUTHENTICATION_ACK_PACKET *);
    sptr_authentication_nak_packet = mtod(packet,AUTHENTICATION_NAK_PACKET *);

    pap_packet_length = htons (sptr_pap_rx_packet->lcp_header.length);

    if ((pap_packet_length < sizeof(LCP_HEADER)) ||
	(pap_packet_length > (number_of_bytes_rxed - sizeof(PPP_HEADER))))
	{
#ifdef PPP_DEBUG
	printf ("PAP: Dropped Packet; bad value %d in length field: \
	    stack 0x%x\n", pap_packet_length,(UINT32) state->stackObj);
#endif /* PPP_DEBUG */
	netMblkClChainFree(packet);
	return ;
	}

    receivedBytesLessHdr = number_of_bytes_rxed - sizeof(PPP_HEADER);

    /* if we get more, trim the excess from the tail */

    excessBytes = receivedBytesLessHdr - pap_packet_length;
    
    if (excessBytes)
        {
        m_adj (packet, -excessBytes);
#ifdef PPP_DEBUG
        printf ("trimming %d excess bytes from PAP packet\n", excessBytes);
#endif /* PPP_DEBUG */
        }

    switch (sptr_pap_rx_packet->lcp_header.code)
	{
	case AUTHENTICATION_REQUEST:
		pap_authentication_request_received (state, packet);
		break;
	case AUTHENTICATION_ACK:
	    if ((pap_packet_length < sizeof(LCP_HEADER) + sizeof(BYTE)) ||
		(sptr_pap_rx_packet->lcp_header.id != 
					stackData->id_sequence_number) ||
		((messageLength =sptr_authentication_ack_packet->message_length)
		!= (pap_packet_length -  (sizeof(LCP_HEADER) + sizeof(BYTE)))))
		{
#ifdef PPP_DEBUG
		printf ("PAP: Dropped Auth Ack; bad value %d in length field: \
		stack 0x%x\n",pap_packet_length, (UINT32) state->stackObj);
#endif /* PPP_DEBUG */
		netMblkClChainFree(packet);
		return ;
		}
	    else
#ifdef PPP_DEBUG
		printf ("PAP: Received Ack; bytes received %d: \
		    pap_packet_length = %d:message length = %d: stack 0x%x\n",
			    number_of_bytes_rxed,
			    pap_packet_length,
			    messageLength,(UINT32) state->stackObj);
#endif /* PPP_DEBUG */

		netMblkClChainFree(packet);
		pap_authentication_ack_received (state);
		break;
	case AUTHENTICATION_NAK:
	    if ((pap_packet_length < sizeof(LCP_HEADER) + sizeof(BYTE)) ||
		(sptr_pap_rx_packet->lcp_header.id != 
					stackData->id_sequence_number) ||
		((messageLength =sptr_authentication_nak_packet->message_length)
		!= (pap_packet_length -  (sizeof(LCP_HEADER) + sizeof(BYTE)))))
		{
#ifdef PPP_DEBUG
		printf ("PAP: Dropped Auth Nak; bad value %d in length field: \
		stack 0x%x\n",pap_packet_length, (UINT32) state->stackObj);
#endif /* PPP_DEBUG */
		netMblkClChainFree(packet);
		return ;
		}
	    else
#ifdef PPP_DEBUG
		printf ("PAP: Received Nak; bytes received %d: \
		    pap_packet_length = %d:message length = %d: stack 0x%x\n",
			    number_of_bytes_rxed,
			    pap_packet_length,
			    messageLength, (UINT32) state->stackObj);
#endif /* PPP_DEBUG */
		netMblkClChainFree(packet);
		pap_authentication_nak_received (state);
		break;
        default:
#ifdef PPP_DEBUG
            printf ("PAP: Dropping packet - Unknown code = %d\n",
                    sptr_pap_rx_packet->lcp_header.code);
#endif /* PPP_DEBUG */
            netMblkClChainFree(packet);        
            break;
	}
     }

/*******************************************************************************
*
* pap_authentication_request_received -
*/

LOCAL void pap_authentication_request_received 
    (
    PFW_PLUGIN_OBJ_STATE * state,
    M_BLK_ID packet
    )
    {
    USHORT name_length;
    USHORT password_length;
    USHORT stack_name_length;
    USHORT stack_password_length;

    char *cptr_peer_id;
    AUTHENTICATION_REQUEST_PACKET *sptr_pap_rx_packet;
    PAP_STACK_DATA *stackData = (PAP_STACK_DATA *)state->stackData;
    PAP_PROFILE_DATA *profileData = (PAP_PROFILE_DATA *)state->profileData;
    int pap_packet_length;

    /* 
     * if we are only a client for authentication, silently
     * discard packet
     */

    if (!stackData->serverEnabled)
	{
#ifdef PPP_DEBUG
	printf ("PAP:Client not replying to Auth request\n");
#endif /* PPP_DEBUG */
	m_freem(packet);
	return;
	}

    sptr_pap_rx_packet = mtod(packet, AUTHENTICATION_REQUEST_PACKET *);
    pap_packet_length = htons (sptr_pap_rx_packet->length);

    /* minimum size is LCP_HEADER + id Length field + pass length field */

    if (pap_packet_length < sizeof(LCP_HEADER) + sizeof(BYTE) + sizeof(BYTE))
	{
#ifdef PPP_DEBUG
	printf ("PAP: Dropped Auth Request; bad value %d in length field: \
	    stack 0x%x\n", pap_packet_length, (UINT32) state->stackObj);
#endif /* PPP_DEBUG */
	netMblkClChainFree(packet);
	return ;
	}

    name_length = sptr_pap_rx_packet->peer_id_length;

    cptr_peer_id = &sptr_pap_rx_packet->peer_id[0] + name_length;

    password_length = (USHORT) *cptr_peer_id;

    if ((name_length + password_length) != (pap_packet_length - 6))
	{
#ifdef PPP_DEBUG
	printf ("PAP: Dropped Auth Request; mismatched length fields\
	    stack 0x%x\n", (UINT32) state->stackObj);
#endif /* PPP_DEBUG */
	netMblkClChainFree(packet);
	return ;
	}

    stackData->lastReceivedAuthRequestPacketId = sptr_pap_rx_packet->id;

    /*  fix for SPR# 76442 */

    stack_name_length     = sizeof (stackData->remoteUserName);
    stack_password_length = sizeof (stackData->remoteUserPassword);

    if (name_length > (stack_name_length - 1))
       {
#ifdef PPP_DEBUG
       printf ("PAP: Dropped Auth Request: name is too long\n");
#endif /* PPP_DEBUG */

       authVerifyCallback (state, sptr_pap_rx_packet->id, FAIL);
       netMblkClChainFree (packet);
       return;
       }

    if (password_length > (stack_password_length - 1))
       {
#ifdef PPP_DEBUG
       printf ("PAP: Dropped Auth Request: password is too long \n");
#endif /* PPP_DEBUG */

       authVerifyCallback (state, sptr_pap_rx_packet->id, FAIL);
       netMblkClChainFree (packet);
       return;
       }


    memcpy (&stackData->remoteUserName[0], &sptr_pap_rx_packet->peer_id[0], 
	    name_length);

    stackData->remoteUserName[name_length] = '\0';

    ++cptr_peer_id;

    memcpy (&stackData->remoteUserPassword[0], cptr_peer_id, password_length);

    stackData->remoteUserPassword[password_length]='\0';

    stackData->lastReceivedAuthRequestPacketId = sptr_pap_rx_packet->id;

    m_freem(packet);

#ifdef PPP_DEBUG
    printf("PAP:Received Auth request:ID %d, from %s password %s\n",
			sptr_pap_rx_packet->id,
			stackData->remoteUserName,
			stackData->remoteUserPassword);

#endif /* PPP_DEBUG */

    (*stackData->controlLayerInterface->pppPasswordAuthVerify) (
		 state, 
		 profileData->localUserName,
		 stackData->remoteUserName, 
		 stackData->remoteUserPassword, 
		 stackData->lastReceivedAuthRequestPacketId, 
		 authVerifyCallback);
    }

/*******************************************************************************
*
* authVerifyCallback -
*/
LOCAL void authVerifyCallback
    (
    PFW_PLUGIN_OBJ_STATE *state,
    BYTE id,
    TEST passOrFail
    )
    {
    PAP_STACK_DATA *stackData = (PAP_STACK_DATA *)state->stackData;

    if (stackData->lastReceivedAuthRequestPacketId != id)
        return;

    if (passOrFail == PASS)
        send_pap_authentication_ack (state, id); 
    else
        send_pap_authentication_nak (state, id);
    }

/*******************************************************************************
*
* pap_authentication_ack_received -
*/
LOCAL void pap_authentication_ack_received 
    (
    PFW_PLUGIN_OBJ_STATE * pluginObjState
    )
    {
    PAP_STACK_DATA *stackData = (PAP_STACK_DATA *)pluginObjState->stackData;

    if (stackData->clientState == PPP_OPENED_STATE)
        return;

    pfwTimerCancel (stackData->authRequestTimer);
    
    if (stackData->lastSentAuthRequestPacket != NULL)
	{
        netMblkClChainFree(stackData->lastSentAuthRequestPacket);
	stackData->lastSentAuthRequestPacket = NULL;
	}

#ifdef PPP_DEBUG
    printf ("PAP:Received Ack \n");
#endif /* PPP_DEBUG */

    (*stackData->controlLayerInterface->pppAuthAckReceived)(pluginObjState);
    
    if (stackData->clientState != PPP_OPENED_STATE)
	{
	stackData->clientState = PPP_OPENED_STATE;
	if ((stackData->serverEnabled  == FALSE) ||
	    (stackData->serverEnabled  == TRUE && 
				stackData->serverState == PPP_OPENED_STATE))
	    {
	    stackData->state = PPP_OPENED_STATE;

	    (*stackData->controlLayerInterface->protocolUp) (pluginObjState);
	    }
	}
    }

/*******************************************************************************
*
* pap_authentication_nak_received -
*/
LOCAL void pap_authentication_nak_received 
    (
    PFW_PLUGIN_OBJ_STATE * state
    )
    {
    PAP_STACK_DATA *stackData = state->stackData;
    PAP_PROFILE_DATA *profileData = state->profileData;

    if (stackData->lastSentAuthRequestPacket != NULL)
	    {
            netMblkClChainFree(stackData->lastSentAuthRequestPacket);
	    stackData->lastSentAuthRequestPacket = NULL;
	    }

#ifdef PPP_DEBUG
    printf ("PAP:Received Nak \n");
#endif /* PPP_DEBUG */

    if (stackData->clientState == PPP_OPENED_STATE ||
	stackData->currentAuthRequestRetries 
				      >= profileData->maxAuthRequestRetries)
        {
        pfwTimerCancel(stackData->authRequestTimer); 
        (*stackData->controlLayerInterface->pppAuthRefused) (state);
	return;
        }
        
    pfwTimerCancel (stackData->authRequestTimer);
    send_pap_authentication_request (state);
    }

/*******************************************************************************
*
* send_pap_authentication_request -