pppconfg.c

这是全套的PPP协议的源码

        index ++;

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

        value = (USHORT) 0;
        }

    *bptr_return_length = (index) * sizeof(USHORT);

    return (TRUE);

	}

/* IPV6 Support */



	/* WindNet Multilink - added for EID support */
	
	if (strstr (value_type_string, "EID") != NULL)
		{
		if (strcmp (value_string,"") == 0) 			{
			*bptr_return_length = 1;
			bptr_return_data [0] = 0;				
			return (TRUE);
			}
		else 
			{
			cptr_parameter = strtok_r (value_string, "-", &addressString);
			addressClass = atoi (cptr_parameter);

			switch (addressClass)
				{
				case 100:
					cptr_parameter = strtok_r (NULL, "-", &addressString);
					addressClass = atoi (cptr_parameter);
					switch (addressClass)
						{
						case 1:
							index = 0;
							bptr_return_data [index ++] = 1;				
							for (count = 1; count <= strlen (addressString); 
																count = count + 2)
								{
								bzero (temp, sizeof (temp));
								strncpy (temp, &addressString [count - 1], 2);
								bptr_return_data [index ++] = strtoul (temp, NULL, 16);				
								}
							*bptr_return_length = index;
							break;							

						default:
							printf ("pppConfg.c : Invalid class for the EID option\n");
							*bptr_return_length = 0;
							break;
						}
					break;
				case 0:
					*bptr_return_length = 1;
					bptr_return_data [0] = 0;				
					break;
				case 1:
					bptr_return_data [0] = 1;				
					strcpy ((char *)&bptr_return_data[1], addressString); 
					*bptr_return_length = 1 + strlen (addressString);
					break;
				case 2:
					bptr_return_data [0] = 2;				
					inet_aton (addressString, &in_addr_ip);
					memcpy (&bptr_return_data [1], &in_addr_ip.s_addr,
													 sizeof (ULONG));
					*bptr_return_length = 1 + sizeof (ULONG);
					break;
				case 3:
					bptr_return_data [0] = 3;
					cptr_parameter = strtok_r (NULL, "-", &addressString);
					while (cptr_parameter)
						{
						bptr_return_data [++index] = (BYTE) strtoul 
													(cptr_parameter, NULL, 16);

						cptr_parameter = strtok_r (NULL, "-", &addressString);
						}
					*bptr_return_length = 7;
					break;
				case 4:
					bptr_return_data [0] = 4;	
					cptr_parameter = strtok_r (NULL, "-", &addressString);
					while (cptr_parameter)
						{
						magicNumber = htonl (strtoul 
											(cptr_parameter, NULL, 10));
						memcpy (&bptr_return_data[(index * sizeof (ULONG)) + 1],
								 &magicNumber, sizeof (ULONG));
						index ++;
						cptr_parameter = strtok_r (NULL, "-", &addressString);
						}
					*bptr_return_length = (index * sizeof (ULONG)) + 1;
					break;
				case 5:
					bptr_return_data [0] = 5;
					strcpy ((char *)&bptr_return_data [1], addressString); 
					*bptr_return_length = 1 + strlen (addressString);
					break;
				default:
					printf ("pppConfg.c : Invalid class for the EID option\n");
					*bptr_return_length = 0;
					break;
				}	
			return TRUE;
			}
		}

	/* WindNet Multilink - added for EID support */

    return (FALSE);
    }
/*******************************************************************************
* get_size_of_numeric_string - 
*/
static BYTE get_size_of_numeric_string (char *value_type_string)
    {
    BYTE size_of_string = 0;

    if (strstr (value_type_string,"0") != NULL)
	{
	size_of_string = 0x00;
	}
    else if (strstr (value_type_string,"1") != NULL)
	{
	size_of_string = 0x01;
	}
    else if (strstr (value_type_string,"2") != NULL)
	{
	size_of_string = 0x02;
	}
    else if (strstr (value_type_string,"3") != NULL)
	{
	size_of_string = 0x03;
	}
    else if (strstr (value_type_string,"4") != NULL)
	{
	size_of_string = 0x04;
	}
    else if (strstr (value_type_string,"5") != NULL)
	{
	size_of_string = 0x05;
	}
    else if (strstr (value_type_string,"6") != NULL)
	{
	size_of_string = 0x06;
	}
    else
	{
	size_of_string = 0x00;
	}

    return (size_of_string);
    }

/*******************************************************************************
* get_my_magic_number -
*/
LOCAL ULONG get_my_magic_number (void)
    {
    ULONG my_magic_number = 0;

    my_magic_number = random();

    while (my_magic_number == 0x00000000L)
	    {
	    my_magic_number = random();
	    }

    return (my_magic_number);
    }

