path: root/src/frag_block.c

#include <sys/ioctl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <math.h>
#include <net/if.h>
#include <strings.h>
#include <stdio.h>
#include <stdio.h>
#include <assert.h>
#include <ctype.h>
#include <string.h>

#include "MESA_handle_logger.h"
#include "MESA_htable.h"
#include "field_stat2.h"
#include "AV_feedback.h"
#include "AV_charater.h"
#include "AV_prog_table.h"
#include "AV_log.h"
#include "AV_kill_connection.h"
#include "AV_types.h"
#include "http.h"

#include "frag_block.h"
#include "frag_common.h"
#include "frag_monitor.h"

extern frag_monitor_runtime_parameter_t 	g_frag_prog_para;
extern Maat_feather_t g_AV_global_feather;

int is_ts_end(char* url)
{
	uint32_t url_len = strlen(url);
	if(0==strcasecmp(url+url_len-strlen(".ts"), ".ts"))
	{
		return 1;
	}
	return 0;
}

char* HLS_fd_substr(char* url, const char* substr, uint32_t* substr_len)
{
	char  buf[2048] = {0};
	char* pos_index = strcasestr(url, ".m3u8");
	char* pos_data = NULL;
	char* pos_1 = NULL;
	
	if(NULL!=pos_index)
	{
		memcpy(buf, url, MIN(sizeof(buf)-1, (uint32_t)(pos_index-url)));
		/*�ܿ�������.m3u8��ǰһ��/֮ǰ*/
		pos_1 = rindex(buf, '/');
		if(NULL!=pos_1)
		{
			*substr_len = pos_1-buf;
			return url;
		}	
	}
	else
	{
		pos_data = strcasestr(url, ".ts");
		if(NULL!=pos_data)
		{
			if(is_ts_end(url))
			{
				/*�����ļ���.ts��β���ܿ�������.ts��ǰһ��/֮ǰ*/
				memcpy(buf, url, MIN(sizeof(buf)-1, (uint32_t)(pos_data-url)));
				pos_1 = rindex(buf, '/');
				if(NULL!=pos_1)
				{
					*substr_len = pos_1-buf;
					return url;
				}				
			}
			else
			{
				/*�����ļ�����.ts��β���ܿ�������.ts֮ǰ������*/
				*substr_len = pos_data-url;
				return url;			
			}
		}
	}
	return NULL;
}

char* OSMF_fd_substr(char* url, const char* substr, uint32_t* substr_len)
{
	char* pos = strcasestr(url, "seg");	
	if(NULL!=pos)
	{		
		*substr_len = pos-url;
		return url;			
	}
	return NULL;
}

int set_opt_unit(uchar type, char* value, uint32_t len, struct opt_unit_t *opt_unit, int *opt_num)
{
	if(value == NULL)
	{
		return 0;
	}
	opt_unit->opt_len = sizeof(UINT) + sizeof(UCHAR) + len;
	opt_unit->opt_type = type;
	opt_unit->opt_value = value;
	*opt_num += 1;	
	return 0;
}

