/*
 * quic_process.c
 *
 *  Created on: 2019Äê4ÔÂ2ÈÕ
 *      Author: root
 */

#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
#include <MESA/stream.h>
#include <MESA/MESA_handle_logger.h>

#include "gquic_process.h"
#include "quic_analysis.h"

int quic_getLinkState(struct _quic_context *_context)
{
	UCHAR state = 0;
	
	if(0==_context->link_state)
	{
		state=SESSION_STATE_PENDING|SESSION_STATE_DATA;
	}
	else
	{
		state=SESSION_STATE_DATA;
	}
	
	return state;
}

char quic_callPlugins(struct streaminfo *pstream, struct _quic_context *_context, void *buff, int buff_len, enum quic_interested_region region_mask, void *a_packet)
{
	char state=PROT_STATE_GIVEME;
	char app_state=APP_STATE_GIVEME;
	stSessionInfo session_info={0};
	
	session_info.plugid=g_quic_param.quic_plugid;
	session_info.prot_flag=(((unsigned long long)1)<<region_mask);
	session_info.session_state=quic_getLinkState(_context) ;
	session_info.app_info=(void*)(&_context->quic_info);
	session_info.buf=buff;
	session_info.buflen=buff_len;
	
	state=PROT_PROCESS(&session_info, &(_context->business_pme), pstream->threadnum, pstream, a_packet);

	if(state&PROT_STATE_DROPPKT)
	{
		app_state=APP_STATE_DROPPKT;
	}

	if(state&PROT_STATE_DROPME)
	{
		if(app_state&APP_STATE_DROPPKT)
		{
			app_state|=APP_STATE_DROPME;
		}
		else
		{
			app_state=APP_STATE_DROPME;
		}
	}

	if(state&PROT_STATE_GIVEME)
	{
		app_state=APP_STATE_GIVEME;
	}
	
	return app_state;
}


unsigned long long get_variable_length(char *p, int offset, int v_len)
{
	switch(v_len)
	{
		case	1:
			return (unsigned long long)(p[offset]);
			break;
		case	2:
			return (unsigned long long)ntohs(*(unsigned short *)((char *)p+offset));
			break;
		case	3:
			return (unsigned long long)*(p+0+offset)<<16|
		           (unsigned long long)*(p+1+offset)<<8|
		           (unsigned long long)*(p+2+offset)<<0;
			break;
		case	4:
			return (unsigned long long)ntohl(*(unsigned int *)(p+offset));
			break;
		case	5:
			return (unsigned long long)*((unsigned char *)(p)+0+offset)<<32|
		           (unsigned long long)*((unsigned char *)(p)+1+offset)<<24|
		           (unsigned long long)*((unsigned char *)(p)+2+offset)<<16|
		           (unsigned long long)*((unsigned char *)(p)+3+offset)<<8|
		           (unsigned long long)*((unsigned char *)(p)+4+offset)<<0;
			break;
		case	6:
			return (unsigned long long)*((unsigned char *)(p)+0+offset)<<40|
		           (unsigned long long)*((unsigned char *)(p)+1+offset)<<32|
		           (unsigned long long)*((unsigned char *)(p)+2+offset)<<24|
		           (unsigned long long)*((unsigned char *)(p)+3+offset)<<16|
		           (unsigned long long)*((unsigned char *)(p)+4+offset)<<8|
		           (unsigned long long)*((unsigned char *)(p)+5+offset)<<0;
			break;
		case	7:
			return (unsigned long long)*((unsigned char *)(p)+0+offset)<<56|
		           (unsigned long long)*((unsigned char *)(p)+1+offset)<<40|
		           (unsigned long long)*((unsigned char *)(p)+2+offset)<<32|
		           (unsigned long long)*((unsigned char *)(p)+3+offset)<<24|
		           (unsigned long long)*((unsigned char *)(p)+4+offset)<<16|
		           (unsigned long long)*((unsigned char *)(p)+5+offset)<<8;
					(unsigned long long)*((unsigned char *)(p)+6+offset)<<0;
			break;
		case	8:
			return (unsigned long long)*((unsigned char *)(p)+0+offset)<<56|
		           (unsigned long long)*((unsigned char *)(p)+1+offset)<<48|
		           (unsigned long long)*((unsigned char *)(p)+2+offset)<<40|
		           (unsigned long long)*((unsigned char *)(p)+3+offset)<<32|
		           (unsigned long long)*((unsigned char *)(p)+4+offset)<<24|
		           (unsigned long long)*((unsigned char *)(p)+5+offset)<<16|
		           (unsigned long long)*((unsigned char *)(p)+6+offset)<<8|
		           (unsigned long long)*((unsigned char *)(p)+7+offset)<<0;
			break;
		default:
			break;
	}

	return 0;
}