/*******************************************************************************
* get_value_string - 
*/
void get_value_string											
    (
    UNION_OPTION_DATA_TYPES		*data,	
    BYTE						length,
    char 						*value_type_string,
    char 						*value_string,
    UNION_OPTION_TYPES 			optionType,
    char						*optionName
    )
    {
    int						index = 0;
    int						i = 0;
    UNION_OPTION_DATA_TYPES	localData; 
    BOOL					bValueSwapped = FALSE;
    BYTE 					offset = 0;
    
    if (length <= 0)
        return;
    
    if (get_value_string_type (data,length, value_type_string, 
                               (BYTE *)value_string, optionType, optionName) == TRUE)
        return;
    
    if ((strstr (value_type_string,"S") != NULL) &&
        (strstr (value_type_string,"String") == NULL) &&
        (strstr (value_type_string, "H") == NULL))
        {
        bValueSwapped = TRUE;
        }
    
    index = length;
    
#if (_BYTE_ORDER == _LITTLE_ENDIAN)
    
    if (bValueSwapped)
        {
        
        while(index--)
            localData.byte_array[i++] = (BYTE) data->byte_array [index]; 
        
        }
    else
        bcopy ((char *)data, (char *)localData.byte_array,  length);
#else
    bcopy ((char *)data, (char *)localData.byte_array,  length);
#endif   
    
    
    if (strstr (value_type_string,"H") != NULL)
        {
        if (length > 0)
            {
            offset = 0;
            for (i = 0; i < length; i++)
                {
                sprintf (value_string + offset,"%02x",localData.byte_array[i]);
                offset += 2;
                }
            }
        return;
        }
    
    switch(length)
        {
        case 0x00 : return;
            
        case 0x01 : sprintf(value_string,"%d", localData._byte);
            return;
            
        case 0x02 : sprintf(value_string,"%d",localData._ushort);
            return;
            
        case 0x04 : sprintf(value_string,"%d", (int)localData._ulong);
            return;
            
        default:sprintf(value_string,"%d",(int)localData._ulong);
            return;
            
        }		
    }



/*******************************************************************************
* get_value_string_type - 
*/
LOCAL BOOLEAN get_value_string_type		
    (
	UNION_OPTION_DATA_TYPES		*uptr_data,	
	BYTE						length,
    char 						*value_type_string,
    BYTE 						*value_string,
    UNION_OPTION_TYPES			optionType,
	char						*optionName
    )
    {
/* WindNet Multilink - added for EID support */
	char 				temp [MAXIMUM_LENGTH_OF_OPTION_STRING];
	BYTE 				addressClass = 0;
	USHORT 				index = 0;
	ULONG 				magicNumber = 0;
	struct	in_addr		ipAddr;
	BOOLEAN				bValueSwapped = FALSE;
/* WindNet Multilink - added for EID support */

	USHORT              hdrCompInfo = 0;
    BYTE                ipv6Address = 0;

	bzero (temp, MAXIMUM_LENGTH_OF_OPTION_STRING);

	if ((strstr (value_type_string,"S") != NULL) &&
		(strstr (value_type_string,"String") == NULL) &&
		(strstr (value_type_string, "H") == NULL))
		{
		bValueSwapped = TRUE;
		}


	if((strcmp (optionName, "LAP") == 0) && 
	   (optionType.lcp == LCP_AUTHENTICATION_PROTOCOL))
		{
		if ((uptr_data->byte_array [0] == (BYTE)0xc2) && 
			(uptr_data->byte_array [1] == (BYTE) 0x23))
			{
            sprintf ((char *)value_string, "%04x",ntohs ((*(USHORT *)uptr_data)));
			return TRUE;
			}
		}


    if (strstr (value_type_string,"String") != NULL)
		{
		strcpy((char *)value_string, (char *)uptr_data);    
		return (TRUE);
		}
   
    /* 
     * replaced strstr with strcmp to distinguish 
     * between string types IP and IPV6 
     */

    if (strcmp (value_type_string,"IP") == 0)
		{

		/* support for RAS-AMM */

		if (length > 4)
			{
			strncpy((char *)value_string, (char *)uptr_data, length);    
			value_string [length] = '\0';
			if ((strstr ((char *)value_string, "RAS-AMM") == NULL) && 
				(strstr ((char *)value_string, "@") == NULL))
				{
				return FALSE;
				}
			return TRUE;
			}

		bzero ((char *)&ipAddr, sizeof (struct in_addr));
		ipAddr.s_addr = (ipAddr.s_addr |
					 (((ULONG)uptr_data->byte_array [0])  << 24)) |
					 (((ULONG)uptr_data->byte_array [1])  << 16) | 
					 (((ULONG)uptr_data->byte_array [2]) << 8) | 
			 		 (((ULONG)uptr_data->byte_array [3]) );

	    ipAddr.s_addr = htonl (ipAddr.s_addr);  

	    inet_ntoa_b (ipAddr, (char *)value_string);

		return (TRUE);
		}

/* IPV6 Support */

    /* Added for IPV6_INTERFACE_IDENTIFIER */

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

		for (index = 0; index < length; index++ )
			{ 
			ipv6Address = 0;
   		    bzero (temp, sizeof (temp));

			ipv6Address = (ipv6Address | ((BYTE)uptr_data->byte_array [index]));

			sprintf (temp, "%01x", ipv6Address);
			strcat ((char *) value_string, temp);
            if (index < length -1)
                strcat ((char *)value_string, ":"); /* Append ":" */
		    }

		return (TRUE);
		}

    /* Added for HC */

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

		for (index = 0; index < length; index = index + 2)
			{ 
			hdrCompInfo = 0;
   		    bzero (temp, sizeof (temp));

			hdrCompInfo = (hdrCompInfo |
						((BYTE)uptr_data->byte_array [index]  << 8)) |
					 	((BYTE)uptr_data->byte_array [index+1] );

			sprintf (temp, "%04x", hdrCompInfo);
			strcat ((char *)value_string, temp);

			if (index < (length - sizeof(USHORT)))
 			    strcat ((char *)value_string, ":"); /* Append ":" */
			}

		return (TRUE);
		}

