pppncptx.c

这是全套的PPP协议的源码

/*******************************************************************************
*
* send_ncp_configuration_ack -
*/

void send_ncp_configuration_ack 
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID pMblk,
    PPP_STATE end_state
    )
    {
    NCP_STACK_DATA * pStackData = (NCP_STACK_DATA *) pluginState->stackData;
    NCP_PACKET *sptr_ncp_rx_packet;
    USHORT number_of_bytes_rxed;
    M_BLK_ID packet = pStackData->last_rxed_ncp_configuration_request_packet;

    PARAMETER_NOT_USED(end_state);
    PARAMETER_NOT_USED(pMblk);
    
    if (packet == NULL)
    	return;

    sptr_ncp_rx_packet = mtod (packet, NCP_PACKET *);

    if (sptr_ncp_rx_packet->ncp_header.code != CONFIGURE_REQUEST)
	{
	return;
	}

    number_of_bytes_rxed = packet->mBlkHdr.mLen;

    sptr_ncp_rx_packet->ncp_header.code = CONFIGURE_ACK;

    ++pStackData->statistics.number_of_tx_packets;
    ++pStackData->statistics.number_of_tx_control_packets[CONFIGURE_ACK];

    pStackData->statistics.number_of_tx_bytes += number_of_bytes_rxed;

    pfwSend (pluginState, packet);
/*
#ifdef PPP_DEBUG
    printf("%s Tx configAck: ",pluginState->pluginObj->name);
    print_options_in_packet(packet);
#endif
*/
    pStackData->last_rxed_ncp_configuration_request_packet = NULL;

    }

/******************************************************************************
*
* send_ncp_configuration_nak -
*/

void send_ncp_configuration_nak 
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID rx_packet,
    PPP_STATE end_state
    )
    {
    NCP_STACK_DATA * pStackData = (NCP_STACK_DATA *) pluginState->stackData;
    NCP_CONFIGURE_NAK *sptr_ncp_configure_nak_packet;
    NCP_PACKET *sptr_ncp_rx_packet;
    USHORT number_of_bytes_to_send;
    BYTE rxed_identifier;
    M_BLK_ID packet = pStackData->last_rxed_ncp_configuration_request_packet;
    NET_POOL_ID netPoolId = pfwNetPoolIdGet(pluginState->pluginObj->pfwObj);
    NCP_PROFILE_DATA * pProfileData =
                                  (NCP_PROFILE_DATA *)pluginState->profileData;

    if (packet == NULL)
	return;

    sptr_ncp_rx_packet = mtod(packet,NCP_PACKET *);
    rxed_identifier = sptr_ncp_rx_packet->ncp_header.id;

    if (++pStackData->number_of_ncp_configuration_naks >
                    pProfileData->maximum_number_of_configuration_failures)
        {
        copy_configuration_options_list(pluginState->pluginObj->pfwObj,
                                    &pStackData->option_lists.tx_nak,
                                    &pStackData->option_lists.tx_reject);

        /*free_ppp_option_list (&pStackData->option_lists.tx_nak);*/
        send_ncp_configuration_reject(pluginState,rx_packet,end_state);
        return;
        }

       
    number_of_bytes_to_send = get_size_of_ppp_options 
			      (&pStackData->option_lists.tx_nak);

    number_of_bytes_to_send += (USHORT) (
		sizeof (sptr_ncp_configure_nak_packet->ppp_header) +
		sizeof (sptr_ncp_configure_nak_packet->ncp_header));

    if (packet->mBlkHdr.mLen > number_of_bytes_to_send) 
        {
	/* We have enough space */
        packet->mBlkHdr.mLen = 0;
        bzero(packet->mBlkHdr.mData,number_of_bytes_to_send);
	}
    else
	{
	m_freem(packet);
        if ((packet = netTupleGet(netPoolId,number_of_bytes_to_send,
				    M_DONTWAIT, MT_DATA, TRUE)) == NULL)
            {
            pStackData->last_rxed_ncp_configuration_request_packet = NULL;
            return;
            }
        }

    sptr_ncp_configure_nak_packet = mtod (packet, NCP_CONFIGURE_NAK *); 

    pStackData->configuration_request_send_interval = 0x0000;

    store_ppp_options_in_packet (&pStackData->option_lists.tx_nak,
		(PPP_OPTION *) &sptr_ncp_configure_nak_packet->options);

    if (pStackData->ncp_protocol == IPV6CP_PROTOCOL)
        {
        saveIpv6IdentifierOption (pluginState,&pStackData->option_lists.tx_nak); 
        }

    packet->mBlkHdr.mLen = number_of_bytes_to_send;

    send_ncp_packet (pluginState,packet, CONFIGURE_NAK, rxed_identifier);

    pStackData->last_rxed_ncp_configuration_request_packet = NULL;
    }


/******************************************************************************
* saveIpv6IdentifierOption - This function saves the last sent config-Nak value
*                            
*/

LOCAL void saveIpv6IdentifierOption
    (
    PFW_PLUGIN_OBJ_STATE * pPfwPlugingObjState,
    OPTION_LIST *          sptr_nak_option_list
    )
    {
    OPTION_LIST_ENTRY * pIpv6Option = NULL;
    IPV6CP_STACK_DATA * pStackData  = pPfwPlugingObjState->stackData;

	pIpv6Option = find_matching_option (sptr_nak_option_list, 
                                   IPV6_INTERFACE_IDENTIFIER_OPTION_TYPE);

    if (pIpv6Option == NULL)
        return;

    bzero (pStackData->lastSentNakIdentifier, INTERFACE_IDENTIFIER_LENGTH);

    memcpy (pStackData->lastSentNakIdentifier, pIpv6Option->uptr_data, 
                                   pIpv6Option->length);
    }

