pppconfg.c

这是全套的PPP协议的源码

	    }

	add_configuration_option_range (pfw,sptr_option_list,option_number,
					length,&option_data[0],&option_name[0],
					&ncp_name[0], value_swapped);
	}
	 else
	{
	printf ("Unknown Configuration String %s\r\n", option_string);
	}
	}
/*************************************************************************/
/* IPCP Address,3,Auto,Negotiation Not Required,Negotiable,IP,128.1.60.1 */
/*************************************************************************/
/*******************************************************************************
* get_configuration_option_values -
*/
LOCAL TEST get_configuration_option_values 
    (
    PFW_OBJ * pfw,
    char *cptr_option_string,
    char *cptr_return_ncp_name,
    char *cptr_return_option_name,
    BYTE *bptr_return_option_number,
    BYTE *bptr_return_data,
    BYTE *bptr_return_length,
    BOOLEAN *eptr_return_value_swapped,
    BOOLEAN *eptr_negotiation_required,
    BOOLEAN *eptr_negotiable,
    BOOLEAN *eptr_automatic_nak_processing
    )
    {
    char negotiation_required_string[30];
    char automatic_nak_processing_string[14];
    char negotiable_string[14];
    BYTE number_of_fields_scanned = 0;
    char *cptr_value = NULL; 

	bzero (negotiation_required_string, sizeof (negotiation_required_string));
	bzero (automatic_nak_processing_string, 
		   sizeof (automatic_nak_processing_string));
	bzero (negotiable_string, sizeof (negotiable_string));

  	cptr_value = parse_ppp_option_line (cptr_option_string,cptr_return_ncp_name,
					cptr_return_option_name,
					bptr_return_option_number,
					automatic_nak_processing_string,
					negotiation_required_string,
					negotiable_string,
					&number_of_fields_scanned);

    if (number_of_fields_scanned != 6)
	{
	printf("Illegal Number of PPP Options %02x Entered %s!!!\r\n",
			    number_of_fields_scanned, cptr_option_string);

	return (FAIL);
	}

   if (strstr (negotiation_required_string,"Not") != NULL)
	{
	*eptr_negotiation_required = FALSE;
	}
    else
	{
	*eptr_negotiation_required = TRUE;
	}

    if (strstr (negotiable_string,"Not") != NULL)
	{
	*eptr_negotiable = FALSE;
	}
    else
	{
	*eptr_negotiable = TRUE;
	}

    if (strstr (automatic_nak_processing_string,"Not") != NULL)
	{
	*eptr_automatic_nak_processing = FALSE;
	}
    else
	{
	*eptr_automatic_nak_processing = TRUE;
	}

    parse_option_value (pfw,cptr_value,bptr_return_data, bptr_return_length,
						eptr_return_value_swapped);

  return (PASS);
    }
/*******************************************************************************
* parse_ppp_option_line -
*/
LOCAL char *parse_ppp_option_line
    (
    char *cptr_option_string,
    char *cptr_return_ncp_name,
    char *cptr_return_option_name,
    BYTE *bptr_return_option_number,
    char *cptr_automatic_nak_processing_string,
    char *cptr_negotiation_required_string,
    char *cptr_negotiable_string,
    BYTE *bptr_number_of_parameters_processed
    )
    {
    char *cptr_parameter = NULL;
    char * holder = NULL;
    char option_number_string[4];
    ULONG option_number = 0;

    cptr_parameter = strtok_r (cptr_option_string,",\n",&holder);

    cptr_parameter = copy_parameter (cptr_return_ncp_name,cptr_parameter,
				&holder,bptr_number_of_parameters_processed);
    cptr_parameter = copy_parameter (cptr_return_option_name,cptr_parameter,
				&holder,bptr_number_of_parameters_processed);
    cptr_parameter = copy_parameter (&option_number_string[0],cptr_parameter,
				&holder,bptr_number_of_parameters_processed);
    cptr_parameter = copy_parameter (cptr_automatic_nak_processing_string,
				cptr_parameter,&holder,
				bptr_number_of_parameters_processed);
    cptr_parameter = copy_parameter (cptr_negotiation_required_string,
				cptr_parameter, &holder,
				bptr_number_of_parameters_processed);
#if 0
    cptr_parameter = copy_parameter (cptr_negotiable_string,
				cptr_parameter,&holder,
				bptr_number_of_parameters_processed);

#else
    strcpy (cptr_negotiable_string,cptr_parameter);
    *bptr_number_of_parameters_processed = 
			    (BYTE) (*bptr_number_of_parameters_processed + 1);

    cptr_parameter = holder;
#endif
    sscanf (option_number_string,"%ld",&option_number);
    *bptr_return_option_number = (BYTE) option_number;

    return (cptr_parameter);
    }