int get_quic_tlv(char *start_pos, quic_tlv_t *tlv, int len, int type, int thread_seq)
{
	if(tlv->value==NULL && len>0)
	{
		tlv->value=(char *)dictator_malloc(thread_seq, len+1);
		memset(tlv->value, 0, len+1);
		tlv->length=len;
		tlv->type=type;
		memcpy(tlv->value, start_pos, tlv->length);
	}
	
	return 0;
}

int get_stream_id(struct streaminfo *pstream, struct _quic_context* _context, char* payload, unsigned char frame_type, int *used_len)
{
	int stream_len=0,offset_len=0;

	_context->quic_info.frame_hdr.frame_type=frame_type;
	
	stream_len=(frame_type&GQUIC_SPECIAL_FRAME_STREAM_ID)+1;
	_context->quic_info.frame_hdr.stream_id=(unsigned int)get_variable_length(payload, *used_len, stream_len);
	*used_len+=stream_len;  // stream ID length

	if(frame_type&GQUIC_SPECIAL_FRAME_STREAM_DLEN)
	{
		_context->quic_info.frame_hdr.data_len=ntohs(*(unsigned short *)(payload+*used_len));
		*used_len+=2;  //data length
	}
			
	offset_len=(frame_type&GQUIC_SPECIAL_FRAME_STREAM_OFFSET) ? (frame_type&GQUIC_SPECIAL_FRAME_STREAM_ID)+1 : 0;
	_context->quic_info.frame_hdr.offset=get_variable_length(payload, *used_len, offset_len);
	*used_len+=offset_len;

	MESA_handle_runtime_log(g_quic_param.logger,
						RLOG_LV_DEBUG,
						"QUIC_FRAME",
						"frame_type: 0X%02X stream_id: %u data length: %u offset length: %u addr: %s",
						frame_type,
						_context->quic_info.frame_hdr.stream_id,
						_context->quic_info.frame_hdr.data_len,
						offset_len,
						printaddr(&pstream->addr, pstream->threadnum));

	return _context->quic_info.frame_hdr.stream_id;
}

unsigned long long get_packet_number(char* data, int offset, char pkn_len)
{
	switch(pkn_len)
	{
		case	1:
			return (unsigned long long)data[offset];
			break;
		case	2:
			return (unsigned long long)ntohs(*(unsigned short *)(data+offset));
			break;
		case	4:
			return (unsigned long long)ntohl(*(unsigned int *)(data+offset));
			break;
		case	8:
			return get_variable_length(data, offset, 8);;
			break;
	}

	return 0;
}

// GQUIC version from 0 to 43
static enum _QUIC_VERSION parse_q0to43_header(struct streaminfo *pstream, struct _quic_context* _context, char *payload, int payload_len, int *used_len)
{
	int i=0,len=0;
	char public_flags=0;
	
	struct _quic_public_header *gquic_hdr=&(_context->quic_info.quic_hdr);
	if(gquic_hdr==NULL)
	{
		gquic_hdr=(struct _quic_public_header *)dictator_malloc(pstream->threadnum, sizeof(struct _quic_public_header));
		memset(gquic_hdr, 0, sizeof(struct _quic_public_header));	
	}

	public_flags=payload[*used_len];
	*used_len+=1;

