pppchapcomponent.c

这是全套的PPP协议的源码

				pStackData->last_id_of_chap_packet_sent)
	    {
#ifdef PPP_DEBUG
	    printf ("CHAP: Dropped Response; bad id %d : stack 0x%x\n",
		sptr_chap_rx_packet->lcp_header.id,(int)state->stackObj);
#endif /* PPP_DEBUG */
	    netMblkClChainFree(packet);
	    return ERROR;
	    }

	if (sptr_chap_rx_packet->value_size != RESPONSE_VALUE_SIZE)
	    {
	    netMblkClChainFree(packet);
	    return ERROR;
	    }

	if (pStackData->serverEnabled == FALSE ||
	    pStackData->serverState < PPP_REQUEST_SENT_STATE)
	    {
#ifdef PPP_DEBUG
	    printf ("CHAP: Dropped Response in state %d\n",
					pStackData->serverState);
#endif /* PPP_DEBUG */
	    netMblkClChainFree(packet);
	    return ERROR;
	    }

	name_length = (USHORT) (chap_packet_length - sizeof (LCP_HEADER) - 
				sizeof (sptr_chap_rx_packet->value_size) -
				sptr_chap_rx_packet->value_size);

        /* fix for SPR# 76442, check lengths */

        pStackData->id = sptr_chap_rx_packet->lcp_header.id;

        stack_name_length = sizeof (pStackData->peer_user_name);

        if (name_length > (stack_name_length - 1))
           {
#ifdef PPP_DEBUG
           printf  ("CHAP: Dropped Response: user name is too long\n");
#endif /* PPP_DEBUG */
           chapCallback (state, sptr_chap_rx_packet->lcp_header.id, FAIL);
           netMblkClChainFree (packet);
           return ERROR;
           }

	memcpy (&pStackData->peer_user_name[0],&sptr_chap_rx_packet->name[0],
							name_length);

	pStackData->peer_user_name[name_length] = '\0';

        memcpy (&pStackData->peer_response[0],&sptr_chap_rx_packet->value[0],
		sptr_chap_rx_packet->value_size);

	responseLength = sptr_chap_rx_packet->value_size;
	pStackData->id = sptr_chap_rx_packet->lcp_header.id;

#ifdef PPP_DEBUG
	printf ("CHAP: Received Response, ID %d, PeerName %s\n",pStackData->id,
				    pStackData->peer_user_name);
#endif /* PPP_DEBUG */
	pStackData->controlLayerInterface->pppChallengeAuthVerify (state,
				pProfileData->localUserName,
				pStackData->peer_user_name,
				pStackData->peer_response, responseLength,
				pStackData->challenge,CHALLENGE_VALUE_SIZE,
				pStackData->id,
				chapCallback);
	}
    else if (sptr_chap_rx_packet->lcp_header.code == CHAP_CHALLENGE)
	{
	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 Challenge; bad value %d in length field: \
		stack 0x%x\n", chap_packet_length,(int)state->stackObj);
#endif /* PPP_DEBUG */
	    netMblkClChainFree(packet);
	    return ERROR;
	    }

	if (pStackData->clientEnabled == FALSE ||
	    pStackData->clientState < PPP_REQUEST_SENT_STATE)
	    {
#ifdef PPP_DEBUG
	    printf ("CHAP:Dropped Challenge; bad state\n");
#endif /* PPP_DEBUG */
	    netMblkClChainFree(packet);
	    return ERROR;
	    }

	memset(secret,0,sizeof(secret));

	/* get secret from control layer */

	pStackData->controlLayerInterface->pppAuthRequest (state,
				pProfileData->localUserName, &secret[0]);

	memset(chap_string_to_encode,0,sizeof(chap_string_to_encode));

	chap_string_to_encode[0] = sptr_chap_rx_packet->lcp_header.id;
	
	secret_length = strlen (secret);

#ifdef PPP_DEBUG
	printf ("CHAP:Received Challenge:ID %d, gotSecret %s for localName %s\n",
				sptr_chap_rx_packet->lcp_header.id,
				secret,pProfileData->localUserName);
