pppoptna.c

这是全套的PPP协议的源码

    OPTION_LIST_ENTRY *sptr_option_entry = NULL;
    unsigned int value_length = 0;
    UNION_OPTION_DATA_TYPES * data_buffer = NULL;

    sptr_option_entry = find_matching_option (sptr_option_list,option_type);

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

    if (length > 0x00 && ((value_length = length/3) > 0))
	{
	data_buffer = (UNION_OPTION_DATA_TYPES *) pfwMalloc (pfw,length);
	if (data_buffer == NULL)
	    {
	    logMsg("PPP: Out of Memory for New Range Option \r\n",1,2,3,4,5,6);
	    return (FAIL);
	    }
	bzero((void *)data_buffer,length);

     /*
	 * added to free the pointers uptr_lowest_value, uptr_highiest_value
	 * and uptr_step in the option_list_entry structure before they are 
	 * assigned with newly allocated buffer.
	 */

    if (sptr_option_entry->range_option != NULL) 
        {
        if (sptr_option_entry->range_option->uptr_lowest_value != NULL)
            {
            pfwFree((void *)(sptr_option_entry->range_option->uptr_lowest_value));   
			sptr_option_entry->range_option->uptr_lowest_value = NULL;
			sptr_option_entry->range_option->uptr_highest_value = NULL;
			sptr_option_entry->range_option->uptr_step = NULL;
            }
        }
     else
        {
         sptr_option_entry->range_option = 
          (RANGE_OPTION_HOLDER *) pfwMalloc (pfw, sizeof (RANGE_OPTION_HOLDER));
         if (sptr_option_entry->range_option == NULL)
             {
             pfwFree (data_buffer);
             data_buffer = NULL; 
             return FAIL;
             }
        }	


	sptr_option_entry->range_option->uptr_lowest_value = data_buffer; 
							  
    sptr_option_entry->range_option->uptr_highest_value = 
		(UNION_OPTION_DATA_TYPES*)((UINT32)data_buffer + value_length); 

	sptr_option_entry->range_option->uptr_step = (UNION_OPTION_DATA_TYPES*)
				   ((UINT32)data_buffer + (value_length << 1)); 

	}
    else
	return (FAIL);

    memcpy (sptr_option_entry->range_option->uptr_lowest_value,
	vptr_option_data,value_length); 
    memcpy (sptr_option_entry->range_option->uptr_highest_value,
	(void *)((ULONG) vptr_option_data + value_length),value_length); 
    memcpy (sptr_option_entry->range_option->uptr_step,
	(void *)((ULONG) vptr_option_data + (value_length << 1)),value_length); 

    sptr_option_entry-> option_flags.range_checking_enabled = PPP_FLAG_ON; 

    return (PASS);
    }
/*******************************************************************************
* remove_configuration_option -
*/
void remove_configuration_option
    (
    OPTION_LIST *sptr_option_list,
    BYTE option_type
    )
    {
    OPTION_LIST_ENTRY *sptr_option = NULL;

    for (sptr_option = sptr_option_list->sptr_forward_link;
	sptr_option != NULL; sptr_option = sptr_option->sptr_forward_link)
	{
	if (sptr_option->type.generic == option_type)
	    {
	    delete_entry_from_option_list (sptr_option_list,sptr_option);
	    break;
	    }
	}

    if (sptr_option == NULL)
	{
	printf("PPP: Tried to delete option not present \r\n");
	}
    }
/*******************************************************************************
* replace_configuration_option -
*/
/* COMMENTED_OUT
void replace_configuration_option
    (
    OPTION_LIST *sptr_option_list,
    OPTION_LIST_ENTRY *sptr_option_to_replace,
    OPTION_STATE state
    )
    {
    BOOLEAN negotiation_required;
    BOOLEAN negotiable;
    BOOLEAN automatic_nak_processing;

    negotiation_required = sptr_option_to_replace->negotiation_required;
    negotiable = sptr_option_to_replace->negotiable;
    automatic_nak_processing = sptr_option_to_replace->automatic_nak_processing;

    remove_configuration_option (sptr_option_list,
					sptr_option_to_replace->type.generic);

    add_new_ppp_option_to_list (sptr_option_list,state,
	    sptr_option_to_replace->type.generic,sptr_option_to_replace->length,
	    sptr_option_to_replace->uptr_data,negotiation_required,negotiable,
	    automatic_nak_processing);
    }
*/
/*******************************************************************************
* free_ppp_option_lists -
*/
void free_ppp_option_lists
    (
    OPTION_LISTS *sptr_option_lists
    )
    {
    /* shankarj undid ### bug(?) fix for Wei */
    free_ppp_option_list (&sptr_option_lists->configured);
    free_ppp_option_list (&sptr_option_lists->remote_configured); 

    free_ppp_option_list (&sptr_option_lists->received);
    free_ppp_option_list (&sptr_option_lists->tx_nak);
    free_ppp_option_list (&sptr_option_lists->rx_nak);
    free_ppp_option_list (&sptr_option_lists->tx_reject);
    free_ppp_option_list (&sptr_option_lists->rx_reject);
    /*free_ppp_option_list (&sptr_option_lists->tx_accepted);*/
    free_ppp_tx_accepted_option_list(&sptr_option_lists->tx_accepted);
    free_ppp_option_list (&sptr_option_lists->rx_accepted);
    }
