tango-kni/common/src/kni_utils.cpp

#include "kni_utils.h"
#include <sys/ioctl.h>
#include <net/if.h>

int kni_stream_addr_trans(const struct layer_addr *addr, char *output, int len){
	char saddr[INET_ADDRSTRLEN];
	inet_ntop(AF_INET, &(addr->tuple4_v4->saddr), saddr, INET_ADDRSTRLEN);
	char daddr[INET_ADDRSTRLEN];
	inet_ntop(AF_INET, &(addr->tuple4_v4->daddr), daddr, INET_ADDRSTRLEN);
	snprintf(output, len, "%s:%d -> %s:%d", saddr, ntohs(addr->tuple4_v4->source), daddr, ntohs(addr->tuple4_v4->dest));
	return 0;
}

uint16_t kni_ip_checksum(const void *buf, size_t hdr_len){
	unsigned long sum = 0;
	const uint16_t *ip1; 
	ip1 = (const uint16_t *)buf;
	while(hdr_len > 1){
		sum += *ip1++;
		if(sum & 0x80000000){
			sum = (sum & 0xFFFF) + (sum >> 16);
		}
		hdr_len -= 2;
	}
	while(sum >> 16){
		sum = (sum & 0xFFFF) + (sum >> 16); 
	}
	return (~sum);
}

uint16_t kni_tcp_checksum(const void *_buf, size_t len, in_addr_t src_addr, in_addr_t dest_addr){
    const uint16_t *buf = (u_int16_t *)_buf;
	uint16_t *ip_src=(uint16_t *)&src_addr, *ip_dst=(uint16_t *)&dest_addr;
	uint32_t sum;
	size_t length=len;
	// Calculate the sum                                            
	sum = 0;
	while(len > 1){
		sum += *buf++;
		if (sum & 0x80000000){
			sum = (sum & 0xFFFF) + (sum >> 16);
		}
		len -= 2;
	}
	if(len & 1){
		// Add the padding if the packet lenght is odd          
		sum += *((uint8_t *)buf); 
	}
	// Add the pseudo-header                                        
	sum += *(ip_src++);
	sum += *ip_src;
	sum += *(ip_dst++);
	sum += *ip_dst;
	sum += htons(IPPROTO_TCP);
	sum += htons(length); 
	// Add the carries                                              
	while(sum >> 16){
		sum = (sum & 0xFFFF) + (sum >> 16);
	}
	// Return the one's complement of sum                           
	return ((uint16_t)(~sum));
}

uint16_t kni_udp_checksum(const void *_buf, size_t len, in_addr_t src_addr, in_addr_t dest_addr){
    const uint16_t *buf = (u_int16_t *)_buf;
	uint16_t *ip_src=(u_int16_t *)&src_addr, *ip_dst=(u_int16_t *)&dest_addr;
	uint32_t sum;
	size_t length=len;
	// Calculate the sum                                            
	sum = 0;
	while(len > 1){
		sum += *buf++;
		if (sum & 0x80000000){
			sum = (sum & 0xFFFF) + (sum >> 16);
		}
		len -= 2;
	}
	if(len & 1){
		// Add the padding if the packet lenght is odd          
		sum += *((uint8_t *)buf);
	}

	// Add the pseudo-header                                        
	sum += *(ip_src++);
	sum += *ip_src;
	sum += *(ip_dst++);
	sum += *ip_dst;
	sum += htons(IPPROTO_UDP);
	sum += htons(length);

	// Add the carries                                              
	while(sum >> 16){
		sum = (sum & 0xFFFF) + (sum >> 16);
	}
	// Return the one's complement of sum                           
	return ( (uint16_t)(~sum)  );
 }


struct kni_tcpopt_info* kni_get_tcpopt(struct tcphdr* tcphdr,int tcphdr_len){
    struct kni_tcpopt_info* tcpopt = (struct kni_tcpopt_info*)ALLOC(struct kni_tcpopt_info, 1);
	tcpopt->mss = KNI_DEFAULT_MSS;
	tcpopt->wscale = KNI_DEFAULT_WINSCLE;

