clilib.c

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

	    	msg_arr_ptr= (struct DHCP_MESSAGE **) realloc (msg_arr_ptr, sizeof (struct DHCP_MESSAGE *) * (*msg_count));
		p = msg_arr_ptr + (*msg_count) - 1;
		*p = dhcp_message_ptr;
		
		printf ("Message valid.\n");
		write_to_log ("Message is valid", 1);
		// If state is not selecting then break on receiving a valid server reply
		// Else wait for more replies according to the retransmission scheme
		if (g_state != SELECTING)
		    break;
		if (count > 0)
		    break;
	     }
	    else 
	    {
		printf ("\n\t\tMessage invalid.\n");
		print_linked_list_contents (dhcp_message_ptr);
	        free_message_mem (dhcp_message_ptr);
		write_to_log ("Message is invalid. Discarding message", 1);
            }	
	}
    }
    return msg_arr_ptr;    
}

u_int8_t convert_character_to_hex (char ch)
{
    u_int8_t hex;
    
    if (ch >= '0' && ch <= '9')
    	hex = ch - '0';
    else
    {
        switch (ch)
        {
    	    case 'A' :
	    case 'a' :
		hex = 10;
		break;
		    
	    case 'B' :
	    case 'b' :
		hex = 11;
		break;
		    
	    case 'C' :
	    case 'c' :
		hex = 12;
		break;
		    
	    case 'D' :
	    case 'd' :
		hex = 13;
		break;
		    
	    case 'E' :
	    case 'e' :
		hex = 14;
		break;
		    
	    case 'F' :
	    case 'f' :
		hex = 15;
		break;
	}
    }
    
    return hex;
}

void generate_trans_id (u_int32_t *trans_id)
{
    extern u_int32_t g_trans_id;
    time_t t;
    srand (time (&t));
    *trans_id = 0;
    *trans_id = rand();
    // Make the upper byte of transaction id equal to zero
    *trans_id &= 0x00ffffff;
    g_trans_id = *trans_id;
}

