pppoptn.c

这是全套的PPP协议的源码

/* pppoptn.c - option list manager */

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

#include "copyright_wrs.h"

/*   
modification history
--------------------  
01u,07aug03,rp  updating include path for random.h
01t,05nov02,ijm use printf instead of logMsg
01s,27jun02,as  modified the function add_new_ppp_option_to_list() to 
                save the option name in the option list entry 
01r,17may02,as  added support for IPV6 Interface identifier specific processing
                in parse_ppp_options_from_configure_request
01r,17jul02,emr  Bring into line for PPP 2.0
01q,26feb02,jr	Setting the pointer to NULL after freeing
01p,07feb02,vk	Modifications as part memory reduction process
01o,10jan02,ijm check option order in received configure reject packets
01n,03jan02,ijm in parse_ppp_options_from_reject_configure,
                check rejected option values
01m,01nov01,ijm reset nak_option_selected field for remote_configured list
                in parse_ppp_options_from_configure_request if some
                options are rejected
01l,21jun01,sd  Changed few functions from static to non-static for BACP support 
01k,22mar01,ijm added check for NULL sptr_receive_list_option in 
                parse_ppp_options_from_reject_configure 
01j,05sep00,cn  added freeing of OPTION_VALUE structs in 
		free_ppp_option_list_entry () to fix a memory leak SPR# 34219. 
		Also fixed add_value_type_array_to_option_entry().
01i,17mar00,sj  look for duplicate options configure request
01h,16mar00,sj  set alternate and range pointers to NULL after duplicating
                 missing required options for nak list/packet
01g,25feb00,sj  re-write of parse_ppp_options_from_packet to use offsets.
01f,25feb00,sj  cleaned up print_options_in_packet
01e,11feb00,sj  fixed print_options_in_packet
01d,26jan00,sj  added changeOptionValueInConfiguredList and 
              	free_ppp_option_list_entry
01c,15dec99,sj  fixed option_list_print and added print_options_in_packet
01b,10nov99,sj  use remote_configured list
01a,02oct99,sj 	derived from Routerware source base
*/
/*
*$Log:: /Rtrware/devdrvrs/ppp/pppoptn $   
 * 
 * 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 "vxWorks.h"
#include "stddef.h"
#include "stdio.h"
#include "ctype.h"
#include "string.h"
#include "stdlib.h"
#include "ppp/kstart.h"
#include "ppp/kppp.h"
#include "private/ppp/pppoptn.h"
#include "pfw/pfw.h"
#include "pfw/pfwMemory.h"
#include "wrn/util/random.h" 
#include "private/ppp/pppIpv6cpComponentP.h"  
#include "logLib.h"


/* defines */
#define CHECK_FOR_DUPLICATE_OPTIONS_IN_CONFIG_REQUEST

#define _PPP_PACKET_PROTOCOL_OFFSET  0
#define _PPP_PACKET_CODE_OFFSET      2
#define _PPP_PACKET_ID_OFFSET        3
#define _PPP_PACKET_LENGTH_OFFSET    4

#define _PPP_PACKET_ID(p)     (UINT8)(p[_PPP_PACKET_ID_OFFSET])
#define _PPP_PACKET_LENGTH(p) (UINT16)((p[_PPP_PACKET_LENGTH_OFFSET] << 8) | \
					p[_PPP_PACKET_LENGTH_OFFSET+1])

#define _PPP_PACKET_FIRST_OPTION_OFFSET 6

#define _PPP_OPTION_TYPE_OFFSET   0
#define _PPP_OPTION_LENGTH_OFFSET 1
#define _PPP_OPTION_DATA_OFFSET   2

#define _PPP_OPTION_TYPE(o)   (UINT8)(o[_PPP_OPTION_TYPE_OFFSET])
#define _PPP_OPTION_LENGTH(o) (UINT8)(o[_PPP_OPTION_LENGTH_OFFSET]) 
#define _PPP_OPTION_DATA_LENGTH(o) ((int)(o[_PPP_OPTION_LENGTH_OFFSET]) - \
						_PPP_OPTION_DATA_OFFSET)
#define _PPP_OPTION_DATA(o)   (UINT8 * )(o + _PPP_OPTION_DATA_OFFSET)

#define _PPP_OPTION_VALID(o,f) (o <(UINT8 *)(f->mBlkHdr.mData + f->mBlkHdr.mLen))

IMPORT void option_list_print ( OPTION_LIST *sptr_option_list);

