pppoptna.c

这是全套的PPP协议的源码

/* pppoptna.c - add options */

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

#include "copyright_wrs.h"

/*
modification history
--------------------
01k,01jul02,as  Added support for backward compatiblity of vjc
                compression
01j,28may02,rvr fixed build warnings 
01i,26feb02,jr  Setting the pointer to NULL after freeing
01h,04feb02,jr  modifications as part of memory reduction process
01g,09nov01,ijm copy alternate list and value type pointers in
                duplicate_option_with_values 
01f,01nov01,ijm tx_accepted list should duplicate configured
                option list with values, spr#71398
01e,20nov00,sj  set value_type fields to NULL in duplicate_option
01d,06mar00,sj  shorts and longs are already swapped by get_option_value
01c,28jan00,sj  added insertAlternateOptionToList
01b,17nov99,sj  copy_configuration_options_lists
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/pfwMemory.h"
#include "logLib.h"

LOCAL TEST add_range_to_configuration_option (PFW_OBJ *,
				OPTION_LIST *sptr_option_list,
				BYTE option_type,BYTE length,
				void *vptr_option_data);

/*******************************************************************************
* add_configuration_option -
*/
void add_configuration_option
    (
    PFW_OBJ * pfw,
    OPTION_LIST *sptr_option_list,
    OPTION_STATE state,
    BYTE option_type,
    BYTE length,
    void *vptr_option_data,
    char *cptr_option_name,
    char *cptr_ncp_name,
    BOOLEAN swap_value,
    BOOLEAN negotiation_required,
    BOOLEAN negotiable,
    BOOLEAN automatic_nak_processing 
    )
    {
	char *  pConfigOptionName = NULL;

#if 0
    ULONG ulong_swap_value;
    USHORT ushort_swap_value;

    if (swap_value == TRUE)
	{
	if (length == sizeof (ULONG))
	    {
	    /*ulong_swap_value = swap_long (*((ULONG *)vptr_option_data));*/
	    ulong_swap_value = htonl(*((ULONG *)vptr_option_data));
	    vptr_option_data = &ulong_swap_value;
	    }
	else if (length == sizeof (USHORT))
	    {
	    /*ushort_swap_value = swap (*((USHORT *)vptr_option_data));*/
	    ushort_swap_value = htons (*((USHORT *)vptr_option_data));
	    vptr_option_data = &ushort_swap_value;
	    }
	else
	    {
	    logMsg("PPP:Adding %s option to %s failed\r\n",
		    (int) cptr_option_name,(int) cptr_ncp_name,3,4,5,6);
	    }
	}
#endif

    /* Get the address of the option name from the Component structure */

    if (cptr_option_name != NULL)
        {

		/* LCP */
        if (strcmp (cptr_ncp_name, "LCP") == 0)
            {
            pConfigOptionName = getLcpOptionName (pfw, cptr_option_name);
            if (pConfigOptionName == NULL)
                {
                logMsg("PPP: Getting %s name from %s component failed\r\n",
		    (int) cptr_option_name, (int) cptr_ncp_name,3,4,5,6);
                return;
                } 
			}

		/* IPCP */
        if (strcmp (cptr_ncp_name, "IPCP") == 0)
            {
            pConfigOptionName = getIpcpOptionName (pfw, cptr_option_name);
            if (pConfigOptionName == NULL)
                {
                logMsg("PPP: Getting %s name from %s component failed\r\n",
			    (int) cptr_option_name, (int) cptr_ncp_name,3,4,5,6);
                return;
                } 
			}

        if (add_new_ppp_option_to_list (pfw, sptr_option_list, state, 
                          option_type, pConfigOptionName, length,
                          vptr_option_data, negotiation_required,
					      negotiable, automatic_nak_processing) == FAIL)
			{
			logMsg("PPP:Adding %s option to %s failed\r\n",
				 (int)  cptr_option_name,(int) cptr_ncp_name,3,4,5,6);
			}
		return;
		}

    if (add_new_ppp_option_to_list (pfw,sptr_option_list,state,option_type,
				    cptr_option_name, length,vptr_option_data,
				    negotiation_required,
					negotiable,
				    automatic_nak_processing) == FAIL)
	{
	printf("PPP:Adding %s option to %s failed\r\n",
				    cptr_option_name,cptr_ncp_name);
	}
    }