/*******************************************************************************
* duplicate_option -
*/
OPTION_LIST_ENTRY *duplicate_option     

    (
    PFW_OBJ * pfw,
    OPTION_LIST_ENTRY *sptr_to_option_to_copy
    )
    {
    OPTION_LIST_ENTRY *sptr_duplicate_option = NULL;
    UNION_OPTION_DATA_TYPES *uptr_matching_option_data = NULL;

    sptr_duplicate_option = (OPTION_LIST_ENTRY *) 
				pfwMalloc (pfw,sizeof (OPTION_LIST_ENTRY));

    if (sptr_duplicate_option != NULL)
	{
	bzero((void *)sptr_duplicate_option,sizeof(OPTION_LIST_ENTRY));

	if (sptr_to_option_to_copy->length != 0x00)
	    {
	    uptr_matching_option_data = (UNION_OPTION_DATA_TYPES *) 
				pfwMalloc (pfw,sptr_to_option_to_copy->length);

	    if (uptr_matching_option_data != NULL)
		{
		bzero((void *)uptr_matching_option_data,
					    sptr_to_option_to_copy->length);

		memcpy (sptr_duplicate_option,sptr_to_option_to_copy,
						   sizeof (OPTION_LIST_ENTRY));
		sptr_duplicate_option->uptr_data = uptr_matching_option_data;

		memcpy (sptr_duplicate_option->uptr_data,
			sptr_to_option_to_copy->uptr_data,
			sptr_to_option_to_copy->length);

 			sptr_duplicate_option->
				alternate_option_list.sptr_forward_link = NULL;
			sptr_duplicate_option->
                              alternate_option_list.sptr_backward_link = NULL;  
			sptr_duplicate_option->range_option = NULL; 

			return (sptr_duplicate_option);
		}
	    else
		{
        if (sptr_duplicate_option != NULL)  
           {
           pfwFree((void *)sptr_duplicate_option);
           sptr_duplicate_option = NULL;    
           }
		 }
	    }
	else
	    {
	    memcpy (sptr_duplicate_option,
		    sptr_to_option_to_copy,sizeof (OPTION_LIST_ENTRY));

  	    sptr_duplicate_option->alternate_option_list.sptr_forward_link
									 =NULL;
	    sptr_duplicate_option->alternate_option_list.sptr_backward_link
									 =NULL;
	    sptr_duplicate_option->range_option = NULL; 

	    return (sptr_duplicate_option);
	    }
	}

    logMsg("PPP: Out of Memory for Copy Option \r\n",1,2,3,4,5,6);

    return (NULL);
    }

