ppplcptx.c

这是全套的PPP协议的源码

/* ppplcptx.c - LCP packet sender */

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

#include "copyright_wrs.h"

/*
modification history
--------------------
01v,28nov03,ijm SPR# 86152: for passive LCP, check for PPP_OPENED_STATE in
                send_lcp_configuration_request
01u,05nov02,ijm use printf instead of logMsg
01t,31oct02,ijm do not regenerate tx_accepted list in REQUEST_SENT, ACK_SENT,
                or ACK_RECEIVED states, SPR#83619
01s,28may02,rvr fixed build warnings with diab compiler 
01r,11nov11,ijm in send_lcp_termination_ack, assign value to mBlkHdr.mLen
01q,01nov01,ijm tx_accepted list should be a duplicate of configured
                list, including values (SPR# 71398)
01p,18aug01,ak	removing unnecessary logMsg in send_lcp_configuration_ack()
01o,21jun01,sd  validating input packet in send_lcp_configuration_ack()
01n,05apr01,ijm freed configuration request packets in lcp_send_termination_ack
01n,15dec00,md  capture last received ConfigRequest before sending ack
01l,09aug00,adb support opening connections in passive mode
01k,01aug00,adb Merging with openstack view
01j,12jul00,md  stored copy of last sent lcp to support proxy authentication
01i,02mar00,sj  rearranging debug printfs for configure ACK
01h,02mar00,sj  start timer after sending retry lcp_echo_request and debug
                messages
01g,28feb00,sj  fixed code_reject and protocol_reject
01f,24feb00,sj  truncate echo reply to PEER's MRU; added TermAck Debug Message
01e,23feb00,sj  changed bzero to memset in ECHO packet TX and RX
01d,22feb00,sj  cancel lcp_timer before sending TERMINATE REQUEST
01c,10jan99,sj  magic in echo packets is a byte array
01b,16dec99,sj  debug messages + fixing last sent LCP id + reset nak_option_sel
01a,11oct99,sj 	created
*/

#include "private/ppp/pppstate.h"
#include "private/ppp/pppoptn.h"
#include "private/ppp/pppLcpComponentP.h"

/*
*$Log:: /Rtrware/devdrvrs/ppp/ppplcpt $
 * 
 * 8     3/12/99 11:27a Nishit
 * Bunch of small changes - mostly in MP
 * related code
 * 
 * 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
*/


IMPORT void print_options_in_packet ( M_BLK_ID packet);

IMPORT M_BLK_ID lcpRecvPcktCopy (PFW_OBJ * pfwObj, M_BLK_ID pPacket);

LOCAL void send_lcp_packet (PFW_PLUGIN_OBJ_STATE * pluginState,
			    M_BLK_ID packet, PPP_CONTROL_CODE code,BYTE id);

LOCAL void send_lcp_configuration_request(PFW_PLUGIN_OBJ_STATE * pluginObjState,
				    M_BLK_ID pMblk, PPP_STATE end_state);
LOCAL void send_lcp_configuration_ack(PFW_PLUGIN_OBJ_STATE * pluginObjState,
				    M_BLK_ID pMblk, PPP_STATE end_state);
LOCAL void send_lcp_configuration_nak(PFW_PLUGIN_OBJ_STATE * pluginObjState,
				    M_BLK_ID pMblk, PPP_STATE end_state);
LOCAL void send_lcp_configuration_reject(PFW_PLUGIN_OBJ_STATE * pluginObjState,
				    M_BLK_ID pMblk, PPP_STATE end_state);
LOCAL void send_lcp_termination_request(PFW_PLUGIN_OBJ_STATE * pluginObjState,
				    M_BLK_ID pMblk, PPP_STATE end_state);
LOCAL void send_lcp_termination_ack(PFW_PLUGIN_OBJ_STATE * pluginObjState,
				    M_BLK_ID pMblk, PPP_STATE end_state);
LOCAL void send_lcp_code_reject(PFW_PLUGIN_OBJ_STATE * pluginObjState,
				    M_BLK_ID pMblk, PPP_STATE end_state);
LOCAL void send_lcp_echo_request(PFW_PLUGIN_OBJ_STATE * pluginObjState,
				    M_BLK_ID pMblk, PPP_STATE end_state);
LOCAL void send_lcp_echo_reply(PFW_PLUGIN_OBJ_STATE * pluginObjState,
				    M_BLK_ID pMblk, PPP_STATE end_state);
LOCAL int store_lcp_config_options_in_packet (OPTION_LIST *, PPP_OPTION *);

