520 lines
23 KiB
C++
520 lines
23 KiB
C++
#include "kni_utils.h"
|
||
#include "ssl_utils.h"
|
||
#include "kni_entry.h"
|
||
#include "marsio.h"
|
||
#include "kni_maat.h"
|
||
#include "MESA/http.h"
|
||
|
||
extern int g_iThreadNum;
|
||
|
||
//APP_STATE_DROPME/GIVEME: 当前tcp会话的剩下包是否回调
|
||
//APP_STATE_FAWPKT/DROPPKT: 当前包是否丢弃or转发，如果是丢弃，当前包不会给后面的插件
|
||
//PROT_STATE_GIVEME/DROPME: 当前http会话的剩下包是否回调
|
||
|
||
|
||
//TODO: seq, ack 是当拿到client hello时传给秋秋，取client hello的 seq, ack, 时间戳和sack没有解, 不用解，只需要知道enable/disable即可
|
||
//TODO: 注意内存泄漏，ALLOC对应的FREE, 还有calloc
|
||
//TOOD: 函数加static
|
||
//TODO: 统计syn/syn/ack个数，流个数， pending not syn个数, not syn/ack个数, 单向流数量, 发往tfe的包数，流数，收到的包数，流数
|
||
|
||
//多个tcpall插件，APP_STATE_DROPPKT, APP_STATE_FAWPKT? 有一个droppkt，就不给后面的插件了
|
||
//一个tcp流中有多个http，ssl会话的情况，只扫描第一个
|
||
|
||
|
||
struct kni_handle *g_kni_handle = NULL;
|
||
struct kni_field_stat_handle *g_kni_fs_handle = NULL;
|
||
|
||
//int g_http_project_id;
|
||
//struct kni_marsio_handle *g_kni_marsio_handle;
|
||
//g_iThreadNum 为sapp线程数
|
||
|
||
static struct pme_info* pme_info_new(){
|
||
struct pme_info* pmeinfo = ALLOC(struct pme_info, 1);
|
||
return pmeinfo;
|
||
}
|
||
|
||
static void pme_info_destroy(struct pme_info *pmeinfo){
|
||
if(pmeinfo != NULL){
|
||
if(pmeinfo->client_tcpopt != NULL){
|
||
FREE(&(pmeinfo->client_tcpopt));
|
||
}
|
||
if(pmeinfo->server_tcpopt != NULL){
|
||
FREE(&(pmeinfo->server_tcpopt));
|
||
}
|
||
FREE(&pmeinfo);
|
||
}
|
||
}
|
||
|
||
static int protocol_identify(const struct streaminfo* stream, char *buf, int len, struct protocol_identify_result *result){
|
||
//判断是http
|
||
struct http_project* project = (struct http_project*)project_req_get_struct(stream, g_kni_handle->http_project_id);
|
||
if(project != NULL){
|
||
result->protocol = KNI_PROTOCOL_HTTP;
|
||
result->domain_len = project->host_len;
|
||
memcpy(result->domain, project->host, result->domain_len);
|
||
return 0;
|
||
}
|
||
|
||
//判断是ssl
|
||
enum chello_parse_result chello_status = CHELLO_PARSE_INVALID_FORMAT;
|
||
struct ssl_chello *chello = NULL;
|
||
chello = ssl_chello_parse((const unsigned char*)buf, len, &chello_status);
|
||
if(chello_status == CHELLO_PARSE_SUCCESS){
|
||
result->protocol = KNI_PROTOCOL_SSL;
|
||
result->domain_len = strnlen(chello->sni, KNI_DOMAIN_MAX);
|
||
memcpy(result->domain, chello->sni, result->domain_len);
|
||
ssl_chello_free(chello);
|
||
return 0;
|
||
}
|
||
|
||
ssl_chello_free(chello);
|
||
result->protocol = KNI_PROTOCOL_UNKNOWN;
|
||
return 0;
|
||
}
|
||
|
||
static int tcp_restore_info_tlv_add(uint16_t type, uint16_t value_len, uint32_t value, char *header, int *offset, int *nr_tlvs){
|
||
int tlv_len = sizeof(tcp_restore_info_tlv) + value_len;
|
||
struct tcp_restore_info_tlv *tlv_info = (struct tcp_restore_info_tlv*)calloc(tlv_len, 1);
|
||
tlv_info->type= htons(type);
|
||
tlv_info->length = htons(tlv_len);
|
||
if(value_len == 1){
|
||
tlv_info->value_as_uint8[0] = value;
|
||
}
|
||
if(value_len == 2){
|
||
tlv_info->value_as_uint16[0] = value;
|
||
}
|
||
if(value_len == 4){
|
||
tlv_info->value_as_uint32[0] = value;
|
||
}
|
||
memcpy(header + *offset, tlv_info, tlv_len);
|
||
*offset += tlv_len;
|
||
(*nr_tlvs)++;
|
||
free(tlv_info);
|
||
return 0;
|
||
}
|
||
|
||
static struct tcp_restore_info_header* tcp_restore_info_header_new(struct pme_info *pmeinfo, struct pkt_info *pktinfo, int *len){
|
||
struct tcp_restore_info_header *header = (struct tcp_restore_info_header*)calloc(TCP_RESTORE_HEADER_MAX, 1);
|
||
int offset = sizeof(struct tcp_restore_info_header);
|
||
int nr_tlvs = 0;
|
||
tcp_restore_info_tlv_add(TCP_RESTORE_INFO_TLV_SEQ, 4, pktinfo->tcphdr->seq, (char*)header, &offset, &nr_tlvs);
|
||
tcp_restore_info_tlv_add(TCP_RESTORE_INFO_TLV_ACK, 4, pktinfo->tcphdr->ack_seq, (char*)header, &offset, &nr_tlvs);
|
||
tcp_restore_info_tlv_add(TCP_RESTORE_INFO_TLV_MSS_CLIENT, 2, htons(pmeinfo->client_tcpopt->mss), (char*)header, &offset, &nr_tlvs);
|
||
tcp_restore_info_tlv_add(TCP_RESTORE_INFO_TLV_MSS_SERVER, 2, htons(pmeinfo->server_tcpopt->mss), (char*)header, &offset, &nr_tlvs);
|
||
tcp_restore_info_tlv_add(TCP_RESTORE_INFO_TLV_WSACLE_CLIENT, 1, pmeinfo->client_tcpopt->wscale, (char*)header, &offset, &nr_tlvs);
|
||
tcp_restore_info_tlv_add(TCP_RESTORE_INFO_TLV_WSACLE_SERVER, 1, pmeinfo->server_tcpopt->wscale, (char*)header, &offset, &nr_tlvs);
|
||
tcp_restore_info_tlv_add(TCP_RESTORE_INFO_TLV_SACK_CLIENT, 1, pmeinfo->client_tcpopt->sack, (char*)header, &offset, &nr_tlvs);
|
||
tcp_restore_info_tlv_add(TCP_RESTORE_INFO_TLV_SACK_SERVER, 1, pmeinfo->server_tcpopt->sack, (char*)header, &offset, &nr_tlvs);
|
||
tcp_restore_info_tlv_add(TCP_RESTORE_INFO_TLV_TS_CLIENT, 1, pmeinfo->client_tcpopt->ts, (char*)header, &offset, &nr_tlvs);
|
||
tcp_restore_info_tlv_add(TCP_RESTORE_INFO_TLV_TS_SERVER, 1, pmeinfo->server_tcpopt->ts, (char*)header, &offset, &nr_tlvs);
|
||
header->__magic__[0] = 0x4d;
|
||
header->__magic__[1] = 0x5a;
|
||
header->nr_tlvs = htons(nr_tlvs);
|
||
*len = offset;
|
||
return header;
|
||
}
|
||
|
||
static char* tcp_restore_info_header_add(struct pme_info *pmeinfo, struct pkt_info *pktinfo, int *len){
|
||
//tcp option: kind 88, len 4, control_info_len
|
||
char *new_pkt = (char*)ALLOC(struct wrapped_packet, 1);
|
||
struct iphdr *iphdr = (struct iphdr*)new_pkt;
|
||
int offset = 0;
|
||
//iphdr
|
||
memcpy(new_pkt, (void*)pktinfo->iphdr, pktinfo->iphdr_len);
|
||
offset += pktinfo->iphdr_len;
|
||
//tcphdr
|
||
struct tcphdr *tcphdr = (struct tcphdr*)(new_pkt + offset);
|
||
memcpy(new_pkt + offset, (void*)pktinfo->tcphdr, 20);
|
||
offset += 20;
|
||
tcphdr->doff = pktinfo->tcphdr->doff + 1;
|
||
struct tcp_option_restore *opt = ALLOC(struct tcp_option_restore, 1);
|
||
opt->kind = 88;
|
||
opt->len = 4;
|
||
opt->offset = htons(pktinfo->data_len);
|
||
memcpy(new_pkt + offset, (void*)opt, 4);
|
||
offset += 4;
|
||
memcpy(new_pkt + offset, (void*)((char*)pktinfo->tcphdr + 20), pktinfo->tcphdr_len - 20);
|
||
offset += pktinfo->tcphdr_len - 20;
|
||
//data
|
||
memcpy(new_pkt + offset, (void*)pktinfo->data, pktinfo->data_len);
|
||
offset += pktinfo->data_len;
|
||
//tcp_restore_info_header
|
||
int header_len = 0;
|
||
struct tcp_restore_info_header* header = tcp_restore_info_header_new(pmeinfo, pktinfo, &header_len);
|
||
memcpy(new_pkt + offset, (void*)header, header_len);
|
||
offset += header_len;
|
||
free(header);
|
||
//iphdr: tot_len
|
||
iphdr->tot_len = htons(offset);
|
||
//iphdr: checksum
|
||
//计算校验和之前一定要先置0
|
||
iphdr->check = 0;
|
||
iphdr->check = kni_ip_checksum((void*)iphdr, pktinfo->iphdr_len);
|
||
//tcphdr: checkdum
|
||
tcphdr->check = 0;
|
||
tcphdr->check = kni_tcp_checksum((void*)tcphdr, offset - pktinfo->iphdr_len, iphdr->saddr, iphdr->daddr);
|
||
*len = offset;
|
||
return new_pkt;
|
||
}
|
||
|
||
static int send_to_tfe(struct kni_marsio_handle *handle, char *raw_data, int raw_len, int thread_seq){
|
||
void *logger = g_kni_handle->logger;
|
||
KNI_LOG_DEBUG(logger, "send packet to tfe");
|
||
marsio_buff_t *tx_buffs[BURST_MAX];
|
||
unsigned int ret = 1;
|
||
//TODO: marsio配置文件: 2500
|
||
int alloc_ret = marsio_buff_malloc_device(handle->dev_handler, tx_buffs, ret, 0, thread_seq);
|
||
if (alloc_ret < 0){
|
||
KNI_LOG_ERROR(logger, "Failed at alloc marsio buffer, ret is %d, thread_seq is %d", ret, thread_seq);
|
||
return -1;
|
||
}
|
||
void * dst_data = marsio_buff_append(tx_buffs[0], raw_len + 14);
|
||
unsigned char ethernet_header[14] = {0xfe, 0x65, 0xb7, 0x03, 0x50, 0xbd, 0xe8, 0x61, 0x1f, 0x13, 0x70, 0x7a, 0x08, 0x00};
|
||
memcpy(dst_data, ethernet_header, 14);
|
||
memcpy((char*)dst_data + 14, raw_data, raw_len);
|
||
marsio_send_burst(handle->dev_sendpath, thread_seq, tx_buffs, ret);
|
||
return 0;
|
||
}
|
||
|
||
static char pending_opstate(const struct streaminfo *stream, struct pme_info *pmeinfo, struct pkt_info *pktinfo){
|
||
void *logger = g_kni_handle->logger;
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_TOT_STM], 0, FS_OP_ADD, 1);
|
||
if(!pktinfo->tcphdr->syn){
|
||
//TODO: pending_opstate 不是syn, bypass这个流
|
||
KNI_LOG_ERROR(logger, "pending opstate: not syn");
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_NO_SYN_EXP], 0, FS_OP_ADD, 1);
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_BYP_PKT], 0, FS_OP_ADD, 1);
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_BYP_STM], 0, FS_OP_ADD, 1);
|
||
return APP_STATE_FAWPKT | APP_STATE_DROPME;
|
||
}
|
||
pmeinfo->client_tcpopt = kni_get_tcpopt(pktinfo->tcphdr, pktinfo->tcphdr_len);
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_BYP_PKT], 0, FS_OP_ADD, 1);
|
||
return APP_STATE_FAWPKT | APP_STATE_GIVEME;
|
||
}
|
||
|
||
static int get_action(struct ipaddr *addr, char *domain, int domain_len, int thread_seq){
|
||
//return KNI_ACTION_INTERCEPT;
|
||
int action = kni_maat_scan_ip(g_kni_handle->maat_handle, addr, thread_seq, g_kni_handle->logger);
|
||
if(action == KNI_ACTION_BYPASS){
|
||
return action;
|
||
}
|
||
action = kni_maat_scan_domain(g_kni_handle->maat_handle, domain, domain_len, thread_seq, g_kni_handle->logger);
|
||
return action;
|
||
}
|
||
|
||
//TODO: 这一块逻辑需要和洋姐和秋秋讨论一下
|
||
static char data_opstate(const struct streaminfo *stream, struct pme_info *pmeinfo, struct pkt_info *pktinfo, int thread_seq){
|
||
void *logger = g_kni_handle->logger;
|
||
char *buf = (char*)pktinfo->iphdr;
|
||
int len = pktinfo->ip_totlen;
|
||
//action取值只能为 KNI_ACTION_INTERCEPT, KNI_ACTION_UNKNOWN, 因为判断是KNI_ACTION_BYPASS之后直接返回 APP_STATE_DROPME了
|
||
if(pmeinfo->action == KNI_ACTION_INTERCEPT){
|
||
send_to_tfe(g_kni_handle->marsio_handle, buf, len, thread_seq);
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_INTCP_PKT], 0, FS_OP_ADD, 1);
|
||
return APP_STATE_DROPPKT | APP_STATE_GIVEME;
|
||
}
|
||
//TODO: client hello如果跨包怎么办？client hello后面一个包先到，这个包该丢掉还是bypass
|
||
//此时 action = KNI_ACTION_UNKNOWN, 说明还没收到第一个数据包
|
||
// syn/ack包
|
||
if(pktinfo->tcphdr->syn && pktinfo->tcphdr->ack){
|
||
pmeinfo->server_tcpopt = kni_get_tcpopt(pktinfo->tcphdr, pktinfo->tcphdr_len);
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_BYP_PKT], 0, FS_OP_ADD, 1);
|
||
return APP_STATE_FAWPKT | APP_STATE_GIVEME;
|
||
}
|
||
if(pktinfo->data_len <= 0){
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_BYP_PKT], 0, FS_OP_ADD, 1);
|
||
return APP_STATE_FAWPKT | APP_STATE_GIVEME;
|
||
}
|
||
//第一个数据包: 如果从第一个数据包判断不出协议，直接返回，后续包也不要了
|
||
//单向流, 直接bypass
|
||
if(stream->dir != DIR_DOUBLE){
|
||
KNI_LOG_INFO(logger, "stream dir is %d, bypass", stream->dir);
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_BYP_PKT], 0, FS_OP_ADD, 1);
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_BYP_STM], 0, FS_OP_ADD, 1);
|
||
return APP_STATE_FAWPKT | APP_STATE_DROPME;
|
||
}
|
||
struct protocol_identify_result *result = ALLOC(struct protocol_identify_result, 1);
|
||
protocol_identify(stream, pktinfo->data, pktinfo->data_len, result);
|
||
pmeinfo->protocol = result->protocol;
|
||
if(pmeinfo->protocol == KNI_PROTOCOL_UNKNOWN){
|
||
KNI_LOG_INFO(logger, "Failed at protocol_identify, protocol is %d\n", pmeinfo->protocol);
|
||
FREE(&result);
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_BYP_PKT], 0, FS_OP_ADD, 1);
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_BYP_STM], 0, FS_OP_ADD, 1);
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_UNKNOWN_STM], 0, FS_OP_ADD, 1);
|
||
return APP_STATE_FAWPKT | APP_STATE_DROPME;
|
||
}
|
||
//protocol = KNI_PROTOCOL_SSL/KNI_PROTOCOL_HTTP, 判断action, action返回值: KNI_ACTION_INTERCEPT/KNI_ACTION_BYPASS
|
||
if(pmeinfo->protocol == KNI_PROTOCOL_SSL){
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_SSL_STM], 0, FS_OP_ADD, 1);
|
||
}
|
||
if(pmeinfo->protocol == KNI_PROTOCOL_HTTP){
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_HTTP_STM], 0, FS_OP_ADD, 1);
|
||
}
|
||
pmeinfo->action = get_action((struct ipaddr*)(&stream->addr), result->domain, result->domain_len, thread_seq);
|
||
FREE(&result);
|
||
if(pmeinfo->action == KNI_ACTION_BYPASS){
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_BYP_PKT], 0, FS_OP_ADD, 1);
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_BYP_STM], 0, FS_OP_ADD, 1);
|
||
return APP_STATE_FAWPKT | APP_STATE_DROPME;
|
||
}
|
||
//TODO: 这块比较奇怪, 收到client hello, 但是没有syn/ack包, 直接bypass了
|
||
if(pmeinfo->client_tcpopt == NULL || pmeinfo->server_tcpopt == NULL){
|
||
KNI_LOG_ERROR(logger, "Failed at intercept, %s, %s", pmeinfo->client_tcpopt == NULL ? "no syn" : "",
|
||
pmeinfo->server_tcpopt == NULL ? "no syn/ack" : "");
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_NO_SA_EXP], 0, FS_OP_ADD, 1);
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_BYP_PKT], 0, FS_OP_ADD, 1);
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_BYP_STM], 0, FS_OP_ADD, 1);
|
||
return APP_STATE_FAWPKT | APP_STATE_DROPME;
|
||
}
|
||
//action = KNI_ACTION_INTERCEPT, 带上控制信息发送给qq, 要修改ip, tcp的校验和
|
||
buf = tcp_restore_info_header_add(pmeinfo, pktinfo, &len);
|
||
send_to_tfe(g_kni_handle->marsio_handle, buf, len, thread_seq);
|
||
FREE(&buf);
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_INTCP_PKT], 0, FS_OP_ADD, 1);
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_INTCP_STM], 0, FS_OP_ADD, 1);
|
||
return APP_STATE_DROPPKT | APP_STATE_GIVEME;
|
||
}
|
||
|
||
static char close_opstate(){
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_BYP_PKT], 0, FS_OP_ADD, 1);
|
||
return APP_STATE_FAWPKT | APP_STATE_DROPME;
|
||
}
|
||
|
||
//从syn包开始回调
|
||
extern "C" char kni_tcpall_entry(const struct streaminfo* stream, void** pme, int thread_seq, const void* a_packet){
|
||
void *logger = g_kni_handle->logger;
|
||
//KNI_LOG_DEBUG(logger, "call kni_tcpall_entry");
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_TOT_PKT], 0, FS_OP_ADD, 1);
|
||
//当前包bypass, 剩下包bypass
|
||
//TODO: ipv6暂时不处理, ipv6: 通过nexthdr链式寻找tcp头(IPPROTO_TCP)
|
||
if(stream->addr.addrtype == ADDR_TYPE_IPV6){
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_IPV6_PKT], 0, FS_OP_ADD, 1);
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_BYP_PKT], 0, FS_OP_ADD, 1);
|
||
return APP_STATE_FAWPKT | APP_STATE_DROPME;
|
||
}
|
||
//a_packet == NULL, 不处理这个包
|
||
if(a_packet == NULL){
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_NULL_PKT], 0, FS_OP_ADD, 1);
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_BYP_PKT], 0, FS_OP_ADD, 1);
|
||
return APP_STATE_FAWPKT | APP_STATE_GIVEME;
|
||
}
|
||
struct pme_info *pmeinfo = *(struct pme_info **)pme;
|
||
//pktinfo
|
||
struct pkt_info *pktinfo = (struct pkt_info*)ALLOC(struct pkt_info, 1);
|
||
pktinfo->iphdr = (struct iphdr*)a_packet;
|
||
pktinfo->iphdr_len = pktinfo->iphdr->ihl * 4;
|
||
pktinfo->ip_totlen = ntohs(pktinfo->iphdr->tot_len);
|
||
pktinfo->tcphdr = (struct tcphdr*)((char*)pktinfo->iphdr + pktinfo->iphdr_len);
|
||
pktinfo->tcphdr_len = pktinfo->tcphdr->doff * 4;
|
||
pktinfo->data = (char*)pktinfo->tcphdr + pktinfo->tcphdr_len;
|
||
pktinfo->data_len = pktinfo->ip_totlen - pktinfo->iphdr_len - pktinfo->tcphdr_len;
|
||
int ret;
|
||
switch(stream->pktstate){
|
||
case OP_STATE_PENDING:
|
||
*pme = pmeinfo = pme_info_new();
|
||
ret = pending_opstate(stream, pmeinfo, pktinfo);
|
||
break;
|
||
case OP_STATE_DATA:
|
||
ret = data_opstate(stream, pmeinfo, pktinfo, thread_seq);
|
||
break;
|
||
case OP_STATE_CLOSE:
|
||
ret = close_opstate();
|
||
break;
|
||
default:
|
||
ret = APP_STATE_FAWPKT | APP_STATE_GIVEME;
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_BYP_PKT], 0, FS_OP_ADD, 1);
|
||
FS_operate(g_kni_fs_handle->handle, g_kni_fs_handle->fields[KNI_FIELD_UNKNOWN_STATE_EXP], 0, FS_OP_ADD, 1);
|
||
KNI_LOG_ERROR(logger, "Unknown stream opstate %d", stream->pktstate);
|
||
break;
|
||
}
|
||
FREE(&pktinfo);
|
||
if((ret & APP_STATE_DROPME)){
|
||
pme_info_destroy(pmeinfo);
|
||
*pme = NULL;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
void http_project_free(int thread_seq, void *project_req_value){
|
||
FREE(&project_req_value);
|
||
}
|
||
|
||
static int http_project_init(){
|
||
void *logger = g_kni_handle->logger;
|
||
int id = project_producer_register(HTTP_PROJECT_NAME, PROJECT_VAL_TYPE_STRUCT, http_project_free);
|
||
if(id < 0){
|
||
KNI_LOG_ERROR(logger, "Failed at project_producer_register, project name is %s, ret is %d", HTTP_PROJECT_NAME, id);
|
||
return -1;
|
||
}
|
||
id = project_customer_register(HTTP_PROJECT_NAME, PROJECT_VAL_TYPE_STRUCT);
|
||
if(id < 0){
|
||
KNI_LOG_ERROR(logger, "Failed at project_customer_register, project name is %s, ret is %d", HTTP_PROJECT_NAME, id);
|
||
return -1;
|
||
}
|
||
return id;
|
||
}
|
||
|
||
extern "C" char kni_http_entry(stSessionInfo* session_info, void **pme, int thread_seq, struct streaminfo *a_stream, const void *a_packet){
|
||
http_infor* http_info = (http_infor*)(session_info->app_info);
|
||
//http_session_seq = 1表示只处理tcp链接中的第一个http会话
|
||
if(http_info->http_session_seq != 1){
|
||
return PROT_STATE_DROPME;
|
||
}
|
||
if(session_info->prot_flag != HTTP_HOST){
|
||
return PROT_STATE_GIVEME;
|
||
}
|
||
int host_len = MIN(session_info->buflen, KNI_DEFAULT_MTU);
|
||
struct http_project* host_info = ALLOC(struct http_project, 1);
|
||
host_info->host_len = host_len;
|
||
memcpy(host_info->host, session_info->buf, host_len);
|
||
if(project_req_add_struct(a_stream, g_kni_handle->http_project_id, host_info) < 0){
|
||
FREE(&host_info);
|
||
host_info = NULL;
|
||
}
|
||
return PROT_STATE_DROPME;
|
||
}
|
||
|
||
static void kni_marsio_destroy(struct kni_marsio_handle *handle){
|
||
//TODO: dev_handler, dev_sendpath不需要free吗
|
||
if(handle != NULL){
|
||
if(handle->instance != NULL){
|
||
marsio_destory(handle->instance);
|
||
}
|
||
}
|
||
FREE(&handle);
|
||
}
|
||
|
||
static struct kni_marsio_handle* kni_marsio_init(const char* profile){
|
||
void *logger = g_kni_handle->logger;
|
||
const char* section = "marsio";
|
||
char appsym[KNI_SYMBOL_MAX];
|
||
char dev_symbol[KNI_SYMBOL_MAX];
|
||
MESA_load_profile_string_def(profile, section, "appsym", appsym, sizeof(appsym), "unknown");
|
||
MESA_load_profile_string_def(profile, section, "dev_symbol", dev_symbol, sizeof(dev_symbol), "unknown");
|
||
KNI_LOG_INFO(logger, "MESA_prof_load, [%s]:\n appsym: %s\n dev_symbol: %s", section, appsym, dev_symbol);
|
||
struct mr_instance *instance = marsio_create();
|
||
if(instance == NULL){
|
||
KNI_LOG_ERROR(logger, "Failed at marsio_create");
|
||
return NULL;
|
||
}
|
||
unsigned int opt_value = 1;
|
||
marsio_option_set(instance, MARSIO_OPT_EXIT_WHEN_ERR, &opt_value, sizeof(opt_value));
|
||
//uint64_t cpu_mask = 0x3c; //??
|
||
//marsio_option_set(handle->instance, MARSIO_OPT_THREAD_MASK, &cpu_mask, sizeof(cpu_mask));
|
||
marsio_init(instance, appsym);
|
||
//设为sapp线程数
|
||
int nr_thread = g_iThreadNum;
|
||
struct mr_vdev * dev_handler = marsio_open_device(instance, dev_symbol, nr_thread, nr_thread);
|
||
if(dev_handler == NULL){
|
||
KNI_LOG_ERROR(logger, "Failed at marsio_open_device, dev_symbol is %s, nr_thread is %d", dev_symbol, nr_thread);
|
||
return NULL;
|
||
}
|
||
struct mr_sendpath * dev_sendpath = marsio_sendpath_create_by_vdev(dev_handler);
|
||
if(dev_sendpath == NULL){
|
||
KNI_LOG_ERROR(logger, "Failed at marsio_sendpath_create_by_vdev");
|
||
return NULL;
|
||
}
|
||
struct kni_marsio_handle *handle = ALLOC(struct kni_marsio_handle, 1);
|
||
handle->instance = instance;
|
||
handle->dev_handler = dev_handler;
|
||
handle->dev_sendpath = dev_sendpath;
|
||
//暂时不用调
|
||
//marsio_thread_init(mr_instance);
|
||
return handle;
|
||
}
|
||
|
||
static struct kni_field_stat_handle * fs_init(const char *profile){
|
||
void *logger = g_kni_handle->logger;
|
||
const char *section = "field_stat";
|
||
char stat_path[KNI_PATH_MAX];
|
||
MESA_load_profile_string_def(profile, section, "stat_path", stat_path, KNI_PATH_MAX, "./fs2_kni.status");
|
||
KNI_LOG_INFO(logger, "MESA_prof_load, [%s]:\n stat_path: %s\n", "field_stat", stat_path);
|
||
screen_stat_handle_t handle = FS_create_handle();
|
||
if(handle == NULL){
|
||
KNI_LOG_ERROR(logger, "Failed at create FS_create_handle");
|
||
return NULL;
|
||
}
|
||
const char* app_name = "fs2_kni";
|
||
FS_set_para(handle, APP_NAME, app_name, strlen(app_name) + 1);
|
||
FS_set_para(handle, OUTPUT_DEVICE, stat_path, strlen(stat_path)+1);
|
||
int value=0;
|
||
FS_set_para(handle, FLUSH_BY_DATE, &value, sizeof(value));
|
||
value=1;
|
||
FS_set_para(handle, PRINT_MODE, &value, sizeof(value));
|
||
value=1;
|
||
FS_set_para(handle, CREATE_THREAD, &value, sizeof(value));
|
||
value=5;
|
||
FS_set_para(handle, STAT_CYCLE, &value, sizeof(value));
|
||
value=4096;
|
||
FS_set_para(handle, MAX_STAT_FIELD_NUM, &value, sizeof(value));
|
||
struct kni_field_stat_handle *fs_handle = ALLOC(struct kni_field_stat_handle, 1);
|
||
fs_handle->handle = handle;
|
||
fs_handle->fields[KNI_FIELD_TOT_PKT] = FS_register(handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "tot_pkt");
|
||
fs_handle->fields[KNI_FIELD_BYP_PKT] = FS_register(handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "byp_pkt");
|
||
fs_handle->fields[KNI_FIELD_INTCP_PKT] = FS_register(handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "intcp_pkt");
|
||
fs_handle->fields[KNI_FIELD_IPV6_PKT] = FS_register(handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "ipv6_pkt");
|
||
fs_handle->fields[KNI_FIELD_NULL_PKT] = FS_register(handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "null_pkt");
|
||
fs_handle->fields[KNI_FIELD_NO_SYN_EXP] = FS_register(handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "no_syn_pkt");
|
||
fs_handle->fields[KNI_FIELD_UNKNOWN_STATE_EXP] = FS_register(handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "unknown_state");
|
||
fs_handle->fields[KNI_FIELD_NO_SA_EXP] = FS_register(handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "no_s/a_pkt");
|
||
fs_handle->fields[KNI_FIELD_TOT_STM] = FS_register(handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "tot_stm");
|
||
fs_handle->fields[KNI_FIELD_BYP_STM] = FS_register(handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "byp_stm");
|
||
fs_handle->fields[KNI_FIELD_INTCP_STM] = FS_register(handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "intcp_stm");
|
||
fs_handle->fields[KNI_FIELD_SSL_STM] = FS_register(handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "ssl_stm");
|
||
fs_handle->fields[KNI_FIELD_HTTP_STM] = FS_register(handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "http_stm");
|
||
fs_handle->fields[KNI_FIELD_UNKNOWN_STM] = FS_register(handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "unknown_stm");
|
||
return fs_handle;
|
||
}
|
||
|
||
|
||
extern "C" int kni_init(){
|
||
g_kni_handle = ALLOC(struct kni_handle, 1);
|
||
const char *profile = "./conf/kni/kni.conf";
|
||
const char *section = "global";
|
||
|
||
//init logger
|
||
char log_path[KNI_PATH_MAX];
|
||
MESA_load_profile_string_def(profile, section, "log_path", log_path, sizeof(log_path), "unknown");
|
||
int log_level;
|
||
MESA_load_profile_int_def(profile, section, "log_level", &log_level, 10);
|
||
void *logger = MESA_create_runtime_log_handle(log_path, log_level);
|
||
if (unlikely(logger == NULL))
|
||
{
|
||
printf("Failed at create logger: %s, exit", log_path);
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
KNI_LOG_INFO(logger, "MESA_prof_load, [%s]:\n log_path: %s\n log_level: %d", section, log_path, log_level);
|
||
g_kni_handle->logger = logger;
|
||
|
||
//init http_project
|
||
int id = http_project_init();
|
||
if(id < 0){
|
||
KNI_LOG_ERROR(logger, "Failed at init http project, exit. ret is %d", id);
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
g_kni_handle->http_project_id = id;
|
||
|
||
//init marsio
|
||
g_kni_handle->marsio_handle = kni_marsio_init(profile);
|
||
if(g_kni_handle->marsio_handle == NULL){
|
||
KNI_LOG_ERROR(logger, "Failed at init marsio, exit");
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
|
||
//init maat
|
||
g_kni_handle->maat_handle = kni_maat_init(profile, logger);
|
||
if(g_kni_handle->maat_handle == NULL){
|
||
KNI_LOG_ERROR(logger, "Failed at init maat, exit");
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
|
||
//init_filedstat
|
||
struct kni_field_stat_handle *fs_handle = fs_init(profile);
|
||
if(fs_handle == NULL){
|
||
KNI_LOG_ERROR(logger, "Failed at init field_stat");
|
||
}
|
||
g_kni_fs_handle = fs_handle;
|
||
|
||
return 0;
|
||
} |