/* IPV6 Support */

    if (strstr (value_type_string,"EID") != NULL)
		{
		addressClass = uptr_data->byte_array [0];

		switch (addressClass)
			{
			case 0:
				strcpy ((char *)value_string, "0"); /* Adding "0" */
				break;

			case 1: 
				strcpy ((char *)value_string, "1"); /* Adding "1" */
				strcat ((char *)value_string, "-"); /* Adding "-" */
				bcopy ((char *)&uptr_data->byte_array[1], (char *)&value_string [2], 
				   (length - 1));

				value_string [length + 1] = '\0';

				break;

			case 5:
				strcpy ((char *)value_string, "5"); /* Adding "5" */
				strcat ((char *)value_string, "-"); /* Adding "-" */
				strncpy ((char *)&value_string [2], (char *)(&uptr_data->byte_array [1]), 
						(length - 1));
				break;

			case 2:
				bzero ((char *)&ipAddr, sizeof (struct in_addr));
				strcpy ((char *)value_string, "2"); /* Adding "2" */
				strcat ((char *)value_string, "-"); /* Adding "-" */

				ipAddr.s_addr = (ipAddr.s_addr |
						 ((ULONG)uptr_data->byte_array [1]  << 24)) |
						 ((ULONG)uptr_data->byte_array [2]  << 16) | 
						 ((ULONG)uptr_data->byte_array [3] << 8) | 
			 			 ((ULONG)uptr_data->byte_array [4] );

            	ipAddr.s_addr = htonl (ipAddr.s_addr);

		    	inet_ntoa_b (ipAddr, (char *)&value_string [2]);

				break;

			case 3:
				strcpy ((char *)value_string, "3"); /* Adding "3" */
				for (index = 1; index < length; index++)
					{ 
					strcat ((char *)value_string, "-"); /* Adding "-" */
					bzero (temp, sizeof (temp));
					sprintf (temp, "%x", uptr_data->byte_array [index]);
					strcat((char *)value_string, temp); 
					}
				break;

			case 4: 
				strcpy ((char *)value_string, "4"); /* Adding "4" */
				for (index = 1; index < length; index = index + 4)
					{ 
					magicNumber = 0;
					bzero (temp, sizeof (temp));
					strcat ((char *)value_string, "-"); /* Adding "-" */

					magicNumber = (magicNumber |
						((ULONG)uptr_data->byte_array [index]  << 24)) |
					 	((ULONG)(ULONG)uptr_data->byte_array [index+1]  << 16) | 
					 	((ULONG)(ULONG)uptr_data->byte_array [index+2] << 8) | 
			 		 	((ULONG)uptr_data->byte_array [index + 3] );

					sprintf (temp, "%ld", magicNumber);
					strcat((char *)value_string, temp); 
					}
				break;

			default:
				break;
			}
		return TRUE;
		}

	return FALSE;
	}