lib.c

关于Linux下DHCP支持IPv6的版本实现

#include "stdhead.h"
#include "lib.h"

void write_to_log (char * str, int time_flag)
{
   time_t curr_time;
   int time_length;
   char *str_curr_time;
   int log_fd; 
   if ((log_fd= open (DEFAULT_EVENT_LOG_FILE, O_CREAT|O_APPEND|O_RDWR, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH)) == -1)
   {
	printf ("Failed to open event log file.\n");
	return;
   }
   
   if (time_flag)
   {
	curr_time = time (&curr_time);
	str_curr_time = ctime (&curr_time);
	write (log_fd, str_curr_time, strlen (str_curr_time));
	write (log_fd, "\t", 1);
   }
   if ((write (log_fd, str, strlen (str))) == -1)
	printf ("Failed to log event.\n");
   if (time_flag)
	write (log_fd, "\n", 1);
   close (log_fd);
}
	

// Safe free function
void safe_free (void *ptr)
{
   if (ptr)
	free (ptr);
}

// Join an IPv6 multicast group
int mcast_join (int socket, char *interface_name, char *mcast_addr)
{
   struct ipv6_mreq mreq6;
   
   mreq6.ipv6mr_interface = if_nametoindex (interface_name);
   inet_pton (AF_INET6, mcast_addr, &mreq6.ipv6mr_multiaddr);
   return (setsockopt (socket, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, &mreq6, sizeof (mreq6)));
}

void build_linked_list (char *m, int len, struct DHCP_MESSAGE *dhcp_message)
{
    int index = 0, i;
    struct OPTIONS *opt;
    
    dhcp_message -> u_msg_type.buffer[0] = m[index++];
    for (i = 2; i >= 0; i--)
	dhcp_message -> u_trans_id.buffer[i] = m[index++];
    dhcp_message -> u_trans_id.buffer[3] = 0;

    opt = (struct OPTIONS *) malloc (sizeof (struct OPTIONS));
    read_option (m, index, len, opt);
    dhcp_message -> opt = opt;
}

void print_linked_list_contents (struct DHCP_MESSAGE *dhcp_message)
{
    struct OPTIONS *q;
    struct DUID *d;
    struct DUID1 *d1;
    struct DUID2 *d2;
    struct DUID3 *d3;
    struct IA *ia;
    struct IA_ADDRESS *ia_addr;
    struct PREFERENCE *pref_ptr;
    struct STATUS_CODE *sc_ptr;
    int i;
    char name[64];
    
    printf ("\nMessage type = %d\n", dhcp_message -> u_msg_type.msg_type);
    printf ("Transaction ID = %d\n\n", dhcp_message -> u_trans_id.trans_id);
    q = dhcp_message -> opt;

    if (!q)
    {
	printf ("No options defined!\n");
	return;
   }
	
    do
    {
	switch (q -> u_opt_code.opt_code)
	{
	    case OPTION_CLIENTID :
	    case OPTION_SERVERID :
		printf ("Option type = %d\n", q -> u_opt_code.opt_code);
		printf ("DUID length = %d\n", q -> u_opt_len.opt_len);
		d = q -> opt_data;
		printf ("DUID type = %d\n", d -> u_duid_type.duid_type);
		
		if (d -> u_duid_type.duid_type == 1)
		{
		    d1 = d -> duid_type;
		    
		    printf ("Time = %d\n", d1 -> u_time.time);
		    printf ("Hardware type = %d\nHardware address = ", d1 -> u_haddr_type.haddr_type);
		    for (i = 0; i < 6; i++)
		    {
			printf ("%x", d1 -> link_layer_address[i]);
			if (i != 5)
			    printf (":");
		    }
		    printf ("\n\n");
		}
		else if (d -> u_duid_type.duid_type == 2)
		{
		    d2 = d -> duid_type;
		    
		    printf ("Identifier length = %d\nIdentifier = ", d2 -> u_identifier_length.identifier_length);
		    for (i = 0; i < d2 -> u_identifier_length.identifier_length; i++)
			printf ("%d", d2 -> identifier[i]);
		    printf ("\nDomain name = ");
		    for (i = 0; i < d2 -> domain_name_len; i++)
			printf ("%c", d2 -> domain_name[i]);
		}
		else if (d -> u_duid_type.duid_type == 3)
		{
		    d3 = d -> duid_type;
		    
		    printf ("Hardware type = %d\nHardware address = ", d3 -> u_haddr_type.haddr_type);
		    for (i = 0; i < 6; i++)
		    {
			printf ("%x", d3 -> link_layer_address[i]);
			if (i != 5)
			    printf (":");
		    }
		    printf ("\n\n");
		}
    		
		q = d -> opt;
		break;
		
	    case OPTION_IA :
		printf ("Option type = IA option\n");
		printf ("option length = %d\n", q -> u_opt_len.opt_len);
		ia = q -> opt_data;

		printf ("IAID = %x\n", ia -> u_iaid.iaid);
		printf ("T1 = %d\n", ia -> u_t1.t1);
		printf ("T2 = %d\n", ia -> u_t2.t2);
		printf ("Status code for IA = %d\n\n", ia -> status);
		q = ia -> opt;
		break;
		
	    case OPTION_IAADDR :
		printf ("Option type = IA address option\n");
		printf ("option length = %d\n", q -> u_opt_len.opt_len);
		ia_addr = q -> opt_data;

		printf ("Temporary address bit = %d\n", ia_addr -> t_bit);
		printf ("Address status = %d\n", ia_addr -> addr_status);
		printf ("Prefix length of the address = %d\n", ia_addr -> prefix_length);
		printf ("IPv6 Address = %s\n", inet_ntop (AF_INET6, ia_addr -> addr, name, 64));
		printf ("Preferred lifetime = %d", ia_addr -> u_pref_lifetime.pref_lifetime);
		printf ("\nValid lifetime = %d", ia_addr -> u_valid_lifetime.valid_lifetime);
		printf ("\n\n");
		q = ia_addr -> opt;
		break;
		
	    case OPTION_PREFERENCE :
		printf ("Option type = Preference option\n");
		printf ("option length = %d\n", q -> u_opt_len.opt_len);
		pref_ptr = q -> opt_data;
		
		printf ("Preference value = %d\n\n", pref_ptr -> preference_value);
		q = pref_ptr -> opt;
		break;
		
	    case OPTION_STATUS_CODE :
		printf ("Option type = Status code\n");
		printf ("option length = %d\n", q -> u_opt_len.opt_len);
		sc_ptr = q -> opt_data;
		
		printf ("Status code = %d\nStatus message = ", sc_ptr -> u_status_code.status_code);
		for (i = 0; i < q -> u_opt_len.opt_len - 2; i++)
		    printf ("%c", sc_ptr -> message[i]);
		printf ("\n\n");
		q = sc_ptr -> opt;
		break;
		
	   default :
		printf ("Invalid option type\n\n");
		q = 0;
		break;
	}
    }
    while (q);
}

