?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update:network关键信息更加详细一些
[LuatOS.git] / components / network / adapter / luat_network_adapter.c
blobe6a1bd0b98f4f22dfadde07f986e96ec60e4446b
1
2 #include "luat_base.h"
3 #include "luat_mem.h"
4 #include "luat_crypto.h"
5 #include "luat_rtos.h"
6 #ifdef LUAT_USE_NETWORK
7 #include "luat_rtos.h"
8 #include "platform_def.h"
9 #include "ctype.h"
10 #include "luat_network_adapter.h"
11
12 #ifndef LWIP_NUM_SOCKETS
13 #define LWIP_NUM_SOCKETS 8
14 #endif
15
16 typedef struct
17 {
18 #ifdef LUAT_USE_LWIP
19 network_ctrl_t lwip_ctrl_table[LWIP_NUM_SOCKETS];
20 // HANDLE network_mutex;
21 #endif
22 int last_adapter_index;
23 int default_adapter_index;
24 llist_head dns_cache_head;
25 #ifdef LUAT_USE_LWIP
26 uint8_t lwip_ctrl_busy[LWIP_NUM_SOCKETS];
27 #endif
28 uint8_t is_init;
29 }network_info_t;
30
31 typedef struct
32 {
33
34 network_adapter_info *opt;
35 void *user_data;
36 uint8_t *ctrl_busy;
37 network_ctrl_t *ctrl_table;
38 uint16_t port;
39 }network_adapter_t;
40
41 static network_adapter_t prv_adapter_table[NW_ADAPTER_QTY];
42 static network_info_t prv_network = {
43 .last_adapter_index = -1,
44 .default_adapter_index = -1,
45 .is_init = 0,
46 };
47 static const char *prv_network_event_id_string[] =
48 {
49 "适配器复位",
50 "LINK状态变更",
51 "超时",
52 "DNS结果",
53 "发送成功",
54 "有新的数据",
55 "接收缓存满了",
56 "断开成功",
57 "对端关闭",
58 "连接成功",
59 "连接异常",
60 "开始监听",
61 "新的客户端来了",
62 "唤醒",
63 "未知",
64 };
65
66 static const char *prv_network_ctrl_state_string[] =
67 {
68 "硬件离线",
69 "离线",
70 "等待DNS",
71 "正在连接",
72 "正在TLS握手",
73 "在线",
74 "在监听",
75 "正在离线",
76 "未知"
77 };
78
79 static const char *prv_network_ctrl_wait_state_string[] =
80 {
81 "无等待",
82 "等待硬件上线",
83 "等待连接完成",
84 "等待发送完成",
85 "等待离线完成",
86 "等待任意网络变化",
87 "未知",
88 };
89
90 static const char *prv_network_ctrl_callback_event_string[] =
91 {
92 "硬件状态回调",
93 "连接状态回调",
94 "离线状态回调",
95 "发送状态回调",
96 "任意网络变化回调",
97 };
98
99 const char *network_ctrl_event_id_string(uint32_t event)
100 {
101 if (event > EV_NW_END || event < EV_NW_RESET)
102 {
103 return prv_network_event_id_string[EV_NW_END - EV_NW_RESET];
104 }
105 return prv_network_event_id_string[event - EV_NW_RESET];
106 }
107
108 const char *network_ctrl_state_string(uint8_t state)
109 {
110 if (state > NW_STATE_DISCONNECTING)
111 {
112 return prv_network_ctrl_state_string[NW_STATE_DISCONNECTING + 1];
113 }
114 return prv_network_ctrl_state_string[state];
115 }
116
117 const char *network_ctrl_wait_state_string(uint8_t state)
118 {
119 if (state > NW_WAIT_EVENT)
120 {
121 return prv_network_ctrl_wait_state_string[NW_WAIT_EVENT + 1];
122 }
123 return prv_network_ctrl_wait_state_string[state];
124 }
125
126 const char *network_ctrl_callback_event_string(uint32_t event)
127 {
128 if (event > EV_NW_RESULT_EVENT || event < EV_NW_RESULT_LINK)
129 {
130 return prv_network_ctrl_callback_event_string[event - EV_NW_RESULT_EVENT + 1];
131 }
132 return prv_network_ctrl_callback_event_string[event - EV_NW_RESULT_EVENT];
133 }
134
135 network_adapter_info* network_adapter_fetch(int id, void** userdata) {
136 if (id >= 0 && id < NW_ADAPTER_QTY) {
137 if (prv_adapter_table[id].opt) {
138 *userdata = prv_adapter_table[id].user_data;
139 return prv_adapter_table[id].opt;
140 }
141 }
142 return NULL;
143 }
144
145 #ifdef LUAT_USE_LWIP
146 #include "../lwip/port/net_lwip.h"
147 #else
148 #include "dhcp_def.h"
149 #endif
150 extern void DBG_Printf(const char* format, ...);
151 extern void DBG_HexPrintf(void *Data, unsigned int len);
152 //#define DBG(x,y...) DBG_Printf("%s %d:"x"\r\n", __FUNCTION__,__LINE__,##y)
153 //#define DBG_ERR(x,y...) DBG_Printf("%s %d:"x"\r\n", __FUNCTION__,__LINE__,##y)
154 static int tls_random( void *p_rng,
155 unsigned char *output, size_t output_len );
156
157 #define __NW_DEBUG_ENABLE__
158 #ifdef __NW_DEBUG_ENABLE__
159 #ifdef LUAT_LOG_NO_NEWLINE
160 #define DBG(x,...) do {if (ctrl->is_debug) {DBG_Printf("%s %d:"x, __FUNCTION__,__LINE__,##__VA_ARGS__);}} while(0)
161 #define DBG_ERR(x,...) DBG_Printf("%s %d:"x, __FUNCTION__,__LINE__,##__VA_ARGS__)
162 #else
163 #define DBG(x,...) do {if (ctrl->is_debug) {DBG_Printf("%s %d:"x"\r\n", __FUNCTION__,__LINE__,##__VA_ARGS__);}} while(0)
164 #define DBG_ERR(x,...) DBG_Printf("%s %d:"x"\r\n", __FUNCTION__,__LINE__,##__VA_ARGS__)
165 #endif
166 #else
167 #define DBG(x,...)
168 #define DBG_ERR(x,...)
169 #endif
170 #define NW_LOCK platform_lock_mutex(ctrl->mutex)
171 #define NW_UNLOCK platform_unlock_mutex(ctrl->mutex)
172
173 #define SOL_SOCKET 0xfff /* options for socket level */
174 #define SO_REUSEADDR 0x0004 /* Allow local address reuse */
175 #define SO_KEEPALIVE 0x0008 /* keep connections alive */
176
177 #define IPPROTO_ICMP 1
178 #define IPPROTO_TCP 6
179 #define TCP_NODELAY 0x01 /* don't delay send to coalesce packets */
180 #define TCP_KEEPALIVE 0x02 /* send KEEPALIVE probes when idle for pcb->keep_idle milliseconds */
181 #define TCP_KEEPIDLE 0x03 /* set pcb->keep_idle - Same as TCP_KEEPALIVE, but use seconds for get/setsockopt */
182 #define TCP_KEEPINTVL 0x04 /* set pcb->keep_intvl - Use seconds for get/setsockopt */
183 #define TCP_KEEPCNT 0x05 /* set pcb->keep_cnt - Use number of probes sent for get/setsockopt */
184
185
186
187 static uint8_t network_check_ip_same(luat_ip_addr_t *ip1, luat_ip_addr_t *ip2)
188 {
189 #ifdef LUAT_USE_LWIP
190 #if defined ENABLE_PSIF
191 return ip_addr_cmp(ip1, ip2);
192 #else
193 #if LWIP_IPV6
194 return ip_addr_cmp_zoneless(ip1, ip2);
195 #else
196 return ip_addr_cmp(ip1, ip2);
197 #endif
198 #endif
199 #else
200 if (ip1->is_ipv6 != ip2->is_ipv6)
201 {
202 return 0;
203 }
204 if (ip1->is_ipv6)
205 {
206 return !memcmp(ip1->ipv6_u8_addr, ip2->ipv6_u8_addr, 16);
207 }
208 else
209 {
210 return (ip1->ipv4 == ip2->ipv4);
211 }
212 #endif
213 }
214
215 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)
216 {
217 int result = -1;
218 if (ctrl->is_tcp)
219 {
220 result = network_socket_send(ctrl, data, len, flags, NULL, 0);
221 }
222 else
223 {
224 if (remote_ip)
225 {
226 result = network_socket_send(ctrl, data, len, flags, remote_ip, remote_port);
227 }
228 else
229 {
230 result = network_socket_send(ctrl, data, len, flags, ctrl->online_ip, ctrl->remote_port);
231 }
232 }
233 if (result >= 0)
234 {
235 ctrl->tx_size += len;
236 }
237 else
238 {
239 ctrl->need_close = 1;
240 }
241 return result;
242 }
243
244 static LUAT_RT_RET_TYPE tls_shorttimeout(LUAT_RT_CB_PARAM)
245 {
246 network_ctrl_t *ctrl = (network_ctrl_t *)param;
247 if (!ctrl->tls_mode)
248 {
249 platform_stop_timer(ctrl->tls_long_timer);
250 return LUAT_RT_RET;
251 }
252 if (0 == ctrl->tls_timer_state)
253 {
254 ctrl->tls_timer_state = 1;
255 }
256 return LUAT_RT_RET;
257 }
258 #ifdef LUAT_USE_TLS
259 static LUAT_RT_RET_TYPE tls_longtimeout(LUAT_RT_CB_PARAM)
260 {
261 network_ctrl_t *ctrl = (network_ctrl_t *)param;
262 platform_stop_timer(ctrl->tls_short_timer);
263 if (!ctrl->tls_mode)
264 {
265 return LUAT_RT_RET;
266 }
267 ctrl->tls_timer_state = 2;
268 return LUAT_RT_RET;
269 }
270
271 static void tls_settimer( void *data, uint32_t int_ms, uint32_t fin_ms )
272 {
273 network_ctrl_t *ctrl = (network_ctrl_t *)data;
274 if (!ctrl->tls_mode)
275 {
276 return;
277 }
278 if (!fin_ms)
279 {
280 platform_stop_timer(ctrl->tls_short_timer);
281 platform_stop_timer(ctrl->tls_long_timer);
282 ctrl->tls_timer_state = -1;
283 return ;
284 }
285 platform_start_timer(ctrl->tls_short_timer, int_ms, 0);
286 platform_start_timer(ctrl->tls_long_timer, fin_ms, 0);
287 ctrl->tls_timer_state = 0;
288 }
289
290 static int tls_gettimer( void *data )
291 {
292 network_ctrl_t *ctrl = (network_ctrl_t *)data;
293 if (!ctrl->tls_mode)
294 {
295 return -ERROR_PARAM_INVALID;
296 }
297 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
298 if(!mbedtls_ssl_is_handshake_over(ctrl->ssl))
299 #else
300 if (ctrl->ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER)
301 #endif
302 {
303 return ctrl->tls_timer_state;
304 }
305 else
306 {
307 return 0;
308 }
309 }
310
311 static void tls_dbg(void *data, int level,
312 const char *file, int line,
313 const char *str)
314 {
315 (void)data;(void)level;DBG_Printf("%s %d:%s", file, line, str);
316 }
317
318 static int tls_send(void *ctx, const unsigned char *buf, size_t len )
319 {
320 network_ctrl_t *ctrl = (network_ctrl_t *)ctx;
321 if (!ctrl->tls_mode)
322 {
323 return -ERROR_PERMISSION_DENIED;
324 }
325 if (network_base_tx(ctrl, buf, len, 0, NULL, 0) != len)
326 {
327 return -0x004E;
328 }
329 else
330 {
331 return len;
332 }
333 }
334 #endif
335 static int tls_recv(void *ctx, unsigned char *buf, size_t len )
336 {
337 #ifdef LUAT_USE_TLS
338 network_ctrl_t *ctrl = (network_ctrl_t *)ctx;
339 luat_ip_addr_t remote_ip;
340 uint16_t remote_port;
341 int result = -1;
342 if (!ctrl->tls_mode)
343 {
344 return -1;
345 }
346 TLS_RECV:
347
348 result = network_socket_receive(ctrl, buf, len, 0, &remote_ip, &remote_port);
349 if (result < 0)
350 {
351 return -0x004C;
352 }
353 if (result > 0)
354 {
355 if (!ctrl->is_tcp)
356 {
357 if ((remote_port == ctrl->remote_port) && network_check_ip_same(&remote_ip, ctrl->online_ip))
358 {
359 goto TLS_RECV;
360 }
361 }
362 return result;
363 }
364 return MBEDTLS_ERR_SSL_WANT_READ;
365 #else
366 return -1;
367 #endif
368 }
369
370 static int network_get_host_by_name(network_ctrl_t *ctrl)
371 {
372 #ifdef LUAT_USE_LWIP
373 network_set_ip_invaild(&ctrl->remote_ip);
374 if (ipaddr_aton(ctrl->domain_name, &ctrl->remote_ip))
375 {
376 return 0;
377 }
378 network_set_ip_invaild(&ctrl->remote_ip);
379 return -1;
380 #else
381 ctrl->remote_ip.is_ipv6 = 0xff;
382 if (network_string_is_ipv4(ctrl->domain_name, ctrl->domain_name_len))
383 {
384 ctrl->remote_ip.is_ipv6 = 0;
385 ctrl->remote_ip.ipv4 = network_string_to_ipv4(ctrl->domain_name, ctrl->domain_name_len);
386 }
387 else
388 {
389 char *name = zalloc(ctrl->domain_name_len + 1);
390 memcpy(name, ctrl->domain_name, ctrl->domain_name_len);
391 network_string_to_ipv6(name, &ctrl->remote_ip);
392 free(name);
393 }
394 if (ctrl->remote_ip.is_ipv6 != 0xff)
395 {
396 return 0;
397 }
398 else
399 {
400 return -1;
401 }
402 #endif
403 }
404
405 static void network_update_dns_cache(network_ctrl_t *ctrl)
406 {
407
408 }
409
410 static void network_get_dns_cache(network_ctrl_t *ctrl)
411 {
412
413 }
414
415 static int network_base_connect(network_ctrl_t *ctrl, luat_ip_addr_t *remote_ip)
416 {
417 #ifdef LUAT_USE_LWIP
418 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
419 if (ctrl->socket_id >= 0)
420 {
421 #ifdef LUAT_USE_TLS
422 if (ctrl->tls_mode)
423 {
424 mbedtls_ssl_free(ctrl->ssl);
425 }
426 #endif
427 if (network_socket_close(ctrl))
428 {
429 network_clean_invaild_socket(ctrl->adapter_index);
430 network_socket_force_close(ctrl);
431 }
432 ctrl->need_close = 0;
433 ctrl->socket_id = -1;
434 }
435 if (remote_ip)
436 {
437 if (network_create_soceket(ctrl, network_ip_is_ipv6(remote_ip)) < 0)
438 {
439 network_clean_invaild_socket(ctrl->adapter_index);
440 if (network_create_soceket(ctrl, network_ip_is_ipv6(remote_ip)) < 0)
441 {
442 return -1;
443 }
444 }
445 if (adapter->opt->is_posix)
446 {
447 volatile uint32_t val;
448 val = ctrl->tcp_keep_alive;
449 network_setsockopt(ctrl, SOL_SOCKET, SO_KEEPALIVE, (void *)&val, sizeof(val));
450 if (ctrl->tcp_keep_alive)
451 {
452 val = ctrl->tcp_keep_idle;
453 network_setsockopt(ctrl, IPPROTO_TCP, TCP_KEEPIDLE, (void*)&val, sizeof(val));
454 val = ctrl->tcp_keep_interval;
455 network_setsockopt(ctrl, IPPROTO_TCP, TCP_KEEPINTVL, (void *)&val, sizeof(val));
456 val = ctrl->tcp_keep_cnt;
457 network_setsockopt(ctrl, IPPROTO_TCP, TCP_KEEPCNT, (void *)&val, sizeof(val));
458 }
459 }
460 else
461 {
462 network_user_cmd(ctrl, NW_CMD_AUTO_HEART_TIME, ctrl->tcp_keep_idle);
463 }
464
465 return network_socket_connect(ctrl, remote_ip);
466 }
467 else
468 {
469 if (network_create_soceket(ctrl, 0) < 0)
470 {
471 network_clean_invaild_socket(ctrl->adapter_index);
472 if (network_create_soceket(ctrl, 0) < 0)
473 {
474 return -1;
475 }
476 }
477 return network_socket_listen(ctrl);
478 }
479 #else
480 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
481 if (ctrl->socket_id >= 0)
482 {
483 network_force_close_socket(ctrl);
484 }
485 if (remote_ip)
486 {
487 if (network_create_soceket(ctrl, remote_ip->is_ipv6) < 0)
488 {
489 network_clean_invaild_socket(ctrl->adapter_index);
490 if (network_create_soceket(ctrl, remote_ip->is_ipv6) < 0)
491 {
492 return -1;
493 }
494 }
495 if (adapter->opt->is_posix)
496 {
497 network_setsockopt(ctrl, SOL_SOCKET, SO_KEEPALIVE, (void *)&ctrl->tcp_keep_alive, sizeof(ctrl->tcp_keep_alive));
498 if (ctrl->tcp_keep_alive)
499 {
500 network_setsockopt(ctrl, IPPROTO_TCP, TCP_KEEPIDLE, (void*)&ctrl->tcp_keep_idle, sizeof(ctrl->tcp_keep_idle));
501 network_setsockopt(ctrl, IPPROTO_TCP, TCP_KEEPINTVL, (void *)&ctrl->tcp_keep_interval, sizeof(ctrl->tcp_keep_interval));
502 network_setsockopt(ctrl, IPPROTO_TCP, TCP_KEEPCNT, (void *)&ctrl->tcp_keep_cnt, sizeof(ctrl->tcp_keep_cnt));
503 }
504 }
505 else
506 {
507 network_user_cmd(ctrl, NW_CMD_AUTO_HEART_TIME, ctrl->tcp_keep_idle);
508 }
509
510 return network_socket_connect(ctrl, remote_ip);
511 }
512 else
513 {
514 luat_ip_addr_t local_ip, net_mask, gate_way;
515 network_get_local_ip_info(ctrl, &local_ip, &net_mask, &gate_way);
516 if (network_create_soceket(ctrl, local_ip.is_ipv6) < 0)
517 {
518 network_clean_invaild_socket(ctrl->adapter_index);
519 if (network_create_soceket(ctrl, local_ip.is_ipv6) < 0)
520 {
521 return -1;
522 }
523 }
524 return network_socket_listen(ctrl);
525 }
526 #endif
527 }
528
529 static int network_prepare_connect(network_ctrl_t *ctrl)
530 {
531
532 if (network_ip_is_vaild(&ctrl->remote_ip))
533 {
534 ;
535 }
536 else if (ctrl->domain_name)
537 {
538 if (network_get_host_by_name(ctrl))
539 {
540 if (network_dns(ctrl))
541 {
542 network_socket_force_close(ctrl);
543 return -1;
544 }
545 ctrl->state = NW_STATE_WAIT_DNS;
546 return 0;
547 }
548 }
549 else
550 {
551
552 return -1;
553 }
554
555 if (network_base_connect(ctrl, &ctrl->remote_ip))
556 {
557 network_socket_force_close(ctrl);
558 return -1;
559 }
560 ctrl->state = NW_STATE_CONNECTING;
561 return 0;
562 }
563
564 static int network_state_link_off(network_ctrl_t *ctrl, OS_EVENT *event, network_adapter_t *adapter)
565 {
566 if (EV_NW_STATE == event->ID)
567 {
568 if (event->Param2)
569 {
570 ctrl->state = NW_STATE_OFF_LINE;
571 if (NW_WAIT_LINK_UP == ctrl->wait_target_state)
572 {
573 return 0;
574 }
575 else if (NW_WAIT_ON_LINE == ctrl->wait_target_state)
576 {
577 if (ctrl->is_server_mode)
578 {
579 if (network_base_connect(ctrl, NULL))
580 {
581 return -1;
582 }
583 ctrl->state = NW_STATE_CONNECTING;
584 }
585 else
586 {
587 if (network_prepare_connect(ctrl))
588 {
589 return -1;
590 }
591 }
592
593 return 1;
594 }
595 }
596 }
597 return 1;
598 }
599
600 static int network_state_off_line(network_ctrl_t *ctrl, OS_EVENT *event, network_adapter_t *adapter)
601 {
602 return 1;
603 }
604
605 static int network_state_wait_dns(network_ctrl_t *ctrl, OS_EVENT *event, network_adapter_t *adapter)
606 {
607 if ((ctrl->need_close) || ctrl->wait_target_state != NW_WAIT_ON_LINE) return -1;
608 switch(event->ID)
609 {
610 case EV_NW_RESET:
611 case EV_NW_SOCKET_ERROR:
612 return -1;
613 case EV_NW_STATE:
614 if (!event->Param2)
615 {
616 return -1;
617 }
618 break;
619 case EV_NW_DNS_RESULT:
620 if (event->Param1)
621 {
622 //更新dns cache
623 ctrl->dns_ip = event->Param2;
624 ctrl->dns_ip_nums = event->Param1;
625 #ifdef LUAT_USE_LWIP
626 for(int i = 0; i < ctrl->dns_ip_nums; i++)
627 {
628 DBG("dns ip%d, ttl %u, %s", i, ctrl->dns_ip[i].ttl_end, ipaddr_ntoa(&ctrl->dns_ip[i].ip));
629 }
630 #endif
631 network_update_dns_cache(ctrl);
632 }
633 else
634 {
635 ctrl->dns_ip_nums = 0;
636 network_get_dns_cache(ctrl);
637 if (!ctrl->dns_ip_nums)
638 {
639 return -1;
640 }
641
642 }
643 if (!ctrl->remote_port)
644 {
645 ctrl->state = NW_STATE_OFF_LINE;
646 return 0;
647 }
648 ctrl->dns_ip_cnt = 0;
649 if (network_base_connect(ctrl, &ctrl->dns_ip[ctrl->dns_ip_cnt].ip))
650 {
651 network_socket_force_close(ctrl);
652 return -1;
653 }
654 else
655 {
656 ctrl->state = NW_STATE_CONNECTING;
657 return 1;
658 }
659 default:
660 return 1;
661 }
662 return -1;
663 }
664
665 static int network_state_connecting(network_ctrl_t *ctrl, OS_EVENT *event, network_adapter_t *adapter)
666 {
667 if ((ctrl->need_close) || (ctrl->wait_target_state != NW_WAIT_ON_LINE)) return -1;
668 switch(event->ID)
669 {
670 case EV_NW_RESET:
671 return -1;
672 case EV_NW_SOCKET_ERROR:
673 case EV_NW_SOCKET_REMOTE_CLOSE:
674 case EV_NW_SOCKET_CLOSE_OK:
675
676 if (network_ip_is_vaild(&ctrl->remote_ip))
677 {
678 return -1;
679 }
680 DBG("dns ip %d no connect!,%d", ctrl->dns_ip_cnt, ctrl->dns_ip_nums);
681 ctrl->dns_ip_cnt++;
682 if (ctrl->dns_ip_cnt >= ctrl->dns_ip_nums)
683 {
684 DBG("all ip try connect failed");
685 return -1;
686 }
687 if (network_base_connect(ctrl, &ctrl->dns_ip[ctrl->dns_ip_cnt].ip))
688 {
689 network_socket_force_close(ctrl);
690 return -1;
691 }
692 else
693 {
694 ctrl->state = NW_STATE_CONNECTING;
695 return 1;
696 }
697 break;
698 case EV_NW_STATE:
699 if (!event->Param2)
700 {
701 return -1;
702 }
703 break;
704 case EV_NW_SOCKET_LISTEN:
705 if (ctrl->is_server_mode)
706 {
707 ctrl->state = NW_STATE_LISTEN;
708 return 1;
709 }
710 break;
711 case EV_NW_SOCKET_CONNECT_OK:
712 #ifdef LUAT_USE_TLS
713 if (ctrl->tls_mode)
714 {
715 mbedtls_ssl_free(ctrl->ssl);
716 memset(ctrl->ssl, 0, sizeof(mbedtls_ssl_context));
717 mbedtls_ssl_setup(ctrl->ssl, ctrl->config);
718 // ctrl->ssl->f_set_timer = tls_settimer;
719 // ctrl->ssl->f_get_timer = tls_gettimer;
720 // ctrl->ssl->p_timer = ctrl;
721 mbedtls_ssl_set_timer_cb(ctrl->ssl, ctrl, tls_settimer, tls_gettimer);
722 // ctrl->ssl->p_bio = ctrl;
723 // ctrl->ssl->f_send = tls_send;
724 // ctrl->ssl->f_recv = tls_recv;
725 mbedtls_ssl_set_bio(ctrl->ssl, ctrl, tls_send, tls_recv, NULL);
726 // add by wendal
727 // cloudflare的https需要设置hostname才能访问
728 if (ctrl->domain_name_len > 0 && ctrl->domain_name_len < 256) {
729 char host[257] = {0};
730 memcpy(host, ctrl->domain_name, ctrl->domain_name_len);
731 mbedtls_ssl_set_hostname(ctrl->ssl, host);
732 //LLOGD("CALL mbedtls_ssl_set_hostname(%s)", host);
733 }
734 else {
735 //LLOGD("skip mbedtls_ssl_set_hostname");
736 }
737
738 ctrl->state = NW_STATE_SHAKEHAND;
739 do
740 {
741 int result = mbedtls_ssl_handshake_step( ctrl->ssl );
742 switch(result)
743 {
744 case MBEDTLS_ERR_SSL_WANT_READ:
745 return 1;
746 case 0:
747 break;
748 default:
749 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
750 #else
751 DBG_ERR("0x%x, %d", -result, ctrl->ssl->state);
752 #endif
753 return -1;
754 }
755 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
756 }while(!mbedtls_ssl_is_handshake_over(ctrl->ssl));
757 #else
758 }while(ctrl->ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER);
759 #endif
760 return 0;
761 }
762 else
763 #endif
764 {
765 ctrl->state = NW_STATE_ONLINE;
766 return 0;
767 }
768
769 default:
770 return 1;
771 }
772 return -1;
773 }
774
775 static int network_state_shakehand(network_ctrl_t *ctrl, OS_EVENT *event, network_adapter_t *adapter)
776 {
777 if ((ctrl->need_close) || ((ctrl->wait_target_state != NW_WAIT_ON_LINE) && (ctrl->wait_target_state != NW_WAIT_TX_OK))) return -1;
778 switch(event->ID)
779 {
780 case EV_NW_RESET:
781 case EV_NW_SOCKET_ERROR:
782 case EV_NW_SOCKET_REMOTE_CLOSE:
783 case EV_NW_SOCKET_CLOSE_OK:
784 ctrl->need_close = 1;
785 return -1;
786 case EV_NW_STATE:
787 if (!event->Param2)
788 {
789 ctrl->need_close = 1;
790 return -1;
791 }
792 break;
793 case EV_NW_SOCKET_TX_OK:
794 ctrl->ack_size += event->Param2;
795 break;
796 #ifdef LUAT_USE_TLS
797 case EV_NW_SOCKET_RX_NEW:
798 do
799 {
800 int result = mbedtls_ssl_handshake_step( ctrl->ssl );
801 switch(result)
802 {
803 case MBEDTLS_ERR_SSL_WANT_READ:
804 return 1;
805 case 0:
806 break;
807 default:
808 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
809 DBG_ERR("0x%x", -result);
810 #else
811 DBG_ERR("0x%x, %d", -result, ctrl->ssl->state);
812 #endif
813 ctrl->need_close = 1;
814 return -1;
815 }
816 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
817 }while(!mbedtls_ssl_is_handshake_over(ctrl->ssl));
818 #else
819 }while(ctrl->ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER);
820 #endif
821 ctrl->state = NW_STATE_ONLINE;
822 if (NW_WAIT_TX_OK == ctrl->wait_target_state)
823 {
824 if (!ctrl->cache_data)
825 {
826 ctrl->need_close = 1;
827 return -1;
828 }
829 int result = mbedtls_ssl_write(ctrl->ssl, ctrl->cache_data, ctrl->cache_len);
830 free(ctrl->cache_data);
831 ctrl->cache_data = NULL;
832 ctrl->cache_len = 0;
833 if (result < 0)
834 {
835 DBG("%08x", -result);
836 ctrl->need_close = 1;
837 return -1;
838 }
839 return 1;
840 }
841 return 0;
842 #endif
843 case EV_NW_SOCKET_CONNECT_OK:
844 DBG_ERR("!");
845 return 1;
846 default:
847 return 1;
848 }
849 return 1;
850 }
851
852 static int network_state_on_line(network_ctrl_t *ctrl, OS_EVENT *event, network_adapter_t *adapter)
853 {
854 if ((ctrl->need_close) || NW_WAIT_OFF_LINE == ctrl->wait_target_state)
855 {
856 return -1;
857 }
858
859 switch(event->ID)
860 {
861 case EV_NW_RESET:
862 case EV_NW_SOCKET_ERROR:
863 case EV_NW_SOCKET_REMOTE_CLOSE:
864 case EV_NW_SOCKET_CLOSE_OK:
865 ctrl->need_close = 1;
866 return -1;
867 case EV_NW_STATE:
868 if (!event->Param2)
869 {
870 ctrl->need_close = 1;
871 return -1;
872 }
873 break;
874 case EV_NW_SOCKET_TX_OK:
875 ctrl->ack_size += event->Param2;
876 if (NW_WAIT_TX_OK == ctrl->wait_target_state)
877 {
878
879 if (ctrl->ack_size == ctrl->tx_size)
880 {
881 #ifdef LUAT_USE_LWIP
882 if (ctrl->is_tcp)
883 {
884 if (ctrl->adapter_index < NW_ADAPTER_INDEX_LWIP_NETIF_QTY)
885 {
886 return net_lwip_check_all_ack(ctrl->socket_id);
887 }
888 else
889 {
890 return 0;
891 }
892 }
893 return 0;
894 #else
895 return 0;
896 #endif
897 }
898 }
899 break;
900 case EV_NW_SOCKET_RX_NEW:
901 #ifdef LUAT_USE_TLS
902 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
903 if (ctrl->tls_mode && !mbedtls_ssl_is_handshake_over(ctrl->ssl))
904 #else
905 if (ctrl->tls_mode && (ctrl->ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER))
906 #endif
907 {
908 DBG("rehandshaking");
909 do
910 {
911 int result = mbedtls_ssl_handshake_step( ctrl->ssl );
912 switch(result)
913 {
914 case MBEDTLS_ERR_SSL_WANT_READ:
915 return 1;
916 case 0:
917 break;
918 default:
919 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
920 DBG_ERR("0x%x", -result);
921 #else
922 DBG_ERR("0x%x, %d", -result, ctrl->ssl->state);
923 #endif
924 ctrl->need_close = 1;
925 return -1;
926 }
927 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
928 }while(!mbedtls_ssl_is_handshake_over(ctrl->ssl));
929 #else
930 }while(ctrl->ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER);
931 #endif
932 }
933 #endif
934 ctrl->new_rx_flag = 1;
935 if (NW_WAIT_TX_OK != ctrl->wait_target_state)
936 {
937 return 0;
938 }
939 break;
940 default:
941 return 1;
942 }
943 return 1;
944 }
945
946 static int network_state_listen(network_ctrl_t *ctrl, OS_EVENT *event, network_adapter_t *adapter)
947 {
948 if ((ctrl->need_close) || NW_WAIT_OFF_LINE == ctrl->wait_target_state)
949 {
950 return -1;
951 }
952 switch(event->ID)
953 {
954 case EV_NW_RESET:
955 case EV_NW_SOCKET_ERROR:
956 case EV_NW_SOCKET_REMOTE_CLOSE:
957 case EV_NW_SOCKET_CLOSE_OK:
958 ctrl->need_close = 1;
959 return -1;
960 case EV_NW_STATE:
961 if (!event->Param2)
962 {
963 ctrl->need_close = 1;
964 return -1;
965 }
966 break;
967 case EV_NW_SOCKET_NEW_CONNECT:
968 case EV_NW_SOCKET_CONNECT_OK:
969 ctrl->state = NW_STATE_ONLINE;
970 return 0;
971 default:
972 return 1;
973 }
974 return 1;
975 }
976
977 static int network_state_disconnecting(network_ctrl_t *ctrl, OS_EVENT *event, network_adapter_t *adapter)
978 {
979 if (ctrl->wait_target_state != NW_WAIT_OFF_LINE)
980 {
981 return -1;
982 }
983 switch(event->ID)
984 {
985 case EV_NW_RESET:
986 case EV_NW_SOCKET_ERROR:
987 case EV_NW_SOCKET_REMOTE_CLOSE:
988 case EV_NW_SOCKET_CLOSE_OK:
989 network_force_close_socket(ctrl);
990 ctrl->state = NW_STATE_OFF_LINE;
991 ctrl->socket_id = -1;
992 return 0;
993 case EV_NW_STATE:
994 if (!event->Param2)
995 {
996 return -1;
997 }
998 else
999 {
1000 network_force_close_socket(ctrl);
1001 ctrl->state = NW_STATE_OFF_LINE;
1002 ctrl->socket_id = -1;
1003 }
1004 break;
1005 default:
1006 return 1;
1007 }
1008 return -1;
1009 }
1010
1011 typedef int (*network_state_fun)(network_ctrl_t *ctrl, OS_EVENT *event, network_adapter_t *adapter);
1012 static network_state_fun network_state_fun_list[]=
1013 {
1014 network_state_link_off,
1015 network_state_off_line,
1016 network_state_wait_dns,
1017 network_state_connecting,
1018 network_state_shakehand,
1019 network_state_on_line,
1020 network_state_listen,
1021 network_state_disconnecting,
1022 };
1023
1024 static void network_default_statemachine(network_ctrl_t *ctrl, OS_EVENT *event, network_adapter_t *adapter)
1025 {
1026 int result = -1;
1027 NW_LOCK;
1028 if (ctrl->state > NW_STATE_DISCONNECTING)
1029 {
1030 ctrl->state = NW_STATE_LINK_OFF;
1031 event->Param1 = -1;
1032
1033 network_force_close_socket(ctrl);
1034 event->ID = ctrl->wait_target_state + EV_NW_RESULT_BASE;
1035
1036 }
1037 else
1038 {
1039 result = network_state_fun_list[ctrl->state](ctrl, event, adapter);
1040 if (result > 0)
1041 {
1042 NW_UNLOCK;
1043 if (ctrl->new_rx_flag && ctrl->user_callback)
1044 {
1045 event->ID = NW_WAIT_EVENT + EV_NW_RESULT_BASE;
1046 event->Param1 = 0;
1047 ctrl->user_callback(event, ctrl->user_data);
1048 }
1049 return ;
1050 }
1051 event->ID = (ctrl->wait_target_state?ctrl->wait_target_state:NW_WAIT_EVENT) + EV_NW_RESULT_BASE;
1052 event->Param1 = result;
1053 }
1054 if ((ctrl->state != NW_STATE_LISTEN) || (result < 0))
1055 {
1056 ctrl->wait_target_state = NW_WAIT_NONE;
1057 }
1058 NW_UNLOCK;
1059 if (ctrl->task_handle)
1060 {
1061 platform_send_event(ctrl->task_handle, event->ID, event->Param1, event->Param2, event->Param3);
1062 }
1063 else if (ctrl->user_callback)
1064 {
1065 ctrl->user_callback(event, ctrl->user_data);
1066 }
1067 }
1068
1069
1070 static int32_t network_default_socket_callback(void *data, void *param)
1071 {
1072 OS_EVENT *event = (OS_EVENT *)data;
1073 OS_EVENT temp_event;
1074 luat_network_cb_param_t *cb_param = (luat_network_cb_param_t *)param;
1075 network_adapter_t *adapter =(network_adapter_t *)(cb_param->param);
1076 int i;
1077 network_ctrl_t *ctrl = (network_ctrl_t *)event->Param3;
1078
1079 if (event->ID > EV_NW_TIMEOUT)
1080 {
1081 if (ctrl && ((event->ID == EV_NW_DNS_RESULT) || (ctrl->tag == cb_param->tag)))
1082 {
1083 if ((event->ID == EV_NW_DNS_RESULT) && (ctrl->wait_target_state != NW_WAIT_ON_LINE))
1084 {
1085 DBG("socket event:0x%x(%s),wait:%d(%s)", event->ID, network_ctrl_event_id_string(event->ID), ctrl->wait_target_state, network_ctrl_wait_state_string(ctrl->wait_target_state));
1086 return 0;
1087 }
1088 if (ctrl->auto_mode)
1089 {
1090 DBG("before process socket %d,event:0x%x(%s),state:%d(%s),wait:%d(%s)", ctrl->socket_id, event->ID, network_ctrl_event_id_string(event->ID),
1091 ctrl->state, network_ctrl_state_string(ctrl->state),
1092 ctrl->wait_target_state, network_ctrl_wait_state_string(ctrl->wait_target_state));
1093 network_default_statemachine(ctrl, event, adapter);
1094 DBG("after process socket %d,state:%d(%s),wait:%d(%s)", ctrl->socket_id, ctrl->state, network_ctrl_state_string(ctrl->state),ctrl->wait_target_state, network_ctrl_wait_state_string(ctrl->wait_target_state));
1095 }
1096 else if (ctrl->task_handle)
1097 {
1098 platform_send_event(ctrl->task_handle, event->ID, event->Param1, event->Param2, event->Param3);
1099 }
1100 else if (ctrl->user_callback)
1101 {
1102 ctrl->user_callback(event, ctrl->user_data);
1103 }
1104 }
1105 else
1106 {
1107 DBG_ERR("cb ctrl invaild %x %08X", ctrl, event->ID);
1108 // 下面这行的打印在部分平台会有问题
1109 // 原因是ctrl可能已经被释放, 再次访问会导致coredump
1110 //DBG_HexPrintf(&ctrl->tag, 8);
1111 DBG_HexPrintf(&cb_param->tag, 8);
1112 }
1113 }
1114 else
1115 {
1116 for (i = 0; i < adapter->opt->max_socket_num; i++)
1117 {
1118 temp_event = *event;
1119 if (adapter->ctrl_busy[i])
1120 {
1121 ctrl = &adapter->ctrl_table[i];
1122 if (ctrl->adapter_index == (uint8_t)(event->Param3))
1123 {
1124 if (ctrl->auto_mode)
1125 {
1126 DBG("before process socket %d,event:0x%x(%s),state:%d(%s),wait:%d(%s)", ctrl->socket_id, event->ID, network_ctrl_event_id_string(event->ID),
1127 ctrl->state, network_ctrl_state_string(ctrl->state),
1128 ctrl->wait_target_state, network_ctrl_wait_state_string(ctrl->wait_target_state));
1129 network_default_statemachine(ctrl, &temp_event, adapter);
1130 DBG("after process socket %d,state:%d(%s),wait:%d(%s)", ctrl->socket_id, ctrl->state, network_ctrl_state_string(ctrl->state), ctrl->wait_target_state, network_ctrl_wait_state_string(ctrl->wait_target_state));
1131 }
1132 else if (ctrl->task_handle)
1133 {
1134 platform_send_event(ctrl->task_handle, event->ID, event->Param1, event->Param2, event->Param3);
1135 }
1136 else if (ctrl->user_callback)
1137 {
1138 ctrl->user_callback(&temp_event, ctrl->user_data);
1139 }
1140 }
1141
1142 }
1143 }
1144 }
1145
1146 return 0;
1147 }
1148
1149 static LUAT_RT_RET_TYPE network_default_timer_callback(LUAT_RT_CB_PARAM)
1150 {
1151 platform_send_event(param, EV_NW_TIMEOUT, 0, 0, 0);
1152 return LUAT_RT_RET;
1153 }
1154
1155 #ifndef LUAT_USE_LWIP
1156 uint8_t network_string_is_ipv4(const char *string, uint32_t len)
1157 {
1158 int i;
1159 for(i = 0; i < len; i++)
1160 {
1161 if (!isdigit((int)string[i]) && (string[i] != '.'))
1162 {
1163 return 0;
1164 }
1165 }
1166 return 1;
1167 }
1168
1169 uint32_t network_string_to_ipv4(const char *string, uint32_t len)
1170 {
1171 int i;
1172 int8_t Buf[4][4];
1173 CmdParam CP;
1174 PV_Union uIP;
1175 char temp[32];
1176 memset(Buf, 0, sizeof(Buf));
1177 CP.param_max_len = 4;
1178 CP.param_max_num = 4;
1179 CP.param_num = 0;
1180 CP.param_str = (int8_t *)Buf;
1181 memcpy(temp, string, len);
1182 temp[len] = 0;
1183 CmdParseParam((int8_t*)temp, &CP, '.');
1184 for(i = 0; i < 4; i++)
1185 {
1186 uIP.u8[i] = strtol((char *)Buf[i], NULL, 10);
1187 }
1188 // DBG("%d.%d.%d.%d", uIP.u8[0], uIP.u8[1], uIP.u8[2], uIP.u8[3]);
1189 return uIP.u32;
1190 }
1191
1192 #define SWAP(x) ((((x) & (uint32_t)0x000000ffUL) << 24) | \
1193 (((x) & (uint32_t)0x0000ff00UL) << 8) | \
1194 (((x) & (uint32_t)0x00ff0000UL) >> 8) | \
1195 (((x) & (uint32_t)0xff000000UL) >> 24))
1196
1197 int network_string_to_ipv6(const char *string, luat_ip_addr_t *ip_addr)
1198 {
1199
1200
1201 uint32_t addr_index, zero_blocks, current_block_index, current_block_value;
1202 const char *s;
1203 ip_addr->is_ipv6 = 0xff;
1204 /* Count the number of colons, to count the number of blocks in a "::" sequence
1205 zero_blocks may be 1 even if there are no :: sequences */
1206 zero_blocks = 8;
1207 for (s = string; *s != 0; s++) {
1208 if (*s == ':') {
1209 zero_blocks--;
1210 } else if (!isxdigit((int)*s)) {
1211 break;
1212 }
1213 }
1214
1215 /* parse each block */
1216 addr_index = 0;
1217 current_block_index = 0;
1218 current_block_value = 0;
1219 for (s = string; *s != 0; s++) {
1220 if (*s == ':') {
1221 if (current_block_index & 0x1) {
1222 ip_addr->ipv6_u32_addr[addr_index++] |= current_block_value;
1223 }
1224 else {
1225 ip_addr->ipv6_u32_addr[addr_index] = current_block_value << 16;
1226 }
1227 current_block_index++;
1228 current_block_value = 0;
1229 if (current_block_index > 7) {
1230 /* address too long! */
1231 return 0;
1232 }
1233 if (s[1] == ':') {
1234 if (s[2] == ':') {
1235 /* invalid format: three successive colons */
1236 return 0;
1237 }
1238 s++;
1239 /* "::" found, set zeros */
1240 while (zero_blocks > 0) {
1241 zero_blocks--;
1242 if (current_block_index & 0x1) {
1243 addr_index++;
1244 } else {
1245 ip_addr->ipv6_u32_addr[addr_index] = 0;
1246 }
1247 current_block_index++;
1248 if (current_block_index > 7) {
1249 /* address too long! */
1250 return 0;
1251 }
1252 }
1253 }
1254 } else if (isxdigit((int)*s)) {
1255 /* add current digit */
1256 current_block_value = (current_block_value << 4) +
1257 (isxdigit((int)*s) ? (uint32_t)(*s - '0') :
1258 (uint32_t)(10 + (isxdigit((int)*s) ? *s - 'a' : *s - 'A')));
1259 } else {
1260 /* unexpected digit, space? CRLF? */
1261 break;
1262 }
1263 }
1264
1265
1266 if (current_block_index & 0x1) {
1267 ip_addr->ipv6_u32_addr[addr_index++] |= current_block_value;
1268 }
1269 else {
1270 ip_addr->ipv6_u32_addr[addr_index] = current_block_value << 16;
1271 }
1272
1273 /* convert to network byte order. */
1274 for (addr_index = 0; addr_index < 4; addr_index++) {
1275 ip_addr->ipv6_u32_addr[addr_index] = SWAP(ip_addr->ipv6_u32_addr[addr_index]);
1276 }
1277
1278
1279
1280 if (current_block_index != 7) {
1281
1282 return 0;
1283 }
1284 ip_addr->is_ipv6 = 1;
1285 return 1;
1286
1287 }
1288
1289 #endif
1290
1291 int network_get_last_register_adapter(void)
1292 {
1293 if (prv_network.default_adapter_index != -1) return prv_network.default_adapter_index;
1294 return prv_network.last_adapter_index;
1295 }
1296
1297 void network_register_set_default(uint8_t adapter_index)
1298 {
1299 prv_network.default_adapter_index = adapter_index;
1300 }
1301
1302 int network_register_adapter(uint8_t adapter_index, network_adapter_info *info, void *user_data)
1303 {
1304 prv_adapter_table[adapter_index].opt = info;
1305 prv_adapter_table[adapter_index].user_data = user_data;
1306 info->socket_set_callback(network_default_socket_callback, &prv_adapter_table[adapter_index], user_data);
1307 #ifdef LUAT_USE_LWIP
1308 if (adapter_index < NW_ADAPTER_INDEX_HW_PS_DEVICE)
1309 {
1310 prv_adapter_table[adapter_index].ctrl_table = prv_network.lwip_ctrl_table;
1311 prv_adapter_table[adapter_index].ctrl_busy = prv_network.lwip_ctrl_busy;
1312 }
1313 else
1314 #endif
1315 {
1316 prv_adapter_table[adapter_index].ctrl_table = zalloc((info->max_socket_num) * sizeof(network_ctrl_t));
1317 prv_adapter_table[adapter_index].ctrl_busy = zalloc(info->max_socket_num);
1318 }
1319
1320 prv_adapter_table[adapter_index].port = 60000;
1321 if (!prv_network.is_init)
1322 {
1323 //prv_network.network_mutex = platform_create_mutex();
1324 INIT_LLIST_HEAD(&prv_network.dns_cache_head);
1325 prv_network.is_init = 0;
1326 }
1327
1328 prv_network.last_adapter_index = adapter_index;
1329 return 0;
1330 }
1331
1332 void network_set_dns_server(uint8_t adapter_index, uint8_t server_index, luat_ip_addr_t *ip)
1333 {
1334 network_adapter_t *adapter = &prv_adapter_table[adapter_index];
1335 adapter->opt->set_dns_server(server_index, ip, adapter->user_data);
1336 }
1337
1338 /*
1339 * 申请一个network_ctrl
1340 */
1341 network_ctrl_t *network_alloc_ctrl(uint8_t adapter_index)
1342 {
1343 int i;
1344 network_ctrl_t *ctrl = NULL;
1345 network_adapter_t *adapter = &prv_adapter_table[adapter_index];
1346 OS_LOCK;
1347 for (i = 0; i < adapter->opt->max_socket_num; i++)
1348 {
1349 if (!adapter->ctrl_busy[i])
1350 {
1351
1352 adapter->ctrl_busy[i] = 1;
1353 ctrl = &adapter->ctrl_table[i];
1354 ctrl->adapter_index = adapter_index;
1355 ctrl->domain_ipv6 = 0;
1356 break;
1357 }
1358 }
1359 OS_UNLOCK;
1360 if (i >= adapter->opt->max_socket_num) {DBG_ERR("adapter no more ctrl!");}
1361 return ctrl;
1362 }
1363
1364 /*
1365 * 归还一个network_ctrl
1366 */
1367 void network_release_ctrl(network_ctrl_t *ctrl)
1368 {
1369 int i;
1370 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1371 NW_UNLOCK;
1372 OS_LOCK;
1373 for (i = 0; i < adapter->opt->max_socket_num; i++)
1374 {
1375 if (&adapter->ctrl_table[i] == ctrl)
1376 {
1377 network_deinit_tls(ctrl);
1378 if (ctrl->timer)
1379 {
1380 platform_stop_timer(ctrl->timer);
1381 platform_release_timer(ctrl->timer);
1382 ctrl->timer = NULL;
1383 }
1384 if (ctrl->cache_data)
1385 {
1386 free(ctrl->cache_data);
1387 ctrl->cache_data = NULL;
1388 }
1389 if (ctrl->dns_ip)
1390 {
1391 free(ctrl->dns_ip);
1392 ctrl->dns_ip = NULL;
1393 }
1394 if (ctrl->domain_name)
1395 {
1396 free(ctrl->domain_name);
1397 ctrl->domain_name = NULL;
1398 }
1399 adapter->ctrl_busy[i] = 0;
1400 platform_release_mutex(ctrl->mutex);
1401 ctrl->mutex = NULL;
1402 break;
1403 }
1404 }
1405 OS_UNLOCK;
1406 if (i >= adapter->opt->max_socket_num) {DBG_ERR("adapter index maybe error!, %d, %x", ctrl->adapter_index, ctrl);}
1407
1408 }
1409
1410 void network_init_ctrl(network_ctrl_t *ctrl, HANDLE task_handle, CBFuncEx_t callback, void *param)
1411 {
1412 uint8_t adapter_index = ctrl->adapter_index;
1413 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1414 if (ctrl->dns_ip)
1415 {
1416 free(ctrl->dns_ip);
1417 ctrl->dns_ip = NULL;
1418 }
1419 if (ctrl->cache_data)
1420 {
1421 free(ctrl->cache_data);
1422 ctrl->cache_data = NULL;
1423 }
1424 if (ctrl->domain_name)
1425 {
1426 free(ctrl->domain_name);
1427 ctrl->domain_name = NULL;
1428 }
1429 HANDLE sem = ctrl->mutex;
1430 memset(ctrl, 0, sizeof(network_ctrl_t));
1431 ctrl->adapter_index = adapter_index;
1432 ctrl->task_handle = task_handle;
1433 ctrl->user_callback = callback;
1434 ctrl->user_data = param;
1435 ctrl->socket_id = -1;
1436 ctrl->socket_param = ctrl;
1437 network_set_ip_invaild(&ctrl->remote_ip);
1438 ctrl->mutex = sem;
1439 if (task_handle)
1440 {
1441 ctrl->timer = platform_create_timer(network_default_timer_callback, task_handle, NULL);
1442 }
1443 if (!ctrl->mutex)
1444 {
1445 ctrl->mutex = platform_create_mutex();
1446 }
1447
1448 }
1449
1450 void network_set_base_mode(network_ctrl_t *ctrl, uint8_t is_tcp, uint32_t tcp_timeout_ms, uint8_t keep_alive, uint32_t keep_idle, uint8_t keep_interval, uint8_t keep_cnt)
1451 {
1452 ctrl->is_tcp = is_tcp;
1453 ctrl->tcp_keep_alive = keep_alive;
1454 ctrl->tcp_keep_idle = keep_idle;
1455 ctrl->tcp_keep_interval = keep_interval;
1456 ctrl->tcp_keep_cnt = keep_cnt;
1457 ctrl->tcp_timeout_ms = tcp_timeout_ms;
1458 }
1459
1460 void network_connect_ipv6_domain(network_ctrl_t *ctrl, uint8_t onoff)
1461 {
1462 ctrl->domain_ipv6 = onoff;
1463 }
1464
1465 int network_set_local_port(network_ctrl_t *ctrl, uint16_t local_port)
1466 {
1467 int i;
1468 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1469 if (local_port)
1470 {
1471 OS_LOCK;
1472 for (i = 0; i < adapter->opt->max_socket_num; i++)
1473 {
1474 if (&adapter->ctrl_table[i] != ctrl)
1475 {
1476 if (adapter->ctrl_table[i].local_port == local_port)
1477 {
1478 OS_UNLOCK;
1479 return -1;
1480 }
1481 }
1482
1483 }
1484 ctrl->local_port = local_port;
1485 OS_UNLOCK;
1486 return 0;
1487 }
1488 else
1489 {
1490 ctrl->local_port = 0;
1491 #if 0
1492 if (ctrl->adapter_index < NW_ADAPTER_INDEX_LWIP_NETIF_QTY)
1493 {
1494 ctrl->local_port = 0;
1495 return 0;
1496 }
1497 OS_LOCK;
1498 adapter->port++;
1499 if (adapter->port < 60000)
1500 {
1501 adapter->port = 60000;
1502 }
1503 ctrl->local_port = adapter->port;
1504 OS_UNLOCK;
1505 #endif
1506 return 0;
1507 }
1508 }
1509
1510 int network_create_soceket(network_ctrl_t *ctrl, uint8_t is_ipv6)
1511 {
1512 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1513 ctrl->socket_id = adapter->opt->create_soceket(ctrl->is_tcp, &ctrl->tag, ctrl->socket_param, is_ipv6, adapter->user_data);
1514 if (ctrl->socket_id < 0)
1515 {
1516 ctrl->tag = 0;
1517 return -1;
1518 }
1519 return 0;
1520 }
1521
1522 int network_socket_connect(network_ctrl_t *ctrl, luat_ip_addr_t *remote_ip)
1523 {
1524 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1525 ctrl->is_server_mode = 0;
1526 ctrl->online_ip = remote_ip;
1527 uint16_t local_port = ctrl->local_port;
1528 if (!local_port)
1529 {
1530 if (ctrl->adapter_index >= NW_ADAPTER_INDEX_HW_PS_DEVICE)
1531 {
1532 adapter->port += 100;
1533 local_port = adapter->port;
1534 if (adapter->port < 60000)
1535 {
1536 adapter->port = 60000;
1537 }
1538 if (local_port < 60000)
1539 {
1540 local_port = 60000;
1541 }
1542 local_port += ctrl->socket_id;
1543 DBG("%d,%d,%d", ctrl->socket_id, local_port, adapter->port);
1544 }
1545 }
1546 return adapter->opt->socket_connect(ctrl->socket_id, ctrl->tag, local_port, remote_ip, ctrl->remote_port, adapter->user_data);
1547 }
1548
1549 int network_socket_listen(network_ctrl_t *ctrl)
1550 {
1551 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1552 ctrl->is_server_mode = 1;
1553 return adapter->opt->socket_listen(ctrl->socket_id, ctrl->tag, ctrl->local_port, adapter->user_data);
1554 }
1555
1556 uint8_t network_accept_enable(network_ctrl_t *ctrl)
1557 {
1558 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1559 return !(adapter->opt->no_accept);
1560 }
1561 //作为server接受一个client
1562 //成功返回0，失败 < 0
1563 int network_socket_accept(network_ctrl_t *ctrl, network_ctrl_t *accept_ctrl)
1564 {
1565 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1566 if (adapter->opt->no_accept)
1567 {
1568 // DBG("%x,%d,%llu,%x,%x,%x",adapter->opt->socket_accept, ctrl->socket_id, ctrl->tag, &ctrl->remote_ip, &ctrl->remote_port, adapter->user_data);
1569 adapter->opt->socket_accept(ctrl->socket_id, ctrl->tag, &ctrl->remote_ip, &ctrl->remote_port, adapter->user_data);
1570 return 0;
1571 }
1572 accept_ctrl->socket_id = adapter->opt->socket_accept(ctrl->socket_id, ctrl->tag, &accept_ctrl->remote_ip, &accept_ctrl->remote_port, adapter->user_data);
1573 if (accept_ctrl->socket_id < 0)
1574 {
1575 return -1;
1576 }
1577 else
1578 {
1579 accept_ctrl->is_tcp = ctrl->is_tcp;
1580 accept_ctrl->tcp_keep_alive = ctrl->tcp_keep_alive;
1581 accept_ctrl->tcp_keep_idle = ctrl->tcp_keep_idle;
1582 accept_ctrl->tcp_keep_interval = ctrl->tcp_keep_interval;
1583 accept_ctrl->tcp_keep_cnt = ctrl->tcp_keep_cnt;
1584 accept_ctrl->tcp_timeout_ms = ctrl->tcp_timeout_ms;
1585 accept_ctrl->local_port = ctrl->local_port;
1586 accept_ctrl->state = NW_STATE_ONLINE;
1587 return 0;
1588 }
1589 }
1590 //主动断开一个tcp连接，需要走完整个tcp流程，用户需要接收到close ok回调才能确认彻底断开
1591 //成功返回0，失败 < 0
1592 int network_socket_disconnect(network_ctrl_t *ctrl)
1593 {
1594 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1595 if (ctrl->socket_id >= 0)
1596 {
1597 return adapter->opt->socket_disconnect(ctrl->socket_id, ctrl->tag, adapter->user_data);
1598 }
1599 return 0;
1600 }
1601 //释放掉socket的控制权
1602 //成功返回0，失败 < 0
1603 int network_socket_close(network_ctrl_t *ctrl)
1604 {
1605 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1606 if (ctrl->socket_id >= 0)
1607 {
1608 return adapter->opt->socket_close(ctrl->socket_id, ctrl->tag, adapter->user_data);
1609 }
1610 return 0;
1611 }
1612 //强行释放掉socket的控制权
1613 //成功返回0，失败 < 0
1614 int network_socket_force_close(network_ctrl_t *ctrl)
1615 {
1616 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1617 if (ctrl->socket_id >= 0)
1618 {
1619 adapter->opt->socket_force_close(ctrl->socket_id, adapter->user_data);
1620 }
1621 ctrl->socket_id = -1;
1622 return 0;
1623 }
1624 //tcp时，不需要remote_ip和remote_port，如果buf为NULL，则返回当前缓存区的数据量，当返回值小于len时说明已经读完了
1625 //udp时，只返回1个block数据，需要多次读直到没有数据为止
1626 //成功返回实际读取的值，失败 < 0
1627 int network_socket_receive(network_ctrl_t *ctrl,uint8_t *buf, uint32_t len, int flags, luat_ip_addr_t *remote_ip, uint16_t *remote_port)
1628 {
1629 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1630 return adapter->opt->socket_receive(ctrl->socket_id, ctrl->tag, buf, len, flags, remote_ip, remote_port, adapter->user_data);
1631 }
1632 //tcp时，不需要remote_ip和remote_port
1633 //成功返回0，失败 < 0
1634 int network_socket_send(network_ctrl_t *ctrl,const uint8_t *buf, uint32_t len, int flags, luat_ip_addr_t *remote_ip, uint16_t remote_port)
1635 {
1636 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1637 return adapter->opt->socket_send(ctrl->socket_id, ctrl->tag, buf, len, flags, remote_ip, remote_port, adapter->user_data);
1638 }
1639
1640 int network_getsockopt(network_ctrl_t *ctrl, int level, int optname, void *optval, uint32_t *optlen)
1641 {
1642 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1643 return adapter->opt->getsockopt(ctrl->socket_id, ctrl->tag, level, optname, optval, optlen, adapter->user_data);
1644 }
1645 int network_setsockopt(network_ctrl_t *ctrl, int level, int optname, const void *optval, uint32_t optlen)
1646 {
1647 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1648 return adapter->opt->setsockopt(ctrl->socket_id, ctrl->tag, level, optname, optval, optlen, adapter->user_data);
1649 }
1650 //非posix的socket，用这个根据实际硬件设置参数
1651 int network_user_cmd(network_ctrl_t *ctrl, uint32_t cmd, uint32_t value)
1652 {
1653 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1654 return adapter->opt->user_cmd(ctrl->socket_id, ctrl->tag, cmd, value, adapter->user_data);
1655 }
1656
1657 int network_dns(network_ctrl_t *ctrl)
1658 {
1659 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1660 if (ctrl->domain_ipv6)
1661 {
1662 return adapter->opt->dns_ipv6(ctrl->domain_name, ctrl->domain_name_len, ctrl, adapter->user_data);
1663 }
1664 else
1665 {
1666 return adapter->opt->dns(ctrl->domain_name, ctrl->domain_name_len, ctrl, adapter->user_data);
1667 }
1668 }
1669
1670 int network_set_mac(uint8_t adapter_index, uint8_t *mac)
1671 {
1672 network_adapter_t *adapter = &prv_adapter_table[adapter_index];
1673 return adapter->opt->set_mac(mac, adapter->user_data);
1674 }
1675
1676 int network_set_static_ip_info(uint8_t adapter_index, luat_ip_addr_t *ip, luat_ip_addr_t *submask, luat_ip_addr_t *gateway, luat_ip_addr_t *ipv6)
1677 {
1678 network_adapter_t *adapter = &prv_adapter_table[adapter_index];
1679 return adapter->opt->set_static_ip(ip, submask, gateway, ipv6, adapter->user_data);
1680 }
1681
1682 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)
1683 {
1684 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1685 return adapter->opt->get_local_ip_info(ip, submask, gateway, adapter->user_data);
1686 }
1687
1688 int network_get_full_local_ip_info(network_ctrl_t *ctrl, uint8_t index, luat_ip_addr_t *ip, luat_ip_addr_t *submask, luat_ip_addr_t *gateway, luat_ip_addr_t *ipv6)
1689 {
1690 network_adapter_t *adapter;
1691 if (ctrl)
1692 {
1693 adapter = &prv_adapter_table[ctrl->adapter_index];
1694 }
1695 else
1696 {
1697 adapter = &prv_adapter_table[index];
1698 }
1699 return adapter->opt->get_full_ip_info(ip, submask, gateway, ipv6, adapter->user_data);
1700 }
1701
1702 void network_force_close_socket(network_ctrl_t *ctrl)
1703 {
1704 #ifdef LUAT_USE_TLS
1705 if (ctrl->tls_mode)
1706 {
1707 mbedtls_ssl_free(ctrl->ssl);
1708 }
1709 #endif
1710 if (network_socket_close(ctrl))
1711 {
1712 network_clean_invaild_socket(ctrl->adapter_index);
1713 network_socket_force_close(ctrl);
1714 }
1715 ctrl->need_close = 0;
1716 ctrl->socket_id = -1;
1717 ctrl->new_rx_flag = 0;
1718 if (ctrl->dns_ip)
1719 {
1720 free(ctrl->dns_ip);
1721 ctrl->dns_ip = NULL;
1722 }
1723 if (ctrl->domain_name)
1724 {
1725 free(ctrl->domain_name);
1726 ctrl->domain_name = NULL;
1727 }
1728 ctrl->dns_ip_cnt = 0;
1729 ctrl->dns_ip_nums = 0;
1730 ctrl->wait_target_state = NW_WAIT_NONE;
1731 }
1732
1733 void network_clean_invaild_socket(uint8_t adapter_index)
1734 {
1735 int i;
1736 int *list;
1737 network_adapter_t *adapter = &prv_adapter_table[adapter_index];
1738 network_ctrl_t *ctrl;
1739 list = malloc(adapter->opt->max_socket_num * sizeof(int));
1740 OS_LOCK;
1741 for (i = 0; i < adapter->opt->max_socket_num; i++)
1742 {
1743 ctrl = &adapter->ctrl_table[i];
1744 if (!adapter->opt->socket_check(ctrl->socket_id, ctrl->tag, adapter->user_data))
1745 {
1746 list[i] = ctrl->socket_id;
1747 }
1748 else
1749 {
1750 ctrl->socket_id = -1;
1751 list[i] = -1;
1752 }
1753 DBG("%d,%d", i, list[i]);
1754 }
1755 OS_UNLOCK;
1756 adapter->opt->socket_clean(list, adapter->opt->max_socket_num, adapter->user_data);
1757 free(list);
1758 }
1759
1760
1761 #ifdef LUAT_USE_TLS
1762 static int tls_verify(void *ctx, mbedtls_x509_crt *crt, int Index, uint32_t *result)
1763 {
1764 network_ctrl_t *ctrl = (network_ctrl_t *)ctx;
1765 DBG("%d, %08x", Index, *result);
1766 return 0;
1767 }
1768 #endif
1769 int network_set_psk_info(network_ctrl_t *ctrl,
1770 const unsigned char *psk, size_t psk_len,
1771 const unsigned char *psk_identity, size_t psk_identity_len)
1772 {
1773 #ifdef LUAT_USE_TLS
1774 if (!ctrl->tls_mode)
1775 {
1776 return -ERROR_PERMISSION_DENIED;
1777 }
1778
1779 // DBG("%.*s, %.*s", psk_len, psk, psk_identity_len, psk_identity);
1780 int ret = mbedtls_ssl_conf_psk( ctrl->config,
1781 psk, psk_len, psk_identity, psk_identity_len );
1782 if (ret != 0)
1783 {
1784 DBG("0x%x", -ret);
1785 return -ERROR_OPERATION_FAILED;
1786 }
1787 return ERROR_NONE;
1788 #else
1789 return -1;
1790 #endif
1791 }
1792
1793 int network_set_server_cert(network_ctrl_t *ctrl, const unsigned char *cert, size_t cert_len)
1794 {
1795 #ifdef LUAT_USE_TLS
1796 int ret;
1797 if (!ctrl->tls_mode)
1798 {
1799 return -ERROR_PERMISSION_DENIED;
1800 }
1801 ret = mbedtls_x509_crt_parse( ctrl->ca_cert, cert, cert_len);
1802 if (ret != 0)
1803 {
1804 DBG("%08x", -ret);
1805 return -ERROR_OPERATION_FAILED;
1806 }
1807
1808 return ERROR_NONE;
1809 #else
1810 return -1;
1811 #endif
1812 }
1813
1814 int network_set_client_cert(network_ctrl_t *ctrl,
1815 const unsigned char *cert, size_t certLen,
1816 const unsigned char *key, size_t keylen,
1817 const unsigned char *pwd, size_t pwdlen)
1818 {
1819 #ifdef LUAT_USE_TLS
1820 int ret;
1821 mbedtls_x509_crt *client_cert = NULL;
1822 mbedtls_pk_context *pkey = NULL;
1823 if (!ctrl->tls_mode)
1824 {
1825 return -ERROR_PERMISSION_DENIED;
1826 }
1827 client_cert = zalloc(sizeof(mbedtls_x509_crt));
1828 pkey = zalloc(sizeof(mbedtls_pk_context));
1829 if (!client_cert || !pkey)
1830 {
1831 goto ERROR_OUT;
1832 }
1833 ret = mbedtls_x509_crt_parse( client_cert, cert, certLen );
1834 if (ret != 0)
1835 {
1836 DBG("%08x", -ret);
1837 goto ERROR_OUT;
1838 }
1839 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
1840 ret = mbedtls_pk_parse_key( pkey, key, keylen, pwd, pwdlen , tls_random, NULL);
1841 #else
1842 ret = mbedtls_pk_parse_key( pkey, key, keylen, pwd, pwdlen );
1843 #endif
1844 if (ret != 0)
1845 {
1846 DBG("%08x", -ret);
1847 goto ERROR_OUT;
1848 }
1849 ret = mbedtls_ssl_conf_own_cert( ctrl->config, client_cert, pkey );
1850 if (ret != 0)
1851 {
1852 DBG("%08x", -ret);
1853 goto ERROR_OUT;
1854 }
1855 return ERROR_NONE;
1856 ERROR_OUT:
1857 if (client_cert) free(client_cert);
1858 if (pkey) free(pkey);
1859 return -1;
1860 #else
1861 return -1;
1862 #endif
1863 }
1864
1865 int network_cert_verify_result(network_ctrl_t *ctrl)
1866 {
1867 #ifdef LUAT_USE_TLS
1868 if (!ctrl->tls_mode)
1869 {
1870 return -1;
1871 }
1872 return mbedtls_ssl_get_verify_result(ctrl->ssl);
1873 #else
1874 return -1;
1875 #endif
1876 }
1877
1878 static int tls_random( void *p_rng,
1879 unsigned char *output, size_t output_len )
1880 {
1881 platform_random((char*)output, output_len);
1882 return 0;
1883 }
1884
1885 int network_init_tls(network_ctrl_t *ctrl, int verify_mode)
1886 {
1887 #ifdef LUAT_USE_TLS
1888 ctrl->tls_mode = 1;
1889 if (!ctrl->ssl)
1890 {
1891 ctrl->ssl = zalloc(sizeof(mbedtls_ssl_context));
1892 ctrl->ca_cert = zalloc(sizeof(mbedtls_x509_crt));
1893 ctrl->config = zalloc(sizeof(mbedtls_ssl_config));
1894 mbedtls_ssl_config_defaults( ctrl->config, MBEDTLS_SSL_IS_CLIENT, ctrl->is_tcp?MBEDTLS_SSL_TRANSPORT_STREAM:MBEDTLS_SSL_TRANSPORT_DATAGRAM, MBEDTLS_SSL_PRESET_DEFAULT);
1895 // ctrl->config->authmode = verify_mode;
1896 mbedtls_ssl_conf_authmode(ctrl->config, verify_mode);
1897 // ctrl->config->hs_timeout_min = 20000;
1898 #if defined(MBEDTLS_SSL_PROTO_DTLS)
1899 mbedtls_ssl_conf_handshake_timeout(ctrl->config, 2000, MBEDTLS_SSL_DTLS_TIMEOUT_DFL_MAX);
1900 #endif
1901 // ctrl->config->f_rng = tls_random;
1902 // ctrl->config->p_rng = NULL;
1903 mbedtls_ssl_conf_rng(ctrl->config, tls_random, NULL);
1904 // ctrl->config->f_dbg = tls_dbg;
1905 // ctrl->config->p_dbg = NULL;
1906 mbedtls_ssl_conf_dbg(ctrl->config, tls_dbg, NULL);
1907 // ctrl->config->f_vrfy = tls_verify;
1908 // ctrl->config->p_vrfy = ctrl;
1909 mbedtls_ssl_conf_verify(ctrl->config, tls_verify, ctrl);
1910 // ctrl->config->ca_chain = ctrl->ca_cert;
1911 mbedtls_ssl_conf_ca_chain(ctrl->config, ctrl->ca_cert, NULL);
1912 // ctrl->config->read_timeout = 20000;
1913 mbedtls_ssl_conf_read_timeout(ctrl->config, 20000);
1914 #ifdef MBEDTLS_SSL_RENEGOTIATION
1915 mbedtls_ssl_conf_renegotiation(ctrl->config, MBEDTLS_SSL_RENEGOTIATION_ENABLED);
1916 mbedtls_ssl_conf_legacy_renegotiation(ctrl->config, MBEDTLS_SSL_LEGACY_ALLOW_RENEGOTIATION);
1917 #endif
1918 ctrl->tls_long_timer = platform_create_timer(tls_longtimeout, ctrl, NULL);
1919 ctrl->tls_short_timer = platform_create_timer(tls_shorttimeout, ctrl, NULL);
1920 }
1921 ctrl->tls_timer_state = -1;
1922 return 0;
1923 #else
1924 DBG("NOT SUPPORT TLS");
1925 return -1;
1926 #endif
1927 }
1928
1929 void network_deinit_tls(network_ctrl_t *ctrl)
1930 {
1931 #ifdef LUAT_USE_TLS
1932 if (ctrl->ssl)
1933 {
1934 mbedtls_ssl_free(ctrl->ssl);
1935 free(ctrl->ssl);
1936 ctrl->ssl = NULL;
1937 }
1938
1939 if (ctrl->config)
1940 {
1941 mbedtls_ssl_config_free(ctrl->config);
1942 free(ctrl->config);
1943 ctrl->config = NULL;
1944 }
1945
1946 if (ctrl->ca_cert)
1947 {
1948 mbedtls_x509_crt_free(ctrl->ca_cert);
1949 free(ctrl->ca_cert);
1950 ctrl->ca_cert = NULL;
1951 }
1952
1953 ctrl->tls_mode = 0;
1954 ctrl->tls_timer_state = -1;
1955 if (ctrl->tls_short_timer)
1956 {
1957 platform_release_timer(ctrl->tls_short_timer);
1958 ctrl->tls_short_timer = NULL;
1959 }
1960 if (ctrl->tls_long_timer)
1961 {
1962 platform_release_timer(ctrl->tls_long_timer);
1963 ctrl->tls_long_timer = NULL;
1964 }
1965 #endif
1966 }
1967
1968 int network_wait_link_up(network_ctrl_t *ctrl, uint32_t timeout_ms)
1969 {
1970 NW_LOCK;
1971 ctrl->auto_mode = 1;
1972 // network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1973 if (network_check_ready(ctrl, 0))
1974 {
1975 ctrl->state = NW_STATE_OFF_LINE;
1976 ctrl->wait_target_state = NW_WAIT_NONE;
1977 NW_UNLOCK;
1978 return 0;
1979 }
1980 ctrl->state = NW_STATE_LINK_OFF;
1981 ctrl->wait_target_state = NW_WAIT_LINK_UP;
1982
1983 NW_UNLOCK;
1984 if (!ctrl->task_handle || !timeout_ms)
1985 {
1986 return 1;
1987 }
1988 uint8_t finish = 0;
1989 OS_EVENT event;
1990 int result;
1991 //DBG_INFO("%s wait for active!,%u,%x", Net->Tag, To * SYS_TICK, Net->hTask);
1992
1993 platform_start_timer(ctrl->timer, timeout_ms, 0);
1994 while (!finish)
1995 {
1996 platform_wait_event(ctrl->task_handle, 0, &event, NULL, 0);
1997 switch (event.ID)
1998 {
1999 case EV_NW_RESULT_LINK:
2000 result = (int)event.Param1;
2001 finish = 1;
2002 break;
2003 case EV_NW_TIMEOUT:
2004 result = -1;
2005 finish = 1;
2006 break;
2007 default:
2008 if (ctrl->user_callback)
2009 {
2010 ctrl->user_callback((void *)&event, ctrl->user_data);
2011 }
2012 break;
2013 }
2014 }
2015 platform_stop_timer(ctrl->timer);
2016 return result;
2017 }
2018 /*
2019 * 1.进行ready检测和等待ready
2020 * 2.有remote_ip则开始连接服务器并等待连接结果
2021 * 3.没有remote_ip则开始对url进行dns解析，解析完成后对所有ip进行尝试连接直到有个成功或者全部失败
2022 * 4.如果是加密模式，还要走握手环节，等到握手环节完成后才能返回结果
2023 * local_port如果为0则api内部自动生成一个
2024 */
2025 int network_connect(network_ctrl_t *ctrl, const char *domain_name, uint32_t domain_name_len, luat_ip_addr_t *remote_ip, uint16_t remote_port, uint32_t timeout_ms)
2026 {
2027 if (ctrl->socket_id >= 0)
2028 {
2029 return -1;
2030 }
2031
2032 NW_LOCK;
2033 ctrl->is_server_mode = 0;
2034 ctrl->tx_size = 0;
2035 ctrl->ack_size = 0;
2036 if (ctrl->dns_ip)
2037 {
2038 free(ctrl->dns_ip);
2039 ctrl->dns_ip = NULL;
2040 }
2041 if (ctrl->cache_data)
2042 {
2043 free(ctrl->cache_data);
2044 ctrl->cache_data = NULL;
2045 }
2046 ctrl->need_close = 0;
2047 if (ctrl->domain_name)
2048 {
2049 free(ctrl->domain_name);
2050 }
2051 ctrl->domain_name = zalloc(domain_name_len + 1);
2052 memcpy(ctrl->domain_name, domain_name, domain_name_len);
2053 ctrl->domain_name_len = domain_name_len;
2054 if (remote_ip)
2055 {
2056 ctrl->remote_ip = *remote_ip;
2057 }
2058 else
2059 {
2060 network_set_ip_invaild(&ctrl->remote_ip);
2061 }
2062 ctrl->auto_mode = 1;
2063 ctrl->remote_port = remote_port;
2064 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
2065 ctrl->wait_target_state = NW_WAIT_ON_LINE;
2066 if (!network_check_ready(ctrl, 0))
2067 {
2068
2069 ctrl->state = NW_STATE_LINK_OFF;
2070 goto NETWORK_CONNECT_WAIT;
2071 }
2072 if (network_prepare_connect(ctrl))
2073 {
2074 ctrl->state = NW_STATE_OFF_LINE;
2075 ctrl->wait_target_state = NW_WAIT_NONE;
2076 NW_UNLOCK;
2077 return -1;
2078 }
2079 NETWORK_CONNECT_WAIT:
2080 NW_UNLOCK;
2081 if (!ctrl->task_handle || !timeout_ms)
2082 {
2083
2084 return 1;
2085 }
2086 uint8_t finish = 0;
2087 OS_EVENT event = {0};
2088 int result;
2089 //DBG_INFO("%s wait for active!,%u,%x", Net->Tag, To * SYS_TICK, Net->hTask);
2090
2091 platform_start_timer(ctrl->timer, timeout_ms, 0);
2092 while (!finish)
2093 {
2094 platform_wait_event(ctrl->task_handle, 0, &event, NULL, 0);
2095 switch (event.ID)
2096 {
2097 case EV_NW_RESULT_CONNECT:
2098 result = (int)event.Param1;
2099 finish = 1;
2100 break;
2101 case EV_NW_TIMEOUT:
2102 result = -1;
2103 finish = 1;
2104 break;
2105 default:
2106 if (ctrl->user_callback)
2107 {
2108 ctrl->user_callback((void *)&event, ctrl->user_data);
2109 }
2110 break;
2111 }
2112 }
2113 platform_stop_timer(ctrl->timer);
2114 return result;
2115 }
2116
2117 int network_listen(network_ctrl_t *ctrl, uint32_t timeout_ms)
2118 {
2119 if (NW_STATE_LISTEN == ctrl->state)
2120 {
2121 DBG("socket %d is listen", ctrl->socket_id);
2122 return 0;
2123 }
2124 if (ctrl->socket_id >= 0)
2125 {
2126 return -1;
2127 }
2128 NW_LOCK;
2129 ctrl->is_server_mode = 1;
2130 ctrl->auto_mode = 1;
2131 ctrl->need_close = 0;
2132 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
2133 ctrl->wait_target_state = NW_WAIT_ON_LINE;
2134 if (!network_check_ready(ctrl, 0))
2135 {
2136
2137 ctrl->state = NW_STATE_LINK_OFF;
2138 goto NETWORK_LISTEN_WAIT;
2139 }
2140 if (network_base_connect(ctrl, NULL))
2141 {
2142 ctrl->state = NW_STATE_OFF_LINE;
2143 ctrl->wait_target_state = NW_WAIT_NONE;
2144 NW_UNLOCK;
2145 return -1;
2146 }
2147 ctrl->state = NW_STATE_CONNECTING;
2148 NETWORK_LISTEN_WAIT:
2149 NW_UNLOCK;
2150 if (!ctrl->task_handle || !timeout_ms)
2151 {
2152
2153 return 1;
2154 }
2155 uint8_t finish = 0;
2156 OS_EVENT event;
2157 int result;
2158 //DBG_INFO("%s wait for active!,%u,%x", Net->Tag, To * SYS_TICK, Net->hTask);
2159
2160 if (timeout_ms != 0xffffffff)
2161 {
2162 platform_start_timer(ctrl->timer, timeout_ms, 0);
2163 }
2164 while (!finish)
2165 {
2166 platform_wait_event(ctrl->task_handle, 0, &event, NULL, 0);
2167 switch (event.ID)
2168 {
2169 case EV_NW_RESULT_CONNECT:
2170 result = (int)event.Param1;
2171 finish = 1;
2172 break;
2173 case EV_NW_TIMEOUT:
2174 result = -1;
2175 finish = 1;
2176 break;
2177 default:
2178 if (ctrl->user_callback)
2179 {
2180 ctrl->user_callback((void *)&event, ctrl->user_data);
2181 }
2182 break;
2183 }
2184 }
2185 if (timeout_ms != 0xffffffff)
2186 {
2187 platform_stop_timer(ctrl->timer);
2188 }
2189 return result;
2190 }
2191
2192 int network_close(network_ctrl_t *ctrl, uint32_t timeout_ms)
2193 {
2194 NW_LOCK;
2195 if (ctrl->cache_data)
2196 {
2197 free(ctrl->cache_data);
2198 ctrl->cache_data = NULL;
2199 }
2200 uint8_t old_state = ctrl->state;
2201 ctrl->auto_mode = 1;
2202 ctrl->need_close = 0;
2203 ctrl->new_rx_flag = 0;
2204 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
2205 #ifdef LUAT_USE_TLS
2206 if (ctrl->tls_mode)
2207 {
2208 mbedtls_ssl_free(ctrl->ssl);
2209 }
2210 #endif
2211 if (ctrl->socket_id < 0)
2212 {
2213
2214 ctrl->state = NW_STATE_OFF_LINE;
2215 ctrl->wait_target_state = NW_WAIT_NONE;
2216 NW_UNLOCK;
2217 return 0;
2218 }
2219
2220 ctrl->state = NW_STATE_DISCONNECTING;
2221 ctrl->wait_target_state = NW_WAIT_OFF_LINE;
2222
2223 if ((NW_STATE_ONLINE == old_state) && ctrl->is_tcp)
2224 {
2225 if (network_socket_disconnect(ctrl))
2226 {
2227 network_force_close_socket(ctrl);
2228 ctrl->state = NW_STATE_OFF_LINE;
2229 ctrl->wait_target_state = NW_WAIT_NONE;
2230 NW_UNLOCK;
2231 return 0;
2232 }
2233 }
2234 else
2235 {
2236 network_force_close_socket(ctrl);
2237 ctrl->state = NW_STATE_OFF_LINE;
2238 ctrl->wait_target_state = NW_WAIT_NONE;
2239 NW_UNLOCK;
2240 return 0;
2241 }
2242 NW_UNLOCK;
2243 if (!ctrl->task_handle || !timeout_ms)
2244 {
2245 return 1;
2246 }
2247 uint8_t finish = 0;
2248 OS_EVENT event;
2249 int result;
2250 //DBG_INFO("%s wait for active!,%u,%x", Net->Tag, To * SYS_TICK, Net->hTask);
2251
2252 platform_start_timer(ctrl->timer, timeout_ms, 0);
2253 while (!finish)
2254 {
2255 platform_wait_event(ctrl->task_handle, 0, &event, NULL, 0);
2256 switch (event.ID)
2257 {
2258 case EV_NW_RESULT_CLOSE:
2259 result = 0;
2260 finish = 1;
2261 break;
2262 case EV_NW_TIMEOUT:
2263 result = 0;
2264 finish = 1;
2265 break;
2266 default:
2267 if (ctrl->user_callback)
2268 {
2269 ctrl->user_callback((void *)&event, ctrl->user_data);
2270 }
2271 break;
2272 }
2273 }
2274 platform_stop_timer(ctrl->timer);
2275 network_socket_force_close(ctrl);
2276 return result;
2277 }
2278 /*
2279 * timeout_ms=0时，为非阻塞接口
2280 */
2281 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)
2282 {
2283 if ((ctrl->need_close) || (ctrl->socket_id < 0) || (ctrl->state != NW_STATE_ONLINE))
2284 {
2285 return -1;
2286 }
2287 NW_LOCK;
2288 int result;
2289
2290 ctrl->auto_mode = 1;
2291 #ifdef LUAT_USE_TLS
2292 if (ctrl->tls_mode)
2293 {
2294 if (ctrl->tls_need_reshakehand)
2295 {
2296 ctrl->tls_need_reshakehand = 0;
2297 if (ctrl->cache_data)
2298 {
2299 free(ctrl->cache_data);
2300 ctrl->cache_data = NULL;
2301 }
2302 ctrl->cache_data = malloc(len);
2303 memcpy(ctrl->cache_data, data, len);
2304 ctrl->cache_len = len;
2305 mbedtls_ssl_session_reset(ctrl->ssl);
2306 do
2307 {
2308 result = mbedtls_ssl_handshake_step( ctrl->ssl );
2309 switch(result)
2310 {
2311 case MBEDTLS_ERR_SSL_WANT_READ:
2312 ctrl->state = NW_STATE_SHAKEHAND;
2313 goto NETWORK_TX_WAIT;
2314 case 0:
2315 break;
2316 default:
2317 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
2318 #else
2319 DBG_ERR("0x%x, %d", -result, ctrl->ssl->state);
2320 #endif
2321 ctrl->need_close = 1;
2322 NW_UNLOCK;
2323 return -1;
2324 }
2325 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
2326 }while(!mbedtls_ssl_is_handshake_over(ctrl->ssl));
2327 #else
2328 }while(ctrl->ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER);
2329 #endif
2330 }
2331
2332 uint32_t done = 0;
2333 while(done < len)
2334 {
2335 result = mbedtls_ssl_write(ctrl->ssl, data + done, len - done);
2336 if (result < 0)
2337 {
2338 DBG("%08x", -result);
2339 ctrl->need_close = 1;
2340 NW_UNLOCK;
2341 return -1;
2342 }
2343 done += result;
2344 }
2345
2346 *tx_len = done;
2347 }
2348 else
2349 #endif
2350 {
2351 result = network_base_tx(ctrl, data, len, flags, remote_ip, remote_port);
2352 if (result < 0)
2353 {
2354 ctrl->need_close = 1;
2355 NW_UNLOCK;
2356 return -1;
2357 }
2358 *tx_len = result;
2359 if (!result && len)
2360 {
2361 NW_UNLOCK;
2362 return 0;
2363 }
2364 }
2365 #ifdef LUAT_USE_TLS
2366 NETWORK_TX_WAIT:
2367 #endif
2368 ctrl->wait_target_state = NW_WAIT_TX_OK;
2369 NW_UNLOCK;
2370
2371 if (!ctrl->task_handle || !timeout_ms)
2372 {
2373 return 1;
2374 }
2375 uint8_t finish = 0;
2376 OS_EVENT event;
2377 //DBG_INFO("%s wait for active!,%u,%x", Net->Tag, To * SYS_TICK, Net->hTask);
2378
2379 platform_start_timer(ctrl->timer, timeout_ms, 0);
2380 while (!finish)
2381 {
2382 platform_wait_event(ctrl->task_handle, 0, &event, NULL, 0);
2383 switch (event.ID)
2384 {
2385 case EV_NW_RESULT_TX:
2386 result = (int)event.Param1;
2387 finish = 1;
2388 break;
2389 case EV_NW_TIMEOUT:
2390 result = -1;
2391 finish = 1;
2392 break;
2393 default:
2394 if (ctrl->user_callback)
2395 {
2396 ctrl->user_callback((void *)&event, ctrl->user_data);
2397 }
2398 break;
2399 }
2400 }
2401 platform_stop_timer(ctrl->timer);
2402 return result;
2403 }
2404 /*
2405 * 实际读到的数据量在rx_len里，如果是UDP模式且为server时，需要看remote_ip和remote_port
2406 */
2407 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)
2408 {
2409 if (((ctrl->need_close && !ctrl->new_rx_flag) || (ctrl->socket_id < 0) || (ctrl->state != NW_STATE_ONLINE)))
2410 {
2411 return -1;
2412 }
2413 NW_LOCK;
2414 int result = -1;
2415 ctrl->auto_mode = 1;
2416 uint32_t read_len = 0;
2417 uint8_t is_error = 0;
2418
2419
2420 if (data)
2421 {
2422 ctrl->new_rx_flag = 0;
2423 #ifdef LUAT_USE_TLS
2424 if (ctrl->tls_mode)
2425 {
2426
2427 do
2428 {
2429 result = mbedtls_ssl_read(ctrl->ssl, data + read_len, len - read_len);
2430 if (result < 0 && (result != MBEDTLS_ERR_SSL_WANT_READ))
2431 {
2432 is_error = 1;
2433 break;
2434 }
2435 else if (result > 0)
2436 {
2437 read_len += result;
2438 if (read_len >= len)
2439 {
2440 break;
2441 }
2442 }
2443 else
2444 {
2445 break;
2446 }
2447 }while(network_socket_receive(ctrl, NULL, len, flags, remote_ip, remote_port) > 0);
2448
2449 if ( !is_error )
2450 {
2451 result = read_len;
2452 }
2453 else
2454 {
2455 result = -1;
2456 }
2457 }
2458 else
2459 #endif
2460 {
2461
2462 result = network_socket_receive(ctrl, data, len, flags, remote_ip, remote_port);
2463 }
2464 }
2465 else
2466 {
2467 #ifdef LUAT_USE_TLS
2468 if (ctrl->tls_mode)
2469 {
2470 read_len = 0;
2471 do
2472 {
2473 result = mbedtls_ssl_read(ctrl->ssl, NULL, 0);
2474 if ((result < 0) && (result != (MBEDTLS_ERR_SSL_WANT_READ)))
2475 {
2476 is_error = 1;
2477 read_len = 0;
2478 break;
2479 }
2480 else if (!result)
2481 {
2482 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
2483 read_len = ctrl->ssl->MBEDTLS_PRIVATE(in_msglen);
2484 #else
2485 read_len = ctrl->ssl->in_msglen;
2486 #endif
2487 break;
2488 }
2489 else if ((MBEDTLS_ERR_SSL_WANT_READ) == result)
2490 {
2491 read_len = 0;
2492 ctrl->new_rx_flag = 0;
2493 DBG("socket %d ssl data need more", ctrl->socket_id);
2494 break;
2495 }
2496 }while(network_socket_receive(ctrl, NULL, len, flags, remote_ip, remote_port) > 0);
2497
2498 if ( !is_error )
2499 {
2500 result = read_len;
2501 }
2502 else
2503 {
2504 result = -1;
2505 }
2506 }
2507 else
2508 #endif
2509 {
2510 result = network_socket_receive(ctrl, data, len, flags, remote_ip, remote_port);
2511 }
2512 }
2513
2514
2515 NW_UNLOCK;
2516 if (result >= 0)
2517 {
2518 *rx_len = result;
2519 return 0;
2520 }
2521 else
2522 {
2523 return -1;
2524 }
2525 }
2526
2527 int network_wait_event(network_ctrl_t *ctrl, OS_EVENT *out_event, uint32_t timeout_ms, uint8_t *is_timeout)
2528 {
2529 if (ctrl->new_rx_flag)
2530 {
2531 ctrl->wait_target_state = NW_WAIT_EVENT;
2532 if (out_event)
2533 {
2534 out_event->ID = 0;
2535 }
2536 return 0;
2537 }
2538 if ((ctrl->need_close) || (ctrl->socket_id < 0) || (ctrl->state != NW_STATE_ONLINE))
2539 {
2540 return -1;
2541 }
2542 NW_LOCK;
2543 ctrl->auto_mode = 1;
2544 ctrl->wait_target_state = NW_WAIT_EVENT;
2545 NW_UNLOCK;
2546 if (!ctrl->task_handle || !timeout_ms)
2547 {
2548 return 1;
2549 }
2550 *is_timeout = 0;
2551 uint8_t finish = 0;
2552 OS_EVENT event;
2553 int result;
2554 //DBG_INFO("%s wait for active!,%u,%x", Net->Tag, To * SYS_TICK, Net->hTask);
2555
2556 platform_start_timer(ctrl->timer, timeout_ms, 0);
2557 while (!finish)
2558 {
2559 platform_wait_event(ctrl->task_handle, 0, &event, NULL, 0);
2560 switch (event.ID)
2561 {
2562 case EV_NW_RESULT_EVENT:
2563 result = (int)event.Param1;
2564 if (result)
2565 {
2566 result = -1;
2567 }
2568 if (out_event)
2569 {
2570 out_event->ID = 0;
2571 }
2572 finish = 1;
2573 break;
2574 case EV_NW_TIMEOUT:
2575 *is_timeout = 1;
2576 result = 0;
2577 finish = 1;
2578 break;
2579 case EV_NW_BREAK_WAIT:
2580 if (out_event)
2581 {
2582 *out_event = event;
2583 }
2584 result = 0;
2585 finish = 1;
2586 break;
2587 default:
2588 if (out_event)
2589 {
2590 *out_event = event;
2591 result = 0;
2592 finish = 1;
2593 break;
2594 }
2595 else if (ctrl->user_callback)
2596 {
2597 ctrl->user_callback((void *)&event, ctrl->user_data);
2598 }
2599 break;
2600 }
2601 }
2602 platform_stop_timer(ctrl->timer);
2603 return result;
2604 }
2605
2606 int network_wait_rx(network_ctrl_t *ctrl, uint32_t timeout_ms, uint8_t *is_break, uint8_t *is_timeout)
2607 {
2608 *is_timeout = 0;
2609 *is_break = 0;
2610 if (ctrl->new_rx_flag)
2611 {
2612 ctrl->wait_target_state = NW_WAIT_EVENT;
2613 return 0;
2614 }
2615 if ((ctrl->need_close) || (ctrl->socket_id < 0) || (ctrl->state != NW_STATE_ONLINE))
2616 {
2617 return -1;
2618 }
2619 NW_LOCK;
2620 ctrl->auto_mode = 1;
2621 ctrl->wait_target_state = NW_WAIT_EVENT;
2622 NW_UNLOCK;
2623
2624 uint8_t finish = 0;
2625 OS_EVENT event;
2626 int result;
2627 //DBG_INFO("%s wait for active!,%u,%x", Net->Tag, To * SYS_TICK, Net->hTask);
2628 if (timeout_ms)
2629 {
2630 platform_start_timer(ctrl->timer, timeout_ms, 0);
2631 }
2632 while (!finish)
2633 {
2634 platform_wait_event(ctrl->task_handle, 0, &event, NULL, 0);
2635 switch (event.ID)
2636 {
2637 case EV_NW_RESULT_EVENT:
2638 result = (int)event.Param1;
2639 if (result)
2640 {
2641 result = -1;
2642 finish = 1;
2643 }
2644 else if (ctrl->new_rx_flag)
2645 {
2646 result = 0;
2647 finish = 1;
2648 }
2649 break;
2650 case EV_NW_TIMEOUT:
2651 *is_timeout = 1;
2652 result = 0;
2653 finish = 1;
2654 break;
2655 case EV_NW_BREAK_WAIT:
2656 *is_break = 1;
2657 result = 0;
2658 finish = 1;
2659 break;
2660 default:
2661 if (ctrl->user_callback)
2662 {
2663 ctrl->user_callback((void *)&event, ctrl->user_data);
2664 }
2665 break;
2666 }
2667 ctrl->wait_target_state = NW_WAIT_EVENT;
2668 }
2669 platform_stop_timer(ctrl->timer);
2670 return result;
2671 }
2672
2673 uint8_t network_check_ready(network_ctrl_t *ctrl, uint8_t adapter_index)
2674 {
2675 network_adapter_t *adapter;
2676 if (ctrl)
2677 {
2678 adapter = &prv_adapter_table[ctrl->adapter_index];
2679 }
2680 else if (adapter_index < NW_ADAPTER_QTY)
2681 {
2682 adapter = &prv_adapter_table[adapter_index];
2683 }
2684 else
2685 {
2686 return 0;
2687 }
2688 if (adapter->opt)
2689 {
2690 return adapter->opt->check_ready(adapter->user_data);
2691 }
2692 else
2693 {
2694 return 0;
2695 }
2696 }
2697
2698 //将IP设置成无效状态
2699 void network_set_ip_invaild(luat_ip_addr_t *ip)
2700 {
2701 #ifdef LUAT_USE_LWIP
2702 #if LWIP_IPV6
2703 ip->type = 0xff;
2704 #else
2705 ip->addr = 0;
2706 #endif
2707 #else
2708 ip->is_ipv6 = 0xff;
2709 #endif
2710 }
2711 //检测IP是不是无效的，无效返回0
2712 uint8_t network_ip_is_vaild(luat_ip_addr_t *ip)
2713 {
2714 #ifdef LUAT_USE_LWIP
2715 #if LWIP_IPV6
2716 return (ip->type != 0xff);
2717 #else
2718 return (ip->addr != 0);
2719 #endif
2720 #else
2721 return (ip->is_ipv6 != 0xff);
2722 #endif
2723 }
2724
2725 uint8_t network_ip_is_ipv6(luat_ip_addr_t *ip)
2726 {
2727 #ifdef LUAT_USE_LWIP
2728 #if LWIP_IPV6
2729 return (IPADDR_TYPE_V6 == ip->type);
2730 #else
2731 return 0;
2732 #endif
2733 #else
2734 return (ip->is_ipv6 && (ip->is_ipv6 != 0xff));
2735 #endif
2736 }
2737
2738 //检测IP是不是有效的IPV4类型，不是返回0
2739 uint8_t network_ip_is_vaild_ipv4(luat_ip_addr_t *ip)
2740 {
2741 #ifdef LUAT_USE_LWIP
2742 #if LWIP_IPV6
2743 return (IPADDR_TYPE_V4 == ip->type);
2744 #else
2745 return (ip->addr != 0);
2746 #endif
2747 #else
2748 return !ip->is_ipv6;
2749 #endif
2750 }
2751
2752 void network_set_ip_ipv4(luat_ip_addr_t *ip, uint32_t ipv4)
2753 {
2754 #ifdef LUAT_USE_LWIP
2755 #if LWIP_IPV6
2756 ip->type = IPADDR_TYPE_V4;
2757 ip->u_addr.ip4.addr = ipv4;
2758 #else
2759 ip->addr = ipv4;
2760 #endif
2761 #else
2762 ip->is_ipv6 = 0;
2763 ip->ipv4 = ipv4;
2764 #endif
2765 }
2766 #endif