	//For Public Reset and Version Negotiation Packets (sent by the server) which don't have a packet number
	if(!public_flags&GQUIC_PUBLIC_FLAG_PKT_NUM)
	{
		if(public_flags&GQUIC_PUBLIC_FLAG_VERSION) //Public Reset Packet
		{
			return QUIC_VERSION_UNKNOWN;// todo
		}
		else // Version Negotiation Packet
		{
			return QUIC_VERSION_UNKNOWN;
		}
	}
	
	gquic_hdr->public_flags=public_flags;

	if(gquic_hdr->public_flags&GQUIC_PUBLIC_FLAG_CID)
	{
		*(unsigned long long *)gquic_hdr->server_CID=get_variable_length(payload, *used_len, sizeof(gquic_hdr->server_CID));
		*used_len+=sizeof(unsigned long long); // CID length
	}
	
	if(gquic_hdr->public_flags&GQUIC_PUBLIC_FLAG_VERSION && ntohs(*(unsigned short *)(payload+*used_len))==0x5130)
	{
		gquic_hdr->quic_version=(unsigned int)ntohl(*(unsigned int *)(payload+*used_len));
		*used_len+=sizeof(int); // skip version
	}
	else
	{
		return QUIC_VERSION_UNKNOWN;
	}

	switch(gquic_hdr->public_flags&0x30) // packet number
	{
		case	0x30: // 6 bytes
			gquic_hdr->packet_number=get_variable_length(payload, *used_len, 6);
			*used_len+=6;
			break;
		case	0x20: // 4 bytes
			gquic_hdr->packet_number=(unsigned long long)ntohl(*(unsigned int *)(payload+*used_len));
			*used_len+=4;
			break;
		case	0x10: // 2bytes
			gquic_hdr->packet_number=(unsigned long long)ntohs(*(unsigned short *)(payload+*used_len));
			*used_len+=2;
			break;
		default:	// 1 byte
			gquic_hdr->packet_number=payload[*used_len];
			*used_len+=1;
			break;
	}
			
	if(gquic_hdr->public_flags==GQUIC_PUBLIC_FLAG_NONCE)
	{
		*used_len+=32; //diversification nonce
	}
	
	if(gquic_hdr->public_flags&GQUIC_PUBLIC_FLAG_VERSION)
	{
		// Version 11 reduced the length of null encryption authentication tag  from 16 to 12 bytes
		if(gquic_hdr->quic_version > GQUIC_VERSION_Q010)
		{
			*used_len+=12;
		}
		else
		{
			*used_len+=16;
		}

		// Version 34 removed entropy bits from packets and ACK frames, 
		// removed private flag from packet header and changed the ACK format to specify ranges of packets acknowledged rather than missing ranges.
		if(gquic_hdr->quic_version < GQUIC_VERSION_Q034)
		{
			*used_len+=1;  //private flags
		}
	}

	_context->is_quic==QUIC_TRUE;
	
	MESA_handle_runtime_log(g_quic_param.logger,
							RLOG_LV_DEBUG,
							"QUIC_IDETIFY",
							"pub_flags: 0X%02X conection ID:[ destination: %llu ] version: Q%03u packet number: %llu dir(1: C2S;2: S2C): %d addr: %s",
							gquic_hdr->public_flags,
							*(unsigned long long *)gquic_hdr->server_CID,
							(((gquic_hdr->quic_version>>8)&0x0000000F)*10) + ((gquic_hdr->quic_version)&0x0000000F),
							gquic_hdr->packet_number,
							pstream->curdir,
							printaddr(&pstream->addr, pstream->threadnum));

	return (enum _QUIC_VERSION)gquic_hdr->quic_version;
}

enum _QUIC_VERSION parse_quic_header(struct streaminfo *pstream, struct _quic_context* _context, char *payload, int payload_len, int *used_len)
{
	int i=0,len=0;
	char client_CID[MAX_CONNECT_ID_LEN*2]={0};
	char server_CID[MAX_CONNECT_ID_LEN*2]={0};
	
