pppncptx.c

这是全套的PPP协议的源码

/* pppncptx.c - NCP packet transmit routines */

/* Copyright 1999 Wind River Systems, Inc. */

#include "copyright_wrs.h"

/*
modification history
--------------------
01l,31oct02,ijm do not regenerate tx_accepted list in REQUEST_SENT, ACK_SENT, or
                ACK_RECEIVED states, SPR#83619
01k,17oct02,ijm set packet length in send_ncp_termination_request
01j,28jun02,as  added new function saveIpv6IdentifierOption() 
                to save the last sent config Nak in the stack data 
                structure
01i,23may02,vk  modified send_ncp_configuration_request with changes in 
                ipcpStackData
01h,10mar02,ak  move validation of packet ptr in send_ncp_configuration_ack
01g,21dec01,ijm set last_rxed_ncp_configuration_request_packet to NULL
                in send_ncp_configuration_ack
01f,03nov01,ijm don't send configure requests if ras addresses
                are exhausted
01e,17apr00,sj  get mBufs from framework netpool
01d,23feb00,cn  fixed send_ncp_code_reject to properly handle bad ncp
		code numbers.
01c,11feb00,sj  added debug messages config Tx, Rx, Ack, Nak, Rej
01b,16dec99,sj  check for null tx_accepted list and copy from configured list
01a,13oct99,sgv created
*/

/*
*$Log:: /RtrwareSB/devdrvrs/ppp/pppnc $
 * 
 * 8     11/19/98 10:18a Nishit
 * Updated according to new
 * PROTOCOL_STACK_PORT commands
 * 
 * 7     10/01/98 11:43a Alex
 * Updated the PPP source code to conform
 * to a single build. 
 * 
 * 6     4/30/98 3:03p Alex
 * Ppp v4.2.0 check in
 * 
 * 1     4/24/98 12:10a Release Engineer
 * code cleanup, code style changes,
 * linted, system level test
 * PPP v4.2.0
*/


#include "private/ppp/pppstate.h"
#include "private/ppp/pppoptn.h"
#include "private/ppp/pppIpcpComponentP.h"
#include "private/ppp/pppIpv6cpComponentP.h"

IMPORT void print_options_in_packet ( M_BLK_ID packet);
IMPORT STATUS retry_ipcp_configure_request (PFW_PLUGIN_OBJ_STATE * pluginState,
                                            int arg);
IMPORT STATUS retry_ipcp_termination_request (PFW_PLUGIN_OBJ_STATE * pluginState,
                                int arg);

void send_ncp_packet (PFW_PLUGIN_OBJ_STATE * state, M_BLK_ID packet,
			    PPP_CONTROL_CODE code,BYTE id);
void send_ncp_configuration_request ( PFW_PLUGIN_OBJ_STATE * pluginState,
    		M_BLK_ID pMblk, PPP_STATE end_state);
void send_ncp_packet ( PFW_PLUGIN_OBJ_STATE * pluginState, 
		M_BLK_ID packet, PPP_CONTROL_CODE code, BYTE id);
void send_ncp_configuration_ack ( PFW_PLUGIN_OBJ_STATE * pluginState,
    		M_BLK_ID pMblk, PPP_STATE end_state);
void send_ncp_configuration_nak ( PFW_PLUGIN_OBJ_STATE * pluginState,
    		M_BLK_ID rx_packet, PPP_STATE end_state);
void send_ncp_configuration_reject ( PFW_PLUGIN_OBJ_STATE * pluginState,
    		M_BLK_ID rx_packet, PPP_STATE end_state);
void send_ncp_termination_request ( PFW_PLUGIN_OBJ_STATE * pluginState,
    		M_BLK_ID pMblk, PPP_STATE end_state);
void send_ncp_termination_ack ( PFW_PLUGIN_OBJ_STATE * pluginState,
    		M_BLK_ID packet, PPP_STATE end_state);