/* changed from static to non-static for usage from bacpoptn.c - WindNet Multilink */
TEST parse_ppp_options_from_packet 
    (
    PFW_OBJ *,
    OPTION_LIST *       sptr_option_list,
    M_BLK_ID            packet
    );

TEST check_options_from_reject_packet (OPTION_LISTS *sptr_option_lists);

OPTION_PARSE_RESULT set_missing_required_options_in_nak 
    (
    PFW_OBJ *,
    OPTION_LIST *       sptr_configured_option_list,
    OPTION_LIST *       sptr_rxed_option_list,
    OPTION_LIST *       sptr_nak_option_list
    );

OPTION_LIST_ENTRY * find_matching_option_beyond 
    (
    OPTION_LIST_ENTRY *  sptr_starting_option, 
    BYTE                 type
    );

/* changed from static to non-static for usage from bacpoptn.c - WindNet Multilink */

LOCAL void resetNakOptionSelectedField 
    (
    OPTION_LIST *                 sptr_option_list
    );

/* IPV6 Support */

LOCAL STATUS checkIpv6InterfaceIdentifierForZero
    (
    OPTION_LIST_ENTRY *           sptr_local_option, 
    OPTION_LIST_ENTRY *           sptr_remote_option
    );

LOCAL OPTION_PARSE_RESULT generateConfigureNakForInterfaceIdentifier
    (
    PFW_PLUGIN_OBJ_STATE *        pPfwPlugingObjState, 
    OPTION_LIST_ENTRY *           pIpv6nakOption,
    OPTION_LIST_ENTRY *           pIpv6LocalOption, 
    OPTION_LIST *                 sptr_nak_option_list,
    OPTION_LIST *                 sptr_rej_option_list,
    OPTION_LIST *                 sptr_receive_option_list
    );

/* IPV6 Support */

/*******************************************************************************
* add_new_ppp_option_to_list -
*/
TEST add_new_ppp_option_to_list
    (
    PFW_OBJ 					*pfw,
    OPTION_LIST 				*sptr_option_list,
    OPTION_STATE 				state,
    BYTE 						option_type,
    char                        *option_name,
    BYTE 						length,
    void 						*vptr_option_data,
    BOOLEAN 					negotiation_required,
    BOOLEAN 					negotiable,
    BOOLEAN 					automatic_nak_processing
    )
    {
    OPTION_LIST_ENTRY 			*sptr_option = NULL;
    UNION_OPTION_TYPES 			type;
    BOOLEAN 					isPresent = FALSE;

    type.generic = option_type;
    sptr_option = find_matching_option(sptr_option_list,option_type);

	if (sptr_option != NULL)
    	{
    	isPresent = TRUE;
    	}

	if(isPresent == FALSE)
    	{
    	sptr_option =(OPTION_LIST_ENTRY *)
                pfwMalloc(pfw,sizeof (OPTION_LIST_ENTRY));

    	if (sptr_option == NULL)
	    	{
	    	printf("PPP: Out of Memory for New Option \r\n");
	    	return (FAIL);
	    	}

    	bzero((void *)sptr_option,sizeof(OPTION_LIST_ENTRY));
		}


    /* Populate the option name in OPTION_LIST_ENTRY structure */

    if (option_name != NULL)
        {
        sptr_option->cptr_option_name = option_name;
        }
	
   	if (sptr_option->length > 0x00)
        {  	
        if (sptr_option->uptr_data != NULL)
            {
            pfwFree (sptr_option->uptr_data);
            sptr_option->uptr_data = NULL;    
            }
        }

    if (length > 0x00)
		{
		sptr_option->uptr_data=
						(UNION_OPTION_DATA_TYPES *)pfwMalloc(pfw,length);
		if (sptr_option->uptr_data == NULL)
	 	    {
	  	    printf("PPP: Out of Memory for New Option \r\n");
	   	    return (FAIL);
	        }
		else
	    	bzero((void *)sptr_option->uptr_data,length);

		memcpy (sptr_option->uptr_data,vptr_option_data,length);
		}

    sptr_option->state 	= (BYTE_ENUM (PPP_STATE)) state;
    sptr_option->type 	= type;
    sptr_option->length = length;

    sptr_option->option_flags.negotiation_required = 
                                       (PPP_FLAGS) negotiation_required;

    sptr_option->option_flags.negotiable = (PPP_FLAGS) negotiable;
    sptr_option->option_flags.automatic_nak_processing = (PPP_FLAGS) 
						    automatic_nak_processing;			

	if( isPresent == FALSE)									
		{
   		add_entry_to_list ((LINK *) &sptr_option_list->sptr_forward_link,
           			(LINK *) &sptr_option->sptr_forward_link);
		}
    return (PASS);
    }