	struct _quic_public_header *long_hdr=&(_context->quic_info.quic_hdr);

	long_hdr->public_flags=payload[*used_len];
	*used_len+=1; //skip public flags

	if(long_hdr->public_flags&0x80)
	{
		long_hdr->quic_version=(unsigned int)ntohl(*(unsigned int *)(payload+*used_len));
		*used_len+=sizeof(int); // skip version
		
		long_hdr->client_CID_len=(payload[*used_len]&0xF) ? (payload[*used_len]&0xF)+3 : 0;
		long_hdr->server_CID_len=((payload[*used_len]>>4)&0xF) ? ((payload[*used_len]>>4)&0xF)+3 : 0;
		*used_len+=sizeof(char);  // both connection_id length
		
		memcpy(long_hdr->server_CID, (void *)(payload+*used_len), long_hdr->server_CID_len);
		*used_len+=long_hdr->server_CID_len;  // Destination connection_id length
		memcpy(long_hdr->client_CID, (void *)(payload+*used_len), long_hdr->client_CID_len);
		*used_len+=long_hdr->client_CID_len;  // source connection_id length
	}
	else
	{
	  if(pstream->curdir==DIR_C2S)// short header only  destination connection ID
	  {
	  	*used_len+=long_hdr->server_CID_len;   // every packet destination connection ID is same
	  }
	}
	
	len=(long_hdr->public_flags&0x03)+1;
	long_hdr->packet_number=get_packet_number(payload, *used_len, len);
	*used_len+=len;

	*used_len+=12;  //message authentication hash

	_context->is_quic==QUIC_TRUE;

	for(i=0,len=0;i<long_hdr->server_CID_len; i++) 
	{
		len+=snprintf(server_CID+len, sizeof(server_CID)-len, "%02X", long_hdr->server_CID[i]);
	}

	for(i=0,len=0;i<long_hdr->client_CID_len; i++) 
	{
		len+=snprintf(client_CID+len, sizeof(client_CID)-len, "%02X", long_hdr->client_CID[i]);
	}

	MESA_handle_runtime_log(g_quic_param.logger,
							RLOG_LV_DEBUG,
							"QUIC_IDETIFY",
							"pub_flags: 0X%02X conection ID:[ destination: %s source: %s ] version: Q%03u packet number: %llu dir(1: C2S;2: S2C): %d addr: %s",
							long_hdr->public_flags,
							server_CID,
							client_CID,
							(((long_hdr->quic_version>>8)&0x0000000F)*10) + ((long_hdr->quic_version)&0x0000000F),
							long_hdr->packet_number,
							pstream->curdir,
							printaddr(&pstream->addr, pstream->threadnum));
	
	return (enum _QUIC_VERSION)long_hdr->quic_version;
}

enum _QUIC_VERSION is_quic_protocol(struct streaminfo *pstream, struct _quic_context* _context, char *payload, int payload_len, int *used_len)
{
	int i=0,len=0;
	size_t s_id_len=0,d_id_len=0;
	char d_CID[128]={0}, s_CID[128]={0};
	unsigned char s_connection_id[MAX_CONNECT_ID_LEN]={0};
	unsigned char d_connection_id[MAX_CONNECT_ID_LEN]={0};
	enum _QUIC_VERSION quic_version=QUIC_VERSION_UNKNOWN;
	
	if(_context->quic_info.quic_hdr.quic_version!=QUIC_VERSION_UNKNOWN)
	{
		// 
		quic_version=(enum _QUIC_VERSION)(_context->quic_info.quic_hdr.quic_version);
	}
	else
	{
		// The most significant bit (0x80) of byte 0 (the first byte) is set to 1 for long headers
		(payload[*used_len]&0x80) ? (quic_version=(enum _QUIC_VERSION)ntohl(*(unsigned int *)(payload+(*used_len+1)))) : QUIC_VERSION_UNKNOWN;
	}