void frag_send_block_log(unsigned char fd_type, char* locate_url, AV_feature_info_t* feature_info, frag_info_t *frag, http_infor* a_http, struct streaminfo *a_tcp)
{
	AV_log_t 		av_log;
	struct opt_unit_t 	opt[MAX_OPT_UNIT_NUM];	
	int 			opt_num = 0;	
	UCHAR 			proxy_flag = 0;
	struct proxydetail*	proxy_detail = NULL;
	unsigned int 		client_seq = 0;
	int  			rec=0,client_seq_len = 0;
	char			media_type = 162;
	
	av_log.pid = feature_info->mid;	
	av_log.fd_type = fd_type;
	av_log.protocol = AV_PROTOCOL_HTTP;
	av_log.a_stream = a_tcp;
	av_log.cfg = &feature_info->av_rule;	

	/*OPT_MEDIA_TYPE:media_type*/
	set_opt_unit(OPT_MEDIA_TYPE, (char *)&media_type, sizeof(media_type), &opt[opt_num], &opt_num);

	/*AV_LOG_OPT_HTTP_SESSION_SEQ*/ 
	set_opt_unit(AV_LOG_OPT_HTTP_SESSION_SEQ, (char *)&a_http->http_session_seq, sizeof(a_http->http_session_seq),&opt[opt_num], &opt_num);
	
	/*AV_LOG_OPT_PROTO_URL...*/
	set_opt_unit(AV_LOG_OPT_PROTO_URL, frag->frag_opt[FRAG_URL].opt_value, frag->frag_opt[FRAG_URL].opt_len-1, &opt[opt_num], &opt_num);
	set_opt_unit(AV_LOG_OPT_PROTO_REFERER, frag->frag_opt[FRAG_REFERER].opt_value, frag->frag_opt[FRAG_REFERER].opt_len-1, &opt[opt_num], &opt_num);
	set_opt_unit(AV_LOG_OPT_HTTP_UA, frag->frag_opt[FRAG_UA].opt_value, frag->frag_opt[FRAG_UA].opt_len-1, &opt[opt_num], &opt_num);
	set_opt_unit(AV_LOG_OPT_HTTP_DOMAIN, frag->frag_opt[FRAG_HOST].opt_value, frag->frag_opt[FRAG_HOST].opt_len-1, &opt[opt_num], &opt_num);

	/*AV_LOG_OPT_HTTP_PROXY_DOMAIN*/
	if((a_tcp->pfather != NULL) && (a_tcp->pfather->type == STREAM_TYPE_HTTP_PROXY))
	{
		proxy_flag = 1; 
		proxy_detail = (struct proxydetail *)(a_tcp->pfather->pdetail);

		if(proxy_detail->append != NULL && proxy_detail->uiApendLen != 0)
		{
			set_opt_unit(AV_LOG_OPT_HTTP_PROXY_DOMAIN, (char *)proxy_detail->append, proxy_detail->uiApendLen,&opt[opt_num], &opt_num);
		}
	}
	
	/*AV_LOG_OPT_HTTP_PROXY_FLAG*/
	set_opt_unit(AV_LOG_OPT_HTTP_PROXY_FLAG, (char *)&proxy_flag, sizeof(proxy_flag), &opt[opt_num], &opt_num);

	
	/*AV_LOG_OPT_TCP_CLIENT_SEQ*/	
	client_seq_len=sizeof(unsigned int);
	rec = MESA_get_stream_opt(a_tcp, MSO_TCP_ISN_C2S, (void *)&client_seq, (int *)&client_seq_len);
	if(rec < 0)
	{
		client_seq = 0;
	}
	set_opt_unit(AV_LOG_OPT_TCP_CLIENT_SEQ, (char *)&client_seq, sizeof(client_seq), &opt[opt_num], &opt_num);

	/*���Ƭ��AV_LOG_OPT_LOG_URI*/
	set_opt_unit(AV_LOG_OPT_LOG_URI, locate_url, strlen(locate_url), &opt[opt_num], &opt_num);
	AV_send_log(&av_log, opt,opt_num);	
	//MESA_handle_runtime_log(g_frag_prog_para.logger, RLOG_LV_FATAL, FRGMNT_PLUGIN_NAME,
    //                        (char*)"[%s:%d] AV_send_log: MID:%llu, url:%s." ,
    //                        __FILE__,__LINE__, feature_info->mid, locate_url);    
}

void frag_kill_connection(uint64 mid, frag_info_t *frag, http_infor* a_http, struct streaminfo *a_tcp, void *a_packet)
{
	struct AV_block_info 	kill_info;	
	struct opt_unit_t 		opt_unit[MAX_OPT_UNIT_NUM];	
	int 					opt_num = 0;

	kill_info.connection_type = CONNECTION_HTTP_STREAMING;
	kill_info.hitted_phase = HITTED_HTTP_REQUEST;
	kill_info.pid = mid;
	kill_info.filesize = 0;
	kill_info.range = MAX_UINT64_VAL;
	kill_info.file_type = frag->media_type;
	
	set_opt_unit(AVK_OPT_URL, frag->frag_opt[FRAG_URL].opt_value, frag->frag_opt[FRAG_URL].opt_len-1, &opt_unit[opt_num], &opt_num);
	AV_kill_connection(a_tcp, (struct ip *)a_packet, &kill_info, opt_unit, opt_num);
}

/*�����Ӵ�������Ƭ��GK*/
/*
char frag_check_block(frag_info_t *frag, http_infor* a_http, struct streaminfo *a_tcp, void *a_packet)
{
	uchar 					rec = PROT_STATE_GIVEME;	
	const char* 			substr = NULL;
	uint32_t 				substr_len = 0;
	AV_feature_info_t*		feature_info = NULL;	
	uint32_t 				feature_info_len = 0;	
	
	switch(frag->media_type)
	{
		case FILE_OSMF:
			substr = OSMF_fd_substr(frag->url, substr, &substr_len);	
			break;			
		case FILE_HLS:
			substr = HLS_fd_substr(frag->url, substr, &substr_len);			
			break;			
		default:
			break;		
	}   
	if(NULL!=substr)
	{
		if(AV_check_conn_feature((const uchar*)substr, substr_len, (void**)&feature_info, &feature_info_len))
		{
			//��£��������־			
			frag_kill_connection(feature_info->mid, frag, a_http, a_tcp, a_packet);
			frag_send_block_log((const uchar*)substr, substr_len, feature_info, feature_info_len, frag, a_http, a_tcp);
			rec = PROT_STATE_DROPME;
		}
		if(NULL!=feature_info)
		{
			AV_free_feature_info(feature_info);
		}
	}
	return rec;
}
*/
	