/*******************************************************************************
* lcpSetSendActionFunctions - updata action table with send functions 
*/
void lcpSetSendActionFunctions 
    (
    STATE_MACHINE_ACTION_TABLE * actionTable
    )
    {
    actionTable->send_configuration_request = send_lcp_configuration_request;
    actionTable->send_configuration_ack = send_lcp_configuration_ack;
    actionTable->send_configuration_nak = send_lcp_configuration_nak;
    actionTable->send_configuration_reject = send_lcp_configuration_reject;
    actionTable->send_termination_request = send_lcp_termination_request;
    actionTable->send_termination_ack = send_lcp_termination_ack;
    actionTable->send_code_reject = send_lcp_code_reject;
    actionTable->send_echo_request = send_lcp_echo_request;
    actionTable->send_echo_reply = send_lcp_echo_reply;
    }

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

/*******************************************************************************
* send_lcp_configuration_request -
*/
LOCAL void send_lcp_configuration_request
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID pMblk,
    PPP_STATE end_state
    )
    {
    USHORT number_of_bytes_to_send;
    LCP_CONFIGURE_REQUEST_PACKET *sptr_configuration_request_packet;
    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *) pluginState->stackData;
    M_BLK_ID packet = NULL;
    M_BLK_ID retryPacket;
    BYTE identifier;
    int lengthOfStoredOptions;

    PARAMETER_NOT_USED(end_state);
    PARAMETER_NOT_USED(pMblk);


    retryPacket = pStackData->last_txed_lcp_configuration_request_packet;

    if ((packet = retryPacket) == NULL)
        {
        /* check if we are opening a new connection */

        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)
           )
            {
            /* if we are opening a new connection and we were not in the stopped
             * state or OPENED state (if LCP is renegotiating) and we are in
             * passive mode then there is nothing to do
             */

            if ((PPP_STOPPED_STATE != pStackData->stateData.state &&
                 PPP_OPENED_STATE != pStackData->stateData.state) &&
                (((LCP_PROFILE_DATA *)(pluginState->profileData))->passiveMode)
               )
                {
                return;
                }

            /*
             * 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.
             */

            copy_configuration_options_to_tx_accepted_options
                (pluginState->pluginObj->pfwObj, &pStackData->option_lists);

            }
        /* get the upper limit on the number of bytes in the packet */

        number_of_bytes_to_send = LCP_PACKET_HEADER_SIZE;
        number_of_bytes_to_send += (USHORT) get_size_of_ppp_options
                                   (&pStackData->option_lists.tx_accepted);

        if ((packet = netTupleGet(pStackData->netPoolId,
             number_of_bytes_to_send, M_DONTWAIT,MT_DATA,TRUE)) == NULL)
            {
            return;
            }
        sptr_configuration_request_packet =
            mtod(packet,LCP_CONFIGURE_REQUEST_PACKET *);
        /*
         * filter options with default values:
         * REF: RFC 1661; page 28, paragraph 1
         */
        lengthOfStoredOptions = store_lcp_config_options_in_packet (
                     &pStackData->option_lists.tx_accepted,
                     (PPP_OPTION *)&sptr_configuration_request_packet->options);

        pStackData->id_sequence_number =
            (BYTE)(pStackData->id_sequence_number + 1);

        identifier = pStackData->id_sequence_number;
        packet->mBlkHdr.mLen = lengthOfStoredOptions + LCP_PACKET_HEADER_SIZE;

#ifdef PPP_DEBUG
        printf  ("LCP configure request sent: time %ld, ID %d\n",tickGet(),
               identifier);
#endif /* PPP_DEBUG */
        }
    else
        {
        sptr_configuration_request_packet =
            mtod(packet,LCP_CONFIGURE_REQUEST_PACKET *);
        identifier = sptr_configuration_request_packet->id;
#ifdef PPP_DEBUG
        printf ("LCP configure request sending retry packet: time %ld, ID %d\n",
               tickGet(),identifier);
#endif /* PPP_DEBUG */
        }

    send_lcp_packet (pluginState,packet, CONFIGURE_REQUEST,identifier);
    }


/*******************************************************************************
* send_lcp_packet -
*/
LOCAL void send_lcp_packet
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID packet,
    PPP_CONTROL_CODE code,
    BYTE id
    )
    {
    M_BLK_ID pDupPacket = NULL;
    PPP_PACKET *sptr_tx_packet;
    USHORT number_of_bytes_to_send = packet->mBlkHdr.mLen;
    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *) pluginState->stackData;
    LCP_PROFILE_DATA * pProfileData =
				(LCP_PROFILE_DATA *)pluginState->profileData;

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


    if (code == CONFIGURE_REQUEST && (pDupPacket = lcpDupPkt(packet)) == NULL)
	    {
	    return;
	    }

    if (((code == CONFIGURE_REQUEST) &&
	 (packet != pStackData->last_txed_lcp_configuration_request_packet)) ||
	(code != CONFIGURE_REQUEST))
	    {
	    #if 0
	    sptr_tx_packet->header.hdlc_address = HDLC_ADDRESS;
	    sptr_tx_packet->header.hdlc_control = UNNUMBERED_INFORMATION;
	    #endif

	    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)LCP_PROTOCOL);

	    if (code == CONFIGURE_REQUEST || code == TERMINATION_REQUEST)
		pStackData->last_id_of_lcp_packet_sent = id;
	    }

    ++pStackData->lcp_statistics.number_of_tx_packets;
    ++pStackData->lcp_statistics.number_of_control_tx_packets[sptr_tx_packet->code];