	switch(quic_version) // +1 meaning: skip public flags
	{
		case	GQUIC_VERSION_Q046:
			quic_version=parse_quic_header(pstream, _context, payload, payload_len, used_len);
			return quic_version;
			break;
		//case	IETF: unsupport
			break;
		default:
			break;
	}

	// Q001~Q043: 0x80 is currently unused, and must be set to 0
	if(payload[*used_len]>0x80)
	{
		return QUIC_VERSION_UNKNOWN;
	}
	
	return parse_q0to43_header(pstream, _context, payload, payload_len, used_len);
}

int parse_extension_tag(struct streaminfo *pstream, struct _quic_stream **quic_stream, void *a_packet, char *payload, int payload_len, int *used_len, int tag_num)
{
	int ret=0,tag_used_num=0;
	int tag_type,skip_tsg=0;
	int total_tag_len=0,tag_len=0;
	int tag_offset_end=0,pre_tag_offset_end=0;
	
	struct _quic_stream *stream=*quic_stream;
	int tag_value_start=tag_num*4*2+(*used_len);  // skip length of type and offset, type(offset)=szieof(int)

	if(stream==NULL)
	{
		stream=(struct _quic_stream *)dictator_malloc(pstream->threadnum, sizeof(struct _quic_stream));
		memset(stream, 0, sizeof(struct _quic_stream));
		stream->ext_tags=(quic_tlv_t *)dictator_malloc(pstream->threadnum, tag_num*sizeof(quic_tlv_t));
		memset(stream->ext_tags, 0, tag_num*sizeof(quic_tlv_t));
		*quic_stream=stream;
	}
	else
	{
		quic_release_exts(pstream->threadnum, stream->ext_tags, stream->ext_tag_num);
		stream->ext_tags=(quic_tlv_t *)dictator_malloc(pstream->threadnum, tag_num*sizeof(quic_tlv_t));
		memset(stream->ext_tags, 0, tag_num*sizeof(quic_tlv_t));
		*quic_stream=stream;
		stream->ext_tag_num=0;
		stream->count++;
	}

	while(tag_num>tag_used_num)
	{
		tag_type=ntohl(*(unsigned int *)(payload+*used_len));
		*used_len+=sizeof(int);
		
		tag_offset_end=*(unsigned int *)(payload+*used_len);
		*used_len+=sizeof(int);
		
		tag_len=tag_offset_end-pre_tag_offset_end;
		if(tag_len<0 || (tag_offset_end>=payload_len) || (tag_len>payload_len-tag_value_start))
		{
			return -1;
		}

		switch(tag_type)
		{
			case	TAG_PAD:
				break;
			case	TAG_VER:
				stream->ver_idx=stream->ext_tag_num;
				get_quic_tlv(payload+tag_value_start, &stream->ext_tags[stream->ext_tag_num], tag_len, tag_type, pstream->threadnum);
				*(unsigned int *)(stream->ext_tags[stream->ext_tag_num].value)=(unsigned int)ntohl(*(unsigned int *)(stream->ext_tags[stream->ext_tag_num].value));
				MESA_handle_runtime_log(g_quic_param.logger,
											RLOG_LV_DEBUG,
											"QUIC_VERSION",
											"Quic version: 0X%X addr: %s",
											*(unsigned int *)(stream->ext_tags[stream->ext_tag_num].value),
											printaddr(&pstream->addr, pstream->threadnum));
				break;
			case	TAG_UAID:
				stream->ua_idx=stream->ext_tag_num;
				get_quic_tlv(payload+tag_value_start, &stream->ext_tags[stream->ext_tag_num], tag_len, tag_type, pstream->threadnum);
				MESA_handle_runtime_log(g_quic_param.logger,
											RLOG_LV_DEBUG,
											"QUIC_UA",
											"User Agent: %s addr: %s",
											stream->ext_tags[stream->ext_tag_num].value,
											printaddr(&pstream->addr, pstream->threadnum));
				stream->ext_tag_num++;
				break;
			case	TAG_SNI:
				stream->sni_idx=stream->ext_tag_num;
				get_quic_tlv(payload+tag_value_start, &stream->ext_tags[stream->ext_tag_num], tag_len, tag_type, pstream->threadnum);
				MESA_handle_runtime_log(g_quic_param.logger,
											RLOG_LV_DEBUG,
											"QUIC_SNI",
											"SNI: %s addr: %s",
											stream->ext_tags[stream->ext_tag_num].value,
											printaddr(&pstream->addr, pstream->threadnum));
				stream->ext_tag_num++;
				break;
			default:
				get_quic_tlv(payload+tag_value_start, &stream->ext_tags[stream->ext_tag_num], tag_len, tag_type, pstream->threadnum);
				stream->ext_tag_num++;
				break;
		}
			
		tag_used_num++;
		tag_value_start+=tag_len;
		total_tag_len+=tag_len;
		pre_tag_offset_end=tag_offset_end;
	}
	
	*used_len += total_tag_len;
	
	return ret;
}