#endif /* PPP_DEBUG */
	/* copy secret */

	memcpy (&chap_string_to_encode[1], secret,secret_length);
	
	length = sizeof (BYTE) + secret_length;
	
	/* copy challenge */

	memcpy ((void *) (&chap_string_to_encode[1 + secret_length]), 
		&sptr_chap_rx_packet->value, sptr_chap_rx_packet->value_size);

	length = length + sptr_chap_rx_packet->value_size;
	
	/* encode */

	mdString (&chap_string_to_encode[0], length, (BYTE *)&response[0], MD5);
	send_chap_peer_packet (state,&response[0],
			    sptr_chap_rx_packet->lcp_header.id);

	}
    else if (sptr_chap_rx_packet->lcp_header.code == CHAP_AUTHENTICATION_ACK)
	{
	if ((chap_packet_length < sizeof(LCP_HEADER)) ||
	    (chap_packet_length > (number_of_bytes_rxed - sizeof(PPP_HEADER))))
	    {
#ifdef PPP_DEBUG
	    printf ("CHAP: Dropped ACK; 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 != 
				pStackData->last_id_of_chap_response_sent)
	    {
#ifdef PPP_DEBUG
	    printf ("CHAP: Dropped Ack; bad id %d : stack 0x%x\n",
		sptr_chap_rx_packet->lcp_header.id,(int)state->stackObj);
#endif /* PPP_DEBUG */
	    netMblkClChainFree(packet);
	    return ERROR;
	    }

	if (pStackData->clientEnabled == FALSE ||
	    pStackData->clientState < PPP_REQUEST_SENT_STATE)
	    {
	    netMblkClChainFree(packet);
	    return ERROR;
	    }

	/* tell control layer that we received an ACK */

	pStackData->controlLayerInterface->pppAuthAckReceived (state);

#ifdef PPP_DEBUG
	printf ("CHAP: Challenge, ID %d, got Ack\n",
				sptr_chap_rx_packet->lcp_header.id);
#endif /* PPP_DEBUG */
	/* cancel retry timer */

	pfwTimerCancel(pStackData->retryTimer);

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

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

		pStackData->controlLayerInterface->protocolUp (state);
		}
	    }
	}
    else if (sptr_chap_rx_packet->lcp_header.code == CHAP_AUTHENTICATION_NAK)
	{
	if ((chap_packet_length < sizeof(LCP_HEADER)) ||
	    (chap_packet_length > (number_of_bytes_rxed - sizeof(PPP_HEADER))))
	    {
#ifdef PPP_DEBUG
	    printf ("CHAP: Dropped NAK; 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 != 
				pStackData->last_id_of_chap_response_sent)
	    {
#ifdef PPP_DEBUG
	    printf ("CHAP: Dropped NAK; bad id %d : stack 0x%x\n",
		sptr_chap_rx_packet->lcp_header.id,(int)state->stackObj);
#endif /* PPP_DEBUG */
	    netMblkClChainFree(packet);
	    return ERROR;
	    }

	if (pStackData->clientEnabled == FALSE ||
	    pStackData->clientState < PPP_REQUEST_SENT_STATE)
	    {
	    netMblkClChainFree(packet);
	    return ERROR;
	    }
	/* cancel retry timer */

	pfwTimerCancel(pStackData->retryTimer);

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

	/* tell the control layer that authentication was refused */

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

    netMblkClChainFree(packet);

    return ERROR; /* this terminates the packet at this layer */
    }

/*******************************************************************************
*
* send_chap_authentication_ack -
*/

LOCAL void send_chap_authentication_ack 
    (
    PFW_PLUGIN_OBJ_STATE * state, 
    BYTE id_from_request_packet 
    )
    {
    AUTHENTICATION_ACK_PACKET *sptr_authentication_ack_packet;
    M_BLK_ID packet;
    int id;
    CHAP_STACK_DATA *pStackData = (CHAP_STACK_DATA *)state->stackData;
    int requiredPacketSize;
    int messageLength;
    NET_POOL_ID netPoolId = pfwNetPoolIdGet(state->pluginObj->pfwObj);

    PARAMETER_NOT_USED (id_from_request_packet);

#ifdef PPP_DEBUG
    printf("In send_chap_authentication_ack\n");
#endif /* PPP_DEBUG */

    id = pStackData->last_id_of_chap_packet_sent;

    messageLength = strlen ("you are authenticated");

    requiredPacketSize = sizeof(PPP_HEADER) + sizeof(LCP_HEADER) + messageLength;

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

    sptr_authentication_ack_packet = mtod (packet, AUTHENTICATION_ACK_PACKET *);

    sptr_authentication_ack_packet->code = CHAP_AUTHENTICATION_ACK;
    sptr_authentication_ack_packet->id = id;
    sptr_authentication_ack_packet->header.protocol_type = htons(CHAP_PROTOCOL);
    
    strncpy (((char *)sptr_authentication_ack_packet + 
		OFFSET(AUTHENTICATION_ACK_PACKET,message_length)),
		"you are authenticated",messageLength);

    sptr_authentication_ack_packet->length = htons (requiredPacketSize - 
						    sizeof(PPP_HEADER));

    packet->mBlkHdr.mLen = requiredPacketSize;

    pfwSend (state,packet);

#ifdef RW_PPP
    if (ppp.fptr_event_upcall != NULL)
	{
	(*ppp.fptr_event_upcall) (PPP_EVENT_AUTHENTICATE_ACK_TRANSMITTED,
	state);
	}
#else
#ifdef PPP_DEBUG
    printf("CHAP: sent auth ACK: stack = 0x%x\n", (UINT32) state->stackObj);
#endif /* PPP_DEBUG */
    pStackData->controlLayerInterface->pppAuthAckTransmitted (state);
#endif
    }

/*******************************************************************************
*
* send_chap_authentication_nak -
*/

LOCAL void send_chap_authentication_nak 
    (
    PFW_PLUGIN_OBJ_STATE * state, 
    BYTE id_from_request_packet 
    )
    {
    AUTHENTICATION_NAK_PACKET *sptr_authentication_nak_packet;
    M_BLK_ID packet;
    int requiredPacketSize;
    int messageLength;
    NET_POOL_ID netPoolId = pfwNetPoolIdGet(state->pluginObj->pfwObj);

    messageLength = strlen ("Authentication refused") ;
    requiredPacketSize = sizeof(PPP_HEADER) + sizeof(LCP_HEADER) + messageLength;

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

    sptr_authentication_nak_packet = mtod (packet, AUTHENTICATION_NAK_PACKET *);

    sptr_authentication_nak_packet->code = CHAP_AUTHENTICATION_NAK;
    sptr_authentication_nak_packet->id = id_from_request_packet;
    sptr_authentication_nak_packet->length =  htons (requiredPacketSize - 
						     sizeof(PPP_HEADER));
    
    sptr_authentication_nak_packet->header.protocol_type = htons(CHAP_PROTOCOL);
    
    strncpy (((char *)sptr_authentication_nak_packet + 
		OFFSET(AUTHENTICATION_NAK_PACKET,message_length)),
		"Authentication refused", messageLength);

    packet->mBlkHdr.mLen = requiredPacketSize;

    pfwSend (state, packet);
    }

/*******************************************************************************
*
* chap_pppPhaseGet -
*/
LOCAL PPP_CONTROL_PHASE chap_pppPhaseGet ()
    {
    return AUTHENTICATE_PHASE;
    }

/*******************************************************************************
* chap_pppStateGet -
*/
LOCAL PPP_STATE chap_pppStateGet
    (
    PFW_PLUGIN_OBJ_STATE * state
    )
    {
    CHAP_STACK_DATA * pStackData = (CHAP_STACK_DATA *)state->stackData;
    return (pStackData->state);
    }

/******************************************************************************
*
* chap_initialize_restart_counter -
*/

LOCAL void chap_initialize_restart_counter
    (
    PFW_PLUGIN_OBJ_STATE *pluginState
    )
    {
    CHAP_STACK_DATA * stackData = (CHAP_STACK_DATA *)pluginState->stackData;

    stackData->current_number_of_retries = 0;
    stackData->number_of_authentication_requests = 0;
    }

/*******************************************************************************
* chap_localUserName -
*/
LOCAL STATUS chap_localUserName
    (
    PFW_OBJ * pfw,
    PFW_PARAMETER_OPERATION_TYPE type,
    void * profileData,
    char * value
    )
    {
    if (type == PFW_PARAMETER_SET)