pppchapcomponent.c

这是全套的PPP协议的源码

    if (pStackData->lastSentResponsePacket != NULL)
	    {
	    netMblkClChainFree(pStackData->lastSentResponsePacket);
	    pStackData->lastSentResponsePacket = NULL;
	    }

    pfwInterfaceReferenceDelete(
			pStackData->lcpNegotiatedAuthProtocols.interfaceObj);

    pfwInterfaceReferenceDelete(
	(PFW_INTERFACE_OBJ *)pStackData->controlLayerInterface);

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

/*******************************************************************************
* profileDataConstruct -
*/
LOCAL STATUS profileDataConstruct
    (
    PFW_OBJ *pfw,
    void *profileData
    )
    {
    CHAP_PROFILE_DATA *pChapProfileData = (CHAP_PROFILE_DATA *)profileData;

    pChapProfileData->maximum_number_of_retries = CHAP_DEFAULT_MAX_RETRIES;
    pChapProfileData->retryInterval = CHAP_DEFAULT_RETRY_TIMEOUT;
    pChapProfileData->challengeInterval = CHAP_DEFAULT_CHALLENGE_INTERVAL;

    chap_localUserName (pfw,PFW_PARAMETER_SET, pChapProfileData, "vxTarget");
    return (OK);
    }

/*******************************************************************************
*
* stackDataConstruct -
*/

LOCAL STATUS stackDataConstruct
    (
    PFW_OBJ *pfw,
    void * stackData,
    void * profileData
    )
    {
    CHAP_STACK_DATA * pStackData = (CHAP_STACK_DATA *) stackData;

    memset(stackData,0, sizeof(CHAP_STACK_DATA));

    pStackData->clientState = PPP_INITIAL_STATE;
    pStackData->serverState = PPP_INITIAL_STATE;
    pStackData->state = PPP_INITIAL_STATE;
    pStackData->id_sequence_number = (BYTE)(tickGet() & 0xff);

    return (OK);
    }

/*******************************************************************************
* chapCallback -
*/
LOCAL void chapCallback
    (
    PFW_PLUGIN_OBJ_STATE * state,
    BYTE id,
    TEST passOrFail
    )
    {
    CHAP_STACK_DATA *pStackData = state->stackData;
    CHAP_PROFILE_DATA *pProfileData = (CHAP_PROFILE_DATA *)state->profileData;

    /* check for stale response */

    if (pStackData->id != id)
	{
	return ;
	}

    /* cancel timer set for retries or periodic retries */

    pfwTimerCancel(pStackData->challengeTimer);

    if (passOrFail == PASS)
	{
#ifdef PPP_DEBUG
	printf("Auth passed\n");
#endif /*PPP_DEBUG*/
	send_chap_authentication_ack (state,id);

	if (pStackData->serverState != PPP_OPENED_STATE)
	    {
	    pStackData->serverState  = PPP_OPENED_STATE;
	    if (pStackData->clientEnabled == FALSE || 
		pStackData->clientState == PPP_OPENED_STATE)
		{
		pStackData->state  = PPP_OPENED_STATE;
		/* tell the control layer that authentication is complete */

		pStackData->controlLayerInterface->protocolUp (state);
		}
	    }

	/* start the periodic CHALLENGE timer */

	if (pProfileData->challengeInterval > 0)
	    pfwTimerStart (pStackData->challengeTimer, PFW_SECOND,
		    pProfileData->challengeInterval,
		    (PFW_TIMER_HANDLER)send_chap_server_packet, (int)state);
	}
    else
	{
#ifdef PPP_DEBUG
	printf("Auth failed\n");
#endif /* PPP_DEBUG */
	send_chap_authentication_nak (state,id);

	pStackData->controlLayerInterface->pppAuthRefused(state);
	}
    return ;
    }