#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 TERMINATION_ACK:
	    printf("%s Tx TerminationAck: id =%d\n ",
			    pluginState->pluginObj->name, sptr_tx_packet->id);
	    break;

	default:
	    break;
	}
#endif /* PPP_DEBUG */

    if ((code == CONFIGURE_REQUEST) &&
    (packet != pStackData->last_txed_lcp_configuration_request_packet))
	{
	if (pStackData->copy_of_last_txed_lcp_configuration_request_packet != NULL)
    netMblkClChainFree(pStackData->copy_of_last_txed_lcp_configuration_request_packet);

    if ((pStackData->copy_of_last_txed_lcp_configuration_request_packet = 
        lcpRecvPcktCopy (pluginState->pluginObj->pfwObj,
		packet)) == NULL)
        {
        printf ("send_lcp_packet: Unable to copy last transmit lcp packet\n");
        }
	}

    pfwSend (pluginState,packet);

    switch (code)
	{
	case CONFIGURE_REQUEST:

	    /* keep reference to last sent packet */

	    if (pDupPacket != NULL)
		pStackData->last_txed_lcp_configuration_request_packet = 
								    pDupPacket;

	    /*if (pStackData->configuration_request_backoff_period_started ==TRUE)*/
		pfwTimerCancel (pStackData->lcp_timer);

	    if (pfwTimerStart(pStackData->lcp_timer,PFW_100_MILLISECOND,
		pProfileData->maximum_configuration_request_send_interval * 10,
		    retry_lcp_configure_request,0) == ERROR)
		{
		printf ("send config Req: timerStart failed; state = %d\n",
			pStackData->stateData.state);
		}

	    break;

	case TERMINATION_REQUEST:

	    pfwTimerCancel (pStackData->lcp_timer);

	    if (pfwTimerStart(pStackData->lcp_timer,PFW_SECOND,
		    pProfileData->maximum_termination_request_send_interval,
		    retry_lcp_termination_request,0) == ERROR)
		{
		printf ("send Termination Req: timerStart failed; state = %d\n",
			pStackData->stateData.state);
		}
	    break;

	case TIME_REMAINING:

	    if (pfwTimerStart(pStackData->time_remaining_timer,PFW_SECOND,
		    pProfileData->time_remaining_timeout,
		    (PFW_TIMER_HANDLER)send_lcp_time_remaining_packet,
		    (int)pluginState)  == ERROR)
		{
		printf ("send Time Remaining: timerStart failed; state = %d\n",
			pStackData->stateData.state);
		}
	    break;

	default:
	    break;
	}
    }

/*******************************************************************************
* send_lcp_configuration_ack -
*/
LOCAL void send_lcp_configuration_ack
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    M_BLK_ID pMblk,
    PPP_STATE end_state
    )
    {
    CONFIGURE_ACK_PACKET *sptr_configuration_ack_packet;
    LCP_STACK_DATA * pStackData = (LCP_STACK_DATA *) pluginState->stackData;
    M_BLK_ID packet = pStackData->last_rxed_lcp_configuration_request_packet;
    OPTION_LIST_ENTRY *sptr_configured_option;
    OPTION_LIST_ENTRY *sptr_accepted_option;

    PARAMETER_NOT_USED(end_state);
    PARAMETER_NOT_USED(pMblk);

	if (packet == NULL) /* WindNet Multilink - checking if packet is NULL here */
		{
		return;
		}

    if (pStackData->copy_of_last_rxed_lcp_configuration_request_packet == NULL)
        {
        if ((pStackData->copy_of_last_rxed_lcp_configuration_request_packet =
            lcpRecvPcktCopy (pluginState->pluginObj->pfwObj,
            pStackData->last_rxed_lcp_configuration_request_packet)) == NULL)
            {
            printf ("LCP: failed to copy last lcp request received packet\n");
            }
        }

    /* 
     * we are about to send an ACK so we reset nak_option_selected counters
     * for the options we are accepting
     */

    sptr_accepted_option=pStackData->option_lists.rx_accepted.sptr_forward_link;

    while (sptr_accepted_option)
	{