/*******************************************************************************
* duplicate_option_with_values -
*/
OPTION_LIST_ENTRY *duplicate_option_with_values		
    (
    PFW_OBJ * pfw,
    OPTION_LIST_ENTRY *sptr_to_option_to_copy
    )
    {
    OPTION_LIST_ENTRY *sptr_duplicate_option = NULL;
    UNION_OPTION_DATA_TYPES *uptr_matching_option_data = NULL;

    sptr_duplicate_option = (OPTION_LIST_ENTRY *)
                pfwMalloc (pfw,sizeof (OPTION_LIST_ENTRY)); 
   
    if (sptr_duplicate_option != NULL)
        {
        bzero((void *)sptr_duplicate_option,sizeof(OPTION_LIST_ENTRY));

        if (sptr_to_option_to_copy->length != 0x00)
            {
            uptr_matching_option_data = (UNION_OPTION_DATA_TYPES *)
                pfwMalloc (pfw,sptr_to_option_to_copy->length); 
		
	    if (uptr_matching_option_data != NULL)
                {
                bzero((void *)uptr_matching_option_data,
                        sptr_to_option_to_copy->length);

                memcpy (sptr_duplicate_option,sptr_to_option_to_copy,
                            sizeof (OPTION_LIST_ENTRY));

                sptr_duplicate_option->uptr_data = uptr_matching_option_data;

                memcpy (sptr_duplicate_option->uptr_data,
                        sptr_to_option_to_copy->uptr_data,
                        sptr_to_option_to_copy->length);

                sptr_duplicate_option->alternate_option_list.sptr_forward_link =
                sptr_to_option_to_copy->alternate_option_list.sptr_forward_link;

                sptr_duplicate_option->alternate_option_list.sptr_backward_link =
                sptr_to_option_to_copy->alternate_option_list.sptr_backward_link;

                sptr_duplicate_option->range_option = 
                                        sptr_to_option_to_copy->range_option;
	

		    return (sptr_duplicate_option);
                }/* end of if uptr_matching_option_data != NULL */

            else
                {
                if (sptr_duplicate_option != NULL)  
                    {
                    pfwFree((void *)sptr_duplicate_option);
                    sptr_duplicate_option = NULL;    
                    }
		        }
            } /* end of if sptr_to_option_to_copy->length != 0 */
        else
            {
            memcpy (sptr_duplicate_option,
            sptr_to_option_to_copy,sizeof (OPTION_LIST_ENTRY));

            sptr_duplicate_option->alternate_option_list.sptr_forward_link =NULL;
            sptr_duplicate_option->alternate_option_list.sptr_backward_link=NULL;
            sptr_duplicate_option->range_option = NULL; 

	  		return (sptr_duplicate_option);
            }
        } /* end of if sptr_duplicate_option != NULL */

    logMsg("PPP: Out of Memory for Copy Option \r\n",1,2,3,4,5,6);
 
    return (NULL);
    }

/*******************************************************************************
* replace_data_field_in_option -
*/
void replace_data_field_in_option		
    (
    PFW_OBJ * pfw,
    OPTION_LIST_ENTRY *sptr_option,
    UNION_OPTION_DATA_TYPES *uptr_new_data,
    BYTE new_length
    )
    {
    void *vptr_allocated_data = NULL;

    if (sptr_option->length > 0x00)
	{
	if (sptr_option->uptr_data != NULL)         
	    {
	    pfwFree((void *)sptr_option->uptr_data);
		sptr_option->uptr_data = NULL; 
	    }
	else
	    {
	    logMsg("PPP: Illegal Option \r\n",1,2,3,4,5,6);
	    }
	}

    vptr_allocated_data = (OPTION_LIST_ENTRY *) pfwMalloc (pfw,new_length);
    if (vptr_allocated_data != NULL)
	{
	bzero((void *)vptr_allocated_data,new_length);

	memcpy (vptr_allocated_data,uptr_new_data,new_length);
	sptr_option->uptr_data = vptr_allocated_data;
	sptr_option->length = new_length;
	}
    }

/*******************************************************************************
* copy_configuration_options_to_tx_accepted_options -
*/
void copy_configuration_options_to_tx_accepted_options
    (
    PFW_OBJ * pfw,
    OPTION_LISTS *sptr_option_lists
    )
    {
    OPTION_LIST_ENTRY *sptr_option_to_copy = NULL;
    OPTION_LIST_ENTRY *sptr_option_to_add = NULL;

    for (sptr_option_to_copy = sptr_option_lists->configured.sptr_forward_link;
	 sptr_option_to_copy != NULL;
	 sptr_option_to_copy = sptr_option_to_copy->sptr_forward_link)
	{
	sptr_option_to_add = duplicate_option_with_values (pfw,sptr_option_to_copy);

	if (sptr_option_to_add != NULL)
	    {
	    add_entry_to_list (
		    (LINK *) &sptr_option_lists->tx_accepted.sptr_forward_link,
		    (LINK *) &sptr_option_to_add->sptr_forward_link);
	    }
	else 
	    {
	    break;
	    }
	}
    }

/*******************************************************************************
* copy_configuration_option_list
*/
void copy_configuration_options_list
    (
    PFW_OBJ * pfw,
    OPTION_LIST *from_list,
    OPTION_LIST *to_list
    )
    {
    OPTION_LIST_ENTRY *sptr_option_to_copy = NULL;
    OPTION_LIST_ENTRY *sptr_option_to_add = NULL;

    for (sptr_option_to_copy = from_list->sptr_forward_link;
	 sptr_option_to_copy != NULL;
	 sptr_option_to_copy = sptr_option_to_copy->sptr_forward_link)
	{
	sptr_option_to_add = duplicate_option (pfw,sptr_option_to_copy);

	if (sptr_option_to_add != NULL)
	    {
	    add_entry_to_list (
		    (LINK *) &to_list->sptr_forward_link,
		    (LINK *) &sptr_option_to_add->sptr_forward_link);
	    }
	else 
	    {
	    break;
	    }
	}
    }