dtls rebase onto stellar develop-2.0

4 files changed, 41 insertions, 48 deletions

diff --git a/decoders/dtls/dtls_parse.c b/decoders/dtls/dtls_parse.c
index 739125a..fc3f2b3 100644
--- a/decoders/dtls/dtls_parse.c
+++ b/decoders/dtls/dtls_parse.c
@@ -361,7 +361,7 @@ int32_t dtls_parser_hello(struct session *sess, struct dtls_handshake_header *ha
 	int is_client = (handshake_hd->msg_type == dtls_type_client_hello) ? DTLS_TRUE : DTLS_FALSE;
 	ret = dtls_get_hello_info(dtls_hello_payload, dtls_hello_len, is_client, &dtls_hello, logger);
 	if(ret == DTLS_PARSER_ERR) {
-		STELLAR_LOG_FATAL(logger, "dtls_get_hello_info", "[%s] error", session_get0_readable_addr(sess));
+		STELLAR_LOG_FATAL(logger, "dtls_get_hello_info", "[%s] error", session_get_readable_addr(sess));
 		return ret;
 	}
 
@@ -422,7 +422,7 @@ static int32_t dtls_parser_hello_verify_request(struct session *sess, struct dtl
 	int ret = dtls_get_hello_verify_req_info( dtls_hvr_payload, dtls_hvr_payload_len, &dtls_hvr, logger);
 	if( DTLS_PARSER_OK != ret) {
 		STELLAR_LOG_FATAL(logger, "dtls_get_hello_verify_req_info", "[%s] error",
-									session_get0_readable_addr(sess));
+									session_get_readable_addr(sess));
 		return ret;
 	}
 
@@ -573,7 +573,7 @@ int32_t dtls_parser_handshake(struct session *sess, struct dtls_parse_ctx **pars
 	struct dtls_handshake_header handshake_hd={0};
 	int32_t ret = dtls_parser_handshake_header(dtls_payload, dtls_payload_len, parse_ctx, &handshake_hd, logger);
 	if (ret < 0) {
-		STELLAR_LOG_DEBUG(logger, "dtls_parser_handshake_header", "addr:%s. ret:%d", session_get0_readable_addr(sess));
+		STELLAR_LOG_DEBUG(logger, "dtls_parser_handshake_header", "addr:%s. ret:%d", session_get_readable_addr(sess));
 		return ret;
 	}
 
@@ -581,19 +581,19 @@ int32_t dtls_parser_handshake(struct session *sess, struct dtls_parse_ctx **pars
 	{
 		case dtls_type_client_hello:
 		case dtls_type_server_hello:
-			STELLAR_LOG_DEBUG(logger, __FUNCTION__, "[%s] This handshake type is %s.", session_get0_readable_addr(sess), 
+			STELLAR_LOG_DEBUG(logger, __FUNCTION__, "[%s] This handshake type is %s.", session_get_readable_addr(sess), 
 														handshake_hd.msg_type==dtls_type_client_hello?"CLIENT_HELLO":"SERVER_HELLO");
 			ret = dtls_parser_hello(sess, &handshake_hd, dtls_msg, logger);
 			break;
 
 		case dtls_type_hello_verify_request:
-			STELLAR_LOG_DEBUG(logger, __FUNCTION__, "[%s] This handshake type is HELLO_VERIFY_REQUEST.", session_get0_readable_addr(sess));
+			STELLAR_LOG_DEBUG(logger, __FUNCTION__, "[%s] This handshake type is HELLO_VERIFY_REQUEST.", session_get_readable_addr(sess));
 			ret = dtls_parser_hello_verify_request(sess, &handshake_hd, dtls_msg, logger);
 			break;
 
 		default:
 			ret = DTLS_PARSER_OK;
-			STELLAR_LOG_DEBUG(logger, __FUNCTION__, "[%s] This message type:%d is not supported.", session_get0_readable_addr(sess), handshake_hd.msg_type);
+			STELLAR_LOG_DEBUG(logger, __FUNCTION__, "[%s] This message type:%d is not supported.", session_get_readable_addr(sess), handshake_hd.msg_type);
 			break;
 	}
 
@@ -642,7 +642,7 @@ int32_t dtls_parser_header(const char *payload, uint32_t payload_len, struct dtl
 
 int8_t dtls_parser_entry(struct session *sess, struct dtls_parse_ctx **parse_ctx, struct dtls_message *dtls_msg, void *logger)
 {
-	const struct packet *pkt = session_get0_current_packet(sess);
+	const struct packet *pkt = session_get_current_packet(sess);
 	const char *udp_payload = (const char *)packet_get_payload_data(pkt);
 	uint32_t udp_payload_len = packet_get_payload_len(pkt);
 	uint32_t offset = 0;
@@ -653,7 +653,7 @@ int8_t dtls_parser_entry(struct session *sess, struct dtls_parse_ctx **parse_ctx
 	if(dtls_content_type < DTLS_CONTENT_TYPE_CHANGE_CIPHER_SPEC || 
 								dtls_content_type > DTLS_CONTENT_TYPE_HEARTBEAT) {
 		STELLAR_LOG_INFO(logger, "dtls_header", "[%s] This is not a dtls package.! first byte:0x%02x ", 
-											session_get0_readable_addr(sess), dtls_content_type);
+											session_get_readable_addr(sess), dtls_content_type);
 		return 0;
 	}
 
@@ -662,13 +662,13 @@ int8_t dtls_parser_entry(struct session *sess, struct dtls_parse_ctx **parse_ctx
 		dtls_parser_header(udp_payload + offset, udp_payload_len - offset, &header, logger);
 		if ( DTLS_CONTENT_TYPE_HANDSHAKE == header.content_type ) {
 			if(offset + DTLS_HEADER_LEN + DTLS_HANDSHAKE_HEADER_LEN > udp_payload_len) {
-				STELLAR_LOG_FATAL(logger, "dtls_header", "[%s] udp_payload_len:%d", session_get0_readable_addr(sess), udp_payload_len);
+				STELLAR_LOG_FATAL(logger, "dtls_header", "[%s] udp_payload_len:%d", session_get_readable_addr(sess), udp_payload_len);
 				break;
 			}
 
 			int ret = dtls_parser_handshake(sess, parse_ctx, &header, dtls_msg, logger);
 			if (DTLS_PARSER_ERR == ret) {
-				STELLAR_LOG_INFO(logger, "dtls_header", "[%s] dtls_parser_handshake error.", session_get0_readable_addr(sess));
+				STELLAR_LOG_INFO(logger, "dtls_header", "[%s] dtls_parser_handshake error.", session_get_readable_addr(sess));
 				break;
 			}
 		} else if(DTLS_CONTENT_TYPE_APPLICATION_DATA == header.content_type) {
@@ -676,7 +676,7 @@ int8_t dtls_parser_entry(struct session *sess, struct dtls_parse_ctx **parse_ctx
 			break;
 		} else {
 			STELLAR_LOG_INFO(logger, "dtls_header", "[%s] This content_type:%d is not supported.",
-									session_get0_readable_addr(sess), header.content_type);
+									session_get_readable_addr(sess), header.content_type);
 			break;
 		}
 
diff --git a/decoders/dtls/dtls_plugin.c b/decoders/dtls/dtls_plugin.c
index 3bcb208..961edff 100644
--- a/decoders/dtls/dtls_plugin.c
+++ b/decoders/dtls/dtls_plugin.c
@@ -23,19 +23,11 @@
 
 struct dtls_decoder
 {
-	int32_t plugin_id;
 	int32_t sess_exdata_index;
-	uint64_t dtls_interested_region_flag;
 	void *logger;
-	uint32_t stun_max_num_before_dtls;		//在进入解析dtls前，识别出的包是stun的个数，如果超过这个个数，则说明这条流不是dtls流。	
-	uint16_t dtls_plugid;
-	uint8_t	reserve[2];
-	struct stellar *st;
-	int32_t sub_topic_id;
+	uint32_t stun_max_num_before_dtls;		//在进入解析dtls前，识别出的包是stun的个数，如果超过这个个数，则说明这条流不是dtls流。
 	int32_t pub_topic_id[MAX_DTLS_MSG_TYPE];
-	struct stellar_module_manager *mod_mgr;
-    struct dtls_map *cipher_names_map;
-    struct dtls_map *extension_names_map;
+	struct module_manager *mod_mgr;
 };
 
 enum dtls_protocol {
@@ -110,14 +102,14 @@ void dtls_decoder_on_message(struct session *sess, enum session_state state, str
 				sess_exdata->protocol=protocol;
 				sess_exdata->stun_skip_sz+=1;
 				STELLAR_LOG_INFO(logger, __FUNCTION__, "[%s] protocol_fingerprint : STUN, sess_stun_skip_sz:%d",
-														session_get0_readable_addr(sess), sess_exdata->stun_skip_sz);
+														session_get_readable_addr(sess), sess_exdata->stun_skip_sz);
 				break;
 			}
 		}
 
 		sess_exdata->protocol=DTLS_PROTOCOL_DTLS;
 		dtls_parser_entry(sess, &sess_exdata->parse_ctx, &dtls_msg, env->logger);
-		if(dtls_msg.msg_content!=NULL) dtls_message_send(stellar_module_manager_get_mq_runtime(env->mod_mgr), &dtls_msg);
+		if(dtls_msg.msg_content!=NULL) dtls_message_send(module_manager_get_mq_runtime(env->mod_mgr), &dtls_msg);
 		break;
 	}
 
@@ -135,7 +127,7 @@ void dtls_decoder_on_message(struct session *sess, enum session_state state, str
 		} else {
 			app_data->offset=0;
 		}
-		dtls_message_send(stellar_module_manager_get_mq_runtime(env->mod_mgr), &dtls_msg);
+		dtls_message_send(module_manager_get_mq_runtime(env->mod_mgr), &dtls_msg);
 		break;
 
 	default:
@@ -260,12 +252,12 @@ static void stellar_dtls_on_msg_dispatch(int topic_id, void *msg, on_msg_cb_func
 	return;
 }
 
-int subscribe_callback(struct stellar_module_manager *mod_mgr, const char *msg_name, on_msg_cb_func *callback, void *args) {
-	int topic_id=mq_schema_get_topic_id(stellar_module_manager_get_mq_schema(mod_mgr), msg_name);
+int subscribe_callback(struct module_manager *mod_mgr, const char *msg_name, on_msg_cb_func *callback, void *args) {
+	int topic_id=mq_schema_get_topic_id(module_manager_get_mq_schema(mod_mgr), msg_name);
 	if(topic_id < 0) {
 		return -1;
 	}
-	int ret=mq_schema_subscribe(stellar_module_manager_get_mq_schema(mod_mgr), topic_id, callback, args);
+	int ret=mq_schema_subscribe(module_manager_get_mq_schema(mod_mgr), topic_id, callback, args);
 	return ret < 0 ? -1 : 0;
 }
 
@@ -285,11 +277,11 @@ int dtls_subscribe(struct dtls_decoder *dtls,
     return 0;
 }
 
-struct dtls_decoder *module_to_dtls_decoder(struct stellar_module *mod)
+struct dtls_decoder *module_to_dtls_decoder(struct module *mod)
 {
 	if(mod==NULL)return NULL;
-	assert(strcmp(stellar_module_get_name(mod), DTLS_MODULE_NAME) == 0);  
-	struct dtls_decoder *dtls_d=(struct dtls_decoder *)stellar_module_get_ctx(mod);
+	assert(strcmp(module_get_name(mod), DTLS_MODULE_NAME) == 0);  
+	struct dtls_decoder *dtls_d=(struct dtls_decoder *)module_get_ctx(mod);
 	if(dtls_d==NULL)return NULL;
 	return dtls_d;
 }
@@ -335,12 +327,12 @@ void dtls_application_free(void *msg, void *msg_free_arg __attribute__((unused))
 	return;
 }
 
-void dtls_decoder_exit(struct stellar_module_manager *mod_mgr, struct stellar_module *mod)
+void dtls_decoder_exit(struct module_manager *mod_mgr, struct module *mod)
 {
 	if(mod_mgr==NULL || mod==NULL)return;
     dtls_destroy_cipher_names_map();
 	dtls_destroy_extension_names_map();
-	stellar_module_free(mod);
+	module_free(mod);
     return ;
 }
 
@@ -352,10 +344,10 @@ struct dtls_msg_schema
 	void *msg_free_arg;
 };
 
-struct stellar_module *dtls_decoder_init(struct stellar_module_manager *mod_mgr)
+struct module *dtls_decoder_init(struct module_manager *mod_mgr)
 {
     memset(&g_dtls_plugin_cfg, 0, sizeof(struct dtls_decoder));
-	g_dtls_plugin_cfg.logger=stellar_module_manager_get_logger(mod_mgr);
+	g_dtls_plugin_cfg.logger=module_manager_get_logger(mod_mgr);
 	// int ret=load_dtls_decoder_config(DTLS_CONFIG_PATH, &g_dtls_plugin_cfg);
 	// if(ret < 0) {
 	// 	STELLAR_LOG_FATAL(g_dtls_plugin_cfg.logger, DTLS_MODULE_NAME, "load_dtls_decoder_config failed, cfg_path: %s", DTLS_CONFIG_PATH);
@@ -367,9 +359,10 @@ struct stellar_module *dtls_decoder_init(struct stellar_module_manager *mod_mgr)
 	dtls_create_cipher_names_map();
 	dtls_create_extension_names_map();
 
-	struct session_manager *sess_mgr=stellar_module_get_session_manager(mod_mgr);
+	struct module *sess_mgr_mod=module_manager_get_module(mod_mgr, SESSION_MANAGER_MODULE_NAME);
+	struct session_manager *sess_mgr=module_to_session_manager(sess_mgr_mod);
 	g_dtls_plugin_cfg.sess_exdata_index=session_manager_new_session_exdata_index(sess_mgr, DTLS_MODULE_NAME, dtls_session_exdata_free, NULL);
-	struct mq_schema *mq_s=stellar_module_manager_get_mq_schema(mod_mgr);
+	struct mq_schema *mq_s=module_manager_get_mq_schema(mod_mgr);
 
 	struct dtls_msg_schema dtls_msg_schema[MAX_DTLS_MSG_TYPE]={
 		{DTLS_CLIENT_HELLO_MSG_NAME, dtls_handshake_free, NULL},
@@ -387,5 +380,5 @@ struct stellar_module *dtls_decoder_init(struct stellar_module_manager *mod_mgr)
 	}
 
 	session_manager_subscribe_udp(sess_mgr, dtls_decoder_on_message, &g_dtls_plugin_cfg);
-	return stellar_module_new(DTLS_MODULE_NAME, &g_dtls_plugin_cfg);
+	return module_new(DTLS_MODULE_NAME, &g_dtls_plugin_cfg);
 }
\ No newline at end of file
diff --git a/include/stellar/dtls.h b/include/stellar/dtls.h
index 4010b43..3209a5a 100644
--- a/include/stellar/dtls.h
+++ b/include/stellar/dtls.h
@@ -9,7 +9,7 @@ extern "C"
 #include <stddef.h>
 #include <stdlib.h>
 #include "stellar/session.h"
-#include "stellar/module_manager.h"
+#include "stellar/module.h"
 #include "uthash/utarray.h"
 
 struct dtls_handshake_extension
@@ -58,7 +58,7 @@ typedef void dtls_on_application_data_callback(struct session *sess,
 
 #define DTLS_MODULE_NAME "DTLS"
 struct dtls_decoder;
-struct dtls_decoder *module_to_dtls_decoder(struct stellar_module *mod);
+struct dtls_decoder *module_to_dtls_decoder(struct module *mod);
 int dtls_subscribe(struct dtls_decoder *dtls,
                    dtls_on_client_hello_callback *on_chello_cb, 
                    dtls_on_server_hello_callback *on_shello_cb, 
diff --git a/test/decoders/dtls/dtls_test_plug.c b/test/decoders/dtls/dtls_test_plug.c
index fa1a9ca..553f578 100644
--- a/test/decoders/dtls/dtls_test_plug.c
+++ b/test/decoders/dtls/dtls_test_plug.c
@@ -259,31 +259,31 @@ void dtls_application_data_callback(struct session *sess,
     if(offset==0) {
         cJSON_AddNumberToObject(g_result_json, "application_data_start", 1);
     }
-    // dtls_record_application_data(application_data, application_data_sz, g_result_json);
+
     if(is_finished) {
         cJSON_AddNumberToObject(g_result_json, "sum_application_data_sz", offset+application_data_sz);
-        cJSON_AddStringToObject(g_result_json, "test_result:", session_get0_readable_addr(sess));
+        cJSON_AddStringToObject(g_result_json, "test_result:", session_get_readable_addr(sess));
     }
     return;
 }
 
-struct stellar_module *dtls_decoder_test_init(struct stellar_module_manager *mod_mgr)
+struct module *dtls_decoder_test_init(struct module_manager *mod_mgr)
 {
-    struct dtls_decoder *dtls_decoder=module_to_dtls_decoder(stellar_module_manager_get_module(mod_mgr, DTLS_MODULE_NAME));
+    struct dtls_decoder *dtls_decoder=module_to_dtls_decoder(module_manager_get_module(mod_mgr, DTLS_MODULE_NAME));
     dtls_subscribe(dtls_decoder, 
                         dtls_client_hello_callback, 
                         dtls_server_hello_callback, 
                         dtls_hello_verify_request_callback, 
                         dtls_application_data_callback, 
                         NULL);
-	struct session_manager *sess_mgr=stellar_module_get_session_manager(mod_mgr);
+    struct module *sess_mgr_mod=module_manager_get_module(mod_mgr, SESSION_MANAGER_MODULE_NAME);
+	struct session_manager *sess_mgr=module_to_session_manager(sess_mgr_mod);
 	g_exdata_index=session_manager_new_session_exdata_index(sess_mgr, "DTLS_TEST_PLUG", dtls_test_session_exdata_free, NULL);
-    return stellar_module_new("TEST_DTLS", NULL);
+    return module_new("TEST_DTLS", NULL);
 }
 
-void dtls_decoder_test_exit(struct stellar_module_manager *mod_mgr, struct stellar_module *mod)
+void dtls_decoder_test_exit(struct module_manager *mod_mgr, struct module *mod)
 {
     (void)(mod_mgr);
-    stellar_module_free(mod);
-    printf("dtls_decoder_test_exit OK!\n");
+    module_free(mod);
 }