pppchapcomponent.c

这是全套的PPP协议的源码

        {
        strcpy(((CHAP_PROFILE_DATA *) profileData)->localUserName, value);
        }
    else if (type == PFW_PARAMETER_GET)
        strcpy(value, ((CHAP_PROFILE_DATA *) profileData)->localUserName);

    return (OK);
    }

/*******************************************************************************
* chap_maxRetries -
*/
LOCAL STATUS chap_maxRetries
    (
    PFW_OBJ * pfw,
    PFW_PARAMETER_OPERATION_TYPE type,
    void * profileData,
    char * value
    )
    {
    if (type == PFW_PARAMETER_SET)
	((CHAP_PROFILE_DATA *) profileData)->maximum_number_of_retries =
								    atoi(value);
    else if (type == PFW_PARAMETER_GET)
	sprintf(value, "%d",
		((CHAP_PROFILE_DATA *) profileData)->maximum_number_of_retries);

    return (OK);
    }


/*******************************************************************************
* chap_challengeInterval -
*/
LOCAL STATUS chap_challengeInterval
    (
    PFW_OBJ * pfw,
    PFW_PARAMETER_OPERATION_TYPE type,
    void * profileData,
    char * value
    )
    {
    if (type == PFW_PARAMETER_SET)
	((CHAP_PROFILE_DATA *) profileData)->challengeInterval = atoi(value);
    else if (type == PFW_PARAMETER_GET)
	sprintf(value, "%ld",
		((CHAP_PROFILE_DATA *) profileData)->challengeInterval);

    return (OK);
    }


/*******************************************************************************
* chap_retryInterval -
*/
LOCAL STATUS chap_retryInterval
    (
    PFW_OBJ * pfw,
    PFW_PARAMETER_OPERATION_TYPE type,
    void * profileData,
    char * value
    )
    {
    if (type == PFW_PARAMETER_SET)
	((CHAP_PROFILE_DATA *) profileData)->retryInterval = atoi(value);
    else if (type == PFW_PARAMETER_GET)
	sprintf(value, "%ld",((CHAP_PROFILE_DATA *)profileData)->retryInterval);

    return (OK);
    }


/*******************************************************************************
*
* send_authentication_packet -
*/

LOCAL void send_authentication_packet 
    (
    PFW_PLUGIN_OBJ_STATE * state,
    M_BLK_ID packet,
    BYTE code,
    BYTE id,
    USHORT protocol_type
    )
    {
    CHAP_STACK_DATA *pStackData = (CHAP_STACK_DATA *)state->stackData;
    PPP_PACKET *sptr_tx_packet;
    USHORT number_of_bytes_to_send;

    sptr_tx_packet = mtod (packet, PPP_PACKET *);
    number_of_bytes_to_send = packet->mBlkHdr.mLen;

    sptr_tx_packet->code = (BYTE_ENUM (PPP_CONTROL_CODE)) code;
    sptr_tx_packet->id = id;
    sptr_tx_packet->length = htons ((USHORT) (number_of_bytes_to_send 
				- sizeof (PPP_HEADER)));

    sptr_tx_packet->header.protocol_type = htons(protocol_type);

    pStackData->statistics.number_of_tx_bytes += number_of_bytes_to_send;

    ++pStackData->statistics.number_of_tx_packets;

    if (code == CHAP_CHALLENGE)
	{
	pStackData->challengePacket = packet;
	sendChapPeriodicChallengeOrRetry(state, CHAP_CHALLENGE_INITIAL);
	}
    else if (code == CHAP_RESPONSE)
	{
	if (pStackData->lastSentResponsePacket != NULL)
	    {
	    netMblkClChainFree(pStackData->lastSentResponsePacket);
	    pStackData->lastSentResponsePacket = NULL;
	    }

	pStackData->lastSentResponsePacket = packet;
	pfwTimerCancel(pStackData->retryTimer);
	pStackData->number_of_authentication_requests = 0;
	sendChapResponseRetry(state,0);
	}
    else 
	pfwSend (state, packet);
    }