	const unsigned char *ptr = ((const unsigned char*)tcphdr + 20);
	int length = tcphdr_len - 20;

	while (length > 0){
		int opcode = *ptr++;
		int opsize;
		switch (opcode){
            case TCPOPT_EOL:
                return tcpopt;
            case TCPOPT_NOP:	/* Ref: RFC 793 section 3.1 */
                length--;
                continue;
            default:
                opsize = *ptr++;
                if (opsize < 2) /* "silly options" */
                    return tcpopt;
                if (opsize > length)
                    return tcpopt;	/* don't parse partial options */
                switch (opcode){
                    case TCPOPT_MAXSEG:
                        if (opsize == TCPOLEN_MAXSEG){
                            uint16_t in_mss = *(uint16_t *)ptr;
                            if(in_mss){ 
                                tcpopt->mss = ntohs(in_mss);
                            }
                        }
                        break;
                        
                    case TCPOPT_WINDOW:
                        if (opsize == TCPOLEN_WINDOW){
                            uint8_t snd_wscale = *(uint8_t *)ptr;
                            // rfc7323 page9: Thus, the shift count MUST be limited to 14 (which allows windows of 2^30 = 1 GiB). 
                            // If a Window Scale option is received with a shift.cnt value larger than 14, 
                            // the TCP SHOULD log the error but MUST use 14 instead of the  specified value.  */
                            tcpopt->wscale = snd_wscale;
                            if(tcpopt->wscale > 14){
                                tcpopt->wscale = 14;
                            }
                            //*wscale_perm=1;
                        }
                        break;
                    case TCPOPT_TIMESTAMP:
                        if ((opsize == TCPOLEN_TIMESTAMP)){
                            tcpopt->ts = 1;
                        }
                        break;
                    case TCPOPT_SACK_PERMITTED:
                        if (opsize == TCPOLEN_SACK_PERMITTED){
                            tcpopt->sack = 1;
                        }
                        break;
                }
                ptr += opsize-2;
                length -= opsize;
        }
	}
	return tcpopt;
}


int kni_ipv4_addr_get_by_eth(const char *ifname, uint32_t *ip){
    struct ifreq ifr;
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if(sockfd == -1) {
        goto error_out;
    }
    strcpy(ifr.ifr_name, ifname);
    if(ioctl(sockfd, SIOCGIFADDR, &ifr) < 0){
        goto error_out;
    }
    *ip = ((struct sockaddr_in*)&(ifr.ifr_addr))->sin_addr.s_addr;
    close(sockfd);
    return 0;

error_out:
    close(sockfd);
    return -1;
}

static int __wrapper_MESA_htable_set_opt(MESA_htable_handle table, enum MESA_htable_opt opt_type, unsigned value, void *logger, const char *symbol)
{
	int ret = MESA_htable_set_opt(table, opt_type, &value, (int)(sizeof(value)));
	if(unlikely(ret != 0))
    {
		KNI_LOG_ERROR(logger, "Failed at MESA_htable_set_opt, htable is %s, opt_type is %d", symbol, opt_type);
    }
	return ret;
}

static int __wrapper_MESA_htable_set_opt(MESA_htable_handle table, enum MESA_htable_opt opt_type, void * val, size_t len, void *logger, const char *symbol)
{
	int ret = MESA_htable_set_opt(table, opt_type, val, (int)len);
	if(unlikely(ret != 0))
    {
		KNI_LOG_ERROR(logger, "Failed at MESA_htable_set_opt, htable is %s, opt_type is %d", symbol, opt_type);
    }
	return ret;
}