void send_ncp_code_reject ( PFW_PLUGIN_OBJ_STATE * pluginState,
    		M_BLK_ID rx_packet, PPP_STATE end_state);
LOCAL M_BLK_ID ncpDupPkt ( M_BLK_ID pPacket);

LOCAL void saveIpv6IdentifierOption
    (
    PFW_PLUGIN_OBJ_STATE * pPfwPlugingObjState,
    OPTION_LIST *          sptr_nak_option_list
    );

void ipcpSetSendActionFunctions
    (
    STATE_MACHINE_ACTION_TABLE *actionTable
    )
    {
    actionTable->send_configuration_request = send_ncp_configuration_request;
    actionTable->send_configuration_ack = send_ncp_configuration_ack;
    actionTable->send_configuration_nak = send_ncp_configuration_nak;
    actionTable->send_configuration_reject = send_ncp_configuration_reject;
    actionTable->send_termination_request = send_ncp_termination_request;
    actionTable->send_termination_ack = send_ncp_termination_ack;
    actionTable->send_code_reject = send_ncp_code_reject;
    actionTable->send_echo_request = NULL;
    actionTable->send_echo_reply = NULL;
    }

/*******************************************************************************
* ncpDupPkt - 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 ncpDupPkt
    (
    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;

    /* 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;
    }

/*******************************************************************************
*
* send_ncp_configuration_request -
*/

void send_ncp_configuration_request 
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID pMblk,
    PPP_STATE end_state
    )
    {
    NCP_STACK_DATA * pStackData = (NCP_STACK_DATA *) pluginState->stackData;
    IPCP_STACK_DATA * pIpcpStackData = NULL;
    NCP_CONFIGURE_REQUEST *sptr_ncp_configure_packet;
    USHORT number_of_bytes_to_send = 0;
    M_BLK_ID pDupPacket = NULL;
    NET_POOL_ID netPoolId = pfwNetPoolIdGet(pluginState->pluginObj->pfwObj);
    M_BLK_ID packet = NULL;
    M_BLK_ID retryPacket;

    PARAMETER_NOT_USED(end_state);
    PARAMETER_NOT_USED(pMblk);

    if (pStackData->ncp_protocol == IPCP_PROTOCOL)
        {
        pIpcpStackData = (IPCP_STACK_DATA * )pluginState->stackData;

        if (pIpcpStackData->useRasAddress && !pIpcpStackData->validRasAddress)
            {
#ifdef PPP_DEBUG 
        logMsg ("ConfRequest not sent since RAS addresses are exhausted\n",
		 1,2,3,4,5,6);
#endif
            return;
            }
         }

    retryPacket = pStackData->last_txed_ncp_configuration_request_packet;

    /* Reuse the mblk in the stackData */

    if ((packet = retryPacket) == NULL)
        {
        /*
         * check if we are opening a new connection.  tx_accepted list should be
         * generated in states lower than REQUEST_SENT or in OPENED state, if
         * peer renegotiates.  If list becomes empty in states REQUEST_SENT, or
         * ACK_SENT, it would mean that the peer rejected the local options, in
         * which case they must not be sent again, SPR#83619.
         */

        if (
            pStackData->option_lists.tx_accepted.sptr_forward_link == NULL &&
            pStackData->option_lists.tx_accepted.sptr_backward_link == NULL &&
            (pStackData->stateData.state <= PPP_STOPPING_STATE ||
             pStackData->stateData.state == PPP_OPENED_STATE)
           )
            {
            copy_configuration_options_to_tx_accepted_options
                (pluginState->pluginObj->pfwObj, &pStackData->option_lists);
            }
        number_of_bytes_to_send = get_size_of_ppp_options
                                      (&pStackData->option_lists.tx_accepted);

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

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

        sptr_ncp_configure_packet = mtod (packet, NCP_CONFIGURE_REQUEST *);

        pStackData->configuration_request_send_interval = 0x0000;

        store_ppp_options_in_packet (&pStackData->option_lists.tx_accepted,
            (PPP_OPTION *) &sptr_ncp_configure_packet->options);

        packet->mBlkHdr.mLen = number_of_bytes_to_send;
        pStackData->id_sequence_number =
            (BYTE)(pStackData->id_sequence_number + 1);
        pStackData->last_request_id = pStackData->id_sequence_number;
        pStackData->length_of_last_txed_request = number_of_bytes_to_send;
        packet->mBlkHdr.mLen = number_of_bytes_to_send;
        }
     else
        {
        sptr_ncp_configure_packet = mtod (packet, NCP_CONFIGURE_REQUEST *);
        }

    if ((pDupPacket = ncpDupPkt(packet)) == NULL)
        {
        /*
         * ncpDupPacket() does not free the source packet when failing. So don't
         * set last_txed_ncp_configuration_request_packet to NULL here
         */

        /* pStackData->last_txed_ncp_configuration_request_packet = NULL; */

        return;
        }

    pStackData->last_txed_ncp_configuration_request_packet = pDupPacket;

    send_ncp_packet (pluginState, packet, CONFIGURE_REQUEST,
                     pStackData->id_sequence_number);
    }

