#include "kni_utils.h" #include #include int kni_stream_addr_trans(struct ipaddr* addr, char *output, int len){ char saddr[INET_ADDRSTRLEN]; inet_ntop(AF_INET, &(addr->v4->saddr), saddr, INET_ADDRSTRLEN); char daddr[INET_ADDRSTRLEN]; inet_ntop(AF_INET, &(addr->v4->daddr), daddr, INET_ADDRSTRLEN); snprintf(output, len, "%s:%d -> %s:%d", saddr, ntohs(addr->v4->source), daddr, ntohs(addr->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; }