/* 
    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 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 != 0)
    {
	// 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_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));
}

void read_option (char *m, int index, int len, struct OPTIONS *opt)
{
    int i, temp;
    struct DUID *d;
    struct DUID1 *d1;
    struct DUID2 *d2;
    struct DUID3 *d3;
    struct IA *ia;
    struct IA_ADDRESS *ia_addr;
    struct OPTIONS *next_opt;
    struct STATUS_CODE *sc_ptr;    
    struct PREFERENCE * preference_ptr;
    u_int8_t *l_ptr;
    union
    {
	char buffer[2];
	u_int16_t type_of_duid;
    } u_type_of_duid;
    
    for (i = 1; i >= 0; i--)
	opt -> u_opt_code.buffer[i] = m[index++];
	
    for (i = 1; i >= 0; i--)
      opt -> u_opt_len.buffer[i] = m[index++];

    switch (opt -> u_opt_code.opt_code)
    {
	case OPTION_CLIENTID :
        case OPTION_SERVERID :
	    d = (struct DUID *) malloc (sizeof (struct DUID));
	    opt -> opt_data = d;
	    
	    for (i = 1; i >= 0; i--)
		u_type_of_duid.buffer[i] = m[index++];

	    switch (u_type_of_duid.type_of_duid)
	    {
		case 1 :
		    d1 = (struct DUID1 *) malloc (sizeof (struct DUID1));
		    d -> u_duid_type.duid_type = 1;
		    
		    for (i = 1; i >= 0; i--)
			d1 -> u_haddr_type.buffer[i] = m[index++];
		    for (i = 3; i >= 0; i--)
			d1 -> u_time.buffer[i] = m[index++];

		    // DUID Type = 2 octets
		    // Hardware type field = 2 octets
		    // Time field = 4 octets
		    d1 -> haddr_len = opt -> u_opt_len.opt_len - 2 - 2 - 4;
		    d1 -> link_layer_address = (u_int8_t *) malloc (sizeof (u_int8_t) * d1->haddr_len);
		    for (i = d1 -> haddr_len; i >= 0; i--)
	                d1 -> link_layer_address[i] = m[index++];
		    d -> duid_type = d1;
		    break;
		    
		case 2 :
		    d2 = (struct DUID2 *) malloc (sizeof (struct DUID2));
		    d -> u_duid_type.duid_type = 2;
		    
		    for (i = 1; i >= 0; i--)
			d2 -> u_identifier_length.buffer[i] = m[index++];

		    d2 -> identifier = (u_int8_t *) malloc (sizeof (u_int8_t) * d2 -> u_identifier_length.identifier_length);
		    for (i = d2 -> u_identifier_length.identifier_length; i >= 0; i--)
	                d2 -> identifier[i] = m[index++];
		    
		    // DUID Type = 2 octets
		    // Identifier length field = 2 octets
		    temp = opt -> u_opt_len.opt_len - 2 - 2 - d2 -> u_identifier_length.identifier_length;
		    d2 -> domain_name = (u_char *) malloc (sizeof (char) * temp);
		    for (i = temp; i >= 0; i--)
	                d2 -> domain_name[i] = m[index++];
		    d2 -> domain_name_len = temp;
		    d -> duid_type = d2;
		    break;

		case 3 :
		    d3 = (struct DUID3 *) malloc (sizeof (struct DUID3));
		    d -> u_duid_type.duid_type = 3;
		    
		    for (i = 1; i >= 0; i--)
			d3 -> u_haddr_type.buffer[i] = m[index++];

		    // DUID Type = 2 octets
		    // Hardware type field = 2 octets
		    d3 -> haddr_len = opt -> u_opt_len.opt_len - 2 - 2;
		    d3->link_layer_address = (u_int8_t *) malloc (sizeof (u_int8_t) * d3->haddr_len);
		    for (i = d3 -> haddr_len; i >= 0; i--)
	                d3 -> link_layer_address[i] = m[index++];
		    d -> duid_type = d3;
		    break;

		default :
#if DEBUG == 3
		    printf ("Unrecognized DUID type\n");
#endif
	    }

	    next_opt = (struct OPTIONS *) malloc (sizeof (struct OPTIONS));
	    if (index == len)
		d -> opt = 0;
	    else
	    {
		read_option (m, index, len, next_opt);
		d -> opt = next_opt;
	    }
	    break;
	    
	case OPTION_IA :
	    ia = (struct IA *) malloc (sizeof (struct IA));
	    opt -> opt_data = ia;
	    
	    for (i = 3; i >= 0; i--)
		ia -> u_iaid.buffer[i] = m[index++];
	    for (i = 3; i >= 0; i--)
		ia -> u_t1.buffer[i] = m[index++];
	    for (i = 3; i >= 0; i--)
		ia -> u_t2.buffer[i] = m[index++];
	    ia -> status = m[index++];
	    next_opt = (struct OPTIONS *) malloc (sizeof (struct OPTIONS));
	    read_option (m, index, len, next_opt);
	    ia -> opt = next_opt;
	    break;
	    
	case OPTION_IAADDR :
	    ia_addr = (struct IA_ADDRESS *) malloc (sizeof (struct IA_ADDRESS));
	    opt -> opt_data = ia_addr;
	    temp = m[index++];
	    if (temp / 128)
		ia_addr -> t_bit = 1;
	    else
		ia_addr -> t_bit = 0;
		
	    ia_addr -> addr_status = temp % 128;
	    ia_addr -> prefix_length = m[index++];
	    for (i = 15; i >= 0; i--)
		ia_addr -> addr[i] = m[index++];
	    for (i = 3; i >= 0; i--)
		ia_addr -> u_pref_lifetime.buffer[i] = m[index++];
	    for (i = 3; i >= 0; i--)
		ia_addr -> u_valid_lifetime.buffer[i] = m[index++];
		
	    ia_addr -> ia_addr_opt = 0;
	    next_opt = (struct OPTIONS *) malloc (sizeof (struct OPTIONS));
	    if (index == len)
		ia_addr -> opt = 0;
	    else
	    {
		read_option (m, index, len, next_opt);
		ia_addr -> opt = next_opt;
	    }
	    break;

        case OPTION_STATUS_CODE :
    	    sc_ptr = (struct STATUS_CODE *) malloc (sizeof (struct STATUS_CODE));
	    opt -> opt_data = sc_ptr;
	    for (i = 1; i >= 0; i--)
	        sc_ptr -> u_status_code.buffer[i] = m[index++];
	    sc_ptr -> message = (char *) malloc (sizeof (char) * (opt -> u_opt_len.opt_len -2));
	    for (i = opt -> u_opt_len.opt_len - 2; i >= 0; i--)
	        sc_ptr -> message[i] = m[index++];
	    
	    next_opt = (struct OPTIONS *) malloc (sizeof (struct OPTIONS));
	    if (index == len)
	        sc_ptr -> opt = 0;
	    else
	    {
	        read_option (m, index, len, next_opt);
	        sc_ptr -> opt = next_opt;