/*******************************************************************************
* sendChapPeriodicChallengeOrRetry -
*/
LOCAL STATUS sendChapPeriodicChallengeOrRetry 
    (
    PFW_PLUGIN_OBJ_STATE * state,
    int retry
    )
    {
    CHAP_STACK_DATA *pStackData = (CHAP_STACK_DATA *)state->stackData;
    CHAP_PROFILE_DATA *pProfileData = (CHAP_PROFILE_DATA *)state->profileData;
    M_BLK_ID packet;
    BOOL isRetry;

#ifdef PPP_DEBUG
    printf ("CHAP Sending Challenge\n");
#endif /* PPP_DEBUG */

    if ((isRetry = (retry != CHAP_CHALLENGE_INITIAL)) &&
	(++pStackData->current_number_of_retries >=
				    pProfileData->maximum_number_of_retries))
	{
#ifdef PPP_DEBUG
	printf ("CHAP Challenge retry timedout!\n");
#endif /* PPP_DEBUG */
	pfwTimerCancel(pStackData->challengeTimer);
	pStackData->controlLayerInterface->pppAuthRefused(state);
	return OK;
	}

    if (isRetry == TRUE)
	{
	send_chap_server_packet(state); 
	}
    else
	{
	if ((packet = pStackData->challengePacket) == NULL)
	    return ERROR;
    
#ifdef PPP_DEBUG
	printf ("CHAP Sending Challenge Packet: stack 0x%x\n",
					(int)state->stackObj);
#endif /* PPP_DEBUG */

	pfwSend(state,packet);
	pfwTimerStart (pStackData->challengeTimer, PFW_SECOND,
		    pProfileData->retryInterval,
		    sendChapPeriodicChallengeOrRetry,1);
	}
    return OK;
    }