/*******************************************************************************
* chapStateMachine - 
*
* This state machine only handles UP,OPEN,DOWN and CLOSE events from the
* control layer
*/
LOCAL void chapStateMachine
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    PPP_EVENT              ppp_event,
    M_BLK_ID               pMblk
    )
    {
    CHAP_STACK_DATA *pStackData = (CHAP_STACK_DATA *)pluginState->stackData;
    LCP_NEGOTIATED_AUTH_PROTOCOL_INTERFACE * authProto = 
		    (LCP_NEGOTIATED_AUTH_PROTOCOL_INTERFACE *)
			    pStackData->lcpNegotiatedAuthProtocols.interfaceObj;

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

	case PPP_OPEN_EVENT:
	    chap_initialize_restart_counter(pluginState);

	    if (authProto->pppLocalAuthenticationProtocolGet(lcpState) 
		== CHAP_PROTOCOL)
		{
		pStackData->serverEnabled =  TRUE;

		send_chap_server_packet(pluginState);
		pStackData->serverState = PPP_ACK_SENT_STATE;
		pStackData->state = PPP_ACK_SENT_STATE;
		}

	    if (authProto->pppRemoteAuthenticationProtocolGet(lcpState) 
		== CHAP_PROTOCOL )
		{
		pStackData->clientEnabled =  TRUE;
		pStackData->clientState = PPP_ACK_RECEIVED_STATE;
		pStackData->state = PPP_ACK_RECEIVED_STATE;
		}

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

	    break;

	case PPP_DOWN_EVENT:
	case PPP_CLOSE_EVENT:

	    pfwTimerCancel(pStackData->challengeTimer);
	    pfwTimerCancel(pStackData->retryTimer);

	    if (pStackData->lastSentResponsePacket != NULL)
		{
		netMblkClChainFree(pStackData->lastSentResponsePacket);
		pStackData->lastSentResponsePacket = NULL;
		}

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

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

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

/*******************************************************************************
*
* send_chap_server_packet -
*/
LOCAL void send_chap_server_packet 
    (
    PFW_PLUGIN_OBJ_STATE * state
    )
    {
    USHORT number_of_bytes_to_send;
    CHAP_PACKET *sptr_chap_packet;
    ULONG random_number1;
    ULONG random_number2;
    ULONG random_number3;
    ULONG random_number4;
    char random_number_string[16];
    BYTE *bptr_name_section;
    M_BLK_ID packet;
    CHAP_STACK_DATA *pStackData = (CHAP_STACK_DATA *)state->stackData;
    CHAP_PROFILE_DATA *pProfileData = (CHAP_PROFILE_DATA *)state->profileData;
    NET_POOL_ID netPoolId = pfwNetPoolIdGet(state->pluginObj->pfwObj);

    number_of_bytes_to_send = sizeof (PPP_HEADER) + sizeof (LCP_HEADER) + 
	sizeof (BYTE) + CHALLENGE_VALUE_SIZE +
	strlen (pProfileData->localUserName);
	
    if ((packet = netTupleGet(netPoolId,number_of_bytes_to_send,
				    M_DONTWAIT, MT_DATA, TRUE)) == NULL)
	{
	return;
	}

    sptr_chap_packet = mtod (packet, CHAP_PACKET *);

    sptr_chap_packet->value_size = CHALLENGE_VALUE_SIZE;

    random_number1 = get_my_random_number();
    random_number2 = get_my_random_number();
    random_number3 = get_my_random_number();
    random_number4 = get_my_random_number();

    memcpy (&random_number_string[0], &random_number1, sizeof (ULONG));
    memcpy (&random_number_string[4], &random_number2, sizeof (ULONG));
    memcpy (&random_number_string[8], &random_number3, sizeof (ULONG));
    memcpy (&random_number_string[12],&random_number4, sizeof (ULONG));
    
    memcpy (&sptr_chap_packet->value,&random_number_string[0],
			CHALLENGE_VALUE_SIZE);
    memcpy (&pStackData->challenge[0],&random_number_string[0],
			CHALLENGE_VALUE_SIZE);

    bptr_name_section = (BYTE *)((ULONG) &sptr_chap_packet->value[0] +
    sptr_chap_packet->value_size);

    /* Copy the user_name */
    strncpy ((char *)bptr_name_section, pProfileData->localUserName,
		(BYTE)strlen (pProfileData->localUserName));

    pStackData->id_sequence_number = (BYTE)(pStackData->id_sequence_number + 1);

    pStackData->last_id_of_chap_packet_sent = pStackData->id_sequence_number;

    packet->mBlkHdr.mLen = number_of_bytes_to_send;

    send_authentication_packet (state, packet, CHAP_CHALLENGE,
	pStackData->id_sequence_number, CHAP_PROTOCOL);

    return;
    }

/********************************************************************************
* send_chap_peer_packet -
*/

LOCAL void send_chap_peer_packet 
    (
    PFW_PLUGIN_OBJ_STATE * state,
    char *cptr_response,
    BYTE id
    )
    {
    USHORT number_of_bytes_to_send;
    CHAP_PACKET *sptr_chap_packet;
    M_BLK_ID packet;
    CHAP_STACK_DATA *pStackData = (CHAP_STACK_DATA *)state->stackData;
    CHAP_PROFILE_DATA *pProfileData = (CHAP_PROFILE_DATA *)state->profileData;
    NET_POOL_ID netPoolId = pfwNetPoolIdGet(state->pluginObj->pfwObj);

    number_of_bytes_to_send = (USHORT) (sizeof (PPP_HEADER) + 
    sizeof (LCP_HEADER) + sizeof (sptr_chap_packet->value_size) +
    RESPONSE_VALUE_SIZE + strlen (pProfileData->localUserName));

    if ((packet = netTupleGet(netPoolId,number_of_bytes_to_send,
				M_DONTWAIT, MT_DATA, TRUE)) == NULL)
	{
	return;
	}

    sptr_chap_packet = mtod (packet, CHAP_PACKET *);

    sptr_chap_packet->value_size = RESPONSE_VALUE_SIZE;

    memcpy (&sptr_chap_packet->value,cptr_response,RESPONSE_VALUE_SIZE);

    memcpy (&sptr_chap_packet->name[0],pProfileData->localUserName,
					strlen (pProfileData->localUserName));

    pStackData->last_id_of_chap_response_sent = id;

    packet->mBlkHdr.mLen = number_of_bytes_to_send;

    send_authentication_packet (state, packet, CHAP_RESPONSE, id,CHAP_PROTOCOL);
    }

/*******************************************************************************
*
* chapReceive -
*/

LOCAL STATUS chapReceive
    (
    PFW_PLUGIN_OBJ_STATE *state,
    M_BLK_ID             * pMblkId
    )
    {
    M_BLK_ID packet;
    USHORT name_length;
    USHORT stack_name_length;
    UINT secret_length;
    UINT length;
    USHORT chap_packet_length;
    char secret[NAME_SIZE*2];
    BYTE chap_string_to_encode[128];
    char response[RESPONSE_VALUE_SIZE];
    CHAP_PACKET *sptr_chap_rx_packet;
    USHORT number_of_bytes_rxed;
    CHAP_STACK_DATA *pStackData = (CHAP_STACK_DATA *)state->stackData;
    CHAP_PROFILE_DATA *pProfileData = (CHAP_PROFILE_DATA *)state->profileData;
    unsigned int responseLength;
    int receivedBytesLessHdr;
    int excessBytes;

    if (pMblkId == NULL || (packet = *pMblkId) == NULL)
	return ERROR;

    number_of_bytes_rxed = packet->mBlkHdr.mLen;

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

    sptr_chap_rx_packet = mtod (packet, CHAP_PACKET *);
    chap_packet_length = htons (sptr_chap_rx_packet->lcp_header.length);

    /* we must have at least what the header says */

    receivedBytesLessHdr = number_of_bytes_rxed - sizeof(PPP_HEADER);

    if (chap_packet_length > receivedBytesLessHdr)
        {
        netMblkClChainFree(packet);
        return (PASS);
        }

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

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


    if (sptr_chap_rx_packet->lcp_header.code == CHAP_RESPONSE)
	{
	if ((chap_packet_length < (sizeof(LCP_HEADER) + sizeof(BYTE))) ||
	    (chap_packet_length > (number_of_bytes_rxed - sizeof(PPP_HEADER))))
	    {
#ifdef PPP_DEBUG
	    printf ("CHAP: Dropped Response; bad value %d in length field: \
		stack 0x%x\n", chap_packet_length,(int)state->stackObj);
#endif /* PPP_DEBUG */
	    netMblkClChainFree(packet);
	    return ERROR;
	    }

	if (sptr_chap_rx_packet->lcp_header.id !=