/*******************************************************************************
* add_alternate_to_configuration_option -
*/
void add_alternate_to_configuration_option
    (
    PFW_OBJ * pfw,
    OPTION_LIST *sptr_option_list,
    BYTE option_type,
    BYTE length,
    void *vptr_option_data,
    char *cptr_option_name,
    char *cptr_ncp_name,
    BOOLEAN swap_value
    )
    {
#if 0
    ULONG ulong_swap_value;
    USHORT ushort_swap_value;

    if (swap_value == TRUE)
	{
	if (length == sizeof (ULONG))
	    {
	    /*ulong_swap_value = swap_long (*((ULONG *)vptr_option_data));*/
	    ulong_swap_value = htonl (*((ULONG *)vptr_option_data));
	    vptr_option_data = &ulong_swap_value;
	    }
	else if (length == sizeof (USHORT))
	    {
	    /*ushort_swap_value = swap (*((USHORT *)vptr_option_data));*/
	    ushort_swap_value = htons (*((USHORT *)vptr_option_data));
	    vptr_option_data = &ushort_swap_value;
	    }
	else
	    {
	    logMsg("PPP:Adding %s option to %s failed\r\n",
                   (int) cptr_option_name, (int) cptr_ncp_name,3,4,5,6);
	    }
	}
#endif

    if (add_option_to_alternate_list (pfw,sptr_option_list,option_type,
	                                  length,vptr_option_data) == FAIL)
	{
	printf("PPP:Adding %s option to %s failed\r\n",
				    cptr_option_name,cptr_ncp_name);
	}
    }

/*******************************************************************************
* insertAlternateOptionToList -
*/
TEST insertAlternateOptionToList
    (
    PFW_OBJ * pfw,
    OPTION_LIST_ENTRY *sptr_option_entry,
    BYTE length,
    void *vptr_option_data,
    ALTERNATE_OPTION *previous
    )
    {
    ALTERNATE_OPTION *newAlternateOption = NULL;

    newAlternateOption =(ALTERNATE_OPTION *)
			    pfwMalloc(pfw,sizeof(ALTERNATE_OPTION));

    if (newAlternateOption == NULL)
	{
	printf("PPP: Out of Memory for New Alternate Option \r\n");
	return (FAIL);
	}
    else
	bzero((void *)newAlternateOption,sizeof(ALTERNATE_OPTION));

    if (length > 0x00)
	{
	newAlternateOption->uptr_data = 
		    (UNION_OPTION_DATA_TYPES *)pfwMalloc(pfw,length);
	if (newAlternateOption->uptr_data == NULL)
	    {
	    logMsg("PPP: Out of Memory for New Option \r\n",1,2,3,4,5,6);
            pfwFree(newAlternateOption);
            newAlternateOption = NULL;  
	    return (FAIL);
	    }
	memcpy (newAlternateOption->uptr_data,vptr_option_data,length);
	newAlternateOption->length = length;
	}

    if (previous == NULL)
	    add_entry_to_front_of_list ((LINK *) &sptr_option_entry->alternate_option_list,
			(LINK *) &newAlternateOption->links.sptr_forward_link);
	else
        insert_entry_in_list ((LINK *) &sptr_option_entry->alternate_option_list,
		    (LINK *) &newAlternateOption->links.sptr_forward_link,
		    (LINK *)&previous->links.sptr_forward_link);

    return PASS;
    }