int frag_url_scan(const char* url, int len, Maat_rule_t *result, int result_num, unsigned char *fd_type, int thread_num)
{
	int ret=0,found_pos=0;
	scan_status_t mid=NULL;

	ret=Maat_full_scan_string(g_AV_global_feather, g_frag_prog_para.frag_url_table_id,
							CHARSET_GBK,
							url,
							len,
							result,
							&found_pos,result_num,
							&mid,thread_num);

	Maat_clean_status(&mid);
	if(ret>0)
	{
		*fd_type = FD_TYPE_DYNAMIC_LIST;
		return ret;
	}	
	return 0;
}

char frag_check_block(frag_info_t *frag, http_infor* a_http, struct streaminfo *a_tcp, void *a_packet, int thread_seq)
{
	uchar 				rec = PROT_STATE_GIVEME;	
	struct Maat_rule_t	maat_result[MAAT_RESULT_NUM];	
	int 				rulenum = 0;		
	AV_feature_info_t	feature_info;	
	char				locate_url[MAX_SERVICE_DEFINE_LEN] = {0};
	char*				maat_define = NULL;
	char				cfg_url[MAX_SERVICE_DEFINE_LEN] = {0};
	char*				pos = NULL;
	char*				saveptr = NULL;
	char*				src = NULL;
	unsigned char		fd_type = NULL;
	int					define_return = 0;

	/*�û��Զ����˳��*/
	/* "%u|%u|%s|%llu|%u|%s",hit_rule.cfg_id, hit_rule.level, logurl, (unsigned long long)msg->prog_id, hit_rule.service);*/
	//rulenum = AV_rule_scan_frag_url(a_http->p_url, a_http->url_len, maat_result, MAAT_RESULT_NUM, &fd_type, thread_seq);
	rulenum = frag_url_scan(a_http->p_url, a_http->url_len, maat_result, MAAT_RESULT_NUM, &fd_type, thread_seq);
	
	for(int i=0;i<rulenum;i++)
	{	
		memset(cfg_url, 0, sizeof(cfg_url));
		maat_define = (char*)dictator_malloc(thread_seq, sizeof(char)*maat_result[i].serv_def_len+1);
		define_return = Maat_read_rule(g_AV_global_feather, &maat_result[i], MAAT_RULE_SERV_DEFINE, maat_define, maat_result[i].serv_def_len);		
		if(0!=define_return)
		{
			maat_define[maat_result[i].serv_def_len] = '\0';
			src = maat_define;		
			pos = strtok_r(src, "|", &saveptr);
			for(int i=0;i<6 && pos!=NULL;i++)
			{
				switch(i)
				{
					case 0:
						sscanf(pos, "%u", &feature_info.av_rule.cfg_id);
						break;
					case 1:					
						sscanf(pos, "%hhu", &feature_info.av_rule.level);
						break;
					case 2:					
						sscanf(pos, "%s", locate_url);
						break;
					case 3:					
						sscanf(pos, "%llu", &feature_info.mid);
						break;
					case 4:					
						sscanf(pos, "%hhu", &feature_info.av_rule.service);
						break;
					case 5:					
						sscanf(pos, "%s", cfg_url);
						break;
					default:
						break;
				}			
				pos = strtok_r(NULL, "|", &saveptr);
			}		
		}
		if(NULL!=maat_define)
		{
			dictator_free(thread_seq, maat_define);
		}
		/*��£��������־*/			
		frag_kill_connection(feature_info.mid, frag, a_http, a_tcp, a_packet);
		frag_send_block_log(fd_type, locate_url, &feature_info, frag, a_http, a_tcp);
		MESA_handle_runtime_log(g_frag_prog_para.logger, RLOG_LV_FATAL, FRGMNT_PLUGIN_NAME,
                            	(char*)"AV_send_log: MID:%llu, url:%s, cfg_url:%s, locate_url:%s" ,
                            	 feature_info.mid, frag->frag_opt[FRAG_URL].opt_value, cfg_url, locate_url);
		rec = PROT_STATE_DROPME;
	}	
	return rec;
}