ppplcptx.c

这是全套的PPP协议的源码

    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID rx_packet
    )
    {
    PROTOCOL_REJECT_PACKET *sptr_protocol_reject_packet;
    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *) pluginState->stackData;
    M_BLK_ID packet = NULL;
    USHORT number_of_bytes_in_tx_packet;
    USHORT number_of_bytes_to_copy;
    /*USHORT number_of_bytes_rxed;*/
    /*LCP_PACKET * sptr_bad_rx_protocol_packet;*/
    USHORT badProtocol;
    char * badProtocolData;

    if (rx_packet == NULL)
	return;

    if (pStackData->stateData.state != PPP_OPENED_STATE)
	{
	/* silently discard bad protocol packets */

	netMblkClChainFree(rx_packet);
	return;
	}

    /*number_of_bytes_rxed = rx_packet->mBlkHdr.mLen;*/
    /*sptr_bad_rx_protocol_packet = mtod(rx_packet,LCP_PACKET *);*/

    badProtocol = (USHORT)(((UINT8)rx_packet->mBlkHdr.mData[0] << 8) |
			    (UINT8)rx_packet->mBlkHdr.mData[1]);

    badProtocolData = &rx_packet->mBlkHdr.mData[2];

    number_of_bytes_to_copy = rx_packet->mBlkHdr.mLen - sizeof(PPP_HEADER);

    number_of_bytes_in_tx_packet = (USHORT) (sizeof (PPP_HEADER) +
					     sizeof (LCP_HEADER) + 
				     sizeof (USHORT_ENUM (PPP_PROTOCOL_TYPE)) +
					     number_of_bytes_to_copy);

    if (number_of_bytes_in_tx_packet >
		    pStackData->lcp_mibs.pppLinkStatusRemoteMRU)
	{
	number_of_bytes_in_tx_packet = (USHORT)
				pStackData->lcp_mibs.pppLinkStatusRemoteMRU +
				sizeof (PPP_HEADER);

	number_of_bytes_to_copy =   number_of_bytes_in_tx_packet -
							 sizeof(LCP_HEADER);
	}

    if ((packet = netTupleGet(pStackData->netPoolId,
	    number_of_bytes_in_tx_packet, M_DONTWAIT,MT_DATA,TRUE)) == NULL)
	{
	netMblkClChainFree (rx_packet);
	return;
	}

    sptr_protocol_reject_packet = mtod(packet,PROTOCOL_REJECT_PACKET *);

    sptr_protocol_reject_packet->rejected_protocol_and_information.protocol = 
							htons(badProtocol);
    memcpy (
     sptr_protocol_reject_packet->rejected_protocol_and_information.information,
		     badProtocolData,number_of_bytes_to_copy);

    pStackData->id_sequence_number++;
	
    packet->mBlkHdr.mLen = number_of_bytes_in_tx_packet;

    netMblkClChainFree (rx_packet);
    send_lcp_packet (pluginState,packet, PROTOCOL_REJECT,
					    pStackData->id_sequence_number);
    }
