listutls.c

这是全套的PPP协议的源码

/* listutls.c - option list manager */

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

#include "copyright_wrs.h"

/*
modification history
--------------------
01a,04oct99,sj 	derived from Routerware source base
*/
/*
 * $Log:: /Rtrware/rwutils/listutls.c                    $
 * 
 * 2     5/01/98 3:41p Nishit
 * Checkin in released (4.2.1) code
 * 
 * 2     4/24/98 10:24a Release Engineer
 * Added MD5 and (de)serialize utility functions 
 * RWUTILS v4.2.1
 * 
 * 1     3/27/98 2:19p Release Engineer
 * check - in
 * 
 * 1     2/13/98 12:17a Release Engineer
 * SNMP changes to correspond with ULONG table indices.
 * Also code cleanup and code style changes.  
 * New serialize and deserialize utility functions where
 * added.
 * RWUTILS v4.2.0
 * 
 * 
 * 2     2/13/96 7:51p Ross
 * Adding version control header.
*/
/*	$Modname: listutls.c$  $version: 1.3$      $date: 10/25/95$   */
/*
* 	$lgb$
1.0 01/12/95 ross
1.1 01/12/95 ross added copyright.
1.2 03/11/95 ross added new list routine.
1.3 10/25/95 ross dynamic load changes
* 	$lge$
*/

#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/vpppstr.h"

/*******************************************************************************
* add_entry_to_list - 
*/
void add_entry_to_list
    (
    LINK *sptr_link, 
    LINK *sptr_link_to_add
    )
    {
    if (sptr_link == NULL)
	{
	printf ("Illegal List\r\n");
	return;
	}

    if (sptr_link_to_add == NULL)
	{
	printf ("Illegal Element to Add\r\n");
	    return;
	}

    sptr_link_to_add->sptr_backward_link = sptr_link->sptr_backward_link;

    if (sptr_link->sptr_backward_link != NULL)
	sptr_link->sptr_backward_link->sptr_forward_link = sptr_link_to_add;
    else
	sptr_link->sptr_forward_link = sptr_link_to_add;

    sptr_link->sptr_backward_link = sptr_link_to_add;

    sptr_link_to_add->sptr_forward_link = NULL;
    }
/*******************************************************************************
* get_entry_from_list -
*/
void *get_entry_from_list
    (
    LINK *sptr_link
    )
    {
    LINK *sptr_return_link;

    if (sptr_link == NULL)
	{
	printf ("Illegal List\r\n");
	return (NULL);
	}

	sptr_return_link = sptr_link->sptr_forward_link;

	if (sptr_return_link != NULL)
	    {
	    sptr_link->sptr_forward_link = 
			sptr_link->sptr_forward_link->sptr_forward_link;

	    if (sptr_link->sptr_forward_link != NULL)
		sptr_link->sptr_forward_link->sptr_backward_link = NULL;
	    else 
		sptr_link->sptr_backward_link = NULL;

	    if (sptr_return_link != NULL)
		{
		sptr_return_link->sptr_forward_link = NULL;
		sptr_return_link->sptr_backward_link = NULL;
		}
	    }

    return (sptr_return_link);
    }

/******************************************************************************
* delete_entry_from_list - 
*/
void delete_entry_from_list
    (
    LINK *sptr_list_link,
    LINK *sptr_link_to_delete
    )
    {
    if (sptr_list_link == NULL)
	{
	printf ("Illegal List\r\n");
	return;
	}

    if (sptr_link_to_delete == NULL)
	{
	printf ("Illegal Element to Delete\r\n");
	return;
	}

    if (sptr_link_to_delete->sptr_forward_link == NULL &&
	sptr_link_to_delete->sptr_backward_link == NULL) /* 1 entry in list */
	{
	sptr_list_link->sptr_forward_link = NULL;
	sptr_list_link->sptr_backward_link = NULL;
	return;
	}

    /* First entry in N (N >= 2) entry list  */

    if (sptr_link_to_delete->sptr_backward_link == NULL) 
	{
	/* new first entry in list have list point to it */

	sptr_list_link->sptr_forward_link = 
				sptr_link_to_delete->sptr_forward_link; 
	}
    else 
	sptr_link_to_delete->sptr_backward_link->sptr_forward_link =
				sptr_link_to_delete->sptr_forward_link;

    if (sptr_link_to_delete->sptr_forward_link == NULL)
	{
	/* Last entry in N (N >= 2) entry list */
	/* new last entry in list because we're deleting the end*/

	sptr_list_link->sptr_backward_link = 
		sptr_link_to_delete->sptr_backward_link;
	}
    else 
	sptr_link_to_delete->sptr_forward_link->sptr_backward_link =
		sptr_link_to_delete->sptr_backward_link;

    sptr_link_to_delete->sptr_forward_link = NULL;
    sptr_link_to_delete->sptr_backward_link = NULL;
    }