/*******************************************************************************
* add_option_to_alternate_list -
*/
TEST add_option_to_alternate_list
    (
    PFW_OBJ * pfw,
    OPTION_LIST *sptr_option_list,
    BYTE option_type,
    BYTE length,
    void *vptr_option_data
    )
    {
    int preference = 0;
    ALTERNATE_OPTION *sptr_alternate_option = NULL;
    OPTION_LIST_ENTRY *sptr_option_entry = NULL;

    sptr_alternate_option =(ALTERNATE_OPTION *)
			    pfwMalloc(pfw,sizeof(ALTERNATE_OPTION));

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

	bzero((void *)sptr_alternate_option,sizeof(ALTERNATE_OPTION));

    if (length > 0x00)
	{

	sptr_alternate_option->uptr_data = 
		    (UNION_OPTION_DATA_TYPES *)pfwMalloc(pfw,length);
	if (sptr_alternate_option->uptr_data == NULL)
	    {
	    logMsg("PPP: Out of Memory for New Option \r\n",1,2,3,4,5,6);
            pfwFree(sptr_alternate_option);
            sptr_alternate_option = NULL;   
	    return (FAIL);
	    }
	}

    sptr_alternate_option->length = length;
   
    if (length > 0x00)
	{
	memcpy (sptr_alternate_option->uptr_data,vptr_option_data,length);
	}

    sptr_option_entry = find_matching_option (sptr_option_list,option_type);

    if (sptr_option_entry != NULL)
	{
         /* get the preference from the alternate option */

	if (sptr_option_entry->alternate_option_list.sptr_forward_link == NULL) 
		{
		preference = 0;
		}
	else
		{
		preference = sptr_option_entry->alternate_option_list.sptr_backward_link->preference;
		}

	sptr_alternate_option-> preference = preference+1;

	sptr_option_entry->option_flags.alternate_checking_enabled = PPP_FLAG_ON;	

  	add_entry_to_list ((LINK *) &sptr_option_entry->alternate_option_list,
		    (LINK *) &sptr_alternate_option->links.sptr_forward_link);

	return (PASS);
	}
    else
	{
        if (sptr_alternate_option->uptr_data != NULL)
		{
		pfwFree ((void *)sptr_alternate_option->uptr_data);
        sptr_alternate_option->uptr_data = NULL;       
		}
		
    if (sptr_alternate_option != NULL)      
        {
        pfwFree ((void *)sptr_alternate_option);
        sptr_alternate_option = NULL;       
        }
   	printf("PPP: No matching primary option for Alternate Option \r\n");
	return (FAIL);
	}
    }
/*******************************************************************************
* add_configuration_option_range -
*/
void add_configuration_option_range
    (
    PFW_OBJ * pfw,
    OPTION_LIST *sptr_option_list,
    BYTE option_type,
    BYTE length,
    void *vptr_option_data,
    char *cptr_option_name,
    char *cptr_ncp_name,
    BOOLEAN swap_value 
    )
    {
    #if 0
    ULONG ulong_swap_value;
    USHORT ushort_swap_value;

    if (swap_value == TRUE)
	{
	if (length == sizeof (ULONG))
	    {
	    /*ulong_swap_value = swap_long (*((ULONG *)vptr_option_data));*/
	    ulong_swap_value = htonl (*((ULONG *)vptr_option_data));
	    vptr_option_data = &ulong_swap_value;
	    }
	else if (length == sizeof (USHORT))
	    {
	    /*ushort_swap_value = swap (*((USHORT *)vptr_option_data));*/
	    ushort_swap_value = htons (*((USHORT *)vptr_option_data));
	    vptr_option_data = &ushort_swap_value;
	    }
	else
	    {
	    logMsg("PPP:Adding %s option to %s failed\r\n",
                  (int) cptr_option_name, (int) cptr_ncp_name,3,4,5,6);
	    }
	}

    #endif
    if (add_range_to_configuration_option (pfw,sptr_option_list,option_type,
					                       length,vptr_option_data) == FAIL)
	{
	printf("PPP:Adding %s option to %s failed\r\n",cptr_option_name,
								cptr_ncp_name);
	}
    }
/*******************************************************************************
* add_range_to_configuration_option -
*/
LOCAL TEST add_range_to_configuration_option 
    (
    PFW_OBJ * pfw,
    OPTION_LIST *sptr_option_list,
    BYTE option_type,
    BYTE length,
    void *vptr_option_data
    )
    {