MESA_htable_handle kni_create_htable(const char *profile, const char *section, void *free_data_cb, void *expire_notify_cb, void *logger)
{
    int mho_screen_print_ctrl;
    int mho_thread_safe;
    int mho_mutex_num;
    int mho_hash_slot_size;
	int mho_hash_max_element_num;
    int mho_expire_time;
	char mho_eliminate_type[KNI_SYMBOL_MAX];
	MESA_load_profile_int_def(profile, section, "mho_screen_print_ctrl", &mho_screen_print_ctrl, 1);
    MESA_load_profile_int_def(profile, section, "mho_thread_safe", &mho_thread_safe, 0);
    MESA_load_profile_int_def(profile, section, "mho_mutex_num", &mho_mutex_num, 12);
    MESA_load_profile_int_def(profile, section, "mho_hash_slot_size", &mho_hash_slot_size, 1234);
	MESA_load_profile_int_def(profile, section, "mho_hash_max_element_num", &mho_hash_max_element_num, 12345);
    MESA_load_profile_int_def(profile, section, "mho_expire_time", &mho_expire_time, 3600);
	MESA_load_profile_string_def(profile, section, "mho_eliminate_type", mho_eliminate_type, sizeof(mho_eliminate_type), "FIFO");
	KNI_LOG_INFO(logger, "MESA_prof_load, [%s]:\n mho_screen_print_ctrl: %d\n mho_thread_safe: %d\n mho_mutex_num: %d\n"
		"mho_hash_slot_size: %d\n mho_hash_max_element_num: %d\n mho_expire_time: %d\n mho_eliminate_type: %s\n", section,
		mho_screen_print_ctrl, mho_thread_safe, mho_mutex_num, mho_hash_slot_size, mho_hash_max_element_num, mho_expire_time, mho_eliminate_type);
	MESA_htable_handle htable = MESA_htable_born();
	if(htable == NULL)
	{
		KNI_LOG_ERROR(logger, "MESA_htable: failed at MESA_htable_born");
		return NULL;
	}
	__wrapper_MESA_htable_set_opt(htable, MHO_SCREEN_PRINT_CTRL, mho_screen_print_ctrl, logger, section);
	__wrapper_MESA_htable_set_opt(htable, MHO_THREAD_SAFE, mho_thread_safe, logger, section);
	__wrapper_MESA_htable_set_opt(htable, MHO_MUTEX_NUM, mho_mutex_num, logger, section);
	__wrapper_MESA_htable_set_opt(htable, MHO_HASH_SLOT_SIZE, mho_hash_slot_size, logger, section);
	__wrapper_MESA_htable_set_opt(htable, MHO_HASH_MAX_ELEMENT_NUM, mho_hash_max_element_num, logger, section);
	__wrapper_MESA_htable_set_opt(htable, MHO_EXPIRE_TIME, mho_expire_time, logger, section);
	if(strncmp(mho_eliminate_type, "LRU", KNI_SYMBOL_MAX) == 0)
	{
		__wrapper_MESA_htable_set_opt(htable, MHO_ELIMIMINATE_TYPE, HASH_ELIMINATE_ALGO_LRU, logger, section);
	}
	else
	{
		__wrapper_MESA_htable_set_opt(htable, MHO_ELIMIMINATE_TYPE, HASH_ELIMINATE_ALGO_FIFO, logger, section);
	}
	if(free_data_cb != NULL){
	 	__wrapper_MESA_htable_set_opt(htable, MHO_CBFUN_DATA_FREE,
	    	(void *)free_data_cb, sizeof(free_data_cb), logger, section);
	}
	if(expire_notify_cb != NULL){
		__wrapper_MESA_htable_set_opt(htable, MHO_CBFUN_DATA_EXPIRE_NOTIFY,
		(void *)expire_notify_cb, sizeof(free_data_cb), logger, section);
	}
	int ret = MESA_htable_mature(htable);
	if(unlikely(ret != 0))
    {
		KNI_LOG_ERROR(logger, "MESA_htable: failed at MESA_htable_mature, htable is %s", section);
		return NULL;
    }
	return htable;
}