/*******************************************************************************
* send_lcp_code_reject -
*/
LOCAL void send_lcp_code_reject
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID rx_packet,
    PPP_STATE end_state
    )
    {
    CODE_REJECT_PACKET *sptr_code_reject_packet;
    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *) pluginState->stackData;
    M_BLK_ID packet = NULL;
    LCP_PACKET *sptr_lcp_rx_packet;
    USHORT number_of_bytes_in_tx_packet;
    /*USHORT number_of_bytes_rxed;*/
    USHORT number_of_bytes_to_copy;
    BYTE rxed_identifier;

    PARAMETER_NOT_USED(end_state);

    if (rx_packet == NULL)
	return;

    /*number_of_bytes_rxed = rx_packet->mBlkHdr.mLen;*/
    sptr_lcp_rx_packet = mtod(rx_packet,LCP_PACKET *);
    number_of_bytes_to_copy = ntohs(sptr_lcp_rx_packet->lcp_header.length);
    rxed_identifier = sptr_lcp_rx_packet->lcp_header.id;

    number_of_bytes_in_tx_packet = (USHORT) (sizeof (PPP_HEADER) +
					     sizeof (LCP_HEADER) +
					     number_of_bytes_to_copy);

    if (number_of_bytes_in_tx_packet >
		    pStackData->lcp_mibs.pppLinkStatusRemoteMRU)
	{
	number_of_bytes_in_tx_packet = (USHORT)
				pStackData->lcp_mibs.pppLinkStatusRemoteMRU +
				sizeof (PPP_HEADER);

	number_of_bytes_to_copy =   number_of_bytes_in_tx_packet -
							sizeof(LCP_HEADER);
	}

    if ((packet = netTupleGet(pStackData->netPoolId,
	    number_of_bytes_in_tx_packet, M_DONTWAIT, MT_DATA, TRUE)) == NULL)
	{
	netMblkClChainFree (rx_packet);
	return;
	}

    sptr_code_reject_packet = mtod(packet,CODE_REJECT_PACKET *);

    memcpy (&sptr_code_reject_packet->rejected_packet,
			&sptr_lcp_rx_packet->lcp_header,number_of_bytes_to_copy);

    netMblkClChainFree (rx_packet);

    pStackData->id_sequence_number++;
    packet->mBlkHdr.mLen = number_of_bytes_in_tx_packet;
    /*send_lcp_packet (pluginState,packet, CODE_REJECT,rxed_identifier);*/
    send_lcp_packet (pluginState,packet, CODE_REJECT,
					    pStackData->id_sequence_number);
    }
/*******************************************************************************
* send_lcp_discard_request -
*/
void send_lcp_discard_request
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID pMblk,
    PPP_STATE end_state
    )
    {
    ULONG magic_number;
    DISCARD_REQUEST_PACKET *sptr_discard_request_packet;
    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *) pluginState->stackData;
    M_BLK_ID packet = NULL;
    
    PARAMETER_NOT_USED(end_state);
    PARAMETER_NOT_USED(pMblk);

    if ((packet = netTupleGet(pStackData->netPoolId,
	    sizeof(DISCARD_REQUEST_PACKET),M_DONTWAIT, MT_DATA, TRUE)) == NULL)
	{
	return;
	}

    sptr_discard_request_packet = mtod(packet,DISCARD_REQUEST_PACKET *);

    if (copy_option (&pStackData->option_lists.tx_accepted,LCP_MAGIC_NUMBER,
		&magic_number,
		sizeof (sptr_discard_request_packet->magic_number)) == FAIL)
	{
	sptr_discard_request_packet->magic_number = DEFAULT_MAGIC_NUMBER;
	}

    sptr_discard_request_packet->magic_number = magic_number;
    
    pStackData->id_sequence_number++;

    packet->mBlkHdr.mLen = sizeof(DISCARD_REQUEST_PACKET);

    send_lcp_packet (pluginState,packet, DISCARD_REQUEST,
					    pStackData->id_sequence_number);
    }