/*******************************************************************************
*
* send_ncp_packet -
*/

void send_ncp_packet 
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID packet,
    PPP_CONTROL_CODE code,
    BYTE id
    )
    {
    PPP_PACKET *sptr_tx_packet;
    USHORT number_of_bytes_to_send = packet->mBlkHdr.mLen;
    NCP_STACK_DATA * pStackData = (NCP_STACK_DATA *) pluginState->stackData;
    NCP_PROFILE_DATA * pProfileData =
                                  (NCP_PROFILE_DATA *)pluginState->profileData;

    pStackData->statistics.number_of_tx_bytes += number_of_bytes_to_send;
    sptr_tx_packet = mtod(packet,PPP_PACKET *);

    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( (USHORT)pStackData->ncp_protocol);

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

    pStackData->statistics.number_of_tx_bytes += number_of_bytes_to_send;

#ifdef PPP_DEBUG

    switch (code)
        {
        case CONFIGURE_REQUEST:
	    printf ("%s Tx configReq: ",pluginState->pluginObj->name);
	    print_options_in_packet(packet);
	    break;

	case CONFIGURE_REJECT:
	    printf("%s Tx configReject: ",pluginState->pluginObj->name);
	    print_options_in_packet(packet);
	    break;

	case CONFIGURE_NAK:
	    printf("%s Tx configNak: ",pluginState->pluginObj->name);
	    print_options_in_packet(packet);
	    break;

	case CONFIGURE_ACK:
	    printf("%s Tx configAck: ",pluginState->pluginObj->name);
	    print_options_in_packet(packet);
	    break;

    case TERMINATION_REQUEST:
        printf ("%s Tx termRequest:",pluginState->pluginObj->name);
        break;

	default:
	    break;
	}
#endif /* PPP_DEBUG */
    pfwSend (pluginState, packet);

    switch (code)
        {
        case CONFIGURE_REQUEST:
            pfwTimerCancel (pStackData->ncp_timer);
            if (pfwTimerStart(pStackData->ncp_timer,PFW_100_MILLISECOND,
                pProfileData->maximum_configuration_request_send_interval * 10,
                retry_ipcp_configure_request,0) == ERROR)
                {
                logMsg("send config Req: timerStart failed; state = %d\n",
                        pStackData->stateData.state,2,3,4,5,6);
                }
            break;

        case TERMINATION_REQUEST:

            pfwTimerCancel (pStackData->ncp_timer);

            if (pfwTimerStart(pStackData->ncp_timer,PFW_SECOND,
                    pProfileData->maximum_termination_request_send_interval,
                    retry_ipcp_termination_request,0) == ERROR)
                {
                logMsg("send Termination Req: timerStart failed; state = %d\n",
                        pStackData->stateData.state,2,3,4,5,6);
                }
            break;

        default:
            break;
        }
    }