/*******************************************************************************
* sendChapResponseRetry -
*/
LOCAL STATUS sendChapResponseRetry 
    (
    PFW_PLUGIN_OBJ_STATE * state,
    int retry
    )
    {
    CHAP_STACK_DATA *pStackData = (CHAP_STACK_DATA *)state->stackData;
    CHAP_PROFILE_DATA *pProfileData = (CHAP_PROFILE_DATA *)state->profileData;
    M_BLK_ID packet;
    M_BLK_ID dupPkt;

    if ((packet = pStackData->lastSentResponsePacket) == NULL)
	    return ERROR;

    if (retry && (pStackData->number_of_authentication_requests++ >=
				    pProfileData->maximum_number_of_retries))
	{
	if (pStackData->lastSentResponsePacket != NULL)
	    {
	    netMblkClChainFree(pStackData->lastSentResponsePacket);
	    pStackData->lastSentResponsePacket = NULL;
	    }

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

    if((dupPkt = chapDupPkt(packet)) == NULL)
	{
	netMblkClChainFree(packet);
	}
    else
	{
	pStackData->lastSentResponsePacket = dupPkt;
	pfwSend(state,packet);
#ifdef PPP_DEBUG
	printf  ("CHAP: Sent Response, ID %d; retry = %d; time %ld\n",
		pStackData->last_id_of_chap_response_sent,retry,tickGet());
#endif /* PPP_DEBUG */
	}

    pfwTimerStart (pStackData->retryTimer, PFW_SECOND,
		pProfileData->retryInterval, sendChapResponseRetry,++retry);
    return OK;
    }

/*******************************************************************************
* get_my_random_number -
*/
LOCAL ULONG get_my_random_number (void)
    {
    ULONG my_random_number;

    my_random_number = random();

    while (my_random_number == 0x00000000L)
            {
            my_random_number = random();
            }

    return (my_random_number);
    }

/*******************************************************************************
* chapDupPkt - DUP the given packet 
*
* RETURNS: The the duplicated MBLK for the packet if successful, else it frees 
* the original packet and returns NULL
*/

LOCAL M_BLK_ID chapDupPkt
    (
    M_BLK_ID pPacket	/* packet to DUP */
    )
    {
    NET_POOL_ID pNetPool = NULL;
    M_BLK_ID pDupPkt = NULL;

    if ((pPacket == NULL) || ((pNetPool  = MBLK_TO_NET_POOL(pPacket)) == NULL))
	return NULL;

    /* dup the given packet/chain */

    if (pPacket->mBlkHdr.mNext != NULL)
	{
	if ((pDupPkt = netMblkChainDup(pNetPool, pPacket, 0, M_COPYALL,
					M_DONTWAIT)) == NULL)
	    return NULL;
	}
    else
	{
	/* get a new MBLK */

	if ((pDupPkt = netMblkGet (pNetPool, M_DONTWAIT, MT_DATA)) == NULL)
	    return NULL;

	if (netMblkDup (pPacket, pDupPkt) == NULL)
	    {
	    netMblkFree(pNetPool,pDupPkt);
	    return NULL;
	    }
	}

    return pDupPkt;
    }

/* WindNet Multilink - AUTH_INFO_INTERFACES */ 

/*******************************************************************************
* chapLocalUserNameGet - Gets the local user name configured in the CHAP 
*													component in the given stack
*
* This function copy the local user name configured in the CHAP component in the 
* given stack. This function is called when a link is added to the bundle to 
* construct the bundle identifier of the link.
*
* RETURNS N/A
*/

void chapLocalUserNameGet
	(
	PFW_PLUGIN_OBJ_STATE		*pChapState,	/* CHAP Component plugin state*/
	char						*pLocalUserName	/* Local user name */
	)
	{
	
	PFW_OBJ	*pfwObj = NULL;
	UINT	paramId = 0;

	if ((pChapState == NULL) || (pLocalUserName == NULL))
		{
		printf ("CHAP:Auth Info Interface:Invalid parameters\n");
		return;
		}

	pfwObj = pfwStackObjPfwGet (pChapState->stackObj);
	if (pfwObj == NULL)
		{
		printf ("NULL Framework Reference\n");
		return;
		}

	paramId = pfwParameterIdGet (pfwObj, "chap_localUserName");
	pfwStackParamGet (pChapState->stackObj, paramId, pLocalUserName);
	}



/*******************************************************************************
* chapLocalUserNameSet - Configure the local username for CHAP component
* 
* This function configures the local user name for the  CHAP component in the 
* given stack. This function is called when a link is configured for a bundle
* 
* RETURNS N/A
*/

void chapLocalUserNameSet
	(
	PFW_PLUGIN_OBJ_STATE	*pAuthState, 
						/* plugin Obj state of the Authentication component */
	char					*pLocalUserName /* Local user name to be set */
	)
	{
	PFW_OBJ	*pfwObj = NULL;
	UINT	paramId = 0;

	if ((pAuthState == NULL) || (pLocalUserName == NULL))
		{
		printf ("CHAP:Auth Info Interface:Invalid parameters\n");
		return;
		}

	pfwObj = pfwStackObjPfwGet (pAuthState->stackObj);
	if (pfwObj == NULL)
		{
		printf ("NULL Framework Reference\n");
		return;
		}

	paramId = pfwParameterIdGet (pfwObj, "chap_localUserName");
	pfwStackParamSet (pAuthState->stackObj, paramId, pLocalUserName);
	}


/*******************************************************************************
* chapRemoteUserNameGet - Gets the remot user name configured in the CHAP 
*													component in the given stack
*
* This function copy the remote user name configured in the CHAP component in the 
* given stack. This function is called when a link is added to the bundle to 
* construct the bundle identifier of the link.
*
* RETURNS N/A
*/

void chapRemoteUserNameGet
	(
	PFW_PLUGIN_OBJ_STATE		*pChapState,/* CHAP Component plugin state */
	char						*pRemoteUserName	/* Remote user name */
	)
	{
	CHAP_STACK_DATA *pStackData = NULL;

    if ((pChapState == NULL) || (pRemoteUserName == NULL))
		{
		printf ("CHAP:Auth Info Interface:Invalid Parameters\n");
		return;
		}

	if ((pStackData = pChapState->stackData) == NULL)
		{
		printf ("CHAP:Auth Info Interface:Invalid Parameters\n");
		return;
		}


	strcpy (pRemoteUserName, pStackData->peer_user_name);
	}

/* WindNet Multilink - AUTH_INFO_INTERFACES */