/*******************************************************************************
* copy_parameter -
*/
char *copy_parameter
    (
    char *cptr_parameter,
    char *cptr_option,
    char ** pHolder,
    BYTE *bptr_number_of_parameters_processed
    )
    {
    char *cptr_next_option = NULL;

    cptr_next_option = strtok_r (NULL,",\n",pHolder);

    if (cptr_option != NULL)
	{
	strcpy (cptr_parameter,cptr_option);
	*bptr_number_of_parameters_processed = 
			(BYTE) (*bptr_number_of_parameters_processed + 1);
	}

    return (cptr_next_option);
    }
/******************************************************************************
* parse_option_value -
*/
void parse_option_value 
    (
    PFW_OBJ * pfw,
    char *cptr_value,
    BYTE *bptr_option_data, 
    BYTE *bptr_length_of_all_options, 
    BOOLEAN *eptr_return_value_swapped
    )
    {
    char 	*cptr_parameter = NULL; 
    BYTE 	number_of_value_strings_processed = 0;
    char 	value_type_string[12];
    char 	value_string[80];
    BYTE 	option_length = 0;
    char 	* holder = NULL;
	char 	partialString [256];

	bzero (partialString, sizeof (partialString));
	strcpy (partialString, cptr_value);

  	number_of_value_strings_processed = 0x00;
    option_length = 0x00;
    *bptr_length_of_all_options = 0x00;
    *eptr_return_value_swapped = FALSE;	/* by default */

    bzero (value_string, sizeof(value_string)); /* WindNet Multilink */
    bzero (value_type_string, sizeof(value_type_string)); /* WindNet Multilink */

    cptr_parameter = strtok_r (partialString,",\n",&holder);

    cptr_parameter = copy_parameter (&value_type_string[0], partialString,
				&holder, &number_of_value_strings_processed);
    cptr_parameter = copy_parameter (&value_string[0], cptr_parameter,
				&holder, &number_of_value_strings_processed);

    while (cptr_parameter != NULL)
	{
	get_option_value (&value_type_string[0], &value_string[0],
					    bptr_option_data, &option_length, 
					    eptr_return_value_swapped);

	*bptr_length_of_all_options = (BYTE) (*bptr_length_of_all_options +
						    option_length);
	bptr_option_data += option_length;

	cptr_parameter = copy_parameter (&value_type_string[0],
					cptr_parameter, &holder,
					&number_of_value_strings_processed);

	cptr_parameter = copy_parameter (&value_string[0], cptr_parameter,
				    &holder,&number_of_value_strings_processed);
	}

    get_option_value (&value_type_string[0], &value_string[0], 
			bptr_option_data, &option_length, 
			eptr_return_value_swapped);

    *bptr_length_of_all_options = (BYTE) (*bptr_length_of_all_options + 
								option_length);
    }
/*******************************************************************************
* get_value_type -
*/
void get_value_type 
    (
    char *cptr_value_type_string,
	char *cptr_value_type
    )
    { 
    BYTE length = 0;


	if ((cptr_value_type == NULL) || (cptr_value_type_string == NULL)) 
	    {
	    return;
	    }

  	for (length = 0x00; ; ++length)
	{
	if (isdigit ((int)cptr_value_type_string[length]) || 
	    (cptr_value_type_string[length] == '\0'))
	    {
	    break;
	    }
	}
	
    bzero(cptr_value_type,(length + 0x1));

	strncpy (cptr_value_type, cptr_value_type_string, length);

	cptr_value_type[length] = '\0';

	return;
}

#if 0
/*******************************************************************************
* fill_in_value_type_array -
*/
LOCAL void fill_in_value_type_array
    (
    PFW_OBJ * pfw,
    VALUE_TYPE *sptr_value_type,
    BYTE index,
    char *cptr_value_type_string, 
    BOOLEAN value_swapped,
    BYTE option_length, 
    BYTE length_of_all_options
    )
    {
    sptr_value_type[index].cptr_value_type_string = 
			    get_value_type (pfw,cptr_value_type_string);
    sptr_value_type[index].value_swapped = (BYTE_ENUM (BOOLEAN)) value_swapped;
    sptr_value_type[index].length = option_length;
    sptr_value_type[index].offset = length_of_all_options;
    }