#if 0
/*******************************************************************************
* send_lcp_link_quality_report 
*/
void send_lcp_link_quality_report
    (
    PFW_PLUGIN_OBJ_STATE * pluginState
    )
    {
    LINK_QUALITY_REPORT *sptr_link_quality_report_packet;
    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *) pluginState->stackData;
    M_BLK_ID packet = NULL;

    if ((packet = netTupleGet(pStackData->netPoolId,sizeof(LINK_QUALITY_REPORT),
					    M_DONTWAIT, MT_DATA,TRUE)) == NULL)
	{
	return;
	}

    sptr_link_quality_report_packet = mtod (packet,LINK_QUALITY_REPORT*);
	

    if (copy_option (&pStackData->option_lists.tx_accepted,LCP_MAGIC_NUMBER,
	    &sptr_link_quality_report_packet->magic_number,
	    sizeof (sptr_link_quality_report_packet->magic_number)) == FAIL)
	{
	sptr_link_quality_report_packet->magic_number = DEFAULT_MAGIC_NUMBER;
	}

	sptr_link_quality_report_packet->LastOutLQRs =
			    pStackData->most_recently_received_LQR.PeerOutLQRs;
	sptr_link_quality_report_packet->LastOutPackets =
			pStackData->most_recently_received_LQR.PeerOutPackets;
	sptr_link_quality_report_packet->LastOutOctets =
			pStackData->most_recently_received_LQR.PeerOutOctets;
	sptr_link_quality_report_packet->PeerInLQRs =
			pStackData->most_recently_received_LQR.SaveInLQRs;
	sptr_link_quality_report_packet->PeerInPackets =
			pStackData->most_recently_received_LQR.SaveInPackets;
	sptr_link_quality_report_packet->PeerInDiscards =
			pStackData->most_recently_received_LQR.SaveInDiscards;
	sptr_link_quality_report_packet->PeerInErrors =
			pStackData->most_recently_received_LQR.SaveInErrors;
	sptr_link_quality_report_packet->PeerInOctets =
			pStackData->most_recently_received_LQR.SaveInOctets;
	sptr_link_quality_report_packet->PeerOutLQRs =
			pStackData->link_quality_counters.OutLQRs;
	sptr_link_quality_report_packet->PeerOutPackets =
			pStackData->link_quality_counters.ifOutUniPackets;
	sptr_link_quality_report_packet->PeerOutOctets =
			pStackData->link_quality_counters.ifOutOctets;

	++pStackData->link_quality_counters.OutLQRs;
	++pStackData->lcp_mibs.pppLqrOutLQRs;

	pStackData->time_to_send_LQR = 0x00000000L;

	packet->mBlkHdr.mLen = sizeof(LINK_QUALITY_REPORT);
	pfwSend (pluginState,packet);
    }

#endif
/*******************************************************************************
* send_lcp_id_packet -
*/
void send_lcp_id_packet
    (
    PFW_PLUGIN_OBJ_STATE * pluginState
    )
    {
    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *) pluginState->stackData;
    LCP_PROFILE_DATA * pProfileData = 
				(LCP_PROFILE_DATA *) pluginState->profileData;
    M_BLK_ID packet = NULL;
    USHORT number_of_bytes_to_send;
    IDENTIFICATION_PACKET *sptr_id_packet;
    ULONG magic_number;
    BYTE length_of_string;

    number_of_bytes_to_send = sizeof (PPP_HEADER) + sizeof (LCP_HEADER);
	
    length_of_string = (BYTE) strlen (pProfileData->tx_identification_message);

    number_of_bytes_to_send = (USHORT) (number_of_bytes_to_send +
					length_of_string);

    if (copy_option (&pStackData->option_lists.configured,LCP_MAGIC_NUMBER,
		&magic_number,sizeof (sptr_id_packet->magic_number)) == FAIL)
	{
	magic_number = DEFAULT_MAGIC_NUMBER;
	}

    number_of_bytes_to_send +=(BYTE) sizeof (sptr_id_packet->magic_number);

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

    sptr_id_packet = mtod(packet,IDENTIFICATION_PACKET *);
    sptr_id_packet->magic_number = magic_number;

    memcpy(&sptr_id_packet->message[0], pProfileData->tx_identification_message,
						    length_of_string);

    pStackData->id_sequence_number++;

#ifdef RW_UPCALL
    if (ppp.fptr_event_upcall != NULL)
	{
	(*ppp.fptr_event_upcall) (PPP_EVENT_LCP_ID_REQUEST,
			    real_port_number,&sptr_id_packet->message[0]);
	}
#else
    (*pStackData->controlLayerInterface->pppLcpIdRequest)(pluginState,
					    &sptr_id_packet->message[0]);
#endif

    packet->mBlkHdr.mLen = number_of_bytes_to_send;

    send_lcp_packet (pluginState,packet, IDENTIFICATION,
				pStackData->id_sequence_number);
    }

/*******************************************************************************
* send_lcp_time_remaining_packet -
*/
void send_lcp_time_remaining_packet
    (
    PFW_PLUGIN_OBJ_STATE * pluginState
    )
    {
    ULONG magic_number;
    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *) pluginState->stackData;
    LCP_PROFILE_DATA * pProfileData = 
				(LCP_PROFILE_DATA *) pluginState->profileData;
    M_BLK_ID packet = NULL;
    USHORT number_of_bytes_to_send;
    TIME_REMAINING_PACKET *sptr_time_remaining_packet;
    ULONG seconds_remaining;

    number_of_bytes_to_send = sizeof (TIME_REMAINING_PACKET);
	
    number_of_bytes_to_send = (USHORT) (number_of_bytes_to_send +
			pProfileData->size_of_time_remaining_message);

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

    sptr_time_remaining_packet = mtod(packet,TIME_REMAINING_PACKET *);

    if (copy_option (&pStackData->option_lists.tx_accepted,LCP_MAGIC_NUMBER,
		&magic_number,
		sizeof (sptr_time_remaining_packet->magic_number)) == FAIL)
	{
	sptr_time_remaining_packet->magic_number = DEFAULT_MAGIC_NUMBER;
	}

    sptr_time_remaining_packet->magic_number = magic_number;
    
    pStackData->id_sequence_number++;

