update:network基础的连发收断完成

components/ethernet/w5500/w5500.c

@@ -10,10 +10,13 @@
 #include "dhcp_def.h"
 #include "dns_def.h"
 #include "platform_def.h"
+
 extern void DBG_Printf(const char* format, ...);
 extern void DBG_HexPrintf(void *Data, unsigned int len);
 #define DBG(x,y...)		DBG_Printf("%s %d:"x"\r\n", __FUNCTION__,__LINE__,##y)
 #define DBG_ERR(x,y...)		DBG_Printf("%s %d:"x"\r\n", __FUNCTION__,__LINE__,##y)
+#define W5500_LOCK	OS_SuspendTask(NULL)
+#define W5500_UNLOCK OS_ResumeTask(NULL)
 
 #define socket_index(n)	(n << 5)
 #define common_reg	(0)
@@ -837,7 +840,7 @@ static void w5500_sys_socket_callback(w5500_ctrl_t *w5500, uint8_t socket_id, ui
 		}
 		if (w5500->network_ready)
 		{
-			if (socket_id) OS_SuspendTask(NULL);
+			if (socket_id) W5500_LOCK;
 			p = llist_traversal(&w5500->socket[socket_id].tx_head, w5500_next_data_cache, &prv_w5500_ctrl->socket[socket_id]);
 			if (p && !p->is_sending)
 			{
@@ -858,7 +861,7 @@ static void w5500_sys_socket_callback(w5500_ctrl_t *w5500, uint8_t socket_id, ui
 			{
 				w5500->socket[socket_id].tx_wait_size = 0;
 			}
-			if (socket_id) OS_ResumeTask(NULL);
+			if (socket_id) W5500_UNLOCK;
 
 		}
 		break;
@@ -877,15 +880,15 @@ static void w5500_sys_socket_callback(w5500_ctrl_t *w5500, uint8_t socket_id, ui
 				if (w5500->socket[socket_id].is_tcp)
 				{
 					socket_data_t *p = w5500_create_data_node(w5500, socket_id, rx_buf.Data, result, NULL, 0);
-					OS_SuspendTask(NULL);
+					W5500_LOCK;
 					llist_add_tail(p, &prv_w5500_ctrl->socket[socket_id].rx_head);
 					prv_w5500_ctrl->socket[socket_id].rx_wait_size += result;
-					OS_ResumeTask(NULL);
+					W5500_UNLOCK;
 					w5500_callback_to_nw_task(w5500, EV_NW_SOCKET_RX_NEW, socket_id, result, 0);
 				}
 				else
 				{
-					OS_SuspendTask(NULL);
+					W5500_LOCK;
 					rx_buf.Pos = 0;
 					while (rx_buf.Pos < result)
 					{
@@ -900,7 +903,7 @@ static void w5500_sys_socket_callback(w5500_ctrl_t *w5500, uint8_t socket_id, ui
 						llist_add_tail(p, &prv_w5500_ctrl->socket[socket_id].rx_head);
 						prv_w5500_ctrl->socket[socket_id].rx_wait_size += len;
 					}
-					OS_ResumeTask(NULL);
+					W5500_UNLOCK;
 					w5500_callback_to_nw_task(w5500, EV_NW_SOCKET_RX_NEW, socket_id, result, 0);
 				}
 			}
@@ -946,7 +949,15 @@ static void w5500_sys_socket_callback(w5500_ctrl_t *w5500, uint8_t socket_id, ui
 		break;
 	case Sn_IR_DISCON:
 		DBG_ERR("socket %d disconnect", socket_id);
-		w5500_callback_to_nw_task(w5500, EV_NW_SOCKET_REMOTE_CLOSE, socket_id, 0, 0);
+		if (w5500_socket_state(w5500, socket_id) != SOCK_CLOSED)
+		{
+			w5500_callback_to_nw_task(w5500, EV_NW_SOCKET_REMOTE_CLOSE, socket_id, 0, 0);
+		}
+		else
+		{
+			w5500_callback_to_nw_task(w5500, EV_NW_SOCKET_CLOSE_OK, socket_id, 0, 0);
+		}
+
 		break;
 	default:
 		break;
@@ -1111,7 +1122,7 @@ static void w5500_task(void *param)
 			}
 			break;
 		case EV_W5500_SOCKET_TX:
-			if (event.Param1) OS_SuspendTask(NULL);
+			if (event.Param1) W5500_LOCK;
 			p = llist_traversal(&w5500->socket[event.Param1].tx_head, w5500_next_data_cache, &prv_w5500_ctrl->socket[event.Param1]);
 			if (p->is_sending)
 			{
@@ -1121,7 +1132,7 @@ static void w5500_task(void *param)
 			{
 				w5500_socket_tx_next_data(w5500, event.Param1);
 			}
-			if (event.Param1) OS_ResumeTask(NULL);
+			if (event.Param1) W5500_UNLOCK;
 			break;
 		case EV_W5500_SOCKET_CONNECT:
 			uPV.u8[0] = 0;
@@ -1144,31 +1155,13 @@ static void w5500_task(void *param)
 			}
 			break;
 		case EV_W5500_SOCKET_CLOSE:
-			if (event.Param2)
+			if ((w5500_socket_state(w5500, event.Param1) != SOCK_CLOSED))
 			{
-				w5500_socket_close(w5500, event.Param1);
-				while(w5500_socket_state(w5500, event.Param1) != SOCK_CLOSED)
-				{
-					w5500_socket_close(w5500, event.Param1);
-					uPV.u8[0]++;
-					if (uPV.u8[0] > 100)
-					{
-						w5500_callback_to_nw_task(w5500, EV_NW_SOCKET_ERROR, event.Param1, 0, 0);
-						break;
-					}
-				}
-				w5500_callback_to_nw_task(w5500, EV_NW_SOCKET_CLOSE_OK, event.Param1, 0, 0);
+				w5500_socket_disconnect(w5500, event.Param1);
 			}
 			else
 			{
-				if ((w5500_socket_state(w5500, event.Param1) != SOCK_CLOSED))
-				{
-					w5500_socket_disconnect(w5500, event.Param1);
-				}
-				else
-				{
-					w5500_callback_to_nw_task(w5500, EV_NW_SOCKET_CLOSE_OK, event.Param1, 0, 0);
-				}
+				w5500_callback_to_nw_task(w5500, EV_NW_SOCKET_CLOSE_OK, event.Param1, 0, 0);
 			}
 			break;
 		case EV_W5500_SOCKET_LISTEN:
@@ -1341,7 +1334,7 @@ static int w5500_create_soceket(uint8_t is_tcp, uint64_t *tag, void *param, uint
 	if (user_data != prv_w5500_ctrl) return -1;
 	int i, socket_id;
 	socket_id = -1;
-	OS_SuspendTask(NULL);
+	W5500_LOCK;
 	for (i = 1; i < MAX_SOCK_NUM; i++)
 	{
 		if (!prv_w5500_ctrl->socket[i].in_use)
@@ -1360,7 +1353,7 @@ static int w5500_create_soceket(uint8_t is_tcp, uint64_t *tag, void *param, uint
 			break;
 		}
 	}
-	OS_ResumeTask(NULL);
+	W5500_UNLOCK;
 	return socket_id;
 }
 
@@ -1372,10 +1365,10 @@ static int w5500_socket_connect_ex(int socket_id, uint64_t tag,  uint16_t local_
 	PV_Union uPV;
 	uPV.u16[0] = local_port;
 	uPV.u16[1] = remote_port;
-	OS_SuspendTask(NULL);
+	W5500_LOCK;
 	llist_traversal(&prv_w5500_ctrl->socket[socket_id].tx_head, w5500_del_data_cache, NULL);
 	llist_traversal(&prv_w5500_ctrl->socket[socket_id].rx_head, w5500_del_data_cache, NULL);
-	OS_ResumeTask(NULL);
+	W5500_UNLOCK;
 	platform_send_event(prv_w5500_ctrl->task_handle, EV_W5500_SOCKET_CONNECT, socket_id, remote_ip->ipv4, uPV.u32);
 	return 0;
 }
@@ -1403,16 +1396,19 @@ static int w5500_socket_disconnect_ex(int socket_id, uint64_t tag,  void *user_d
 
 static int w5500_socket_force_close(int socket_id, void *user_data)
 {
-	OS_SuspendTask(NULL);
+	W5500_LOCK;
 	w5500_socket_close(prv_w5500_ctrl, socket_id);
-	prv_w5500_ctrl->socket[socket_id].in_use = 0;
-	prv_w5500_ctrl->socket[socket_id].tag = 0;
-	llist_traversal(&prv_w5500_ctrl->socket[socket_id].tx_head, w5500_del_data_cache, NULL);
-	llist_traversal(&prv_w5500_ctrl->socket[socket_id].rx_head, w5500_del_data_cache, NULL);
-	prv_w5500_ctrl->socket[socket_id].rx_wait_size = 0;
-	prv_w5500_ctrl->socket[socket_id].tx_wait_size = 0;
-	prv_w5500_ctrl->socket[socket_id].param = NULL;
-	OS_ResumeTask(NULL);
+	if (prv_w5500_ctrl->socket[socket_id].in_use)
+	{
+		prv_w5500_ctrl->socket[socket_id].in_use = 0;
+		prv_w5500_ctrl->socket[socket_id].tag = 0;
+		llist_traversal(&prv_w5500_ctrl->socket[socket_id].tx_head, w5500_del_data_cache, NULL);
+		llist_traversal(&prv_w5500_ctrl->socket[socket_id].rx_head, w5500_del_data_cache, NULL);
+		prv_w5500_ctrl->socket[socket_id].rx_wait_size = 0;
+		prv_w5500_ctrl->socket[socket_id].tx_wait_size = 0;
+		prv_w5500_ctrl->socket[socket_id].param = NULL;
+	}
+	W5500_UNLOCK;
 	return 0;
 }
 
@@ -1445,43 +1441,50 @@ static int w5500_socket_receive(int socket_id, uint64_t tag,  uint8_t *buf, uint
 {
 	int result = w5500_check_socket(user_data, socket_id, tag);
 	if (result) return result;
-	OS_SuspendTask(NULL);
+	W5500_LOCK;
 	uint32_t read_len = 0;
-
-	socket_data_t *p = (socket_data_t *)llist_traversal(&prv_w5500_ctrl->socket[socket_id].rx_head, w5500_next_data_cache, &prv_w5500_ctrl->socket[socket_id]);
-	if (prv_w5500_ctrl->socket[socket_id].is_tcp)
+	if (buf)
 	{
-		while((read_len < len) && p)
+		socket_data_t *p = (socket_data_t *)llist_traversal(&prv_w5500_ctrl->socket[socket_id].rx_head, w5500_next_data_cache, &prv_w5500_ctrl->socket[socket_id]);
+		if (prv_w5500_ctrl->socket[socket_id].is_tcp)
+		{
+			while((read_len < len) && p)
+			{
+				prv_w5500_ctrl->socket[socket_id].rx_wait_size -= w5500_socket_read_data(buf + read_len, &read_len, len, p);
+				p = (socket_data_t *)llist_traversal(&prv_w5500_ctrl->socket[socket_id].rx_head, w5500_next_data_cache, &prv_w5500_ctrl->socket[socket_id]);
+			}
+		}
+		else
 		{
 			prv_w5500_ctrl->socket[socket_id].rx_wait_size -= w5500_socket_read_data(buf + read_len, &read_len, len, p);
-			p = (socket_data_t *)llist_traversal(&prv_w5500_ctrl->socket[socket_id].rx_head, w5500_next_data_cache, &prv_w5500_ctrl->socket[socket_id]);
+		}
+		if (llist_empty(&prv_w5500_ctrl->socket[socket_id].rx_head))
+		{
+			prv_w5500_ctrl->socket[socket_id].rx_wait_size = 0;
 		}
 	}
 	else
 	{
-		prv_w5500_ctrl->socket[socket_id].rx_wait_size -= w5500_socket_read_data(buf + read_len, &read_len, len, p);
-	}
-	if (llist_empty(&prv_w5500_ctrl->socket[socket_id].rx_head))
-	{
-		prv_w5500_ctrl->socket[socket_id].rx_wait_size = 0;
+		read_len = prv_w5500_ctrl->socket[socket_id].rx_wait_size;
 	}
-	OS_ResumeTask(NULL);
+	W5500_UNLOCK;
 	return read_len;
 }
 static int w5500_socket_send(int socket_id, uint64_t tag, const uint8_t *buf, uint32_t len, int flags, luat_ip_addr_t *remote_ip, uint16_t remote_port, void *user_data)
 {
 	int result = w5500_check_socket(user_data, socket_id, tag);
 	if (result) return result;
-	if (prv_w5500_ctrl->socket[socket_id].tx_wait_size >= SOCK_BUF_LEN) return -1;
+	if (prv_w5500_ctrl->socket[socket_id].tx_wait_size >= SOCK_BUF_LEN) return 0;
 
 	socket_data_t *p = w5500_create_data_node(prv_w5500_ctrl, socket_id, buf, len, remote_ip, remote_port);
 	if (p)
 	{
-		OS_SuspendTask(NULL);
+		W5500_LOCK;
 		llist_add_tail(p, &prv_w5500_ctrl->socket[socket_id].tx_head);
 		prv_w5500_ctrl->socket[socket_id].tx_wait_size += len;
-		OS_ResumeTask(NULL);
+		W5500_UNLOCK;
 		platform_send_event(prv_w5500_ctrl->task_handle, EV_W5500_SOCKET_TX, socket_id, 0, 0);
+		result = len;
 	}
 	else
 	{
@@ -1508,7 +1511,7 @@ void w5500_socket_clean(int *vaild_socket_list, uint32_t num, void *user_data)
 		DBG("%d,%d",i,socket_list[i]);
 		if ( !socket_list[i] )
 		{
-			OS_SuspendTask(NULL);
+			W5500_LOCK;
 			prv_w5500_ctrl->socket[i].in_use = 0;
 			prv_w5500_ctrl->socket[i].tag = 0;
 			llist_traversal(&prv_w5500_ctrl->socket[i].tx_head, w5500_del_data_cache, NULL);
@@ -1516,7 +1519,7 @@ void w5500_socket_clean(int *vaild_socket_list, uint32_t num, void *user_data)
 			prv_w5500_ctrl->socket[i].rx_wait_size = 0;
 			prv_w5500_ctrl->socket[i].tx_wait_size = 0;
 			w5500_socket_close(prv_w5500_ctrl, i);
-			OS_ResumeTask(NULL);
+			W5500_UNLOCK;
 		}
 	}
 }
@@ -1529,6 +1532,35 @@ static int w5500_setsockopt(int socket_id, uint64_t tag,  int level, int optname
 {
 	return -1;
 }
+static int w5500_get_local_ip_info(luat_ip_addr_t *ip, luat_ip_addr_t *submask, luat_ip_addr_t *gateway, void *user_data)
+{
+	if (user_data != prv_w5500_ctrl) return -1;
+
+	if (prv_w5500_ctrl->static_ip)
+	{
+		ip->ipv4 = prv_w5500_ctrl->static_ip;
+		ip->is_ipv6 = 0;
+		submask->ipv4 = prv_w5500_ctrl->static_submask;
+		submask->is_ipv6 = 0;
+		gateway->ipv4 = prv_w5500_ctrl->static_gateway;
+		gateway->is_ipv6 = 0;
+		return 0;
+	}
+	else
+	{
+		if (!prv_w5500_ctrl->ip_ready)
+		{
+			return -1;
+		}
+		ip->ipv4 = prv_w5500_ctrl->dhcp_client.ip;
+		ip->is_ipv6 = 0;
+		submask->ipv4 = prv_w5500_ctrl->dhcp_client.submask;
+		submask->is_ipv6 = 0;
+		gateway->ipv4 = prv_w5500_ctrl->dhcp_client.gateway;
+		gateway->is_ipv6 = 0;
+		return 0;
+	}
+}
 
 static int w5500_user_cmd(int socket_id, uint64_t tag, uint32_t cmd, uint32_t value, void *user_data)
 {
@@ -1584,6 +1616,7 @@ static network_adapter_info prv_w5500_adapter =
 		.user_cmd = w5500_user_cmd,
 		.dns = w5500_dns,
 		.set_dns_server = w5500_set_dns_server,
+		.get_local_ip_info = w5500_get_local_ip_info,
 		.socket_set_callback = w5500_socket_set_callback,
 		.name = "w5500",
 		.max_socket_num = MAX_SOCK_NUM - 1,

components/network/adapter/luat_lib_network.c

@@ -156,18 +156,40 @@ static int l_network_create(lua_State *L)
 	return 1;
 }
 
+/*
+作为客户端断开连接
+@api network.debug(ctrl, onoff)
+@user_data network.create得到的ctrl
+@boolean true 打开debug开关
+@return nil 无返回值
+@usage network.debug(ctrl, true)
+*/
+static int l_network_set_debug(lua_State *L)
+{
+	luat_network_ctrl_t *l_ctrl = ((luat_network_ctrl_t *)luaL_checkudata(L, 1, LUAT_NW_CTRL_TYPE));
+	if (lua_isboolean(L, 2))
+	{
+		l_ctrl->netc->is_debug = lua_toboolean(L, 2);
+	}
+	return 0;
+}
+
 /*
 等待网卡linkup
 @api network.linkup(ctrl)
 @user_data network.create得到的ctrl
-@return true已经linkup，false没有linkup，之后需要接收network.LINK消息
-@usage local result = network.linkup(ctrl)
+@return
+boolean true有异常发生，false没有异常，如果有error则不需要看下一个返回值了
+boolean true已经linkup，false没有linkup，之后需要接收network.LINK消息
+@usage local error, result = network.linkup(ctrl)
 */
 static int l_network_linkup(lua_State *L)
 {
 	luat_network_ctrl_t *l_ctrl = ((luat_network_ctrl_t *)luaL_checkudata(L, 1, LUAT_NW_CTRL_TYPE));
-	lua_pushboolean(L, !network_wait_link_up(l_ctrl->netc, 0));
-	return 1;
+	int result = network_wait_link_up(l_ctrl->netc, 0);
+	lua_pushboolean(L, result < 0);
+	lua_pushboolean(L, result == 0);
+	return 2;
 
 
 }
@@ -178,7 +200,7 @@ static int l_network_linkup(lua_State *L)
 @user_data network.create得到的ctrl
 @string or int ip或者域名，如果是IPV4，可以是大端格式的int值
 @int 服务器端口号，小端格式
-@int 本地端口号，小端格式，如果不写，则自动分配一个，如果用户填了端口号则需要小于60000
+@int 本地端口号，小端格式，如果不写，则自动分配一个，如果用户填了端口号则需要小于60000, 默认不写
 @boolean 是否是UDP，默认false
 @int tcp keep live模式下的idle时间，如果留空则表示不启用，如果是不支持标准posix接口的网卡（比如W5500），则为心跳间隔
 @int tcp keep live模式下的探测间隔时间
@@ -187,16 +209,17 @@ static int l_network_linkup(lua_State *L)
 @string TCP模式下的客户端ca证书数据，UDP模式下的PSK-ID，TCP模式下如果不需要验证客户端证书时，忽略，一般不需要验证客户端证书
 @string TCP模式下的客户端私钥加密数据
 @string TCP模式下的客户端私钥口令数据
-
-@return true已经linkup，false没有linkup，之后需要接收network.LINK消息
-@usage local result = network.linkup(ctrl)
+@return
+boolean true有异常发生，false没有异常，如果有error则不需要看下一个返回值了，如果有异常，后续要close
+boolean true已经connect，false没有connect，之后需要接收network.ON_LINE消息
+@usage local error, result = network.connect(ctrl, "xxx.xxx.xxx.xxx", xxxx)
 */
 static int l_network_connect(lua_State *L)
 {
 	luat_network_ctrl_t *l_ctrl = ((luat_network_ctrl_t *)luaL_checkudata(L, 1, LUAT_NW_CTRL_TYPE));
 	luat_ip_addr_t ip_addr;
 	uint8_t is_udp = 0;
-	int param_pos = 1;
+	int param_pos = 2;
 	uint32_t keep_idle, keep_interval, keep_cnt;
 	const char *ip;
 	const char *server_cert;
@@ -205,7 +228,7 @@ static int l_network_connect(lua_State *L)
 	const char *client_password;
 	size_t ip_len, server_cert_len, client_cert_len, client_key_len, client_password_len;
 	ip_addr.is_ipv6 = 0xff;
-	if (lua_isinteger(L, ++param_pos))
+	if (lua_isinteger(L, param_pos))
 	{
 		ip_addr.is_ipv6 = 0;
 		ip_addr.ipv4 = lua_tointeger(L, param_pos);
@@ -249,25 +272,207 @@ static int l_network_connect(lua_State *L)
 	}
 	network_set_base_mode(l_ctrl->netc, !is_udp, keep_idle, keep_idle, keep_interval, keep_cnt);
 	network_set_local_port(l_ctrl->netc, local_port);
-	lua_pushboolean(L, !network_connect(l_ctrl->netc, ip, ip_len, ip_addr.is_ipv6?NULL:&ip_addr, remote_port, 0));
-	return 1;
+	int result = network_connect(l_ctrl->netc, ip, ip_len, ip_addr.is_ipv6?NULL:&ip_addr, remote_port, 0);
+	lua_pushboolean(L, result < 0);
+	lua_pushboolean(L, result == 0);
+	return 2;
 }
 
+/*
+作为客户端断开连接
+@api network.close(ctrl)
+@user_data network.create得到的ctrl
+@return
+boolean true有异常发生，false没有异常，如果有error则不需要看下一个返回值了
+boolean true已经断开，false没有断开，之后需要接收network.CLOSED消息
+@usage local error, result = network.close(ctrl)
+*/
 static int l_network_close(lua_State *L)
 {
-
+	luat_network_ctrl_t *l_ctrl = ((luat_network_ctrl_t *)luaL_checkudata(L, 1, LUAT_NW_CTRL_TYPE));
+	int result = network_close(l_ctrl->netc, 0);
+	lua_pushboolean(L, result < 0);
+	lua_pushboolean(L, result == 0);
+	return 2;
 }
 
+/*
+发送数据给对端
+@api network.tx(ctrl, data, ip, port, flag)
+@user_data network.create得到的ctrl
+@string or user_data zbuff  要发送的数据
+@string or int 对端IP，如果是TCP应用则忽略，如果是UDP，如果留空则用connect时候的参数，如果是IPV4，可以是大端格式的int值
+@int 对端端口号，小端格式，如果是TCP应用则忽略，如果是UDP，如果留空则用connect时候的参数
+@int 发送参数，目前预留，不起作用
+@return
+boolean true有异常发生，false没有异常，如果有error则不需要看下一个返回值了，如果有异常，后续要close
+boolean true缓冲区满了，false没有异常，如果true，则需要等待一段时间或者等到network.TX_OK消息后再尝试发送，同时忽略下一个返回值
+boolean true已经收到应答，false没有收到应答，之后需要接收network.TX_OK消息， 也可以忽略继续发送，直到full==true
+@usage local error, full, result = network.tx(ctrl, "123456", "xxx.xxx.xxx.xxx", xxxx)
+*/
 static int l_network_tx(lua_State *L)
 {
+	luat_network_ctrl_t *l_ctrl = ((luat_network_ctrl_t *)luaL_checkudata(L, 1, LUAT_NW_CTRL_TYPE));
+	luat_ip_addr_t ip_addr;
+	luat_zbuff_t *buff = NULL;
+	const char *ip;
+	const char *data;
+	size_t ip_len, data_len;
+	ip_addr.is_ipv6 = 0xff;
+	if (lua_isstring(L, 2))
+	{
+		data_len = 0;
+		data = luaL_checklstring(L, 2, &data_len);
+	}
+	else
+	{
+		buff = ((luat_zbuff_t *)luaL_checkudata(L, 2, LUAT_ZBUFF_TYPE));
+		data = buff->addr;
+		data_len = buff->used;
+	}
+
+	if (lua_isstring(L, 3))
+	{
+		ip_len = 0;
+	    ip = luaL_checklstring(L, 3, &ip_len);
 
+		if (network_string_is_ipv4(ip, ip_len))
+		{
+			ip_addr.is_ipv6 = 0;
+			ip_addr.ipv4 = network_string_to_ipv4(ip, ip_len);
+		}
+		else
+		{
+			char *name = luat_heap_malloc(ip_len + 1);
+			memcpy(name, ip, ip_len);
+			name[ip_len] = 0;
+			network_string_to_ipv6(name, &ip_addr);
+			free(name);
+		}
+	}
+	else if (lua_isinteger(L, 3))
+	{
+		ip_addr.is_ipv6 = 0;
+		ip_addr.ipv4 = lua_tointeger(L, 3);
+	}
+	uint32_t tx_len;
+	int result = network_tx(l_ctrl->netc, data, data_len, luaL_optinteger(L, 5, 0), &ip_addr, luaL_optinteger(L, 4, 0), &tx_len, 0);
+	lua_pushboolean(L, result < 0);
+	lua_pushboolean(L, tx_len != data_len);
+	lua_pushboolean(L, result == 0);
+	return 2;
 }
 
+/*
+接收对端发出的数据，注意数据已经缓存在底层，使用本函数只是提取出来，UDP模式下一次只会取出一个数据包
+@api network.rx(ctrl, buff, start, flag)
+@user_data network.create得到的ctrl
+@user_data zbuff 存放接收的数据，如果缓冲区不够大会自动扩容
+@int 接收参数，目前预留，不起作用
+@return
+boolean true有异常发生，false没有异常，如果有异常，后续要close
+int 本次接收到数据长度
+string 对端IP，只有UDP模式下才有意义，TCP模式返回nil，注意返回的格式，如果是IPV4，1byte 0x00 + 4byte地址 如果是IPV6，1byte 0x01 + 16byte地址
+int 对端port，只有UDP模式下才有意义，TCP模式返回0
+@usage local error, data_len, ip, port = network.rx(ctrl, buff)
+*/
 static int l_network_rx(lua_State *L)
 {
+	luat_network_ctrl_t *l_ctrl = ((luat_network_ctrl_t *)luaL_checkudata(L, 1, LUAT_NW_CTRL_TYPE));
+	luat_zbuff_t *buff = ((luat_zbuff_t *)luaL_checkudata(L, 2, LUAT_ZBUFF_TYPE));
+
+	luat_ip_addr_t ip_addr;
+	uint8_t ip[17];
+	uint16_t port;
+	uint8_t new_flag = 0;
+	int rx_len;
+	int total_len;
+	int result = network_rx(l_ctrl->netc, NULL, 0, 0, NULL, NULL, &total_len);
+	if (result < 0)
+	{
+		lua_pushboolean(L, 1);
+		lua_pushinteger(L, 0);
+		lua_pushnil(L);
+		lua_pushnil(L);
+	}
+	else if (!total_len)
+	{
+		lua_pushboolean(L, 0);
+		lua_pushinteger(L, 0);
+		lua_pushnil(L);
+		lua_pushnil(L);
+	}
+	else
+	{
+		if ((buff->len - buff->used) < total_len)
+		{
+			__zbuff_resize(buff, total_len + buff->used);
+		}
+		result = network_rx(l_ctrl->netc, buff->addr + buff->used, total_len, 0, &ip_addr, &port, &rx_len);
+		if (result < 0)
+		{
+			lua_pushboolean(L, 1);
+			lua_pushinteger(L, 0);
+			lua_pushnil(L);
+			lua_pushnil(L);
+		}
+		else if (!rx_len)
+		{
+			lua_pushboolean(L, 0);
+			lua_pushinteger(L, 0);
+			lua_pushnil(L);
+			lua_pushnil(L);
+		}
+		else
+		{
+			buff->used += rx_len;
+			lua_pushboolean(L, 0);
+			lua_pushinteger(L, rx_len);
+			if (l_ctrl->netc->is_tcp)
+			{
+				lua_pushnil(L);
+				lua_pushnil(L);
+			}
+			else
+			{
+				if (ip_addr.is_ipv6)
+				{
+					ip[0] = 0;
+					memcpy(ip + 1, &ip_addr.ipv4, 4);
+					lua_pushlstring(L, ip, 5);
+				}
+				else
+				{
+					ip[0] = 1;
+					memcpy(ip + 1, &ip_addr.ipv6_u8_addr, 16);
+					lua_pushlstring(L, ip, 17);
+				}
+				lua_pushinteger(L, port);
+			}
+		}
+	}
+	return 4;
+}
 
+/*
+等待新的socket消息，在连接成功和发送数据成功后，使用一次将network状态转换到接收新数据
+@api network.wait(ctrl)
+@user_data network.create得到的ctrl
+@return
+boolean true有异常发生，false没有异常，如果有异常，后续要close
+boolean true有新的数据需要接收，false没有数据，之后需要接收network.EVENT消息
+@usage local error, result = network.wait(ctrl)
+*/
+static int l_network_wait(lua_State *L)
+{
+	luat_network_ctrl_t *l_ctrl = ((luat_network_ctrl_t *)luaL_checkudata(L, 1, LUAT_NW_CTRL_TYPE));
+	int result = network_wait_event(l_ctrl->netc, NULL, 0, NULL);
+	lua_pushboolean(L, result < 0);
+	lua_pushboolean(L, result == 0);
+	return 2;
 }
 
+
 static int l_network_listen(lua_State *L)
 {
 
@@ -294,11 +499,13 @@ static int l_network_release(lua_State *L)
 static const rotable_Reg_t reg_network_adapter[] =
 {
 	{"create",			ROREG_FUNC(l_network_create)},
+	{"debug",		ROREG_FUNC(l_network_set_debug)},
 	{"linkup",			ROREG_FUNC(l_network_linkup)},
 	{"connect",			ROREG_FUNC(l_network_connect)},
 	{"close",			ROREG_FUNC(l_network_close)},
 	{"tx",			ROREG_FUNC(l_network_tx)},
 	{"rx",			ROREG_FUNC(l_network_rx)},
+	{"wait",			ROREG_FUNC(l_network_wait)},
 	{"listen",			ROREG_FUNC(l_network_listen)},
 	{"accept",			ROREG_FUNC(l_network_accept)},
 	{"release",			ROREG_FUNC(l_network_release)},
@@ -307,8 +514,7 @@ static const rotable_Reg_t reg_network_adapter[] =
 	{ "AP",     		ROREG_INT(NW_ADAPTER_INDEX_AP)},
     { "LINK",           ROREG_INT(EV_NW_RESULT_LINK & 0x0fffffff)},
 	{ "ON_LINE",          	ROREG_INT(EV_NW_RESULT_CONNECT & 0x0fffffff)},
-    { "LISTEN",           ROREG_INT(EV_NW_RESULT_LISTEN & 0x0fffffff)},
-	{ "RX_NEW",          	ROREG_INT(EV_NW_RESULT_RX & 0x0fffffff)},
+	{ "EVENT",          	ROREG_INT(EV_NW_RESULT_EVENT & 0x0fffffff)},
 	{ "TX_OK",     		ROREG_INT(EV_NW_RESULT_TX & 0x0fffffff)},
 	{ "CLOSED",     		ROREG_INT(EV_NW_RESULT_CLOSE & 0x0fffffff)},
 	{ NULL,            ROREG_INT(0)}

components/network/adapter/luat_network_adapter.c

@@ -5,15 +5,21 @@
 #include "luat_rtos.h"
 #include "platform_def.h"
 #include "bsp_common.h"
-#define LUAT_LOG_TAG "net_adapter"
-#include "luat_log.h"
 #include "ctype.h"
 
 extern void DBG_Printf(const char* format, ...);
 extern void DBG_HexPrintf(void *Data, unsigned int len);
-#define DBG(x,y...)		DBG_Printf("%s %d:"x"\r\n", __FUNCTION__,__LINE__,##y)
-#define DBG_ERR(x,y...)		DBG_Printf("%s %d:"x"\r\n", __FUNCTION__,__LINE__,##y)
-
+//#define DBG(x,y...)		DBG_Printf("%s %d:"x"\r\n", __FUNCTION__,__LINE__,##y)
+//#define DBG_ERR(x,y...)		DBG_Printf("%s %d:"x"\r\n", __FUNCTION__,__LINE__,##y)
+
+#define __NW_DEBUG_ENABLE__
+#ifdef __NW_DEBUG_ENABLE__
+#define DBG(x,y...)	do {if (ctrl->is_debug) {DBG_Printf("%s %d:"x"\r\n", __FUNCTION__,__LINE__,##y);}} while(0)
+#define DBG_ERR(x,y...) do {if (ctrl->is_debug) {DBG_Printf("%s %d:"x"\r\n", __FUNCTION__,__LINE__,##y);}} while(0)
+#else
+#define DBG(x,y...)
+#define DBG_ERR(x,y...)
+#endif
 #define NW_LOCK		OS_SuspendTask(NULL)
 #define NW_UNLOCK	OS_ResumeTask(NULL)
 
@@ -54,6 +60,41 @@ static network_info_t prv_network = {
 		.is_init = 0,
 };
 
+static int network_base_tx(network_ctrl_t *ctrl, const uint8_t *data, uint32_t len, int flags, luat_ip_addr_t *remote_ip, uint16_t remote_port)
+{
+	int result = -1;
+	if (ctrl->is_tcp)
+	{
+		result = network_socket_send(ctrl, data, len, flags, NULL, 0);
+	}
+	else
+	{
+		if (remote_ip)
+		{
+			result = network_socket_send(ctrl, data, len, flags, remote_ip, remote_port);
+		}
+		else
+		{
+			if (ctrl->remote_ip.is_ipv6 != 0xff)
+			{
+				result = network_socket_send(ctrl, data, len, flags, &ctrl->remote_ip, ctrl->remote_port);
+			}
+			else
+			{
+				result = network_socket_send(ctrl, data, len, flags, &ctrl->dns_ip[ctrl->dns_ip_cnt], ctrl->remote_port);
+			}
+		}
+	}
+	if (result >= 0)
+	{
+		ctrl->tx_size += len;
+	}
+	else
+	{
+		ctrl->need_close = 1;
+	}
+	return result;
+}
 
 static int network_get_host_by_name(network_ctrl_t *ctrl)
 {
@@ -80,17 +121,23 @@ static int network_get_host_by_name(network_ctrl_t *ctrl)
 	}
 }
 
+static void network_force_close_socket(network_ctrl_t *ctrl)
+{
+	if (network_socket_close(ctrl))
+	{
+		network_clean_invaild_socket(ctrl->adapter_index);
+		network_socket_force_close(ctrl);
+	}
+	ctrl->need_close = 0;
+	ctrl->socket_id = -1;
+}
 
 static int network_base_connect(network_ctrl_t *ctrl, luat_ip_addr_t *remote_ip)
 {
 	network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
 	if (ctrl->socket_id >= 0)
 	{
-		if (network_socket_close(ctrl))
-		{
-			network_socket_force_close(ctrl);
-		}
-		ctrl->socket_id = -1;
+		network_force_close_socket(ctrl);
 	}
 	if (network_create_soceket(ctrl, remote_ip->is_ipv6) < 0)
 	{
@@ -158,11 +205,11 @@ static int network_state_link_off(network_ctrl_t *ctrl, OS_EVENT *event, network
 		if (event->Param2)
 		{
 			ctrl->state = NW_STATE_OFF_LINE;
-			if (NW_STATE_WAIT_LINK == ctrl->target_state)
+			if (NW_WAIT_LINK_UP == ctrl->wait_target_state)
 			{
 				return 0;
 			}
-			else if (NW_STATE_ONLINE == ctrl->target_state)
+			else if (NW_WAIT_ON_LINE == ctrl->wait_target_state)
 			{
 				if (network_prepare_connect(ctrl))
 				{
@@ -182,7 +229,7 @@ static int network_state_off_line(network_ctrl_t *ctrl, OS_EVENT *event, network
 
 static int network_state_wait_dns(network_ctrl_t *ctrl, OS_EVENT *event, network_adapter_t *adapter)
 {
-	if (ctrl->target_state != NW_STATE_ONLINE) return -1;
+	if ((ctrl->need_close) || ctrl->wait_target_state != NW_WAIT_ON_LINE) return -1;
 	switch(event->ID)
 	{
 	case EV_NW_RESET:
@@ -218,7 +265,7 @@ static int network_state_wait_dns(network_ctrl_t *ctrl, OS_EVENT *event, network
 
 static int network_state_connecting(network_ctrl_t *ctrl, OS_EVENT *event, network_adapter_t *adapter)
 {
-	if (ctrl->target_state != NW_STATE_ONLINE) return -1;
+	if ((ctrl->need_close) || (ctrl->wait_target_state != NW_WAIT_ON_LINE)) return -1;
 	switch(event->ID)
 	{
 	case EV_NW_RESET:
@@ -232,12 +279,32 @@ static int network_state_connecting(network_ctrl_t *ctrl, OS_EVENT *event, netwo
 			return -1;
 		}
 		break;
-
+	case EV_NW_SOCKET_LISTEN:
+		if (ctrl->is_server_mode)
+		{
+			ctrl->state = NW_STATE_LISTEN;
+			return 0;
+		}
+		break;
 	case EV_NW_SOCKET_CONNECT_OK:
 		if (ctrl->tls_mode)
 		{
 			ctrl->state = NW_STATE_SHAKEHAND;
-			return 1;
+	    	do
+	    	{
+	    		int result = mbedtls_ssl_handshake_step( ctrl->ssl );
+	    		switch(result)
+	    		{
+	    		case MBEDTLS_ERR_SSL_WANT_READ:
+	    			return 1;
+	    		case 0:
+	    			break;
+	    		default:
+	    			DBG_ERR("0x%x, %d", -result, ctrl->ssl->state);
+	    			return -1;
+	    		}
+	    	}while(ctrl->ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER);
+	    	return 0;
 		}
 		else
 		{
@@ -252,7 +319,7 @@ static int network_state_connecting(network_ctrl_t *ctrl, OS_EVENT *event, netwo
 
 static int network_state_shakehand(network_ctrl_t *ctrl, OS_EVENT *event, network_adapter_t *adapter)
 {
-	if ((ctrl->target_state != NW_STATE_ONLINE) || (ctrl->target_state != NW_STATE_TX_OK)) return -1;
+	if ((ctrl->need_close) || (ctrl->wait_target_state != NW_WAIT_ON_LINE) || (ctrl->wait_target_state != NW_WAIT_TX_OK)) return -1;
 	switch(event->ID)
 	{
 	case EV_NW_RESET:
@@ -266,19 +333,44 @@ static int network_state_shakehand(network_ctrl_t *ctrl, OS_EVENT *event, networ
 			return -1;
 		}
 		break;
-
-	case EV_NW_SOCKET_CONNECT_OK:
-		if (ctrl->tls_mode)
-		{
-			ctrl->state = NW_STATE_SHAKEHAND;
-			return 1;
-		}
-		else
+	case EV_NW_SOCKET_TX_OK:
+		ctrl->tx_size += event->Param2;
+		if (ctrl->is_debug)
 		{
-			ctrl->state = NW_STATE_ONLINE;
-			return 0;
-		}
 
+		}
+		break;
+	case EV_NW_SOCKET_RX_NEW:
+    	do
+    	{
+    		int result = mbedtls_ssl_handshake_step( ctrl->ssl );
+    		switch(result)
+    		{
+    		case MBEDTLS_ERR_SSL_WANT_READ:
+    			return 1;
+    		case 0:
+    			break;
+    		default:
+    			DBG_ERR("0x%x, %d", -result, ctrl->ssl->state);
+    			return -1;
+    		}
+    	}while(ctrl->ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER);
+    	ctrl->state = NW_STATE_ONLINE;
+    	if (NW_WAIT_TX_OK == ctrl->wait_target_state)
+    	{
+    		int result = mbedtls_ssl_write(ctrl->ssl, ctrl->cache_data, ctrl->cache_len);
+    	    if (result < 0)
+    	    {
+    	    	DBG("%08x", -result);
+    			ctrl->need_close = 1;
+    			return -1;
+    	    }
+    	    return 1;
+    	}
+    	return 0;
+	case EV_NW_SOCKET_CONNECT_OK:
+		DBG_ERR("!");
+		return 1;
 	default:
 		return 1;
 	}
@@ -286,13 +378,8 @@ static int network_state_shakehand(network_ctrl_t *ctrl, OS_EVENT *event, networ
 
 static int network_state_on_line(network_ctrl_t *ctrl, OS_EVENT *event, network_adapter_t *adapter)
 {
-	switch(ctrl->target_state)
+	if ((ctrl->need_close) || NW_WAIT_OFF_LINE == ctrl->wait_target_state)
 	{
-	case NW_STATE_TX_OK:
-	case NW_STATE_NEW_RX:
-	case NW_STATE_OFF_LINE:
-		break;
-	default:
 		return -1;
 	}
 
@@ -302,32 +389,130 @@ static int network_state_on_line(network_ctrl_t *ctrl, OS_EVENT *event, network_
 	case EV_NW_SOCKET_ERROR:
 	case EV_NW_SOCKET_REMOTE_CLOSE:
 	case EV_NW_SOCKET_CLOSE_OK:
+		ctrl->need_close = 1;
 		return -1;
 	case EV_NW_STATE:
 		if (!event->Param2)
 		{
+			ctrl->need_close = 1;
 			return -1;
 		}
 		break;
 	case EV_NW_SOCKET_TX_OK:
+		ctrl->ack_size += event->Param2;
+		if (NW_WAIT_TX_OK == ctrl->wait_target_state)
+		{
+
+			if (ctrl->ack_size == ctrl->tx_size)
+			{
+				return 0;
+			}
+		}
 		break;
 	case EV_NW_SOCKET_RX_NEW:
+		ctrl->new_rx_flag = 1;
+		if (NW_WAIT_TX_OK != ctrl->wait_target_state)
+		{
+			return 0;
+		}
 		break;
 	default:
 		return 1;
 	}
+	return 1;
 }
 
 static int network_state_listen(network_ctrl_t *ctrl, OS_EVENT *event, network_adapter_t *adapter)
 {
+	if ((ctrl->need_close) || NW_WAIT_OFF_LINE == ctrl->wait_target_state)
+	{
+		return -1;
+	}
+	switch(event->ID)
+	{
+	case EV_NW_RESET:
+	case EV_NW_SOCKET_ERROR:
+		ctrl->need_close = 1;
+		return -1;
+	case EV_NW_SOCKET_REMOTE_CLOSE:
+	case EV_NW_SOCKET_CLOSE_OK:
+		if (adapter->opt->no_accept)
+		{
+			if (network_socket_listen(ctrl))
+			{
+				return -1;
+			}
+			ctrl->state = NW_STATE_CONNECTING;
+			ctrl->wait_target_state = NW_WAIT_ON_LINE;
+			return 1;
+		}
+		else
+		{
+			break;
+		}
+	case EV_NW_STATE:
+		if (!event->Param2)
+		{
+			ctrl->need_close = 1;
+			return -1;
+		}
+		break;
+	case EV_NW_SOCKET_TX_OK:
+		ctrl->ack_size += event->Param2;
+		if (NW_WAIT_TX_OK == ctrl->wait_target_state)
+		{
 
+			if (ctrl->ack_size == ctrl->tx_size)
+			{
+				return 0;
+			}
+		}
+		break;
+	case EV_NW_SOCKET_RX_NEW:
+		ctrl->new_rx_flag = 1;
+		if (NW_WAIT_TX_OK != ctrl->wait_target_state)
+		{
+			return 0;
+		}
+		break;
+	case EV_NW_SOCKET_NEW_CONNECT:
+		break;
+	default:
+		return 1;
+	}
+	return 1;
 }
 
 static int network_state_disconnecting(network_ctrl_t *ctrl, OS_EVENT *event, network_adapter_t *adapter)
 {
-	if (ctrl->target_state != NW_STATE_OFF_LINE)
+	if (ctrl->wait_target_state != NW_WAIT_OFF_LINE)
 	{
-
+		return -1;
+	}
+	switch(event->ID)
+	{
+	case EV_NW_RESET:
+	case EV_NW_SOCKET_ERROR:
+	case EV_NW_SOCKET_REMOTE_CLOSE:
+	case EV_NW_SOCKET_CLOSE_OK:
+		network_force_close_socket(ctrl);
+		ctrl->state = NW_STATE_OFF_LINE;
+		ctrl->socket_id = -1;
+		return 0;
+	case EV_NW_STATE:
+		if (!event->Param2)
+		{
+			return -1;
+		}
+		else
+		{
+			network_force_close_socket(ctrl);
+			ctrl->state = NW_STATE_OFF_LINE;
+			ctrl->socket_id = -1;
+		}
+		break;
+	default:
+		return 1;
 	}
 }
 
@@ -351,13 +536,9 @@ static void network_default_statemachine(network_ctrl_t *ctrl, OS_EVENT *event,
 	{
 		ctrl->state = NW_STATE_LINK_OFF;
 		event->Param1 = -1;
-		if (network_socket_close(ctrl))
-		{
-			network_clean_invaild_socket(ctrl->adapter_index);
-			network_socket_force_close(ctrl);
-		}
-		ctrl->socket_id = -1;
-		event->ID = ctrl->target_state + EV_NW_RESULT_BASE;
+		network_force_close_socket(ctrl);
+		event->ID = ctrl->wait_target_state + EV_NW_RESULT_BASE;
+
 	}
 	else
 	{
@@ -366,10 +547,10 @@ static void network_default_statemachine(network_ctrl_t *ctrl, OS_EVENT *event,
 		{
 			return ;
 		}
-		event->ID = ctrl->target_state + EV_NW_RESULT_BASE;
+		event->ID = ctrl->wait_target_state + EV_NW_RESULT_BASE;
 		event->Param1 = result;
 	}
-
+	ctrl->wait_target_state = NW_WAIT_NONE;
 	if (ctrl->task_handle)
 	{
 		platform_send_event(ctrl->task_handle, event->ID, event->Param1, event->Param2, event->Param3);
@@ -395,7 +576,9 @@ static int32_t network_default_socket_callback(void *data, void *param)
 		{
 			if (ctrl->auto_mode)
 			{
+				DBG("%d,%d,%d", ctrl->socket_id, ctrl->state, ctrl->wait_target_state);
 				network_default_statemachine(ctrl, event, adapter);
+				DBG("%d,%d,%d", ctrl->socket_id, ctrl->state, ctrl->wait_target_state);
 			}
 			else if (ctrl->task_handle)
 			{
@@ -408,7 +591,7 @@ static int32_t network_default_socket_callback(void *data, void *param)
 		}
 		else
 		{
-			LLOGE("cb ctrl invaild %x", ctrl);
+			DBG_ERR("cb ctrl invaild %x", ctrl);
 			DBG_HexPrintf(&ctrl->tag, 8);
 			DBG_HexPrintf(&cb_param->tag, 8);
 		}
@@ -422,7 +605,9 @@ static int32_t network_default_socket_callback(void *data, void *param)
 				ctrl = &adapter->ctrl_table[i];
 				if (ctrl->auto_mode)
 				{
+					DBG("%d,%d,%d", ctrl->socket_id, ctrl->state, ctrl->wait_target_state);
 					network_default_statemachine(ctrl, event, adapter);
+					DBG("%d,%d,%d", ctrl->socket_id, ctrl->state, ctrl->wait_target_state);
 				}
 				else if (ctrl->task_handle)
 				{
@@ -492,7 +677,7 @@ int network_string_to_ipv6(const char *string, luat_ip_addr_t *ip_addr)
 
   uint32_t addr_index, zero_blocks, current_block_index, current_block_value;
   const char *s;
-  ip_addr->is_ipv6 = 0;
+  ip_addr->is_ipv6 = 0xff;
   /* Count the number of colons, to count the number of blocks in a "::" sequence
 	 zero_blocks may be 1 even if there are no :: sequences */
   zero_blocks = 8;
@@ -628,7 +813,7 @@ network_ctrl_t *network_alloc_ctrl(uint8_t adapter_index)
 			break;
 		}
 	}
-	if (i >= adapter->opt->max_socket_num) {LLOGE("adapter no more ctrl!");}
+	if (i >= adapter->opt->max_socket_num) {DBG_ERR("adapter no more ctrl!");}
 	NW_UNLOCK;
 	return ctrl;
 }
@@ -651,7 +836,7 @@ void network_release_ctrl(network_ctrl_t *ctrl)
 		}
 	}
 	NW_UNLOCK;
-	if (i >= adapter->opt->max_socket_num) {LLOGE("adapter index maybe error!, %d, %x", ctrl->adapter_index, ctrl);}
+	if (i >= adapter->opt->max_socket_num) {DBG_ERR("adapter index maybe error!, %d, %x", ctrl->adapter_index, ctrl);}
 
 }
 
@@ -741,7 +926,6 @@ int network_socket_connect(network_ctrl_t *ctrl, luat_ip_addr_t *remote_ip)
 {
 	network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
 	ctrl->is_server_mode = 0;
-	DBG("%x", remote_ip->ipv4);
 	return adapter->opt->socket_connect(ctrl->socket_id, ctrl->tag, ctrl->local_port, remote_ip, ctrl->remote_port, adapter->user_data);
 }
 
@@ -847,6 +1031,12 @@ int network_dns(network_ctrl_t *ctrl)
 	return adapter->opt->dns(require->uri.Data, require->uri.Pos, adapter->user_data);
 }
 
+int network_get_local_ip_info(network_ctrl_t *ctrl, luat_ip_addr_t *ip, luat_ip_addr_t *submask, luat_ip_addr_t *gateway, void *user_data)
+{
+	network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
+	return adapter->opt->get_local_ip_info(ip, submask, gateway, adapter->user_data);
+}
+
 void network_clean_invaild_socket(uint8_t adapter_index)
 {
 	int i;
@@ -867,7 +1057,7 @@ void network_clean_invaild_socket(uint8_t adapter_index)
 			ctrl->socket_id = -1;
 			list[i] = -1;
 		}
-		LLOGD("%d,%d", i, list[i]);
+		DBG("%d,%d", i, list[i]);
 	}
 	adapter->opt->socket_clean(list, adapter->opt->max_socket_num, adapter->user_data);
 	NW_UNLOCK;
@@ -920,47 +1110,47 @@ int network_wait_link_up(network_ctrl_t *ctrl, uint32_t timeout_ms)
 	if (network_check_ready(ctrl))
 	{
 		ctrl->state = NW_STATE_OFF_LINE;
-		ctrl->target_state = NW_STATE_LINK_OFF;
+		ctrl->wait_target_state = NW_WAIT_NONE;
 		NW_UNLOCK;
 		return 0;
 	}
 	ctrl->state = NW_STATE_LINK_OFF;
-	ctrl->target_state = NW_STATE_WAIT_LINK;
+	ctrl->wait_target_state = NW_WAIT_LINK_UP;
 
 	NW_UNLOCK;
 	if (!ctrl->task_handle || !timeout_ms)
 	{
 		return 1;
 	}
-	uint8_t Finish = 0;
-	OS_EVENT Event;
-	int32_t Result;
+	uint8_t finish = 0;
+	OS_EVENT event;
+	int result;
 	//DBG_INFO("%s wait for active!,%u,%x", Net->Tag, To * SYS_TICK, Net->hTask);
 
 	platform_start_timer(ctrl->timer, timeout_ms, 0);
-	while (!Finish)
+	while (!finish)
 	{
-		platform_wait_event(ctrl->task_handle, 0, &Event, NULL, 0);
-		switch (Event.ID)
+		platform_wait_event(ctrl->task_handle, 0, &event, NULL, 0);
+		switch (event.ID)
 		{
 		case EV_NW_RESULT_LINK:
-			Result = (int)Event.Param1;
-			Finish = 1;
+			result = (int)event.Param1;
+			finish = 1;
 			break;
 		case EV_NW_TIMEOUT:
-			Result = -1;
-			Finish = 1;
+			result = -1;
+			finish = 1;
 			break;
 		default:
 			if (ctrl->user_callback)
 			{
-				ctrl->user_callback((void *)&Event, ctrl->task_handle);
+				ctrl->user_callback((void *)&event, ctrl->task_handle);
 			}
 			break;
 		}
 	}
 	platform_stop_timer(ctrl->timer);
-	return Result;
+	return result;
 }
 /*
  * 1.进行ready检测和等待ready
@@ -976,6 +1166,7 @@ int network_connect(network_ctrl_t *ctrl, const char *domain_name, uint32_t doma
 		return -1;
 	}
 	NW_LOCK;
+	ctrl->need_close = 0;
 	ctrl->domain_name = domain_name;
 	ctrl->domain_name_len = domain_name_len;
 	if (remote_ip)
@@ -989,7 +1180,7 @@ int network_connect(network_ctrl_t *ctrl, const char *domain_name, uint32_t doma
 	ctrl->auto_mode = 1;
 	ctrl->remote_port = remote_port;
 	network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
-	ctrl->target_state = NW_STATE_ONLINE;
+	ctrl->wait_target_state = NW_WAIT_ON_LINE;
 	if (!network_check_ready(ctrl))
 	{
 
@@ -999,7 +1190,7 @@ int network_connect(network_ctrl_t *ctrl, const char *domain_name, uint32_t doma
 	if (network_prepare_connect(ctrl))
 	{
 		ctrl->state = NW_STATE_OFF_LINE;
-		ctrl->target_state = NW_STATE_LINK_OFF;
+		ctrl->wait_target_state = NW_WAIT_NONE;
 		NW_UNLOCK;
 		return -1;
 	}
@@ -1010,35 +1201,35 @@ NETWORK_CONNECT_WAIT:
 
 		return 1;
 	}
-	uint8_t Finish = 0;
-	OS_EVENT Event;
-	int32_t Result;
+	uint8_t finish = 0;
+	OS_EVENT event;
+	int result;
 	//DBG_INFO("%s wait for active!,%u,%x", Net->Tag, To * SYS_TICK, Net->hTask);
 
 	platform_start_timer(ctrl->timer, timeout_ms, 0);
-	while (!Finish)
+	while (!finish)
 	{
-		platform_wait_event(ctrl->task_handle, 0, &Event, NULL, 0);
-		switch (Event.ID)
+		platform_wait_event(ctrl->task_handle, 0, &event, NULL, 0);
+		switch (event.ID)
 		{
 		case EV_NW_RESULT_CONNECT:
-			Result = (int)Event.Param1;
-			Finish = 1;
+			result = (int)event.Param1;
+			finish = 1;
 			break;
 		case EV_NW_TIMEOUT:
-			Result = -1;
-			Finish = 1;
+			result = -1;
+			finish = 1;
 			break;
 		default:
 			if (ctrl->user_callback)
 			{
-				ctrl->user_callback((void *)&Event, ctrl->task_handle);
+				ctrl->user_callback((void *)&event, ctrl->task_handle);
 			}
 			break;
 		}
 	}
 	platform_stop_timer(ctrl->timer);
-	return Result;
+	return result;
 }
 
 int network_listen(network_ctrl_t *ctrl, uint16_t local_port, uint32_t timeout_ms)
@@ -1052,6 +1243,7 @@ int network_close(network_ctrl_t *ctrl, uint32_t timeout_ms)
 	NW_LOCK;
 	uint8_t old_state = ctrl->state;
 	ctrl->auto_mode = 1;
+	ctrl->need_close = 0;
 	network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
 #ifdef LUAT_USE_TLS
 	if (ctrl->tls_mode)
@@ -1063,109 +1255,297 @@ int network_close(network_ctrl_t *ctrl, uint32_t timeout_ms)
 	{
 
 		ctrl->state = NW_STATE_OFF_LINE;
-		ctrl->target_state = NW_STATE_LINK_OFF;
+		ctrl->wait_target_state = NW_WAIT_NONE;
 		NW_UNLOCK;
 		return 0;
 	}
 
 	ctrl->state = NW_STATE_DISCONNECTING;
-	ctrl->target_state = NW_STATE_LINK_OFF;
+	ctrl->wait_target_state = NW_WAIT_OFF_LINE;
 
 	if ((NW_STATE_ONLINE == old_state) && ctrl->is_tcp)
 	{
 		if (network_socket_disconnect(ctrl))
 		{
-			network_clean_invaild_socket(ctrl->adapter_index);
-			network_socket_force_close(ctrl);
+			network_force_close_socket(ctrl);
 			ctrl->state = NW_STATE_OFF_LINE;
-			ctrl->target_state = NW_STATE_LINK_OFF;
+			ctrl->wait_target_state = NW_WAIT_NONE;
 			return 0;
 		}
 	}
 	else
 	{
-		if (network_socket_close(ctrl))
-		{
-			network_clean_invaild_socket(ctrl->adapter_index);
-			network_socket_force_close(ctrl);
-
-		}
+		network_force_close_socket(ctrl);
 		ctrl->state = NW_STATE_OFF_LINE;
-		ctrl->target_state = NW_STATE_LINK_OFF;
+		ctrl->wait_target_state = NW_WAIT_NONE;
 		return 0;
 	}
-NETWORK_CONNECT_WAIT:
 	NW_UNLOCK;
 	if (!ctrl->task_handle || !timeout_ms)
 	{
 		return 1;
 	}
-	uint8_t Finish = 0;
-	OS_EVENT Event;
-	int32_t Result;
+	uint8_t finish = 0;
+	OS_EVENT event;
+	int result;
 	//DBG_INFO("%s wait for active!,%u,%x", Net->Tag, To * SYS_TICK, Net->hTask);
 
 	platform_start_timer(ctrl->timer, timeout_ms, 0);
-	while (!Finish)
+	while (!finish)
 	{
-		platform_wait_event(ctrl->task_handle, 0, &Event, NULL, 0);
-		switch (Event.ID)
+		platform_wait_event(ctrl->task_handle, 0, &event, NULL, 0);
+		switch (event.ID)
 		{
 		case EV_NW_RESULT_CLOSE:
-			Result = 0;
-			Finish = 1;
+			result = 0;
+			finish = 1;
 			break;
 		case EV_NW_TIMEOUT:
-			Result = 0;
-			Finish = 1;
+			result = 0;
+			finish = 1;
 			break;
 		default:
 			if (ctrl->user_callback)
 			{
-				ctrl->user_callback((void *)&Event, ctrl->task_handle);
+				ctrl->user_callback((void *)&event, ctrl->task_handle);
 			}
 			break;
 		}
 	}
 	platform_stop_timer(ctrl->timer);
 	network_socket_force_close(ctrl);
-	return Result;
+	return result;
 }
 /*
  * timeout_ms=0时，为非阻塞接口
  */
-int network_tx(network_ctrl_t *ctrl, const uint8_t *data, uint32_t len, uint32_t timeout_ms)
+int network_tx(network_ctrl_t *ctrl, const uint8_t *data, uint32_t len, int flags, luat_ip_addr_t *remote_ip, uint16_t remote_port, uint32_t *tx_len, uint32_t timeout_ms)
 {
-	if ((ctrl->socket_id < 0) || (ctrl->state != NW_STATE_ONLINE))
+	if ((ctrl->need_close) || (ctrl->socket_id < 0) || (ctrl->state != NW_STATE_ONLINE))
 	{
 		return -1;
 	}
 	NW_LOCK;
+	int result;
+
 	ctrl->auto_mode = 1;
 	network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
+#ifdef LUAT_USE_TLS
+	if (ctrl->tls_mode)
+	{
+		if (ctrl->tls_need_reshakehand)
+		{
+			ctrl->tls_need_reshakehand = 0;
+			ctrl->cache_data = data;
+			ctrl->cache_len = len;
+	    	mbedtls_ssl_session_reset(ctrl->ssl);
+	    	do
+	    	{
+	    		result = mbedtls_ssl_handshake_step( ctrl->ssl );
+	    		switch(result)
+	    		{
+	    		case MBEDTLS_ERR_SSL_WANT_READ:
+	    			ctrl->state = NW_STATE_SHAKEHAND;
+	    			goto NETWORK_TX_WAIT;
+	    		case 0:
+	    			break;
+	    		default:
+	    			DBG_ERR("0x%x, %d", -result, ctrl->ssl->state);
+	    			ctrl->need_close = 1;
+	    			NW_UNLOCK;
+	    			return -1;
+	    		}
+	    	}while(ctrl->ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER);
+		}
+		result = mbedtls_ssl_write(ctrl->ssl, data, len);
+	    if (result < 0)
+	    {
+	    	DBG("%08x", -result);
+			ctrl->need_close = 1;
+			NW_UNLOCK;
+			return -1;
+	    }
+	}
+	else
+#endif
+	{
+		result = network_base_tx(ctrl, data, len, flags, remote_ip, remote_port);
+		if (result < 0)
+		{
+			ctrl->need_close = 1;
+			NW_UNLOCK;
+			return -1;
+		}
+		*tx_len = result;
+		if (!result && len)
+		{
+			NW_UNLOCK;
+			return 0;
+		}
+	}
+
+NETWORK_TX_WAIT:
+	ctrl->wait_target_state = NW_WAIT_TX_OK;
+	NW_UNLOCK;
+
+	if (!ctrl->task_handle || !timeout_ms)
+	{
+		return 1;
+	}
+	uint8_t finish = 0;
+	OS_EVENT event;
+	//DBG_INFO("%s wait for active!,%u,%x", Net->Tag, To * SYS_TICK, Net->hTask);
 
+	platform_start_timer(ctrl->timer, timeout_ms, 0);
+	while (!finish)
+	{
+		platform_wait_event(ctrl->task_handle, 0, &event, NULL, 0);
+		switch (event.ID)
+		{
+		case EV_NW_RESULT_TX:
+			result = (int)event.Param1;
+			if (!result)
+			{
+				result = -1;
+			}
+			finish = 1;
+			break;
+		case EV_NW_TIMEOUT:
+			result = -1;
+			finish = 1;
+			break;
+		default:
+			if (ctrl->user_callback)
+			{
+				ctrl->user_callback((void *)&event, ctrl->task_handle);
+			}
+			break;
+		}
+	}
+	platform_stop_timer(ctrl->timer);
+	return result;
 }
 /*
- * timeout_ms=0时，为非阻塞接口
- * 实际读到的数据量在read_len里，如果是UDP模式且为server时，需要看remote_ip和remote_port
+ * 实际读到的数据量在rx_len里，如果是UDP模式且为server时，需要看remote_ip和remote_port
  */
-int network_rx(network_ctrl_t *ctrl, uint8_t *data, uint32_t len, uint32_t *read_len, luat_ip_addr_t *remote_ip, uint16_t *remote_port, uint32_t timeout_ms)
+int network_rx(network_ctrl_t *ctrl, uint8_t *data, uint32_t len, int flags, luat_ip_addr_t *remote_ip, uint16_t *remote_port, uint32_t *rx_len)
 {
-	if ((ctrl->socket_id < 0) || (ctrl->state != NW_STATE_ONLINE))
+	if ((ctrl->need_close) || (ctrl->socket_id < 0) || (ctrl->state != NW_STATE_ONLINE))
 	{
 		return -1;
 	}
+	NW_LOCK;
+	int result = -1;
 	ctrl->auto_mode = 1;
-	network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
+	if (ctrl->new_rx_flag)
+	{
+		if (data)
+		{
+			ctrl->new_rx_flag = 0;
+	#ifdef LUAT_USE_TLS
+			if (ctrl->tls_mode)
+			{
+				result = mbedtls_ssl_read(ctrl->ssl, data, len);
+				if (MBEDTLS_ERR_SSL_WANT_READ == result)
+				{
+					result = 0;
+				}
+			}
+			else
+	#endif
+			{
 
+				result = network_socket_receive(ctrl, data, len, flags, remote_ip, remote_port);
+			}
+		}
+		else
+		{
+			result = network_socket_receive(ctrl, data, len, flags, remote_ip, remote_port);
+		}
+	}
+	else
+	{
+		result = 0;
+	}
+	NW_UNLOCK;
+	if (result >= 0)
+	{
+		*rx_len = result;
+		return 0;
+	}
+	else
+	{
+		return -1;
+	}
 }
 
-/*
- * 如果event为NULL，则自动处理掉接收到的非socket的event，直到超时，否则收到非socket的event或者正常的socket rx，就返回成功
- */
-int network_wait_event(network_ctrl_t *ctrl, OS_EVENT *event, uint32_t timeout_ms, uint8_t *is_timeout)
+int network_wait_event(network_ctrl_t *ctrl, OS_EVENT *out_event, uint32_t timeout_ms, uint8_t *is_timeout)
 {
+	if ((ctrl->need_close) || (ctrl->socket_id < 0) || (ctrl->state != NW_STATE_ONLINE))
+	{
+		return -1;
+	}
+	if (ctrl->new_rx_flag)
+	{
+		return 0;
+	}
+	NW_LOCK;
 	ctrl->auto_mode = 1;
-	network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
+	ctrl->wait_target_state = NW_WAIT_EVENT;
+	NW_UNLOCK;
+	if (!ctrl->task_handle || !timeout_ms)
+	{
+		return 1;
+	}
+	*is_timeout = 0;
+	uint8_t finish = 0;
+	OS_EVENT event;
+	int result;
+	//DBG_INFO("%s wait for active!,%u,%x", Net->Tag, To * SYS_TICK, Net->hTask);
+
+	platform_start_timer(ctrl->timer, timeout_ms, 0);
+	while (!finish)
+	{
+		platform_wait_event(ctrl->task_handle, 0, &event, NULL, 0);
+		switch (event.ID)
+		{
+		case EV_NW_RESULT_EVENT:
+			result = (int)event.Param1;
+			if (result)
+			{
+				result = -1;
+			}
+			finish = 1;
+			break;
+		case EV_NW_TIMEOUT:
+			*is_timeout = 1;
+			result = 0;
+			finish = 1;
+			break;
+		case EV_NW_BREAK_WAIT:
+			if (out_event)
+			{
+				*out_event = event;
+			}
+			result = 0;
+			finish = 1;
+			break;
+		default:
+			if (out_event)
+			{
+				*out_event = event;
+				result = 0;
+				finish = 1;
+				break;
+			}
+			else if (ctrl->user_callback)
+			{
+				ctrl->user_callback((void *)&event, ctrl->task_handle);
+			}
+			break;
+		}
+	}
+	platform_stop_timer(ctrl->timer);
+	return result;
 }
 #endif

components/network/adapter/luat_network_adapter.h

@@ -32,6 +32,7 @@ enum
 	EV_NW_SOCKET_ERROR,
 	EV_NW_SOCKET_LISTEN,
 	EV_NW_SOCKET_NEW_CONNECT,	//作为server接收到新的connect，只有允许accept操作的才有，否则直接上报CONNECT_OK
+	EV_NW_BREAK_WAIT,
 	EV_NW_END,
 
 	NW_STATE_LINK_OFF = 0,
@@ -42,18 +43,21 @@ enum
 	NW_STATE_ONLINE,
 	NW_STATE_LISTEN,
 	NW_STATE_DISCONNECTING,
-	NW_STATE_TX_OK,
-	NW_STATE_NEW_RX,
-	NW_STATE_WAIT_LINK,
+
+	NW_WAIT_NONE = 0,
+	NW_WAIT_LINK_UP,
+	NW_WAIT_ON_LINE,
+	NW_WAIT_TX_OK,
+	NW_WAIT_OFF_LINE,
+	NW_WAIT_EVENT,
 
 	//一旦使用高级API，回调会改为下面的，param1 = 0成功，其他失败
 	EV_NW_RESULT_BASE = EV_NW_END + 1,
-	EV_NW_RESULT_LINK = EV_NW_RESULT_BASE + NW_STATE_WAIT_LINK,
-	EV_NW_RESULT_CONNECT = EV_NW_RESULT_BASE + NW_STATE_ONLINE,
-	EV_NW_RESULT_LISTEN = EV_NW_RESULT_BASE +  NW_STATE_LISTEN,
-	EV_NW_RESULT_CLOSE = EV_NW_RESULT_BASE + NW_STATE_OFF_LINE,
-	EV_NW_RESULT_TX = EV_NW_RESULT_BASE + NW_STATE_TX_OK,
-	EV_NW_RESULT_RX = EV_NW_RESULT_BASE + NW_STATE_NEW_RX,
+	EV_NW_RESULT_LINK = EV_NW_RESULT_BASE + NW_WAIT_LINK_UP,
+	EV_NW_RESULT_CONNECT = EV_NW_RESULT_BASE + NW_WAIT_ON_LINE,
+	EV_NW_RESULT_CLOSE = EV_NW_RESULT_BASE + NW_WAIT_OFF_LINE,
+	EV_NW_RESULT_TX = EV_NW_RESULT_BASE + NW_WAIT_TX_OK,
+	EV_NW_RESULT_EVENT = EV_NW_RESULT_BASE + NW_WAIT_EVENT,
 
 	NW_ADAPTER_INDEX_ETH0 = 0,		//以太网
 	NW_ADAPTER_INDEX_STA,			//wifi sta和蜂窝
@@ -134,12 +138,16 @@ typedef struct
 	uint16_t remote_port;
 	uint16_t local_port;
 #ifdef LUAT_USE_TLS
+	const uint8_t *cache_data;
+	uint32_t cache_len;
 	int tls_timer_state;
 	uint32_t tls_send_timeout_ms;
 	uint8_t tls_mode;
     uint8_t tls_need_reshakehand;
     uint8_t tls_init_done;
 #endif
+    uint8_t need_close;
+    uint8_t new_rx_flag;
     uint8_t dns_ip_cnt;
     uint8_t tcp_keep_alive;
 	uint8_t tcp_keep_interval;
@@ -148,8 +156,9 @@ typedef struct
     uint8_t is_tcp;
     uint8_t is_server_mode;
     uint8_t auto_mode;
-    uint8_t target_state;
+    uint8_t wait_target_state;
     uint8_t state;
+    uint8_t is_debug;
 }network_ctrl_t;
 
 typedef struct
@@ -201,7 +210,7 @@ typedef struct
 	//成功返回实际读取的值，失败 < 0
 	int (*socket_receive)(int socket_id, uint64_t tag, uint8_t *buf, uint32_t len, int flags, luat_ip_addr_t *remote_ip, uint16_t *remote_port, void *user_data);
 	//tcp时，不需要remote_ip和remote_port
-	//成功返回0，失败 < 0
+	//成功返回>0的len，缓冲区满了=0，失败 < 0，如果发送了len=0的空包，也是返回0，注意判断
 	int (*socket_send)(int socket_id, uint64_t tag, const uint8_t *buf, uint32_t len, int flags, luat_ip_addr_t *remote_ip, uint16_t remote_port, void *user_data);
 	//检查socket合法性，成功返回0，失败 < 0
 	int (*socket_check)(int socket_id, uint64_t tag, void *user_data);
@@ -214,6 +223,7 @@ typedef struct
 
 	int (*dns)(const char *domain_name, uint32_t len, void *user_data);
 	int (*set_dns_server)(uint8_t server_index, luat_ip_addr_t *ip, void *user_data);
+	int (*get_local_ip_info)(luat_ip_addr_t *ip, luat_ip_addr_t *submask, luat_ip_addr_t *gateway, void *user_data);
 	//所有网络消息都是通过cb_fun回调
 	//cb_fun回调时第一个参数为OS_EVENT，包含了socket的必要信息，第二个是luat_network_cb_param_t，其中的param是这里传入的param
 	//OS_EVENT ID为EV_NW_XXX，param1是socket id param2是各自参数 param3是
@@ -307,6 +317,7 @@ int network_getsockopt(network_ctrl_t *ctrl, int level, int optname, void *optva
 int network_setsockopt(network_ctrl_t *ctrl, int level, int optname, const void *optval, uint32_t optlen);
 //非posix的socket，用这个根据实际硬件设置参数
 int network_user_cmd(network_ctrl_t *ctrl,  uint32_t cmd, uint32_t value);
+int network_get_local_ip_info(network_ctrl_t *ctrl, luat_ip_addr_t *ip, luat_ip_addr_t *submask, luat_ip_addr_t *gateway, void *user_data);
 //url已经是ip形式了，返回1，并且填充remote_ip
 //成功返回0，失败 < 0
 int network_dns(network_ctrl_t *ctrl);
@@ -375,18 +386,19 @@ int network_close(network_ctrl_t *ctrl, uint32_t timeout_ms);
 /*
  * timeout_ms=0时，为非阻塞接口
  */
-int network_tx(network_ctrl_t *ctrl, const uint8_t *data, uint32_t len, uint32_t timeout_ms);
+int network_tx(network_ctrl_t *ctrl, const uint8_t *data, uint32_t len, int flags, luat_ip_addr_t *remote_ip, uint16_t remote_port, uint32_t *tx_len, uint32_t timeout_ms);
 /*
  * timeout_ms=0时，为非阻塞接口
  * 实际读到的数据量在read_len里，如果是UDP模式且为server时，需要看remote_ip和remote_port
  */
-int network_rx(network_ctrl_t *ctrl, uint8_t *data, uint32_t len, uint32_t *read_len, luat_ip_addr_t *remote_ip, uint16_t *remote_port, uint32_t timeout_ms);
+int network_rx(network_ctrl_t *ctrl, uint8_t *data, uint32_t len, int flags, luat_ip_addr_t *remote_ip, uint16_t *remote_port, uint32_t *rx_len);
 
 /*
- * 如果event为NULL，则自动处理掉接收到的非socket的event，直到超时，否则收到非socket的event或者正常的socket rx，就返回成功
+ * 接收到socket异常消息均会返回
+ * 如果event为NULL，则自动处理掉接收到的非socket的event，直到超时，而socket消息则如果is_read=1，则接收到新的数据会返回，如果is_read=0，则接收任意新的消息都会返回
+ * 如果event不为NULL，收到任意消息都会返回
  */
-int network_wait_event(network_ctrl_t *ctrl, OS_EVENT *event, uint32_t timeout_ms, uint8_t *is_timeout);
-
+int network_wait_event(network_ctrl_t *ctrl, OS_EVENT *out_event, uint32_t timeout_ms, uint8_t *is_timeout);
 /****************************高级api结束********************************************************************/
 #endif
 #endif