#endif
/*******************************************************************************
* get_option_value - 
*/
void get_option_value
    (
    char *value_type_string,
    char *value_string,
    BYTE *bptr_return_data, 
    BYTE *bptr_return_length,
    BOOLEAN *eptr_return_value_swapped
    )
    {
    char *value_format_string = NULL;
    int  temp_data[8];
    #if 0
    USHORT ushort_option_value;
    #endif
    unsigned int integer_option_value = 0;
    int index = 0;
    int i = 0;
    int length = 0;

	bzero ((char *)temp_data, sizeof (temp_data));

    if (get_option_value_type (value_type_string,value_string,bptr_return_data,
			bptr_return_length, eptr_return_value_swapped) == TRUE)
	{
	return;
	}

    *bptr_return_length = get_size_of_numeric_string (value_type_string);
    
    if (*bptr_return_length == 0x00)
	{
	return;
	}

    if (strstr (value_type_string,"H") != NULL)
	{
	value_format_string = cptr_hex_values[*bptr_return_length];
	sscanf (value_string, value_format_string, temp_data, temp_data + 1,
		temp_data + 2, temp_data + 3, temp_data + 4,
		temp_data + 5, temp_data + 6, temp_data + 7);
	for (index = 0; index < 8; index += 1)
	    {
	    bptr_return_data[index] = (BYTE) temp_data[index];
	    }
	}
    else
	{
	integer_option_value = atoi(value_string);
	length = *bptr_return_length;

	i = 0;
	while(length--)
	    bptr_return_data[length] = 
			(UINT8)((integer_option_value >> (i++ << 3)) & 0xff);

#if 0
	value_format_string = "%d";
	if (*bptr_return_length == sizeof(USHORT))
	    {
	    /*sscanf(value_string, value_format_string,&ushort_option_value);*/
	    ushort_option_value = atoi(value_string);
	    memcpy(&bptr_return_data[0],&ushort_option_value,sizeof(USHORT));
	    }
	else
	    {
	    ushort_option_value = atoi(value_string);
	    memcpy(&bptr_return_data[0],&ushort_option_value,sizeof(USHORT));
	    sscanf(value_string, value_format_string,
				     &bptr_return_data[0]);
	    }
#endif
	}
    }

/*******************************************************************************
* get_option_value_type - 
*/
LOCAL BOOLEAN get_option_value_type
    (
    char *value_type_string,
    char *value_string,
    BYTE *bptr_return_data,
    BYTE *bptr_return_length,
    BOOLEAN *eptr_return_value_swapped
    )
    {
    struct in_addr in_addr_ip;
    ULONG size_of_string = 0;
	USHORT value = 0;

/* WindNet Multilink - added for EID support */
	char * cptr_parameter = NULL;
	char * addressString = NULL;
	char temp [3];
	BYTE addressClass = 0;
	USHORT index = 0, count = 0;
	ULONG magicNumber = 0;
/* WindNet Multilink - added for EID support */

	bzero ((char *)&in_addr_ip, sizeof (in_addr_ip));
	bzero (temp, sizeof (temp));

    if (strstr (value_type_string,"String") != NULL)
	{
	if (strlen (value_type_string) != strlen ("String"))
	    {
	    size_of_string = 0x00000000L;

	    sscanf (value_type_string + strlen ("String"),"%d",
		    (int *) &size_of_string);
	    memset (bptr_return_data,(int) NULL,size_of_string);
	    *bptr_return_length = (BYTE) size_of_string;
	    }
	else
	    {
	    *bptr_return_length = (BYTE) strlen (value_string);
	    }

	strcpy ((char *) bptr_return_data,value_string);

	return (TRUE);
	}
    else if (strstr (value_type_string,"S") != NULL)
	{
	*eptr_return_value_swapped = TRUE;
	}
    else
	{
	*eptr_return_value_swapped = FALSE;
	}

    /* 
     * replaced strstr with strcmp to distinguish 
     * between string types IP and IPV6 
     */

    if (strcmp (value_type_string,"IP") == 0)
	{
	/* support for RAS-AMM */
	if ((strstr (value_string, "RAS") != NULL) || 
		(strstr (value_string, "@") != NULL))
		{
	    *bptr_return_length = (BYTE) strlen (value_string);		
		strcpy ((char *) bptr_return_data,value_string);

		return TRUE;
		}

	/*ip_address = get_ip_address_string (value_string);*/

	inet_aton(value_string,&in_addr_ip);

	/*in_addr_ip.s_addr = htonl(in_addr_ip.s_addr);*/

	memcpy (bptr_return_data,&in_addr_ip.s_addr,sizeof (ULONG));
	*bptr_return_length = sizeof (ULONG);

	return (TRUE);
	}

/* IPV6 Support */

    /* IPV6 Address */

    if (strstr (value_type_string,"IPV6") != NULL)
	{

	/* equivalent routine to convert IPV6 can be used instead */

	cptr_parameter = strtok_r (NULL, ":", &value_string);

	while (cptr_parameter)
		{
		bptr_return_data [index++] = (BYTE) strtoul (cptr_parameter, NULL, 16);
		cptr_parameter = strtok_r (NULL, ":", &value_string);
		}

	*bptr_return_length = sizeof (ULONG) + sizeof (ULONG);

	return (TRUE);
	}


    /* IPV6 Header Compression */

    if (strstr (value_type_string,"NBO") != NULL)
	{

    cptr_parameter = strtok_r (NULL, ":", &value_string);

    while (cptr_parameter)
        {   
        value = (USHORT) htons (strtoul (cptr_parameter, NULL, 16));

        memcpy ((void *)&bptr_return_data [(index * sizeof (USHORT))], 
                        (const void *)&value, sizeof (USHORT));