/* 
    This function converts the message from the linked list into a character
    buffer. It returns the length of the buffer.
*/
int store_in_buffer (struct DHCP_MESSAGE *dhcp_message, char *buff)
{
    int i;
    char *start = buff;
    struct OPTIONS *options_ptr;
    struct DUID *duid_ptr;
    struct DUID1 *duid1_ptr;
    struct DUID2 *duid2_ptr;
    struct DUID3 *duid3_ptr;
    struct IA *ia_ptr;
    struct IA_ADDRESS *ia_addr_ptr;
    struct PREFERENCE *pref_ptr;
    struct STATUS_CODE *sc_ptr;

    // MESSAGE TYPE
    *buff = dhcp_message->u_msg_type.buffer[0];
    buff++;
    
    // TRANSACTION ID
    for (i = 2; i >= 0; i--)
    {
	*buff = dhcp_message->u_trans_id.buffer[i];
	buff++;
    }
    
    options_ptr = dhcp_message->opt;
    while (options_ptr)
    {
	// OPTIONS CODE
	*buff = options_ptr->u_opt_code.buffer[1];
	buff++;
    	*buff = options_ptr->u_opt_code.buffer[0];
	buff++;
	    
	// OPTIONS LEN
        *buff = options_ptr->u_opt_len.buffer[1];
        buff++;
        *buff = options_ptr->u_opt_len.buffer[0];
        buff++;
    
	switch (options_ptr -> u_opt_code.opt_code)
        {
    	    case OPTION_CLIENTID :
	    case OPTION_SERVERID :
		duid_ptr = (struct DUID *) options_ptr->opt_data;
    		
		// DUID TYPE
		*buff = duid_ptr->u_duid_type.buffer[1];
    		buff++;
    		*buff = duid_ptr->u_duid_type.buffer[0];
    		buff++;
		
		switch (duid_ptr -> u_duid_type.duid_type)
		{
		    case 1 :		
			duid1_ptr = (struct DUID1 *) duid_ptr->duid_type;

    			// DUID HARDWARE ADDRESS TYPE
    			*buff = duid1_ptr->u_haddr_type.buffer[1];
        		buff++;
	   		*buff = duid1_ptr->u_haddr_type.buffer[0];
			buff++;

			// Time field
			for (i = 3; i >= 0; i--)
			{
			    *buff = duid1_ptr->u_time.buffer[i];		
			    buff++;
		        }
			
			// DUID HARDWARE ADDRESS
			for (i = duid1_ptr -> haddr_len; i >= 0; i--)
			{
			    *buff = duid1_ptr->link_layer_address[i];		
			    buff++;
		        }
			break;
			
		    case 2 :    
			duid2_ptr = (struct DUID2 *) duid_ptr->duid_type;

    			// Identifier length
    			*buff = duid2_ptr->u_identifier_length.buffer[1];
        		buff++;
	   		*buff = duid2_ptr->u_identifier_length.buffer[0];
			buff++;

			// Identifier
			for (i = duid2_ptr->u_identifier_length.identifier_length; i >= 0; i--)
			{
			    *buff = duid2_ptr-> identifier[i];
			    buff++;
		        }
			
			// Domain name
			for (i = duid2_ptr -> domain_name_len; i >= 0; i--)
			{
			    *buff = duid2_ptr-> domain_name[i];		
			    buff++;
		        }
			break;
			
		    case 3 :
			duid3_ptr = (struct DUID3 *) duid_ptr->duid_type;
        
    			// DUID HARDWARE ADDRESS TYPE
    			*buff = duid3_ptr->u_haddr_type.buffer[1];
        		buff++;
	   		*buff = duid3_ptr->u_haddr_type.buffer[0];
			buff++;

			// DUID HARDWARE ADDRESS
			for (i = duid3_ptr -> haddr_len; i >= 0; i--)
			{
			    *buff = duid3_ptr->link_layer_address[i];		
			    buff++;
		        }
			break;
		}
			    
		// GO TO THE NEXT OPTIONS HEADER
		options_ptr = duid_ptr->opt;
		break;
		
	    case OPTION_IA :
		// IA OPTION DATA
		ia_ptr = (struct IA *)options_ptr->opt_data;
   
    		// IAID
    		for (i = 3; i >= 0; i--)
		{
	    	    *buff = ia_ptr->u_iaid.buffer[i];
	    	    buff++;
		}	
    
    		//  T1
    		for (i = 3; i >= 0; i--)
    		{
	    	    *buff = ia_ptr->u_t1.buffer[i];
	    	    buff++;
		}	
    
		// T2
		for (i = 3; i >= 0; i--)
		{
	    	    *buff = ia_ptr->u_t2.buffer[i];
	    	    buff++;
		}

    		// STATUS
    		*buff = ia_ptr->status;
    		buff++;
    
   		options_ptr = ia_ptr->opt;
		break;	    

	    case OPTION_IAADDR :
		ia_addr_ptr = (struct IA_ADDRESS *) options_ptr->opt_data;
   
		// ADDRESS STATUS
		*buff = ia_addr_ptr->addr_status;
		
		// TEMPORARY ADDRESS BIT
		if (ia_addr_ptr -> t_bit)
		    *buff = *buff & (1 << 7);
		else
		    *buff = *buff & (0 << 7);
		buff++;
    
		//  PREFIX LENGTH
    		*buff = ia_addr_ptr->prefix_length;
		buff++;
    
    		// IPv6 ADDRESS
		for (i = 15; i >= 0; i--)
		{
	    	    *buff = ia_addr_ptr->addr[i];
	    	    buff++;
		}    

		// PREFERRED LIFETIME
		for (i = 3; i >= 0; i--)
		{
	    	    *buff = ia_addr_ptr->u_pref_lifetime.buffer[i];
	    	    buff++;
		}

		// VALID LIFETIME
		for (i = 3; i >= 0; i--)
		{
	    	    *buff = ia_addr_ptr->u_valid_lifetime.buffer[i];
	    	    buff++;
		}

    		// OPTIONS FIELD OF THE IA ADDRESS OPTION
		// Not considered yet

		// NEXT OPTION
		options_ptr = ia_addr_ptr->opt;
		break;
		
	    case OPTION_PREFERENCE :
		pref_ptr = (struct PREFERENCE *) options_ptr -> opt_data;
		
		// Preference value
		*buff = pref_ptr -> preference_value;
		buff++;
		
		// Next option
		options_ptr = pref_ptr -> opt;
		break;
		
	    case OPTION_STATUS_CODE :
		sc_ptr = (struct STATUS_CODE *) options_ptr -> opt_data;
		
		// Status code
		for (i = 1; i >= 0; i--)
		{
		    *buff = sc_ptr -> u_status_code.buffer[i];
		    buff++;
		}
		
		// Status message
		for (i = options_ptr -> u_opt_len.opt_len - 2; i >= 0; i--)
		{
		    *buff = sc_ptr -> message[i];
		    buff++;
		}

		// NEXT OPTION
		options_ptr = sc_ptr->opt;
		break;
	}
    }
	
    // RETURN THE TOTAL NUMBER OF BYTES
    return (abs (start-buff));
}

u_int8_t convert_character_to_hex (char ch)
{
    u_int8_t hex;
    
    if (ch >= '0' && ch <= '9')
    	hex = ch - '0';
    else