#if 0
int gquic_frame_type_ack(struct quic_stream* a_quic_stream, char * quic_data, UINT32 quic_data_len, UINT8 frame_type, UINT32 *used_len)
{
	UINT8 num_timestamp, num_ranges, num_revived, num_blocks;
	UINT32 len_largest_observed=0, len_missing_packet=0;
	
	*used_len+=1;
	len_largest_observed = read_largest_observed_len(frame_type);
	len_missing_packet = read_missing_packet_len(frame_type);
	//No longer Entropy after Q034
	if(a_quic_stream->version < 34)
	{
		//Send Entropy
		*used_len += 1;
		*used_len += len_largest_observed;
		*used_len += 2;    //ack delay time
		strncpy((char*)&num_timestamp, quic_data+*used_len,1);
		*used_len += 1;
		if(num_timestamp > 0)
		{
			*used_len += 1;
			*used_len += 4;
			*used_len += (num_timestamp - 1)*(1+2);
		}
		if(frame_type & ACK_N)
		{
			strncpy((char*)&num_ranges, quic_data+*used_len,1);
			*used_len += 1;
			
			*used_len += num_ranges*(len_missing_packet+1);
			
			strncpy((char*)&num_revived, quic_data+*used_len,1);
			*used_len += 1;
			
			//Num Revived x Length Largest Observed
			*used_len += num_revived*len_largest_observed;
		}
	}
	else
	{
		*used_len += len_largest_observed;  //Largest Acked
		*used_len += 2;  //Largest Acked Delta Time
		
		if(frame_type & ACK_N) //Ack Block
		{
			strncpy((char*)&num_blocks, quic_data+*used_len,1);
			*used_len += 1;
		}
		
		*used_len += len_missing_packet; //First Ack Block Length
		if(num_blocks)
		{
			//Gap to next block
			*used_len += 1;
			num_blocks -= 1;
			*used_len += (num_blocks - 1)*len_missing_packet;
		}
		
		strncpy((char*)&num_timestamp, quic_data+*used_len,1);  //Timestamp
		*used_len += 1;
		if(num_timestamp > 0)
		{
			*used_len += 1;  //Delta Largest Acked
			*used_len += 4;  //Time Since Largest Acked
			
			//Num Timestamp x (Delta Largest Acked + Time Since Previous Timestamp)
			*used_len += (num_timestamp - 1)*(1+2);
		}
	}

	return 0;
}