/*******************************************************************************
* get_size_of_ppp_options -
*/
USHORT get_size_of_ppp_options
    (
    OPTION_LIST *sptr_option_list
    )
    {
    USHORT number_of_option_bytes = 0;
    OPTION_LIST_ENTRY *sptr_option = NULL;

    number_of_option_bytes = 0x0000;

    for (sptr_option = sptr_option_list->sptr_forward_link; sptr_option != NULL;
	sptr_option = sptr_option->sptr_forward_link)
	{
	#if 0
	number_of_option_bytes += (USHORT) (sizeof (sptr_option->type) + 
						sizeof (sptr_option->length));
	#endif
	number_of_option_bytes += (USHORT) (sizeof (BYTE) + sizeof (BYTE));
	number_of_option_bytes = (USHORT) (number_of_option_bytes + 
						sptr_option->length);
	}

    return (number_of_option_bytes);
    }

/*******************************************************************************
* store_ppp_options_in_packet - 
*/
void store_ppp_options_in_packet
    (
    OPTION_LIST *sptr_option_list,
    PPP_OPTION *sptr_destination_option
    )
    {
    struct _ppp_option
	{
	BYTE type;
	BYTE length;
	BYTE data[1];
	} * _ppp_option = (struct _ppp_option * ) sptr_destination_option;

    OPTION_LIST_ENTRY *sptr_source_option = NULL;

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

	memcpy (&_ppp_option->data, sptr_source_option->uptr_data,
						sptr_source_option->length);

	_ppp_option = (struct _ppp_option * )((UINT32)_ppp_option +
						(UINT32)_ppp_option->length);
	}
    }
/*******************************************************************************
* parse_ppp_options_from_configure_request -
*/
OPTION_PARSE_RESULT parse_ppp_options_from_configure_request
    (
    PFW_OBJ * pfw,
    OPTION_LISTS *sptr_option_lists,
    M_BLK_ID    packet,
    PFW_PLUGIN_OBJ_STATE * pluginState
    )
    {
    OPTION_LIST_ENTRY *    sptr_configured_option        = NULL;
    OPTION_LIST_ENTRY *    sptr_receive_list_option      = NULL;
    OPTION_LIST_ENTRY *    sptr_localConfigured_option   = NULL;

    TEST option_value_ok;
    OPTION_PARSE_RESULT return_code;

    free_ppp_option_list (&sptr_option_lists->received);
    free_ppp_option_list (&sptr_option_lists->tx_nak);
    free_ppp_option_list (&sptr_option_lists->tx_reject);
    free_ppp_option_list (&sptr_option_lists->rx_accepted);



    if (parse_ppp_options_from_packet (pfw,&sptr_option_lists->received, packet)
	== FAIL)
	{
	return (OPTION_PARSING_ERROR);
	}

#ifdef PPP_DEBUG
	printf("%s Rx ConfigReq: ",pluginState->pluginObj->name);
	option_list_print(&sptr_option_lists->received);
	printf("\n");
#endif /* PPP_DEBUG */

    return_code = set_missing_required_options_in_nak (pfw,
			&sptr_option_lists->remote_configured,
			/*&sptr_option_lists->configured,*/
			&sptr_option_lists->received,
			&sptr_option_lists->tx_nak);


    /* IPV6 Support */

    /* If peer didn't sent the Confg-Request with IPV6 option construct Nak */

    if ((return_code == SOME_OPTIONS_ARE_NACKED) && 
            (strcmp (pluginState->pluginObj->name, "PPP_IPV6CP") == 0))
        {
        OPTION_LIST_ENTRY * sptr_nak_option = NULL;

        sptr_nak_option = find_matching_option (
                  &sptr_option_lists->tx_nak, IPV6_INTERFACE_IDENTIFIER_OPTION_TYPE);

        if (sptr_nak_option != NULL)
            {
            OPTION_LIST_ENTRY * sptr_local_option = NULL;

            sptr_local_option = find_matching_option (
                 &sptr_option_lists->configured, IPV6_INTERFACE_IDENTIFIER_OPTION_TYPE);

            if (sptr_local_option != NULL)
                {
                return_code = generateConfigureNakForInterfaceIdentifier (pluginState,
                                          sptr_nak_option, sptr_local_option, 
					                      &sptr_option_lists->tx_nak, 
                                          &sptr_option_lists->tx_reject,
                                          &sptr_option_lists->received); 
                }
            }
        }