/******************************************************************************
*
* send_ncp_configuration_reject -
*/

void send_ncp_configuration_reject 
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID rx_packet,
    PPP_STATE end_state
    )
    {
    NCP_CONFIGURE_REJECT *sptr_ncp_configure_reject_packet;
    USHORT number_of_bytes_to_send;
    NCP_PACKET *sptr_ncp_rx_packet;
    NCP_STACK_DATA * pStackData = (NCP_STACK_DATA *) pluginState->stackData;
    BYTE rxed_identifier;
    M_BLK_ID packet = pStackData->last_rxed_ncp_configuration_request_packet;
    NET_POOL_ID netPoolId = pfwNetPoolIdGet(pluginState->pluginObj->pfwObj);

    number_of_bytes_to_send = get_size_of_ppp_options 
				(&pStackData->option_lists.tx_reject);

    if (packet == NULL)
	return;

    number_of_bytes_to_send += (USHORT) (sizeof (PPP_HEADER) +
	    sizeof (NCP_HEADER));

    sptr_ncp_rx_packet = mtod(packet,NCP_PACKET *);
    rxed_identifier = sptr_ncp_rx_packet->ncp_header.id;

    pStackData->last_rxed_ncp_configuration_request_packet = NULL;
    
    if (packet->mBlkHdr.mLen > number_of_bytes_to_send)
        {
	packet->mBlkHdr.mLen = 0;
        bzero(packet->mBlkHdr.mData,number_of_bytes_to_send);
	}
    else
        {
        m_freem(packet);
        if ((packet = netTupleGet(netPoolId,number_of_bytes_to_send,
				    M_DONTWAIT, MT_DATA, TRUE)) == NULL)
            {
            return;
            }
        }

    sptr_ncp_configure_reject_packet = mtod(packet,NCP_CONFIGURE_REJECT *);

    pStackData->configuration_request_send_interval = 0x0000;

    store_ppp_options_in_packet (&pStackData->option_lists.tx_reject,
		(PPP_OPTION *) &sptr_ncp_configure_reject_packet->options);

    packet->mBlkHdr.mLen = number_of_bytes_to_send;

    send_ncp_packet (pluginState, packet, CONFIGURE_REJECT,rxed_identifier);
    }

/******************************************************************************
*
* send_ncp_termination_request -
*/

void send_ncp_termination_request 
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID pMblk,
    PPP_STATE end_state
    )
    {
    NCP_STACK_DATA * pStackData = (NCP_STACK_DATA *) pluginState->stackData;
    M_BLK_ID packet = NULL;
    NET_POOL_ID netPoolId = pfwNetPoolIdGet(pluginState->pluginObj->pfwObj);

    PARAMETER_NOT_USED(end_state);
    PARAMETER_NOT_USED(pMblk);

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

    pStackData->id_sequence_number++;

    ++pStackData->number_of_ncp_termination_requests;

    pStackData->last_id_of_ncp_packet_sent = pStackData->id_sequence_number;

    packet->mBlkHdr.mLen = sizeof (NCP_TERMINATE_REQUEST);
	 
    send_ncp_packet (pluginState,packet, TERMINATION_REQUEST,
					pStackData->id_sequence_number);
    }

/******************************************************************************
*
* send_ncp_termination_ack -
*/

void send_ncp_termination_ack 
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID packet,
    PPP_STATE end_state
    )
    {
    NCP_TERMINATE_ACK *sptr_termination_ack_packet;

    PARAMETER_NOT_USED(end_state);

    if (packet == NULL)
        return;

    sptr_termination_ack_packet = mtod(packet,NCP_TERMINATE_ACK *);

    send_ncp_packet (pluginState,packet,TERMINATION_ACK,
			sptr_termination_ack_packet->ncp_header.id);
    }

/******************************************************************************
*
* send_ncp_code_reject - 
*/

void send_ncp_code_reject 
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID rx_packet,
    PPP_STATE end_state
    )
    {
    NCP_CODE_REJECT_PACKET *sptr_ncp_code_reject_packet;
    USHORT number_of_bytes_in_tx_packet;
    M_BLK_ID packet = NULL;
    NCP_PACKET *sptr_ncp_rx_packet;
    USHORT number_of_bytes_rxed;
    BYTE rxed_identifier;
    NET_POOL_ID netPoolId = pfwNetPoolIdGet(pluginState->pluginObj->pfwObj);

    if (rx_packet == NULL)
        return;

    number_of_bytes_rxed = rx_packet->mBlkHdr.mLen;
    sptr_ncp_rx_packet = mtod(rx_packet,NCP_PACKET *);
    rxed_identifier = sptr_ncp_rx_packet->ncp_header.id;

    /* 
     * we do not copy the PPP protocol field, so we offset both
     * the received data pointer and the byte count by sizeof (PPP_HEADER)
     */

    number_of_bytes_in_tx_packet = (USHORT) (sizeof (PPP_HEADER) +
                                             sizeof (NCP_HEADER) +
                                             (number_of_bytes_rxed -
					     sizeof (PPP_HEADER)));

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


    sptr_ncp_code_reject_packet = mtod (packet, NCP_CODE_REJECT_PACKET *);

    memcpy (&sptr_ncp_code_reject_packet->rejected_packet,
	    (char *) ((int) sptr_ncp_rx_packet + sizeof (PPP_HEADER)),
	    (number_of_bytes_rxed - sizeof (PPP_HEADER)));

    packet->mBlkHdr.mLen = number_of_bytes_in_tx_packet;
    packet->mBlkHdr.mData = (char *) &sptr_ncp_code_reject_packet->ppp_header;

    m_freem(rx_packet);

    send_ncp_packet (pluginState, packet, CODE_REJECT,rxed_identifier);
    }