// return value: Have no meaning, only numerical value
int gquic_frame_type_control(struct quic_stream* a_quic_stream, char * quic_data, UINT32 quic_data_len, UINT8 frame_type, uint32_t pkt_num_len, UINT32 *used_len)
{
	int len_reason;
	*used_len+=1;
	
	switch(frame_type)
	{
		case RST_STREAM:
			*used_len +=4; //stream id
			*used_len+=8; //Byte Offset
			*used_len+=4; //Error Code
			a_quic_stream->fin_flag=QUIC_TRUE;
			break;
		case CONNECTION_CLOSE:
			len_reason = 0;
			*used_len += 4; //Error Code
			len_reason = a_pntoh16(quic_data, *used_len);  //Reason Phrase Length
			*used_len += 2;
			//Reason Phrase,If length remaining == len_reason, it is Connection Close
			if(get_remaining_len(quic_data_len, *used_len) == len_reason)
			{
				return QUIC_DATA;
			}
			a_quic_stream->fin_flag=(a_quic_stream->fin_flag==QUIC_FALSE) ? QUIC_HALF_CLOSE : QUIC_TRUE;
			break;
		case GOAWAY:
			len_reason = 0;
			*used_len += 4;  //Error Code
			*used_len += 4; //Last Good Stream ID
			len_reason = a_pntoh16(quic_data, *used_len);  //Reason Phrase Length
			*used_len += 2;
			*used_len += len_reason; //Reason Phrase
			break;
		case WINDOW_UPDATE:
			*used_len += 4;  //Stream ID
			*used_len += 8;  //Byte Offset
			break;
		case BLOCKED:
			*used_len += 4; //Stream ID
			break;
		case STOP_WAITING:
			//No longer Entropy after Q034
			if(a_quic_stream->version < 34)
			{
				*used_len += 1; // Send Entropy
			}
			//Least Unacked Delta
			*used_len += pkt_num_len;
			break;
		case PING: //No Payload
		case PADDING:
		default:
			return QUIC_FALSE;
			break;
	}

	return QUIC_TRUE;
}
#endif

int gquic_frame_type_stream(struct streaminfo *pstream, struct _quic_context* _context, char *payload, int payload_len, int *used_len, char frame_type, void *a_packet)
{
	int ret=0;
	unsigned short tag_num = 0;
	unsigned int stream_id, message_tag;

	stream_id=get_stream_id(pstream, _context, payload, frame_type, used_len);

	message_tag=(unsigned int)ntohl(*(unsigned int *)(payload+*used_len));
	*used_len+=4; 

	tag_num=*(unsigned short *)(payload+*used_len);
	*used_len+=2; //tag_num
	*used_len+=2; //padding
	
	switch(message_tag)
	{
		case CHLO: //MTAG_CHLO;
			ret=parse_extension_tag(pstream, &_context->quic_info.client_hello, a_packet, payload, payload_len, used_len, tag_num);
			if(ret>=0)
			{
				ret=quic_callPlugins(pstream, _context, (void *)(_context->quic_info.client_hello), sizeof(void *), QUIC_CLIENT_HELLO_MASK, a_packet);
			}
			break;
		case SHLO:  //MTAG_SHLO;
			ret=parse_extension_tag(pstream, &_context->quic_info.server_hello, a_packet, payload, payload_len, used_len, tag_num);
			if(ret>=0)
			{
				ret=quic_callPlugins(pstream, _context, (void *)(_context->quic_info.server_hello), sizeof(void *), QUIC_SERVER_HELLO_MASK, a_packet);
			}
			break;
		case REJ: //MTAG_REJ;
			ret=parse_extension_tag(pstream, &_context->quic_info.rej, a_packet, payload, payload_len, used_len, tag_num);
			if(ret>=0)
			{
				ret=quic_callPlugins(pstream, _context, (void *)(_context->quic_info.rej), sizeof(void *), QUIC_SERVER_HELLO_MASK, a_packet);
			}
			break;
		default:
			break;
	}

	return (ret>=0) ? ret : APP_STATE_GIVEME;
}