/*******************************************************************************
* add_entry_to_front_of_list -
*/
void add_entry_to_front_of_list
    (
    LINK *sptr_link,
    LINK *sptr_link_to_add
    )
    {
    if (sptr_link == NULL)
	{
	printf ("Illegal List\r\n");
	    return;
	}

    if (sptr_link_to_add == NULL)
	{
	printf ("Illegal Element to Add\r\n");
	return;
	}

    if (sptr_link->sptr_forward_link != NULL)
	{
	sptr_link_to_add->sptr_forward_link = sptr_link->sptr_forward_link;

	sptr_link->sptr_forward_link->sptr_backward_link = sptr_link_to_add;
	}
    else
	{
	sptr_link->sptr_backward_link = sptr_link_to_add;
	}

    sptr_link->sptr_forward_link = sptr_link_to_add;
    sptr_link_to_add->sptr_backward_link = NULL;
    }
/*******************************************************************************
* insert_entry_in_list -
*/
void insert_entry_in_list 
    (
    LINK *sptr_link, 
    LINK *sptr_link_to_add,
    LINK *sptr_link_after_which_to_add
    )
    {
    if (sptr_link == NULL)
	{
	printf ("Illegal List\r\n");
	return;
	}

    if (sptr_link_after_which_to_add == NULL)
	{
	printf ("Illegal List Element\r\n");
	return;
	}

    if (sptr_link_to_add == NULL)
	{
	printf ("Illegal Element to Add\r\n");
	return;
	}

    if (sptr_link_after_which_to_add->sptr_forward_link != NULL)
	{
	sptr_link_to_add->sptr_forward_link = 
		sptr_link_after_which_to_add->sptr_forward_link;

	sptr_link_after_which_to_add->sptr_forward_link->sptr_backward_link =
							    sptr_link_to_add;
	}
    else
	{
	sptr_link->sptr_backward_link = sptr_link_to_add;
	}

    sptr_link_after_which_to_add->sptr_forward_link = sptr_link_to_add;
	
    sptr_link_to_add->sptr_backward_link = sptr_link_after_which_to_add;
    }
/*******************************************************************************
* get_pointer_to_first_entry_in_list -
*/
void *get_pointer_to_first_entry_in_list
    (
    LINK *sptr_link
    )
    {
    LINK *sptr_return_link;

    if (sptr_link == NULL)
	{
	printf ("Illegal List\r\n");
	return (NULL);
	}

    sptr_return_link = sptr_link->sptr_forward_link;

    return (sptr_return_link);
    }
/*******************************************************************************
* get_pointer_to_next_entry_in_list -
*/
void *get_pointer_to_next_entry_in_list
    (
    LINK *sptr_current_entry
    )
    {
    LINK *sptr_return_link;

    if (sptr_current_entry == NULL)
	{
	printf ("Illegal Current List Element\r\n");
	return (NULL);
	}

    sptr_return_link = sptr_current_entry->sptr_forward_link;

    return (sptr_return_link);
    }
/*******************************************************************************
* get_pointer_to_last_entry_in_list - 
*/
void *get_pointer_to_last_entry_in_list
    (
    LINK *sptr_link
    )
    {
    LINK *sptr_return_link;

    if (sptr_link == NULL)
	{
	printf ("Illegal List\r\n");
	return (NULL);
	}

    sptr_return_link = sptr_link->sptr_backward_link;

    return (sptr_return_link);
    }
/*******************************************************************************
*  get_pointer_to_previous_entry_in_list -
*/
void *get_pointer_to_previous_entry_in_list
    (
    LINK *sptr_current_entry
    )
    {
    LINK *sptr_return_link;

    if (sptr_current_entry == NULL)
	{
	printf ("Illegal Current List Element\r\n");
	return (NULL);
	}

    sptr_return_link = sptr_current_entry->sptr_backward_link;

    return ((void *) sptr_return_link);
    }
/*******************************************************************************
* free_list -
*/
void free_list
    (
    LINK *sptr_list,
    void (*fptr_free) (void *vptr_data_to_free)
    )
    {
    LINK *sptr_list_entry;

    while (TRUE)
	{
	sptr_list_entry = get_entry_from_list (sptr_list);

	if (sptr_list_entry == NULL)
	    {
	    break;
	    }
	else
	    {
	    (*fptr_free) (sptr_list_entry);
	    }
	}
    }
/*******************************************************************************
* get_entry_from_list_using_index -
*/
void *get_entry_from_list_using_index
    (
    LINK *sptr_list,
    USHORT element_index_to_find
    )
    {
    LINK *sptr_list_entry;
    USHORT current_element_index;

    current_element_index = 0x0000;

    for (sptr_list_entry = get_pointer_to_first_entry_in_list (sptr_list) ;
	 sptr_list_entry != NULL; 
	 sptr_list_entry = get_pointer_to_next_entry_in_list (sptr_list_entry))
	{
	if (current_element_index == element_index_to_find)
	    {
	    break;
	    }

	++current_element_index;
	}

    return (sptr_list_entry);
    }