gfwleak/mesa-platform-quic
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: adapt to stellar-2.0

Browse Source
This commit is contained in:
lijia
2024-06-07 19:03:56 +08:00
parent 1ab2559887
commit 82cd2ced07
17 changed files with 605 additions and 723 deletions
Download Patch File Download Diff File Expand all files Collapse all files

446
src/quic_process.cpp
View File

@@ -11,21 +11,23 @@
#include <stdint.h>
#include <sys/time.h>
#include <arpa/inet.h>
#include <MESA/stream.h>
#include <MESA/MESA_handle_logger.h>
#include "quic_entry.h"
#include "quic_process.h"
#include "quic_deprotection.h"
enum PARSE_RESULT
#ifdef __cplusplus
extern "C"
{
PARSE_RESULT_UNKNOWN,
PARSE_RESULT_VERSION,
PARSE_RESULT_CLIENT_HELLO,
PARSE_RESULT_PAYLOAD,
PARSE_RESULT_MAX
};
#endif
#include "quic_util.h"
#include <stellar/stellar.h>
#include <stellar/session.h>
#include <stellar/session_mq.h>
#include <stellar/session_exdata.h>
#ifdef __cplusplus
}
#endif
#ifndef PRINTADDR
#define PRINTADDR(a, b) ((b)<RLOG_LV_FATAL ? printaddr(&(a->addr), a->threadnum) : "")
@@ -39,49 +41,73 @@ struct quic_client_hello_msg_hdr
uint8_t random[32];
};
int check_port(unsigned short port)
static int check_port(const struct quic_param *quic_plugin_env, unsigned short port)
{
int i=0;
for(i=0; i< g_quic_param.quic_port_num; i++)
for (int i = 0; i < quic_plugin_env->quic_port_num; i++)
{
if(g_quic_param.quic_port_list[i]==port)
if (quic_plugin_env->quic_port_list[i] == port)
{
return 1;
}
}
return 0;
}
int is_quic_port(const struct streaminfo *pstream)
int quic_protocol_identify(struct session *sess, struct quic_param *quic_plugin_env)
{
unsigned short source=0, dest=0;
switch(pstream->addr.addrtype)
enum session_addr_type addr_type;
struct session_addr *saddr = session_get0_addr(sess, &addr_type);
unsigned short sport, dport;
if (addr_type == SESSION_ADDR_TYPE_IPV4_UDP)
{
case ADDR_TYPE_IPV4:
case __ADDR_TYPE_IP_PAIR_V4:
source=(unsigned short)ntohs(pstream->addr.ipv4->source);
dest=(unsigned short)ntohs(pstream->addr.ipv4->dest);
break;
case ADDR_TYPE_IPV6:
case __ADDR_TYPE_IP_PAIR_V6:
source=(unsigned short)ntohs(pstream->addr.ipv6->source);
dest=(unsigned short)ntohs(pstream->addr.ipv6->dest);
break;
default:
return 0;
break;
sport = saddr->ipv4.sport;
dport = saddr->ipv4.dport;
}
if(check_port(source) || check_port(dest))
else if (addr_type == SESSION_ADDR_TYPE_IPV6_UDP)
{
return 1;
sport = saddr->ipv6.sport;
dport = saddr->ipv6.dport;
}
return 0;
else
{
return 0;
}
if (0 == (check_port(quic_plugin_env, sport) || check_port(quic_plugin_env, dport)))
{
return 0;
}
return 1;
}
// int is_quic_port(const struct streaminfo *pstream)
// {
// unsigned short source=0, dest=0;
// switch(pstream->addr.addrtype)
// {
// case ADDR_TYPE_IPV4:
// case __ADDR_TYPE_IP_PAIR_V4:
// source=(unsigned short)ntohs(pstream->addr.ipv4->source);
// dest=(unsigned short)ntohs(pstream->addr.ipv4->dest);
// break;
// case ADDR_TYPE_IPV6:
// case __ADDR_TYPE_IP_PAIR_V6:
// source=(unsigned short)ntohs(pstream->addr.ipv6->source);
// dest=(unsigned short)ntohs(pstream->addr.ipv6->dest);
// break;
// default:
// return 0;
// break;
// }
// if(check_port(source) || check_port(dest))
// {
// return 1;
// }
// return 0;
// }
static int gquic_pkn_bit2length(unsigned char bit_value)
{
switch(bit_value)
@@ -96,19 +122,18 @@ static int gquic_pkn_bit2length(unsigned char bit_value)
return 1;
}
static int copy_extension_tag(const char *tag_start_pos, int tag_len, char **out, int thread_seq)
static int copy_extension_tag(const char *tag_start_pos, int tag_len, struct qstring *out, int thread_seq)
{
if(tag_start_pos!=NULL && tag_len>0)
{
if(*out!=NULL)
if(out->str!=NULL)
{
dictator_free(thread_seq, *out);
*out=NULL;
FREE(out->str);
}
(*out)=(char *)dictator_malloc(thread_seq, tag_len+1);
memcpy(*out, tag_start_pos, tag_len);
(*out)[tag_len]='\0';
out->str=(char *)CALLOC(1, tag_len+1);
memcpy((void *)out->str, tag_start_pos, tag_len);
out->str_len = tag_len;
return tag_len;
}
@@ -137,57 +162,6 @@ static int msb2_varint_decode(const unsigned char *buf, long *out)
return nfollow;
}
int quic_call_business_state(struct quic_context *context)
{
UCHAR state = 0;
if(0==context->link_state)
{
state=SESSION_STATE_PENDING|SESSION_STATE_DATA;
context->link_state=1;
}
else
{
state=SESSION_STATE_DATA;
}
return state;
}
unsigned char quic_call_business_plug(const struct streaminfo *pstream, struct quic_context *context, void *buff, int buff_len, enum quic_interested_region region_mask, const void *a_packet)
{
char state=PROT_STATE_GIVEME;
char app_state=APP_STATE_GIVEME;
stSessionInfo session_info={0};
if(region_mask==QUIC_INTEREST_KEY_MASK)
{
session_info.plugid=g_quic_param.quic_plugid;
session_info.prot_flag=0;
session_info.session_state=SESSION_STATE_CLOSE;
session_info.app_info=NULL;
session_info.buf=NULL;
session_info.buflen=0;
}
else
{
session_info.plugid=g_quic_param.quic_plugid;
session_info.prot_flag=(((unsigned long long)1)<<region_mask);
session_info.session_state=quic_call_business_state(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, (struct streaminfo *)pstream, a_packet);
if(state&PROT_STATE_DROPPKT)
{
app_state=APP_STATE_DROPPKT;
}
return app_state;
}
/*
//https://docs.google.com/document/d/1FcpCJGTDEMblAs-Bm5TYuqhHyUqeWpqrItw2vkMFsdY/edit
@@ -316,11 +290,11 @@ int parse_special_frame_stream(struct quic_info* quic_info, const char *payload,
return PARSE_RESULT_VERSION;
}
if(quic_info->client_hello==NULL)
{
quic_info->client_hello=(struct quic_client_hello *)dictator_malloc(thread_seq, sizeof(struct quic_client_hello));
memset(quic_info->client_hello, 0, sizeof(struct quic_client_hello));
}
// if(quic_info->client_hello==NULL)
// {
// quic_info->client_hello=(struct quic_client_hello *)CALLOC(1, sizeof(struct quic_client_hello));
// memset(quic_info->client_hello, 0, sizeof(struct quic_client_hello));
// }
tag_value_start_offset=payload_offset+tag_num*4*2; // skip length of type and offset, type(offset)=szieof(int)
@@ -341,11 +315,11 @@ int parse_special_frame_stream(struct quic_info* quic_info, const char *payload,
switch(ext_tag_type)
{
case TAG_UAID:
copy_extension_tag(payload+tag_value_start_offset, one_tag_len, &quic_info->client_hello->user_agent, thread_seq);
copy_extension_tag(payload+tag_value_start_offset, one_tag_len, &quic_info->user_agent, thread_seq);
parse_result=PARSE_RESULT_CLIENT_HELLO;
break;
case TAG_SNI:
copy_extension_tag(payload+tag_value_start_offset, one_tag_len, &quic_info->client_hello->sni, thread_seq);
copy_extension_tag(payload+tag_value_start_offset, one_tag_len, &quic_info->sni, thread_seq);
parse_result=PARSE_RESULT_CLIENT_HELLO;
break;
default:
@@ -361,7 +335,7 @@ int parse_special_frame_stream(struct quic_info* quic_info, const char *payload,
return parse_result;
}
int parse_quic_transport_parameter(struct quic_client_hello *client_hello, const char *quic_para, int quic_para_len, int thread_seq)
int parse_quic_transport_parameter(struct quic_info *quic_info, const char *quic_para, int quic_para_len, int thread_seq)
{
int one_para_length=0;
int para_offset=0;
@@ -378,7 +352,7 @@ int parse_quic_transport_parameter(struct quic_client_hello *client_hello, const
{
return 0;
}
para_offset+=copy_extension_tag(quic_para+para_offset, one_para_length, &client_hello->user_agent, thread_seq);
para_offset+=copy_extension_tag(quic_para+para_offset, one_para_length, &quic_info->user_agent, thread_seq);
return 1;
default:
one_para_length=(int)(quic_para[para_offset++]); // length=1
@@ -394,7 +368,7 @@ int parse_quic_transport_parameter(struct quic_client_hello *client_hello, const
return 0;
}
int parse_extension_server_name(struct quic_client_hello *client_hello, const char *ext_server_name, int ext_server_name_length, int thread_seq)
int parse_extension_server_name(struct quic_info *quic_info, const char *ext_server_name, int ext_server_name_length, int thread_seq)
{
unsigned short sni_type=0;
unsigned short sni_length=0;
@@ -421,12 +395,12 @@ int parse_extension_server_name(struct quic_client_hello *client_hello, const ch
}
extension_offset+=2;
copy_extension_tag(ext_server_name+extension_offset, sni_length, &client_hello->sni, thread_seq);
copy_extension_tag(ext_server_name+extension_offset, sni_length, &quic_info->sni, thread_seq);
return 1;
}
int parse_tls_client_hello(struct quic_client_hello **client_hello, const char *payload, int payload_len, int thread_seq)
int parse_tls_client_hello(struct quic_info *quic_info, const char *payload, int payload_len, int thread_seq)
{
int ret=0,skip_len=0;
int payload_offset=0;
@@ -472,11 +446,11 @@ int parse_tls_client_hello(struct quic_client_hello **client_hello, const char *
payload_offset+=2;
if(*client_hello==NULL)
{
*client_hello=(struct quic_client_hello *)dictator_malloc(thread_seq, sizeof(struct quic_client_hello));
memset(*client_hello, 0, sizeof(struct quic_client_hello));
}
// if(*client_hello==NULL)
// {
// *client_hello=(struct quic_client_hello *)CALLOC(1, sizeof(struct quic_client_hello));
// // memset(*client_hello, 0, sizeof(struct quic_client_hello));
// }
extension_start_pos=payload+payload_offset;
@@ -496,11 +470,11 @@ int parse_tls_client_hello(struct quic_client_hello **client_hello, const char *
switch(one_ext_type)
{
case EXTENSION_SERVER_NAME:
ret=parse_extension_server_name(*client_hello, extension_start_pos+extension_offset, one_ext_len, thread_seq);
ret=parse_extension_server_name(quic_info, extension_start_pos+extension_offset, one_ext_len, thread_seq);
break;
case EXTENSION_QUIC_PARAM_TLS_13:
case EXTENSION_QUIC_PARAM_TLS_33:
ret=parse_quic_transport_parameter(*client_hello, extension_start_pos+extension_offset, one_ext_len, thread_seq);
ret=parse_quic_transport_parameter(quic_info, extension_start_pos+extension_offset, one_ext_len, thread_seq);
break;
default:
break;
@@ -538,7 +512,7 @@ int parse_quic_decrypted_payload(struct quic_info *quic_info, const char * paylo
if(join_payload[0] == QUIC_HANDSHAKE_TYPE_CLIENTHELLO)
{
return parse_tls_client_hello(&(quic_info->client_hello), join_payload, join_payload_len, thread_seq);
return parse_tls_client_hello(quic_info, join_payload, join_payload_len, thread_seq);
}
}
else //if(quic_version>=GQUIC_VERSION_Q047 && quic_version<=GQUIC_VERSION_Q059)
@@ -645,11 +619,11 @@ int parse_quic_uncryption_payload(struct quic_info *quic_info, const char * payl
+--------+--------+--------+--------+--------+--------+
*/
enum QUIC_VERSION identify_gquic_version0to43(const char *payload, int payload_len, int *payload_offset)
enum QUIC_VERSION_T identify_gquic_version0to43(const char *payload, int payload_len, int *payload_offset)
{
unsigned char pkn_length=0;
unsigned char public_flags=0;
enum QUIC_VERSION quic_version=QUIC_VERSION_UNKNOWN;
enum QUIC_VERSION_T quic_version=QUIC_VERSION_UNKNOWN;
public_flags=payload[*payload_offset];
*payload_offset+=1;
@@ -671,7 +645,7 @@ enum QUIC_VERSION identify_gquic_version0to43(const char *payload, int payload_l
if(public_flags&GQUIC_PUBLIC_FLAG_VERSION && (*(unsigned char *)(payload+*payload_offset)==0x51))
{
quic_version=(enum QUIC_VERSION)ntohl(*(unsigned int *)(payload+*payload_offset));
quic_version=(enum QUIC_VERSION_T)ntohl(*(unsigned int *)(payload+*payload_offset));
*payload_offset+=sizeof(int); // skip version
}
@@ -708,9 +682,9 @@ enum QUIC_VERSION identify_gquic_version0to43(const char *payload, int payload_l
return quic_version;
}
enum QUIC_VERSION identify_quic_version(const char *payload, int payload_len, int *payload_offset)
enum QUIC_VERSION_T identify_quic_version(const char *payload, int payload_len, int *payload_offset)
{
enum QUIC_VERSION quic_version=(enum QUIC_VERSION)ntohl(*(unsigned int *)(payload+(*payload_offset+1)));
enum QUIC_VERSION_T quic_version=(enum QUIC_VERSION_T)ntohl(*(unsigned int *)(payload+(*payload_offset+1)));
if(quic_version>=GQUIC_VERSION_Q044 && quic_version<=GQUIC_VERSION_Q048)
{
parse_gquic_version_44to48_header(payload, payload_len, payload_offset);
@@ -741,9 +715,9 @@ enum QUIC_VERSION identify_quic_version(const char *payload, int payload_len, in
return QUIC_VERSION_UNKNOWN;
}
enum QUIC_VERSION is_quic_protocol(const char *payload, int payload_len, int *payload_offset)
enum QUIC_VERSION_T is_quic_protocol(const char *payload, int payload_len, int *payload_offset)
{
enum QUIC_VERSION quic_version=QUIC_VERSION_UNKNOWN;
enum QUIC_VERSION_T quic_version=QUIC_VERSION_UNKNOWN;
unsigned char frame_type=(unsigned char)(payload[0]);
if(payload_len<=4)
@@ -767,40 +741,39 @@ enum QUIC_VERSION is_quic_protocol(const char *payload, int payload_len, int *pa
return quic_version;
}
unsigned char parse_quic_all_version(struct quic_info *quic_info, const char *payload, int payload_len, int thread_seq)
enum PARSE_RESULT parse_quic_all_version(const struct quic_param *g_quic_plugin_env, struct quic_info *quic_info, const char *payload, int payload_len, int thread_seq)
{
int ret=0, payload_offset=0;
enum QUIC_VERSION quic_version=QUIC_VERSION_UNKNOWN;
int ret = 0, payload_offset = 0;
enum QUIC_VERSION_T quic_version = QUIC_VERSION_UNKNOWN;
if(payload==NULL || payload_len<=0)
if (payload == NULL || payload_len <= 0)
{
return PARSE_RESULT_UNKNOWN;
}
quic_version=is_quic_protocol(payload, payload_len, &payload_offset);
if(quic_version==QUIC_VERSION_UNKNOWN)
quic_version = is_quic_protocol(payload, payload_len, &payload_offset);
if (quic_version == QUIC_VERSION_UNKNOWN)
{
return PARSE_RESULT_UNKNOWN;
}
quic_info->quic_version=quic_version;
if(quic_version>=GQUIC_VERSION_Q001 && quic_version<=GQUIC_VERSION_Q048)
quic_info->quic_version = quic_version;
if (quic_version >= GQUIC_VERSION_Q001 && quic_version <= GQUIC_VERSION_Q048)
{
if(payload_len > payload_offset)
if (payload_len > payload_offset)
{
return parse_quic_uncryption_payload(quic_info, payload+payload_offset, payload_len-payload_offset, thread_seq);
return (enum PARSE_RESULT)parse_quic_uncryption_payload(quic_info, payload + payload_offset, payload_len - payload_offset, thread_seq);
}
return PARSE_RESULT_VERSION;
}
else if(((quic_version>=MVFST_VERSION_00 && quic_version<=MVFST_VERSION_0F) ||
(quic_version>=GQUIC_VERSION_Q049 && quic_version<=GQUIC_VERSION_Q059) ||
(quic_version>=GQUIC_VERSION_T050 && quic_version<=GQUIC_VERSION_T059) ||
(quic_version>=GQUIC_VERSION_T050 && quic_version<=GQUIC_VERSION_T059) ||
(quic_version>=IQUIC_VERSION_I022 && quic_version<=IQUIC_VERSION_I029) ||
(quic_version==IQUIC_VERSION_RFC9000))
&& g_quic_param.decrypted_switch>0
)
else if (((quic_version >= MVFST_VERSION_00 && quic_version <= MVFST_VERSION_0F) ||
(quic_version >= GQUIC_VERSION_Q049 && quic_version <= GQUIC_VERSION_Q059) ||
(quic_version >= GQUIC_VERSION_T050 && quic_version <= GQUIC_VERSION_T059) ||
(quic_version >= GQUIC_VERSION_T050 && quic_version <= GQUIC_VERSION_T059) ||
(quic_version >= IQUIC_VERSION_I022 && quic_version <= IQUIC_VERSION_I029) ||
(quic_version == IQUIC_VERSION_RFC9000)) &&
g_quic_plugin_env->decrypted_switch > 0)
{
quic_dpt_t *dpt = quic_deprotection_new();
if (quic_deprotection(dpt, (const u_char *)payload, payload_len) != 0)
@@ -809,11 +782,11 @@ unsigned char parse_quic_all_version(struct quic_info *quic_info, const char *pa
return PARSE_RESULT_VERSION;
}
if(g_quic_param.decrypted_switch==2)
if (g_quic_plugin_env->decrypted_switch == 2)
{
ret = parse_quic_decrypted_payload(quic_info, (const char *)dpt->payload.data, dpt->payload.len, thread_seq);
ret = parse_quic_decrypted_payload(quic_info, (const char *)dpt->payload.data, dpt->payload.len, thread_seq);
quic_deprotection_free(dpt);
return ret;
return (enum PARSE_RESULT)ret;
}
quic_deprotection_free(dpt);
}
@@ -821,106 +794,121 @@ unsigned char parse_quic_all_version(struct quic_info *quic_info, const char *pa
{
return PARSE_RESULT_VERSION;
}
return PARSE_RESULT_VERSION;
}
unsigned char quic_analyze_entry(const struct streaminfo *pstream, struct quic_context* context, int thread_seq, const void* a_packet)
void quic_analyze_entry(struct session *sess, const struct quic_param *g_quic_plugin_env, struct quic_context *qcontext, int thread_seq, const char *payload, size_t payload_len)
{
unsigned char parse_result=PARSE_RESULT_UNKNOWN;
char state=APP_STATE_GIVEME;
struct quic_message *qmsg;
int push_payload = 0;
enum PARSE_RESULT parse_res = PARSE_RESULT_UNKNOWN;
if(pstream==NULL || pstream->pudpdetail==NULL || context==NULL)
{
return APP_STATE_DROPME;
}
if ((qcontext->parse_pkt_cnt++) >= g_quic_plugin_env->max_parse_pkt_num){
push_payload = 1;
}else{
if(0 == qcontext->msg_state[QUIC_VERSION]
|| 0 == qcontext->msg_state[QUIC_SNI]
|| 0 == qcontext->msg_state[QUIC_USER_AGENT]){
if(NULL == qcontext->quic_info.sni.str
|| NULL == qcontext->quic_info.user_agent.str){
parse_res = parse_quic_all_version(g_quic_plugin_env, &(qcontext->quic_info), payload, payload_len, thread_seq);
if(PARSE_RESULT_VERSION == parse_res){
push_payload = 1;
}
}
struct udpdetail *udp_detail=pstream->pudpdetail;
switch(context->pre_parse_state)
{
case PARSE_RESULT_CLIENT_HELLO:
parse_result=PARSE_RESULT_PAYLOAD;
break;
case PARSE_RESULT_VERSION:
parse_result=parse_quic_all_version(&(context->quic_info), (const char *)udp_detail->pdata, udp_detail->datalen, thread_seq);
if(parse_result==PARSE_RESULT_VERSION || parse_result==PARSE_RESULT_UNKNOWN)
{
parse_result=PARSE_RESULT_PAYLOAD;
if((0 == qcontext->msg_state[QUIC_VERSION]) && (qcontext->quic_info.quic_version != 0)){
qmsg = quic_create_message(QUIC_VERSION, qcontext);
quic_session_mq_publish_message_safe(sess, g_quic_plugin_env->quic_topic_id, qmsg);
qcontext->msg_state[QUIC_VERSION] = 1;
}
break;
case PARSE_RESULT_PAYLOAD:
case PARSE_RESULT_UNKNOWN:
default:
if(context->parse_first_pkt==1)
{
context->parse_first_pkt=0;
if(context->quic_info.client_hello==NULL)
{
parse_result=PARSE_RESULT_VERSION;
}
else
{
parse_result=PARSE_RESULT_CLIENT_HELLO;
}
break;
if((0 == qcontext->msg_state[QUIC_SNI]) && qcontext->quic_info.sni.str){
qmsg = quic_create_message(QUIC_SNI, qcontext);
quic_session_mq_publish_message_safe(sess, g_quic_plugin_env->quic_topic_id, qmsg);
qcontext->msg_state[QUIC_SNI] = 1;
}
if((context->parse_pkt_cnt++)>=g_quic_param.max_parse_pkt_num)
{
parse_result=PARSE_RESULT_PAYLOAD;
break;
if((0 == qcontext->msg_state[QUIC_USER_AGENT]) && qcontext->quic_info.user_agent.str){
qmsg = quic_create_message(QUIC_USER_AGENT, qcontext);
quic_session_mq_publish_message_safe(sess, g_quic_plugin_env->quic_topic_id, qmsg);
qcontext->msg_state[QUIC_USER_AGENT] =1;
}
parse_result=parse_quic_all_version(&(context->quic_info), (const char *)udp_detail->pdata, udp_detail->datalen, thread_seq);
break;
}
}
switch(parse_result)
{
case PARSE_RESULT_VERSION:
context->pre_parse_state=PARSE_RESULT_VERSION;
state=quic_call_business_plug(pstream, context, (void *)&(context->quic_info.quic_version), sizeof(unsigned int), QUIC_USEING_VERSION_MASK, a_packet);
break;
case PARSE_RESULT_CLIENT_HELLO:
context->pre_parse_state=PARSE_RESULT_CLIENT_HELLO;
state=quic_call_business_plug(pstream, context, (void *)&(context->quic_info), sizeof(void *), QUIC_CLIENT_HELLO_MASK, a_packet);
break;
case PARSE_RESULT_PAYLOAD:
state=quic_call_business_plug(pstream, context, udp_detail->pdata, udp_detail->datalen, QUIC_APPLICATION_DATA_MASK, a_packet);
break;
default:
return APP_STATE_DROPME;
break;
if(push_payload){
qcontext->quic_info.payload.str = payload;
qcontext->quic_info.payload.str_len = payload_len;
qmsg = quic_create_message(QUIC_PAYLOAD, qcontext);
quic_session_mq_publish_message_safe(sess, g_quic_plugin_env->quic_topic_id, qmsg);
}
return state;
return;
}
struct quic_info *quic_protocol_identify(const struct streaminfo *a_stream)
void quic_session_mq_publish_message_safe(struct session *sess, int topic_id, void *msg)
{
if(!is_quic_port(a_stream) || a_stream==NULL || a_stream->pudpdetail==NULL)
{
return NULL;
int ret = session_mq_publish_message(sess, topic_id, msg);
if(ret < 0){
FREE(msg);
}
struct quic_info tmp_quic_info={0, NULL};
unsigned char parse_result=APP_STATE_GIVEME;
parse_result=parse_quic_all_version(&tmp_quic_info, (const char *)a_stream->pudpdetail->pdata, a_stream->pudpdetail->datalen, a_stream->threadnum);
if(parse_result!=PARSE_RESULT_UNKNOWN)
{
struct quic_context *context=(struct quic_context *)dictator_malloc(a_stream->threadnum, sizeof(struct quic_context));
memset(context, 0, sizeof(struct quic_context));
context->quic_info=tmp_quic_info;
context->parse_first_pkt=1;
context->pre_parse_state=PARSE_RESULT_UNKNOWN;
stream_bridge_async_data_put(a_stream, g_quic_param.context_bridge_id, (void *)context);
return &(context->quic_info);
}
return NULL;
return;
}
struct quic_message *quic_create_message(enum quic_message_type mtype, struct quic_context *context)
{
struct quic_message *msg = (struct quic_message *)CALLOC(1, sizeof(struct quic_message));
msg->magic = QUIC_MSG_HDR_MAGIC;
msg->type = mtype;
msg->qctx = context;
return msg;
}
#ifdef __cplusplus
extern "C"
{
#endif
enum quic_message_type quic_message_type_get(const struct quic_message *msg)
{
assert(QUIC_MSG_HDR_MAGIC == msg->magic);
if(QUIC_MSG_HDR_MAGIC != msg->magic){
return QUIC_MSG_MAX;
}
return msg->type;
}
void quic_message_get_version(const struct quic_message *msg, unsigned int *result)
{
assert(QUIC_MSG_HDR_MAGIC == msg->magic);
if(result){
*result = msg->qctx->quic_info.quic_version;
}
}
void quic_message_get_sni(const struct quic_message *msg, struct qstring *result)
{
assert(QUIC_MSG_HDR_MAGIC == msg->magic);
if(result){
result->str = msg->qctx->quic_info.sni.str;
result->str_len = msg->qctx->quic_info.sni.str_len;
}
}
void quic_message_get_user_agent(const struct quic_message *msg, struct qstring *result)
{
assert(QUIC_MSG_HDR_MAGIC == msg->magic);
if(result){
result->str = msg->qctx->quic_info.user_agent.str;
result->str_len = msg->qctx->quic_info.user_agent.str_len;
}
}
void quic_message_get_payload(const struct quic_message *msg, struct qstring *result)
{
assert(QUIC_MSG_HDR_MAGIC == msg->magic);
if(result){
result->str = msg->qctx->quic_info.payload.str;
result->str_len = msg->qctx->quic_info.payload.str_len;
}
}
#ifdef __cplusplus
}
#endif