//frame type->stream->offset->data length
int gquic_proc_unencrypt(struct streaminfo *pstream, struct _quic_context* _context, void *a_packet, char * payload, int payload_len, int *used_len)
{
	unsigned int ret=0;
	unsigned char frame_type;
				
	while(*used_len<payload_len)
	{	 
		frame_type=payload[*used_len];
		*used_len+=1;  //skip frame_type
		
		switch(frame_type)
		{
			case	GQUIC_REGULAR_FRAME_PADDING:
				return 0; //todo
				break;
			case	GQUIC_REGULAR_FRAME_RST_STREAM:
				return 0; //todo
				break;
			case	GQUIC_REGULAR_FRAME_CONNECTION_CLOSE:
				return 0; //todo
				break;
			case	GQUIC_REGULAR_FRAME_GOAWAY:
				return 0; //todo
				break;
			case	GQUIC_REGULAR_FRAME_WINDOW_UPDATE:
				return 0; //todo
				break;
			case	GQUIC_REGULAR_FRAME_BLOCKED:
				return 0; //todo
				break;
			case	GQUIC_REGULAR_FRAME_STOP_WAITING:
				return 0; //todo
				break;
			case	GQUIC_REGULAR_FRAME_PING:
				return 0; //todo
				break;
			default: //Regular Frame Types
				if(frame_type&GQUIC_SPECIAL_FRAME_STREAM)
				{
					ret=gquic_frame_type_stream(pstream, _context, payload, payload_len, used_len, frame_type, a_packet);
				}
				else if(frame_type&GQUIC_SPECIAL_FRAME_ACK)
				{
					return 0; //todo
				}
				else if(frame_type&GQUIC_SPECIAL_FRAME_CONGEST_FB)
				{
					return 0; //todo
				}
				else
				{
					return -1;
				}
				break;
		}
	}
	
	return APP_STATE_GIVEME;
}


//QUIC_DATA:is quic data pcap;QUIC_TRUE:is handshake pcap;QUIC_RETURN_DROPME:not quic protocol;
int parse_gquic_Q046(struct streaminfo *pstream, struct _quic_context* _context, void *a_packet, char * payload, int payload_len, int *used_len)
{
	unsigned char frame_type;
	unsigned short tag_num=0;
	unsigned int stream_id, message_tag;
		
	while(*used_len < payload_len)
	{
		frame_type=payload[*used_len];
		*used_len+=1;  //skip frame_type
		
		if(frame_type&IQUIC_FRAME_STREAM_HEX08)
		{
			gquic_frame_type_stream(pstream, _context, payload, payload_len, used_len, frame_type, a_packet);
		}
		else
		{
			return 0; //todo
		}
	}
	
	return QUIC_RETURN_NORM;
}

//cid->version->nounce->pkt num->ahn hash(12)
int quic_process(struct streaminfo *pstream, struct _quic_context* _context, int thread_seq, void* a_packet)
{
	int used_len=0;
	int ret=APP_STATE_GIVEME;
	enum _QUIC_VERSION is_gquic=QUIC_VERSION_UNKNOWN;
	struct udpdetail *udp_detail=pstream->pudpdetail;
	
	if(udp_detail->pdata==NULL || udp_detail->datalen<=0)
	{
		return APP_STATE_GIVEME;
	}

	is_gquic=is_quic_protocol(pstream, _context, (char *)udp_detail->pdata, udp_detail->datalen, &used_len);
	if(is_gquic!=QUIC_VERSION_UNKNOWN)
	{
		if(_context->quic_info.quic_hdr.packet_number==1)
		{
			ret=quic_callPlugins(pstream, _context, &(_context->quic_info.quic_hdr.quic_version), sizeof(_context->quic_info.quic_hdr.quic_version), QUIC_VERSION_MASK, a_packet);
			if(ret&APP_STATE_DROPME | ret&APP_STATE_DROPPKT)
			{
				return ret;
			}
		}
		
		switch(is_gquic)
		{
			case	GQUIC_VERSION_Q043:
				ret=gquic_proc_unencrypt(pstream, _context, a_packet, (char *)udp_detail->pdata, udp_detail->datalen, &used_len);
				break;
			case	GQUIC_VERSION_Q046:
				ret=parse_gquic_Q046(pstream, _context, a_packet, (char *)udp_detail->pdata, udp_detail->datalen, &used_len);
				break;
			default:
				break;
		}
	}

	if(_context->is_quic==QUIC_TRUE)
	{
		return APP_STATE_GIVEME;
	}
	
	return APP_STATE_DROPME;;
}