#ifdef RW_UPCALL
    if (ppp.fptr_event_upcall != NULL)
	{
	(*ppp.fptr_event_upcall) (PPP_EVENT_LCP_TIME_REMAINING_REQUEST,
	    real_port_number, &sptr_time_remaining_packet->seconds_remaining);
	}
#else
    seconds_remaining = sptr_time_remaining_packet->seconds_remaining;
    (*pStackData->controlLayerInterface->pppLcpTimeRemainingRequest)
		(pluginState,&seconds_remaining,
				&sptr_time_remaining_packet->message[0]);
    sptr_time_remaining_packet->seconds_remaining = seconds_remaining;
#endif

    packet->mBlkHdr.mLen = number_of_bytes_to_send;

    send_lcp_packet (pluginState,packet, TIME_REMAINING,
					    pStackData->id_sequence_number);
    }

/*******************************************************************************
* store_lcp_config_options_in_packet - 
*
* This function is a special version of the generic version
* store_ppp_options_in_packet() in pppoptn.c. This function filters out
* options with default values 
*
* REF: RFC 1661; page 28, paragraph 1
*/
LOCAL int store_lcp_config_options_in_packet
    (
    OPTION_LIST *sptr_option_list,
    PPP_OPTION *sptr_destination_option
    )
    {
    USHORT defaultMru = htons(DEFAULT_MAXIMUM_MRU);
    ULONG defaultAccm = DEFAULT_ASYNC_CONTROL_CHARACTER_MAP;
    ULONG defaultMagic = DEFAULT_MAGIC_NUMBER;
    int number_of_option_bytes = 0;

    struct _ppp_option
	{
	BYTE type;
	BYTE length;
	BYTE data[1];
	} * _ppp_option = (struct _ppp_option * ) sptr_destination_option;

    OPTION_LIST_ENTRY *sptr_source_option;

    for (sptr_source_option = sptr_option_list->sptr_forward_link; 
	 sptr_source_option != NULL;
	 sptr_source_option = sptr_source_option->sptr_forward_link
	 )
	{
	_ppp_option->type = (BYTE)sptr_source_option->type.generic;
	_ppp_option->length = (BYTE) (sptr_source_option->length +
				    sizeof (_ppp_option->type)+
				    sizeof (_ppp_option->length));

	/* do not include default values for MRU, ACCM and MAGIC */
	switch(_ppp_option->type)
	    {
	    case LCP_MAXIMUM_RECEIVE_UNIT:
		if (memcmp(sptr_source_option->uptr_data,
						    (char *)&defaultMru,2) != 0)
		    break;
		else
		    continue;

	    case LCP_ASYNC_CONTROL_CHARACTER_MAP:
		if (_ppp_option->length == sizeof(defaultAccm))
		    {
		    if (memcmp(sptr_source_option->uptr_data,
						(char *)&defaultAccm,4) != 0)
			break;
		    else
			continue;
		    }
		break;

	    case LCP_MAGIC_NUMBER:
		if (memcmp(sptr_source_option->uptr_data,
					       (char *)&defaultMagic,4) !=0)
		    break;
		else
		    continue;

	    default:
		break;
	    }

	memcpy (&_ppp_option->data, sptr_source_option->uptr_data,
						sptr_source_option->length);
	number_of_option_bytes = (USHORT) (number_of_option_bytes + 
						_ppp_option->length);
	_ppp_option = (struct _ppp_option * )((UINT32)_ppp_option +
						(UINT32)_ppp_option->length);
	}
    return number_of_option_bytes;
    }