?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'master' of https://gitee.com/openLuat/LuatOS
[LuatOS.git] / components / network / adapter / luat_network_adapter.c
blob77d6575d91c9cd52de7351d3a7603b6865d9c445
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 // 如果 适配器自带check_ack函数, 那就直接调用, 不需要再调用全局的
887 if (prv_adapter_table[ctrl->adapter_index].opt->check_ack) {
888 return prv_adapter_table[ctrl->adapter_index].opt->check_ack(ctrl->adapter_index, ctrl->socket_id);
889 }
890 // TODO 待全部bsp都增加check_ack函数后, 就不再需要下面的调用了
891 return net_lwip_check_all_ack(ctrl->socket_id);
892 }
893 else
894 {
895 return 0;
896 }
897 }
898 return 0;
899 #else
900 return 0;
901 #endif
902 }
903 }
904 break;
905 case EV_NW_SOCKET_RX_NEW:
906 #ifdef LUAT_USE_TLS
907 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
908 if (ctrl->tls_mode && !mbedtls_ssl_is_handshake_over(ctrl->ssl))
909 #else
910 if (ctrl->tls_mode && (ctrl->ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER))
911 #endif
912 {
913 DBG("rehandshaking");
914 do
915 {
916 int result = mbedtls_ssl_handshake_step( ctrl->ssl );
917 switch(result)
918 {
919 case MBEDTLS_ERR_SSL_WANT_READ:
920 return 1;
921 case 0:
922 break;
923 default:
924 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
925 DBG_ERR("0x%x", -result);
926 #else
927 DBG_ERR("0x%x, %d", -result, ctrl->ssl->state);
928 #endif
929 ctrl->need_close = 1;
930 return -1;
931 }
932 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
933 }while(!mbedtls_ssl_is_handshake_over(ctrl->ssl));
934 #else
935 }while(ctrl->ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER);
936 #endif
937 }
938 #endif
939 ctrl->new_rx_flag = 1;
940 if (NW_WAIT_TX_OK != ctrl->wait_target_state)
941 {
942 return 0;
943 }
944 break;
945 default:
946 return 1;
947 }
948 return 1;
949 }
950
951 static int network_state_listen(network_ctrl_t *ctrl, OS_EVENT *event, network_adapter_t *adapter)
952 {
953 if ((ctrl->need_close) || NW_WAIT_OFF_LINE == ctrl->wait_target_state)
954 {
955 return -1;
956 }
957 switch(event->ID)
958 {
959 case EV_NW_RESET:
960 case EV_NW_SOCKET_ERROR:
961 case EV_NW_SOCKET_REMOTE_CLOSE:
962 case EV_NW_SOCKET_CLOSE_OK:
963 ctrl->need_close = 1;
964 return -1;
965 case EV_NW_STATE:
966 if (!event->Param2)
967 {
968 ctrl->need_close = 1;
969 return -1;
970 }
971 break;
972 case EV_NW_SOCKET_NEW_CONNECT:
973 case EV_NW_SOCKET_CONNECT_OK:
974 ctrl->state = NW_STATE_ONLINE;
975 return 0;
976 default:
977 return 1;
978 }
979 return 1;
980 }
981
982 static int network_state_disconnecting(network_ctrl_t *ctrl, OS_EVENT *event, network_adapter_t *adapter)
983 {
984 if (ctrl->wait_target_state != NW_WAIT_OFF_LINE)
985 {
986 return -1;
987 }
988 switch(event->ID)
989 {
990 case EV_NW_RESET:
991 case EV_NW_SOCKET_ERROR:
992 case EV_NW_SOCKET_REMOTE_CLOSE:
993 case EV_NW_SOCKET_CLOSE_OK:
994 network_force_close_socket(ctrl);
995 ctrl->state = NW_STATE_OFF_LINE;
996 ctrl->socket_id = -1;
997 return 0;
998 case EV_NW_STATE:
999 if (!event->Param2)
1000 {
1001 return -1;
1002 }
1003 else
1004 {
1005 network_force_close_socket(ctrl);
1006 ctrl->state = NW_STATE_OFF_LINE;
1007 ctrl->socket_id = -1;
1008 }
1009 break;
1010 default:
1011 return 1;
1012 }
1013 return -1;
1014 }
1015
1016 typedef int (*network_state_fun)(network_ctrl_t *ctrl, OS_EVENT *event, network_adapter_t *adapter);
1017 static network_state_fun network_state_fun_list[]=
1018 {
1019 network_state_link_off,
1020 network_state_off_line,
1021 network_state_wait_dns,
1022 network_state_connecting,
1023 network_state_shakehand,
1024 network_state_on_line,
1025 network_state_listen,
1026 network_state_disconnecting,
1027 };
1028
1029 static void network_default_statemachine(network_ctrl_t *ctrl, OS_EVENT *event, network_adapter_t *adapter)
1030 {
1031 int result = -1;
1032 uint8_t close_flag = 0;
1033 NW_LOCK;
1034 if (ctrl->state > NW_STATE_DISCONNECTING)
1035 {
1036 ctrl->state = NW_STATE_LINK_OFF;
1037 event->Param1 = -1;
1038
1039 network_force_close_socket(ctrl);
1040 event->ID = ctrl->wait_target_state + EV_NW_RESULT_BASE;
1041
1042 }
1043 else
1044 {
1045 if ((NW_STATE_DISCONNECTING == ctrl->state) && (NW_WAIT_OFF_LINE == ctrl->wait_target_state))
1046 {
1047 close_flag = 1;
1048 }
1049 result = network_state_fun_list[ctrl->state](ctrl, event, adapter);
1050 if (result > 0)
1051 {
1052 NW_UNLOCK;
1053 if (ctrl->new_rx_flag && ctrl->user_callback)
1054 {
1055 event->ID = NW_WAIT_EVENT + EV_NW_RESULT_BASE;
1056 event->Param1 = 0;
1057 ctrl->user_callback(event, ctrl->user_data);
1058 }
1059 return ;
1060 }
1061 if (close_flag && (NW_WAIT_NONE == ctrl->wait_target_state))
1062 {
1063 event->ID = EV_NW_RESULT_CLOSE;
1064 }
1065 else
1066 {
1067 event->ID = (ctrl->wait_target_state?ctrl->wait_target_state:NW_WAIT_EVENT) + EV_NW_RESULT_BASE;
1068 }
1069 event->Param1 = result;
1070 }
1071 if ((ctrl->state != NW_STATE_LISTEN) || (result < 0))
1072 {
1073 ctrl->wait_target_state = NW_WAIT_NONE;
1074 }
1075 NW_UNLOCK;
1076 if (ctrl->task_handle)
1077 {
1078 platform_send_event(ctrl->task_handle, event->ID, event->Param1, event->Param2, event->Param3);
1079 }
1080 else if (ctrl->user_callback)
1081 {
1082 ctrl->user_callback(event, ctrl->user_data);
1083 }
1084 }
1085
1086
1087 static int32_t network_default_socket_callback(void *data, void *param)
1088 {
1089 OS_EVENT *event = (OS_EVENT *)data;
1090 OS_EVENT temp_event;
1091 luat_network_cb_param_t *cb_param = (luat_network_cb_param_t *)param;
1092 network_adapter_t *adapter =(network_adapter_t *)(cb_param->param);
1093 int i;
1094 network_ctrl_t *ctrl = (network_ctrl_t *)event->Param3;
1095
1096 if (event->ID > EV_NW_TIMEOUT)
1097 {
1098 if (ctrl && ((event->ID == EV_NW_DNS_RESULT) || (ctrl->tag == cb_param->tag)))
1099 {
1100 if ((event->ID == EV_NW_DNS_RESULT) && (ctrl->wait_target_state != NW_WAIT_ON_LINE))
1101 {
1102 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));
1103 return 0;
1104 }
1105 if (ctrl->auto_mode)
1106 {
1107 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),
1108 ctrl->state, network_ctrl_state_string(ctrl->state),
1109 ctrl->wait_target_state, network_ctrl_wait_state_string(ctrl->wait_target_state));
1110 network_default_statemachine(ctrl, event, adapter);
1111 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));
1112 }
1113 else if (ctrl->task_handle)
1114 {
1115 platform_send_event(ctrl->task_handle, event->ID, event->Param1, event->Param2, event->Param3);
1116 }
1117 else if (ctrl->user_callback)
1118 {
1119 ctrl->user_callback(event, ctrl->user_data);
1120 }
1121 }
1122 else
1123 {
1124 DBG_ERR("cb ctrl invaild %x %08X", ctrl, event->ID);
1125 // 下面这行的打印在部分平台会有问题
1126 // 原因是ctrl可能已经被释放, 再次访问会导致coredump
1127 //DBG_HexPrintf(&ctrl->tag, 8);
1128 DBG_HexPrintf(&cb_param->tag, 8);
1129 }
1130 }
1131 else
1132 {
1133 for (i = 0; i < adapter->opt->max_socket_num; i++)
1134 {
1135 temp_event = *event;
1136 if (adapter->ctrl_busy[i])
1137 {
1138 ctrl = &adapter->ctrl_table[i];
1139 if (ctrl->adapter_index == (uint8_t)(event->Param3))
1140 {
1141 if (ctrl->auto_mode)
1142 {
1143 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),
1144 ctrl->state, network_ctrl_state_string(ctrl->state),
1145 ctrl->wait_target_state, network_ctrl_wait_state_string(ctrl->wait_target_state));
1146 network_default_statemachine(ctrl, &temp_event, adapter);
1147 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));
1148 }
1149 else if (ctrl->task_handle)
1150 {
1151 platform_send_event(ctrl->task_handle, event->ID, event->Param1, event->Param2, event->Param3);
1152 }
1153 else if (ctrl->user_callback)
1154 {
1155 ctrl->user_callback(&temp_event, ctrl->user_data);
1156 }
1157 }
1158
1159 }
1160 }
1161 }
1162
1163 return 0;
1164 }
1165
1166 static LUAT_RT_RET_TYPE network_default_timer_callback(LUAT_RT_CB_PARAM)
1167 {
1168 platform_send_event(param, EV_NW_TIMEOUT, 0, 0, 0);
1169 return LUAT_RT_RET;
1170 }
1171
1172 #ifndef LUAT_USE_LWIP
1173 uint8_t network_string_is_ipv4(const char *string, uint32_t len)
1174 {
1175 int i;
1176 for(i = 0; i < len; i++)
1177 {
1178 if (!isdigit((int)string[i]) && (string[i] != '.'))
1179 {
1180 return 0;
1181 }
1182 }
1183 return 1;
1184 }
1185
1186 uint32_t network_string_to_ipv4(const char *string, uint32_t len)
1187 {
1188 int i;
1189 int8_t Buf[4][4];
1190 CmdParam CP;
1191 PV_Union uIP;
1192 char temp[32];
1193 memset(Buf, 0, sizeof(Buf));
1194 CP.param_max_len = 4;
1195 CP.param_max_num = 4;
1196 CP.param_num = 0;
1197 CP.param_str = (int8_t *)Buf;
1198 memcpy(temp, string, len);
1199 temp[len] = 0;
1200 CmdParseParam((int8_t*)temp, &CP, '.');
1201 for(i = 0; i < 4; i++)
1202 {
1203 uIP.u8[i] = strtol((char *)Buf[i], NULL, 10);
1204 }
1205 // DBG("%d.%d.%d.%d", uIP.u8[0], uIP.u8[1], uIP.u8[2], uIP.u8[3]);
1206 return uIP.u32;
1207 }
1208
1209 #define SWAP(x) ((((x) & (uint32_t)0x000000ffUL) << 24) | \
1210 (((x) & (uint32_t)0x0000ff00UL) << 8) | \
1211 (((x) & (uint32_t)0x00ff0000UL) >> 8) | \
1212 (((x) & (uint32_t)0xff000000UL) >> 24))
1213
1214 int network_string_to_ipv6(const char *string, luat_ip_addr_t *ip_addr)
1215 {
1216
1217
1218 uint32_t addr_index, zero_blocks, current_block_index, current_block_value;
1219 const char *s;
1220 ip_addr->is_ipv6 = 0xff;
1221 /* Count the number of colons, to count the number of blocks in a "::" sequence
1222 zero_blocks may be 1 even if there are no :: sequences */
1223 zero_blocks = 8;
1224 for (s = string; *s != 0; s++) {
1225 if (*s == ':') {
1226 zero_blocks--;
1227 } else if (!isxdigit((int)*s)) {
1228 break;
1229 }
1230 }
1231
1232 /* parse each block */
1233 addr_index = 0;
1234 current_block_index = 0;
1235 current_block_value = 0;
1236 for (s = string; *s != 0; s++) {
1237 if (*s == ':') {
1238 if (current_block_index & 0x1) {
1239 ip_addr->ipv6_u32_addr[addr_index++] |= current_block_value;
1240 }
1241 else {
1242 ip_addr->ipv6_u32_addr[addr_index] = current_block_value << 16;
1243 }
1244 current_block_index++;
1245 current_block_value = 0;
1246 if (current_block_index > 7) {
1247 /* address too long! */
1248 return 0;
1249 }
1250 if (s[1] == ':') {
1251 if (s[2] == ':') {
1252 /* invalid format: three successive colons */
1253 return 0;
1254 }
1255 s++;
1256 /* "::" found, set zeros */
1257 while (zero_blocks > 0) {
1258 zero_blocks--;
1259 if (current_block_index & 0x1) {
1260 addr_index++;
1261 } else {
1262 ip_addr->ipv6_u32_addr[addr_index] = 0;
1263 }
1264 current_block_index++;
1265 if (current_block_index > 7) {
1266 /* address too long! */
1267 return 0;
1268 }
1269 }
1270 }
1271 } else if (isxdigit((int)*s)) {
1272 /* add current digit */
1273 current_block_value = (current_block_value << 4) +
1274 (isxdigit((int)*s) ? (uint32_t)(*s - '0') :
1275 (uint32_t)(10 + (isxdigit((int)*s) ? *s - 'a' : *s - 'A')));
1276 } else {
1277 /* unexpected digit, space? CRLF? */
1278 break;
1279 }
1280 }
1281
1282
1283 if (current_block_index & 0x1) {
1284 ip_addr->ipv6_u32_addr[addr_index++] |= current_block_value;
1285 }
1286 else {
1287 ip_addr->ipv6_u32_addr[addr_index] = current_block_value << 16;
1288 }
1289
1290 /* convert to network byte order. */
1291 for (addr_index = 0; addr_index < 4; addr_index++) {
1292 ip_addr->ipv6_u32_addr[addr_index] = SWAP(ip_addr->ipv6_u32_addr[addr_index]);
1293 }
1294
1295
1296
1297 if (current_block_index != 7) {
1298
1299 return 0;
1300 }
1301 ip_addr->is_ipv6 = 1;
1302 return 1;
1303
1304 }
1305
1306 #endif
1307
1308 int network_get_last_register_adapter(void)
1309 {
1310 if (prv_network.default_adapter_index != -1) return prv_network.default_adapter_index;
1311 return prv_network.last_adapter_index;
1312 }
1313
1314 void network_register_set_default(uint8_t adapter_index)
1315 {
1316 prv_network.default_adapter_index = adapter_index;
1317 }
1318
1319 int network_register_adapter(uint8_t adapter_index, network_adapter_info *info, void *user_data)
1320 {
1321 prv_adapter_table[adapter_index].opt = info;
1322 prv_adapter_table[adapter_index].user_data = user_data;
1323 info->socket_set_callback(network_default_socket_callback, &prv_adapter_table[adapter_index], user_data);
1324 #ifdef LUAT_USE_LWIP
1325 if (adapter_index < NW_ADAPTER_INDEX_HW_PS_DEVICE)
1326 {
1327 prv_adapter_table[adapter_index].ctrl_table = prv_network.lwip_ctrl_table;
1328 prv_adapter_table[adapter_index].ctrl_busy = prv_network.lwip_ctrl_busy;
1329 }
1330 else
1331 #endif
1332 {
1333 prv_adapter_table[adapter_index].ctrl_table = zalloc((info->max_socket_num) * sizeof(network_ctrl_t));
1334 prv_adapter_table[adapter_index].ctrl_busy = zalloc(info->max_socket_num);
1335 }
1336
1337 prv_adapter_table[adapter_index].port = 60000;
1338 if (!prv_network.is_init)
1339 {
1340 //prv_network.network_mutex = platform_create_mutex();
1341 INIT_LLIST_HEAD(&prv_network.dns_cache_head);
1342 prv_network.is_init = 0;
1343 }
1344
1345 prv_network.last_adapter_index = adapter_index;
1346 return 0;
1347 }
1348
1349 void network_set_dns_server(uint8_t adapter_index, uint8_t server_index, luat_ip_addr_t *ip)
1350 {
1351 network_adapter_t *adapter = &prv_adapter_table[adapter_index];
1352 adapter->opt->set_dns_server(server_index, ip, adapter->user_data);
1353 }
1354
1355 /*
1356 * 申请一个network_ctrl
1357 */
1358 network_ctrl_t *network_alloc_ctrl(uint8_t adapter_index)
1359 {
1360 int i;
1361 network_ctrl_t *ctrl = NULL;
1362 if (adapter_index >= NW_ADAPTER_QTY || prv_adapter_table[adapter_index].opt == NULL) {
1363 DBG_ERR("adapter index %d is invalid!", adapter_index);
1364 return NULL;
1365 }
1366 network_adapter_t *adapter = &prv_adapter_table[adapter_index];
1367 OS_LOCK;
1368 for (i = 0; i < adapter->opt->max_socket_num; i++)
1369 {
1370 if (!adapter->ctrl_busy[i])
1371 {
1372
1373 adapter->ctrl_busy[i] = 1;
1374 ctrl = &adapter->ctrl_table[i];
1375 ctrl->adapter_index = adapter_index;
1376 ctrl->domain_ipv6 = 0;
1377 break;
1378 }
1379 }
1380 OS_UNLOCK;
1381 if (i >= adapter->opt->max_socket_num) {DBG_ERR("adapter no more ctrl!");}
1382 return ctrl;
1383 }
1384
1385 /*
1386 * 归还一个network_ctrl
1387 */
1388 void network_release_ctrl(network_ctrl_t *ctrl)
1389 {
1390 int i;
1391 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1392 NW_UNLOCK;
1393 OS_LOCK;
1394 for (i = 0; i < adapter->opt->max_socket_num; i++)
1395 {
1396 if (&adapter->ctrl_table[i] == ctrl)
1397 {
1398 network_deinit_tls(ctrl);
1399 if (ctrl->timer)
1400 {
1401 platform_stop_timer(ctrl->timer);
1402 platform_release_timer(ctrl->timer);
1403 ctrl->timer = NULL;
1404 }
1405 if (ctrl->cache_data)
1406 {
1407 free(ctrl->cache_data);
1408 ctrl->cache_data = NULL;
1409 }
1410 if (ctrl->dns_ip)
1411 {
1412 free(ctrl->dns_ip);
1413 ctrl->dns_ip = NULL;
1414 }
1415 if (ctrl->domain_name)
1416 {
1417 free(ctrl->domain_name);
1418 ctrl->domain_name = NULL;
1419 }
1420 adapter->ctrl_busy[i] = 0;
1421 platform_release_mutex(ctrl->mutex);
1422 ctrl->mutex = NULL;
1423 break;
1424 }
1425 }
1426 OS_UNLOCK;
1427 if (i >= adapter->opt->max_socket_num) {DBG_ERR("adapter index maybe error!, %d, %x", ctrl->adapter_index, ctrl);}
1428
1429 }
1430
1431 void network_init_ctrl(network_ctrl_t *ctrl, HANDLE task_handle, CBFuncEx_t callback, void *param)
1432 {
1433 uint8_t adapter_index = ctrl->adapter_index;
1434 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1435 if (ctrl->dns_ip)
1436 {
1437 free(ctrl->dns_ip);
1438 ctrl->dns_ip = NULL;
1439 }
1440 if (ctrl->cache_data)
1441 {
1442 free(ctrl->cache_data);
1443 ctrl->cache_data = NULL;
1444 }
1445 if (ctrl->domain_name)
1446 {
1447 free(ctrl->domain_name);
1448 ctrl->domain_name = NULL;
1449 }
1450 HANDLE sem = ctrl->mutex;
1451 memset(ctrl, 0, sizeof(network_ctrl_t));
1452 ctrl->adapter_index = adapter_index;
1453 ctrl->task_handle = task_handle;
1454 ctrl->user_callback = callback;
1455 ctrl->user_data = param;
1456 ctrl->socket_id = -1;
1457 ctrl->socket_param = ctrl;
1458 network_set_ip_invaild(&ctrl->remote_ip);
1459 ctrl->mutex = sem;
1460 if (task_handle)
1461 {
1462 ctrl->timer = platform_create_timer(network_default_timer_callback, task_handle, NULL);
1463 }
1464 if (!ctrl->mutex)
1465 {
1466 ctrl->mutex = platform_create_mutex();
1467 }
1468
1469 }
1470
1471 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)
1472 {
1473 ctrl->is_tcp = is_tcp;
1474 ctrl->tcp_keep_alive = keep_alive;
1475 ctrl->tcp_keep_idle = keep_idle;
1476 ctrl->tcp_keep_interval = keep_interval;
1477 ctrl->tcp_keep_cnt = keep_cnt;
1478 ctrl->tcp_timeout_ms = tcp_timeout_ms;
1479 }
1480
1481 void network_set_debug_onoff(network_ctrl_t *ctrl, uint8_t on_off)
1482 {
1483 ctrl->is_debug = on_off;
1484 }
1485
1486 void network_connect_ipv6_domain(network_ctrl_t *ctrl, uint8_t onoff)
1487 {
1488 ctrl->domain_ipv6 = onoff;
1489 }
1490
1491 int network_set_local_port(network_ctrl_t *ctrl, uint16_t local_port)
1492 {
1493 int i;
1494 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1495 if (local_port)
1496 {
1497 OS_LOCK;
1498 for (i = 0; i < adapter->opt->max_socket_num; i++)
1499 {
1500 if (&adapter->ctrl_table[i] != ctrl)
1501 {
1502 if (adapter->ctrl_table[i].local_port == local_port)
1503 {
1504 OS_UNLOCK;
1505 return -1;
1506 }
1507 }
1508
1509 }
1510 ctrl->local_port = local_port;
1511 OS_UNLOCK;
1512 return 0;
1513 }
1514 else
1515 {
1516 ctrl->local_port = 0;
1517 #if 0
1518 if (ctrl->adapter_index < NW_ADAPTER_INDEX_LWIP_NETIF_QTY)
1519 {
1520 ctrl->local_port = 0;
1521 return 0;
1522 }
1523 OS_LOCK;
1524 adapter->port++;
1525 if (adapter->port < 60000)
1526 {
1527 adapter->port = 60000;
1528 }
1529 ctrl->local_port = adapter->port;
1530 OS_UNLOCK;
1531 #endif
1532 return 0;
1533 }
1534 }
1535
1536 int network_create_soceket(network_ctrl_t *ctrl, uint8_t is_ipv6)
1537 {
1538 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1539 ctrl->socket_id = adapter->opt->create_soceket(ctrl->is_tcp, &ctrl->tag, ctrl->socket_param, is_ipv6, adapter->user_data);
1540 if (ctrl->socket_id < 0)
1541 {
1542 ctrl->tag = 0;
1543 return -1;
1544 }
1545 return 0;
1546 }
1547
1548 int network_socket_connect(network_ctrl_t *ctrl, luat_ip_addr_t *remote_ip)
1549 {
1550 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1551 ctrl->is_server_mode = 0;
1552 ctrl->online_ip = remote_ip;
1553 uint16_t local_port = ctrl->local_port;
1554 if (!local_port)
1555 {
1556 if (ctrl->adapter_index >= NW_ADAPTER_INDEX_HW_PS_DEVICE)
1557 {
1558 adapter->port += 100;
1559 local_port = adapter->port;
1560 if (adapter->port < 60000)
1561 {
1562 adapter->port = 60000;
1563 }
1564 if (local_port < 60000)
1565 {
1566 local_port = 60000;
1567 }
1568 local_port += ctrl->socket_id;
1569 DBG("%d,%d,%d", ctrl->socket_id, local_port, adapter->port);
1570 }
1571 }
1572 return adapter->opt->socket_connect(ctrl->socket_id, ctrl->tag, local_port, remote_ip, ctrl->remote_port, adapter->user_data);
1573 }
1574
1575 int network_socket_listen(network_ctrl_t *ctrl)
1576 {
1577 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1578 ctrl->is_server_mode = 1;
1579 return adapter->opt->socket_listen(ctrl->socket_id, ctrl->tag, ctrl->local_port, adapter->user_data);
1580 }
1581
1582 uint8_t network_accept_enable(network_ctrl_t *ctrl)
1583 {
1584 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1585 return !(adapter->opt->no_accept);
1586 }
1587 //作为server接受一个client
1588 //成功返回0，失败 < 0
1589 int network_socket_accept(network_ctrl_t *ctrl, network_ctrl_t *accept_ctrl)
1590 {
1591 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1592 if (adapter->opt->no_accept)
1593 {
1594 // 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);
1595 adapter->opt->socket_accept(ctrl->socket_id, ctrl->tag, &ctrl->remote_ip, &ctrl->remote_port, adapter->user_data);
1596 return 0;
1597 }
1598 accept_ctrl->socket_id = adapter->opt->socket_accept(ctrl->socket_id, ctrl->tag, &accept_ctrl->remote_ip, &accept_ctrl->remote_port, adapter->user_data);
1599 if (accept_ctrl->socket_id < 0)
1600 {
1601 return -1;
1602 }
1603 else
1604 {
1605 accept_ctrl->is_tcp = ctrl->is_tcp;
1606 accept_ctrl->tcp_keep_alive = ctrl->tcp_keep_alive;
1607 accept_ctrl->tcp_keep_idle = ctrl->tcp_keep_idle;
1608 accept_ctrl->tcp_keep_interval = ctrl->tcp_keep_interval;
1609 accept_ctrl->tcp_keep_cnt = ctrl->tcp_keep_cnt;
1610 accept_ctrl->tcp_timeout_ms = ctrl->tcp_timeout_ms;
1611 accept_ctrl->local_port = ctrl->local_port;
1612 accept_ctrl->state = NW_STATE_ONLINE;
1613 return 0;
1614 }
1615 }
1616 //主动断开一个tcp连接，需要走完整个tcp流程，用户需要接收到close ok回调才能确认彻底断开
1617 //成功返回0，失败 < 0
1618 int network_socket_disconnect(network_ctrl_t *ctrl)
1619 {
1620 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1621 if (ctrl->socket_id >= 0)
1622 {
1623 return adapter->opt->socket_disconnect(ctrl->socket_id, ctrl->tag, adapter->user_data);
1624 }
1625 return 0;
1626 }
1627 //释放掉socket的控制权
1628 //成功返回0，失败 < 0
1629 int network_socket_close(network_ctrl_t *ctrl)
1630 {
1631 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1632 if (ctrl->socket_id >= 0)
1633 {
1634 return adapter->opt->socket_close(ctrl->socket_id, ctrl->tag, adapter->user_data);
1635 }
1636 return 0;
1637 }
1638 //强行释放掉socket的控制权
1639 //成功返回0，失败 < 0
1640 int network_socket_force_close(network_ctrl_t *ctrl)
1641 {
1642 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1643 if (ctrl->socket_id >= 0)
1644 {
1645 adapter->opt->socket_force_close(ctrl->socket_id, adapter->user_data);
1646 }
1647 ctrl->socket_id = -1;
1648 return 0;
1649 }
1650 //tcp时，不需要remote_ip和remote_port，如果buf为NULL，则返回当前缓存区的数据量，当返回值小于len时说明已经读完了
1651 //udp时，只返回1个block数据，需要多次读直到没有数据为止
1652 //成功返回实际读取的值，失败 < 0
1653 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)
1654 {
1655 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1656 return adapter->opt->socket_receive(ctrl->socket_id, ctrl->tag, buf, len, flags, remote_ip, remote_port, adapter->user_data);
1657 }
1658 //tcp时，不需要remote_ip和remote_port
1659 //成功返回0，失败 < 0
1660 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)
1661 {
1662 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1663 return adapter->opt->socket_send(ctrl->socket_id, ctrl->tag, buf, len, flags, remote_ip, remote_port, adapter->user_data);
1664 }
1665
1666 int network_getsockopt(network_ctrl_t *ctrl, int level, int optname, void *optval, uint32_t *optlen)
1667 {
1668 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1669 return adapter->opt->getsockopt(ctrl->socket_id, ctrl->tag, level, optname, optval, optlen, adapter->user_data);
1670 }
1671 int network_setsockopt(network_ctrl_t *ctrl, int level, int optname, const void *optval, uint32_t optlen)
1672 {
1673 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1674 return adapter->opt->setsockopt(ctrl->socket_id, ctrl->tag, level, optname, optval, optlen, adapter->user_data);
1675 }
1676 //非posix的socket，用这个根据实际硬件设置参数
1677 int network_user_cmd(network_ctrl_t *ctrl, uint32_t cmd, uint32_t value)
1678 {
1679 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1680 return adapter->opt->user_cmd(ctrl->socket_id, ctrl->tag, cmd, value, adapter->user_data);
1681 }
1682
1683 int network_dns(network_ctrl_t *ctrl)
1684 {
1685 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1686 if (ctrl->domain_ipv6)
1687 {
1688 return adapter->opt->dns_ipv6(ctrl->domain_name, ctrl->domain_name_len, ctrl, adapter->user_data);
1689 }
1690 else
1691 {
1692 return adapter->opt->dns(ctrl->domain_name, ctrl->domain_name_len, ctrl, adapter->user_data);
1693 }
1694 }
1695
1696 int network_set_mac(uint8_t adapter_index, uint8_t *mac)
1697 {
1698 network_adapter_t *adapter = &prv_adapter_table[adapter_index];
1699 return adapter->opt->set_mac(mac, adapter->user_data);
1700 }
1701
1702 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)
1703 {
1704 network_adapter_t *adapter = &prv_adapter_table[adapter_index];
1705 return adapter->opt->set_static_ip(ip, submask, gateway, ipv6, adapter->user_data);
1706 }
1707
1708 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)
1709 {
1710 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1711 return adapter->opt->get_local_ip_info(ip, submask, gateway, adapter->user_data);
1712 }
1713
1714 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)
1715 {
1716 network_adapter_t *adapter;
1717 if (ctrl)
1718 {
1719 adapter = &prv_adapter_table[ctrl->adapter_index];
1720 }
1721 else
1722 {
1723 adapter = &prv_adapter_table[index];
1724 }
1725 return adapter->opt->get_full_ip_info(ip, submask, gateway, ipv6, adapter->user_data);
1726 }
1727
1728 void network_force_close_socket(network_ctrl_t *ctrl)
1729 {
1730 #ifdef LUAT_USE_TLS
1731 if (ctrl->tls_mode)
1732 {
1733 mbedtls_ssl_free(ctrl->ssl);
1734 }
1735 #endif
1736 if (network_socket_close(ctrl))
1737 {
1738 network_clean_invaild_socket(ctrl->adapter_index);
1739 network_socket_force_close(ctrl);
1740 }
1741 ctrl->need_close = 0;
1742 ctrl->socket_id = -1;
1743 ctrl->new_rx_flag = 0;
1744 if (ctrl->dns_ip)
1745 {
1746 free(ctrl->dns_ip);
1747 ctrl->dns_ip = NULL;
1748 }
1749 if (ctrl->domain_name)
1750 {
1751 free(ctrl->domain_name);
1752 ctrl->domain_name = NULL;
1753 }
1754 ctrl->dns_ip_cnt = 0;
1755 ctrl->dns_ip_nums = 0;
1756 ctrl->wait_target_state = NW_WAIT_NONE;
1757 }
1758
1759 void network_clean_invaild_socket(uint8_t adapter_index)
1760 {
1761 int i;
1762 int *list;
1763 network_adapter_t *adapter = &prv_adapter_table[adapter_index];
1764 network_ctrl_t *ctrl;
1765 list = malloc(adapter->opt->max_socket_num * sizeof(int));
1766 OS_LOCK;
1767 for (i = 0; i < adapter->opt->max_socket_num; i++)
1768 {
1769 ctrl = &adapter->ctrl_table[i];
1770 if (!adapter->opt->socket_check(ctrl->socket_id, ctrl->tag, adapter->user_data))
1771 {
1772 list[i] = ctrl->socket_id;
1773 }
1774 else
1775 {
1776 ctrl->socket_id = -1;
1777 list[i] = -1;
1778 }
1779 DBG("%d,%d", i, list[i]);
1780 }
1781 OS_UNLOCK;
1782 adapter->opt->socket_clean(list, adapter->opt->max_socket_num, adapter->user_data);
1783 free(list);
1784 }
1785
1786
1787 #ifdef LUAT_USE_TLS
1788 static int tls_verify(void *ctx, mbedtls_x509_crt *crt, int Index, uint32_t *result)
1789 {
1790 network_ctrl_t *ctrl = (network_ctrl_t *)ctx;
1791 DBG("%d, %08x", Index, *result);
1792 return 0;
1793 }
1794 #endif
1795 int network_set_psk_info(network_ctrl_t *ctrl,
1796 const unsigned char *psk, size_t psk_len,
1797 const unsigned char *psk_identity, size_t psk_identity_len)
1798 {
1799 #ifdef LUAT_USE_TLS
1800 if (!ctrl->tls_mode)
1801 {
1802 return -ERROR_PERMISSION_DENIED;
1803 }
1804
1805 // DBG("%.*s, %.*s", psk_len, psk, psk_identity_len, psk_identity);
1806 int ret = mbedtls_ssl_conf_psk( ctrl->config,
1807 psk, psk_len, psk_identity, psk_identity_len );
1808 if (ret != 0)
1809 {
1810 DBG("0x%x", -ret);
1811 return -ERROR_OPERATION_FAILED;
1812 }
1813 return ERROR_NONE;
1814 #else
1815 return -1;
1816 #endif
1817 }
1818
1819 int network_set_server_cert(network_ctrl_t *ctrl, const unsigned char *cert, size_t cert_len)
1820 {
1821 #ifdef LUAT_USE_TLS
1822 int ret;
1823 if (!ctrl->tls_mode)
1824 {
1825 return -ERROR_PERMISSION_DENIED;
1826 }
1827 ret = mbedtls_x509_crt_parse( ctrl->ca_cert, cert, cert_len);
1828 if (ret != 0)
1829 {
1830 DBG("%08x", -ret);
1831 return -ERROR_OPERATION_FAILED;
1832 }
1833
1834 return ERROR_NONE;
1835 #else
1836 return -1;
1837 #endif
1838 }
1839
1840 int network_set_client_cert(network_ctrl_t *ctrl,
1841 const unsigned char *cert, size_t certLen,
1842 const unsigned char *key, size_t keylen,
1843 const unsigned char *pwd, size_t pwdlen)
1844 {
1845 #ifdef LUAT_USE_TLS
1846 int ret;
1847 mbedtls_x509_crt *client_cert = NULL;
1848 mbedtls_pk_context *pkey = NULL;
1849 if (!ctrl->tls_mode)
1850 {
1851 return -ERROR_PERMISSION_DENIED;
1852 }
1853 client_cert = zalloc(sizeof(mbedtls_x509_crt));
1854 pkey = zalloc(sizeof(mbedtls_pk_context));
1855 if (!client_cert || !pkey)
1856 {
1857 goto ERROR_OUT;
1858 }
1859 ret = mbedtls_x509_crt_parse( client_cert, cert, certLen );
1860 if (ret != 0)
1861 {
1862 DBG("%08x", -ret);
1863 goto ERROR_OUT;
1864 }
1865 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
1866 ret = mbedtls_pk_parse_key( pkey, key, keylen, pwd, pwdlen , tls_random, NULL);
1867 #else
1868 ret = mbedtls_pk_parse_key( pkey, key, keylen, pwd, pwdlen );
1869 #endif
1870 if (ret != 0)
1871 {
1872 DBG("%08x", -ret);
1873 goto ERROR_OUT;
1874 }
1875 ret = mbedtls_ssl_conf_own_cert( ctrl->config, client_cert, pkey );
1876 if (ret != 0)
1877 {
1878 DBG("%08x", -ret);
1879 goto ERROR_OUT;
1880 }
1881 return ERROR_NONE;
1882 ERROR_OUT:
1883 if (client_cert) free(client_cert);
1884 if (pkey) free(pkey);
1885 return -1;
1886 #else
1887 return -1;
1888 #endif
1889 }
1890
1891 int network_cert_verify_result(network_ctrl_t *ctrl)
1892 {
1893 #ifdef LUAT_USE_TLS
1894 if (!ctrl->tls_mode)
1895 {
1896 return -1;
1897 }
1898 return mbedtls_ssl_get_verify_result(ctrl->ssl);
1899 #else
1900 return -1;
1901 #endif
1902 }
1903
1904 static int tls_random( void *p_rng,
1905 unsigned char *output, size_t output_len )
1906 {
1907 platform_random((char*)output, output_len);
1908 return 0;
1909 }
1910
1911 int network_init_tls(network_ctrl_t *ctrl, int verify_mode)
1912 {
1913 #ifdef LUAT_USE_TLS
1914 ctrl->tls_mode = 1;
1915 if (!ctrl->ssl)
1916 {
1917 ctrl->ssl = zalloc(sizeof(mbedtls_ssl_context));
1918 ctrl->ca_cert = zalloc(sizeof(mbedtls_x509_crt));
1919 ctrl->config = zalloc(sizeof(mbedtls_ssl_config));
1920 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);
1921 // ctrl->config->authmode = verify_mode;
1922 mbedtls_ssl_conf_authmode(ctrl->config, verify_mode);
1923 // ctrl->config->hs_timeout_min = 20000;
1924 #if defined(MBEDTLS_SSL_PROTO_DTLS)
1925 mbedtls_ssl_conf_handshake_timeout(ctrl->config, 2000, MBEDTLS_SSL_DTLS_TIMEOUT_DFL_MAX);
1926 #endif
1927 // ctrl->config->f_rng = tls_random;
1928 // ctrl->config->p_rng = NULL;
1929 mbedtls_ssl_conf_rng(ctrl->config, tls_random, NULL);
1930 // ctrl->config->f_dbg = tls_dbg;
1931 // ctrl->config->p_dbg = NULL;
1932 mbedtls_ssl_conf_dbg(ctrl->config, tls_dbg, NULL);
1933 // ctrl->config->f_vrfy = tls_verify;
1934 // ctrl->config->p_vrfy = ctrl;
1935 mbedtls_ssl_conf_verify(ctrl->config, tls_verify, ctrl);
1936 // ctrl->config->ca_chain = ctrl->ca_cert;
1937 mbedtls_ssl_conf_ca_chain(ctrl->config, ctrl->ca_cert, NULL);
1938 // ctrl->config->read_timeout = 20000;
1939 mbedtls_ssl_conf_read_timeout(ctrl->config, 20000);
1940 #ifdef MBEDTLS_SSL_RENEGOTIATION
1941 mbedtls_ssl_conf_renegotiation(ctrl->config, MBEDTLS_SSL_RENEGOTIATION_ENABLED);
1942 mbedtls_ssl_conf_legacy_renegotiation(ctrl->config, MBEDTLS_SSL_LEGACY_ALLOW_RENEGOTIATION);
1943 #endif
1944 ctrl->tls_long_timer = platform_create_timer(tls_longtimeout, ctrl, NULL);
1945 ctrl->tls_short_timer = platform_create_timer(tls_shorttimeout, ctrl, NULL);
1946 }
1947 ctrl->tls_timer_state = -1;
1948 return 0;
1949 #else
1950 DBG("NOT SUPPORT TLS");
1951 return -1;
1952 #endif
1953 }
1954
1955 void network_deinit_tls(network_ctrl_t *ctrl)
1956 {
1957 #ifdef LUAT_USE_TLS
1958 if (ctrl->ssl)
1959 {
1960 mbedtls_ssl_free(ctrl->ssl);
1961 free(ctrl->ssl);
1962 ctrl->ssl = NULL;
1963 }
1964
1965 if (ctrl->config)
1966 {
1967 mbedtls_ssl_config_free(ctrl->config);
1968 free(ctrl->config);
1969 ctrl->config = NULL;
1970 }
1971
1972 if (ctrl->ca_cert)
1973 {
1974 mbedtls_x509_crt_free(ctrl->ca_cert);
1975 free(ctrl->ca_cert);
1976 ctrl->ca_cert = NULL;
1977 }
1978
1979 ctrl->tls_mode = 0;
1980 ctrl->tls_timer_state = -1;
1981 if (ctrl->tls_short_timer)
1982 {
1983 platform_release_timer(ctrl->tls_short_timer);
1984 ctrl->tls_short_timer = NULL;
1985 }
1986 if (ctrl->tls_long_timer)
1987 {
1988 platform_release_timer(ctrl->tls_long_timer);
1989 ctrl->tls_long_timer = NULL;
1990 }
1991 #endif
1992 }
1993
1994 int network_wait_link_up(network_ctrl_t *ctrl, uint32_t timeout_ms)
1995 {
1996 NW_LOCK;
1997 ctrl->auto_mode = 1;
1998 // network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
1999 if (network_check_ready(ctrl, 0))
2000 {
2001 ctrl->state = NW_STATE_OFF_LINE;
2002 ctrl->wait_target_state = NW_WAIT_NONE;
2003 NW_UNLOCK;
2004 return 0;
2005 }
2006 ctrl->state = NW_STATE_LINK_OFF;
2007 ctrl->wait_target_state = NW_WAIT_LINK_UP;
2008
2009 NW_UNLOCK;
2010 if (!ctrl->task_handle || !timeout_ms)
2011 {
2012 return 1;
2013 }
2014 uint8_t finish = 0;
2015 OS_EVENT event;
2016 int result;
2017 //DBG_INFO("%s wait for active!,%u,%x", Net->Tag, To * SYS_TICK, Net->hTask);
2018
2019 platform_start_timer(ctrl->timer, timeout_ms, 0);
2020 while (!finish)
2021 {
2022 platform_wait_event(ctrl->task_handle, 0, &event, NULL, 0);
2023 switch (event.ID)
2024 {
2025 case EV_NW_RESULT_LINK:
2026 result = (int)event.Param1;
2027 finish = 1;
2028 break;
2029 case EV_NW_TIMEOUT:
2030 result = -1;
2031 finish = 1;
2032 break;
2033 default:
2034 if (ctrl->user_callback)
2035 {
2036 ctrl->user_callback((void *)&event, ctrl->user_data);
2037 }
2038 break;
2039 }
2040 }
2041 platform_stop_timer(ctrl->timer);
2042 return result;
2043 }
2044 /*
2045 * 1.进行ready检测和等待ready
2046 * 2.有remote_ip则开始连接服务器并等待连接结果
2047 * 3.没有remote_ip则开始对url进行dns解析，解析完成后对所有ip进行尝试连接直到有个成功或者全部失败
2048 * 4.如果是加密模式，还要走握手环节，等到握手环节完成后才能返回结果
2049 * local_port如果为0则api内部自动生成一个
2050 */
2051 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)
2052 {
2053 if (ctrl->socket_id >= 0)
2054 {
2055 return -1;
2056 }
2057
2058 NW_LOCK;
2059 ctrl->is_server_mode = 0;
2060 ctrl->tx_size = 0;
2061 ctrl->ack_size = 0;
2062 if (ctrl->dns_ip)
2063 {
2064 free(ctrl->dns_ip);
2065 ctrl->dns_ip = NULL;
2066 }
2067 if (ctrl->cache_data)
2068 {
2069 free(ctrl->cache_data);
2070 ctrl->cache_data = NULL;
2071 }
2072 ctrl->need_close = 0;
2073 if (ctrl->domain_name)
2074 {
2075 free(ctrl->domain_name);
2076 }
2077 ctrl->domain_name = zalloc(domain_name_len + 1);
2078 memcpy(ctrl->domain_name, domain_name, domain_name_len);
2079 ctrl->domain_name_len = domain_name_len;
2080 if (remote_ip)
2081 {
2082 ctrl->remote_ip = *remote_ip;
2083 }
2084 else
2085 {
2086 network_set_ip_invaild(&ctrl->remote_ip);
2087 }
2088 ctrl->auto_mode = 1;
2089 ctrl->remote_port = remote_port;
2090 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
2091 ctrl->wait_target_state = NW_WAIT_ON_LINE;
2092 if (!network_check_ready(ctrl, 0))
2093 {
2094
2095 ctrl->state = NW_STATE_LINK_OFF;
2096 goto NETWORK_CONNECT_WAIT;
2097 }
2098 if (network_prepare_connect(ctrl))
2099 {
2100 ctrl->state = NW_STATE_OFF_LINE;
2101 ctrl->wait_target_state = NW_WAIT_NONE;
2102 NW_UNLOCK;
2103 return -1;
2104 }
2105 NETWORK_CONNECT_WAIT:
2106 NW_UNLOCK;
2107 if (!ctrl->task_handle || !timeout_ms)
2108 {
2109
2110 return 1;
2111 }
2112 uint8_t finish = 0;
2113 OS_EVENT event = {0};
2114 int result;
2115 //DBG_INFO("%s wait for active!,%u,%x", Net->Tag, To * SYS_TICK, Net->hTask);
2116
2117 platform_start_timer(ctrl->timer, timeout_ms, 0);
2118 while (!finish)
2119 {
2120 platform_wait_event(ctrl->task_handle, 0, &event, NULL, 0);
2121 switch (event.ID)
2122 {
2123 case EV_NW_RESULT_CONNECT:
2124 result = (int)event.Param1;
2125 finish = 1;
2126 break;
2127 case EV_NW_TIMEOUT:
2128 result = -1;
2129 finish = 1;
2130 break;
2131 default:
2132 if (ctrl->user_callback)
2133 {
2134 ctrl->user_callback((void *)&event, ctrl->user_data);
2135 }
2136 break;
2137 }
2138 }
2139 platform_stop_timer(ctrl->timer);
2140 return result;
2141 }
2142
2143 int network_listen(network_ctrl_t *ctrl, uint32_t timeout_ms)
2144 {
2145 if (NW_STATE_LISTEN == ctrl->state)
2146 {
2147 DBG("socket %d is listen", ctrl->socket_id);
2148 return 0;
2149 }
2150 if (ctrl->socket_id >= 0)
2151 {
2152 return -1;
2153 }
2154 NW_LOCK;
2155 ctrl->is_server_mode = 1;
2156 ctrl->auto_mode = 1;
2157 ctrl->need_close = 0;
2158 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
2159 ctrl->wait_target_state = NW_WAIT_ON_LINE;
2160 if (!network_check_ready(ctrl, 0))
2161 {
2162
2163 ctrl->state = NW_STATE_LINK_OFF;
2164 goto NETWORK_LISTEN_WAIT;
2165 }
2166 if (network_base_connect(ctrl, NULL))
2167 {
2168 ctrl->state = NW_STATE_OFF_LINE;
2169 ctrl->wait_target_state = NW_WAIT_NONE;
2170 NW_UNLOCK;
2171 return -1;
2172 }
2173 ctrl->state = NW_STATE_CONNECTING;
2174 NETWORK_LISTEN_WAIT:
2175 NW_UNLOCK;
2176 if (!ctrl->task_handle || !timeout_ms)
2177 {
2178
2179 return 1;
2180 }
2181 uint8_t finish = 0;
2182 OS_EVENT event;
2183 int result;
2184 //DBG_INFO("%s wait for active!,%u,%x", Net->Tag, To * SYS_TICK, Net->hTask);
2185
2186 if (timeout_ms != 0xffffffff)
2187 {
2188 platform_start_timer(ctrl->timer, timeout_ms, 0);
2189 }
2190 while (!finish)
2191 {
2192 platform_wait_event(ctrl->task_handle, 0, &event, NULL, 0);
2193 switch (event.ID)
2194 {
2195 case EV_NW_RESULT_CONNECT:
2196 result = (int)event.Param1;
2197 finish = 1;
2198 break;
2199 case EV_NW_TIMEOUT:
2200 result = -1;
2201 finish = 1;
2202 break;
2203 default:
2204 if (ctrl->user_callback)
2205 {
2206 ctrl->user_callback((void *)&event, ctrl->user_data);
2207 }
2208 break;
2209 }
2210 }
2211 if (timeout_ms != 0xffffffff)
2212 {
2213 platform_stop_timer(ctrl->timer);
2214 }
2215 return result;
2216 }
2217
2218 int network_close(network_ctrl_t *ctrl, uint32_t timeout_ms)
2219 {
2220 NW_LOCK;
2221 if (ctrl->cache_data)
2222 {
2223 free(ctrl->cache_data);
2224 ctrl->cache_data = NULL;
2225 }
2226 uint8_t old_state = ctrl->state;
2227 ctrl->auto_mode = 1;
2228 ctrl->need_close = 0;
2229 ctrl->new_rx_flag = 0;
2230 network_adapter_t *adapter = &prv_adapter_table[ctrl->adapter_index];
2231 #ifdef LUAT_USE_TLS
2232 if (ctrl->tls_mode)
2233 {
2234 mbedtls_ssl_free(ctrl->ssl);
2235 }
2236 #endif
2237 if (ctrl->socket_id < 0)
2238 {
2239
2240 ctrl->state = NW_STATE_OFF_LINE;
2241 ctrl->wait_target_state = NW_WAIT_NONE;
2242 NW_UNLOCK;
2243 return 0;
2244 }
2245
2246 ctrl->state = NW_STATE_DISCONNECTING;
2247 ctrl->wait_target_state = NW_WAIT_OFF_LINE;
2248
2249 if ((NW_STATE_ONLINE == old_state) && ctrl->is_tcp)
2250 {
2251 if (network_socket_disconnect(ctrl))
2252 {
2253 network_force_close_socket(ctrl);
2254 ctrl->state = NW_STATE_OFF_LINE;
2255 ctrl->wait_target_state = NW_WAIT_NONE;
2256 NW_UNLOCK;
2257 return 0;
2258 }
2259 }
2260 else
2261 {
2262 network_force_close_socket(ctrl);
2263 ctrl->state = NW_STATE_OFF_LINE;
2264 ctrl->wait_target_state = NW_WAIT_NONE;
2265 NW_UNLOCK;
2266 return 0;
2267 }
2268 NW_UNLOCK;
2269 if (!ctrl->task_handle || !timeout_ms)
2270 {
2271 return 1;
2272 }
2273 uint8_t finish = 0;
2274 OS_EVENT event;
2275 int result;
2276 //DBG_INFO("%s wait for active!,%u,%x", Net->Tag, To * SYS_TICK, Net->hTask);
2277
2278 platform_start_timer(ctrl->timer, timeout_ms, 0);
2279 while (!finish)
2280 {
2281 platform_wait_event(ctrl->task_handle, 0, &event, NULL, 0);
2282 switch (event.ID)
2283 {
2284 case EV_NW_RESULT_CLOSE:
2285 result = 0;
2286 finish = 1;
2287 break;
2288 case EV_NW_TIMEOUT:
2289 result = 0;
2290 finish = 1;
2291 break;
2292 default:
2293 if (ctrl->user_callback)
2294 {
2295 ctrl->user_callback((void *)&event, ctrl->user_data);
2296 }
2297 break;
2298 }
2299 }
2300 platform_stop_timer(ctrl->timer);
2301 network_socket_force_close(ctrl);
2302 return result;
2303 }
2304 /*
2305 * timeout_ms=0时，为非阻塞接口
2306 */
2307 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)
2308 {
2309 if ((ctrl->need_close) || (ctrl->socket_id < 0) || (ctrl->state != NW_STATE_ONLINE))
2310 {
2311 return -1;
2312 }
2313 NW_LOCK;
2314 int result;
2315
2316 ctrl->auto_mode = 1;
2317 #ifdef LUAT_USE_TLS
2318 if (ctrl->tls_mode)
2319 {
2320 if (ctrl->tls_need_reshakehand)
2321 {
2322 ctrl->tls_need_reshakehand = 0;
2323 if (ctrl->cache_data)
2324 {
2325 free(ctrl->cache_data);
2326 ctrl->cache_data = NULL;
2327 }
2328 ctrl->cache_data = malloc(len);
2329 memcpy(ctrl->cache_data, data, len);
2330 ctrl->cache_len = len;
2331 mbedtls_ssl_session_reset(ctrl->ssl);
2332 do
2333 {
2334 result = mbedtls_ssl_handshake_step( ctrl->ssl );
2335 switch(result)
2336 {
2337 case MBEDTLS_ERR_SSL_WANT_READ:
2338 ctrl->state = NW_STATE_SHAKEHAND;
2339 goto NETWORK_TX_WAIT;
2340 case 0:
2341 break;
2342 default:
2343 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
2344 #else
2345 DBG_ERR("0x%x, %d", -result, ctrl->ssl->state);
2346 #endif
2347 ctrl->need_close = 1;
2348 NW_UNLOCK;
2349 return -1;
2350 }
2351 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
2352 }while(!mbedtls_ssl_is_handshake_over(ctrl->ssl));
2353 #else
2354 }while(ctrl->ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER);
2355 #endif
2356 }
2357
2358 uint32_t done = 0;
2359 while(done < len)
2360 {
2361 result = mbedtls_ssl_write(ctrl->ssl, data + done, len - done);
2362 if (result < 0)
2363 {
2364 DBG("%08x", -result);
2365 ctrl->need_close = 1;
2366 NW_UNLOCK;
2367 return -1;
2368 }
2369 done += result;
2370 }
2371 if (tx_len)
2372 *tx_len = done;
2373 }
2374 else
2375 #endif
2376 {
2377 result = network_base_tx(ctrl, data, len, flags, remote_ip, remote_port);
2378 if (result < 0)
2379 {
2380 ctrl->need_close = 1;
2381 NW_UNLOCK;
2382 return -1;
2383 }
2384 if (tx_len)
2385 *tx_len = result;
2386 if (!result && len)
2387 {
2388 NW_UNLOCK;
2389 return 0;
2390 }
2391 }
2392 #ifdef LUAT_USE_TLS
2393 NETWORK_TX_WAIT:
2394 #endif
2395 ctrl->wait_target_state = NW_WAIT_TX_OK;
2396 NW_UNLOCK;
2397
2398 if (!ctrl->task_handle || !timeout_ms)
2399 {
2400 return 1;
2401 }
2402 uint8_t finish = 0;
2403 OS_EVENT event;
2404 //DBG_INFO("%s wait for active!,%u,%x", Net->Tag, To * SYS_TICK, Net->hTask);
2405
2406 platform_start_timer(ctrl->timer, timeout_ms, 0);
2407 while (!finish)
2408 {
2409 platform_wait_event(ctrl->task_handle, 0, &event, NULL, 0);
2410 switch (event.ID)
2411 {
2412 case EV_NW_RESULT_TX:
2413 result = (int)event.Param1;
2414 finish = 1;
2415 break;
2416 case EV_NW_TIMEOUT:
2417 result = -1;
2418 finish = 1;
2419 break;
2420 default:
2421 if (ctrl->user_callback)
2422 {
2423 ctrl->user_callback((void *)&event, ctrl->user_data);
2424 }
2425 break;
2426 }
2427 }
2428 platform_stop_timer(ctrl->timer);
2429 return result;
2430 }
2431 /*
2432 * 实际读到的数据量在rx_len里，如果是UDP模式且为server时，需要看remote_ip和remote_port
2433 */
2434 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)
2435 {
2436 if (((ctrl->need_close && !ctrl->new_rx_flag) || (ctrl->socket_id < 0) || (ctrl->state != NW_STATE_ONLINE)))
2437 {
2438 return -1;
2439 }
2440 NW_LOCK;
2441 int result = -1;
2442 ctrl->auto_mode = 1;
2443 uint32_t read_len = 0;
2444 uint8_t is_error = 0;
2445
2446
2447 if (data)
2448 {
2449 ctrl->new_rx_flag = 0;
2450 #ifdef LUAT_USE_TLS
2451 if (ctrl->tls_mode)
2452 {
2453
2454 do
2455 {
2456 result = mbedtls_ssl_read(ctrl->ssl, data + read_len, len - read_len);
2457 if (result < 0 && (result != MBEDTLS_ERR_SSL_WANT_READ))
2458 {
2459 is_error = 1;
2460 break;
2461 }
2462 else if (result > 0)
2463 {
2464 read_len += result;
2465 if (read_len >= len)
2466 {
2467 break;
2468 }
2469 }
2470 else
2471 {
2472 break;
2473 }
2474 }while(network_socket_receive(ctrl, NULL, len, flags, remote_ip, remote_port) > 0);
2475
2476 if ( !is_error )
2477 {
2478 result = read_len;
2479 }
2480 else
2481 {
2482 result = -1;
2483 }
2484 }
2485 else
2486 #endif
2487 {
2488
2489 result = network_socket_receive(ctrl, data, len, flags, remote_ip, remote_port);
2490 }
2491 }
2492 else
2493 {
2494 #ifdef LUAT_USE_TLS
2495 if (ctrl->tls_mode)
2496 {
2497 read_len = 0;
2498 do
2499 {
2500 result = mbedtls_ssl_read(ctrl->ssl, NULL, 0);
2501 if ((result < 0) && (result != (MBEDTLS_ERR_SSL_WANT_READ)))
2502 {
2503 is_error = 1;
2504 read_len = 0;
2505 break;
2506 }
2507 else if (!result)
2508 {
2509 #if MBEDTLS_VERSION_NUMBER >= 0x03000000
2510 read_len = ctrl->ssl->MBEDTLS_PRIVATE(in_msglen);
2511 #else
2512 read_len = ctrl->ssl->in_msglen;
2513 #endif
2514 break;
2515 }
2516 else if ((MBEDTLS_ERR_SSL_WANT_READ) == result)
2517 {
2518 read_len = 0;
2519 ctrl->new_rx_flag = 0;
2520 DBG("socket %d ssl data need more", ctrl->socket_id);
2521 break;
2522 }
2523 }while(network_socket_receive(ctrl, NULL, len, flags, remote_ip, remote_port) > 0);
2524
2525 if ( !is_error )
2526 {
2527 result = read_len;
2528 }
2529 else
2530 {
2531 result = -1;
2532 }
2533 }
2534 else
2535 #endif
2536 {
2537 result = network_socket_receive(ctrl, data, len, flags, remote_ip, remote_port);
2538 }
2539 }
2540
2541
2542 NW_UNLOCK;
2543 if (result >= 0)
2544 {
2545 *rx_len = result;
2546 return 0;
2547 }
2548 else
2549 {
2550 return -1;
2551 }
2552 }
2553
2554 int network_wait_event(network_ctrl_t *ctrl, OS_EVENT *out_event, uint32_t timeout_ms, uint8_t *is_timeout)
2555 {
2556 if (ctrl->new_rx_flag)
2557 {
2558 ctrl->wait_target_state = NW_WAIT_EVENT;
2559 if (out_event)
2560 {
2561 out_event->ID = 0;
2562 }
2563 return 0;
2564 }
2565 if ((ctrl->need_close) || (ctrl->socket_id < 0) || (ctrl->state != NW_STATE_ONLINE))
2566 {
2567 return -1;
2568 }
2569 NW_LOCK;
2570 ctrl->auto_mode = 1;
2571 ctrl->wait_target_state = NW_WAIT_EVENT;
2572 NW_UNLOCK;
2573 if (!ctrl->task_handle || !timeout_ms)
2574 {
2575 return 1;
2576 }
2577 *is_timeout = 0;
2578 uint8_t finish = 0;
2579 OS_EVENT event;
2580 int result;
2581 //DBG_INFO("%s wait for active!,%u,%x", Net->Tag, To * SYS_TICK, Net->hTask);
2582
2583 platform_start_timer(ctrl->timer, timeout_ms, 0);
2584 while (!finish)
2585 {
2586 platform_wait_event(ctrl->task_handle, 0, &event, NULL, 0);
2587 switch (event.ID)
2588 {
2589 case EV_NW_RESULT_EVENT:
2590 result = (int)event.Param1;
2591 if (result)
2592 {
2593 result = -1;
2594 }
2595 if (out_event)
2596 {
2597 out_event->ID = 0;
2598 }
2599 finish = 1;
2600 break;
2601 case EV_NW_TIMEOUT:
2602 *is_timeout = 1;
2603 result = 0;
2604 finish = 1;
2605 break;
2606 case EV_NW_BREAK_WAIT:
2607 if (out_event)
2608 {
2609 *out_event = event;
2610 }
2611 result = 0;
2612 finish = 1;
2613 break;
2614 default:
2615 if (out_event)
2616 {
2617 *out_event = event;
2618 result = 0;
2619 finish = 1;
2620 break;
2621 }
2622 else if (ctrl->user_callback)
2623 {
2624 ctrl->user_callback((void *)&event, ctrl->user_data);
2625 }
2626 break;
2627 }
2628 }
2629 platform_stop_timer(ctrl->timer);
2630 return result;
2631 }
2632
2633 int network_wait_rx(network_ctrl_t *ctrl, uint32_t timeout_ms, uint8_t *is_break, uint8_t *is_timeout)
2634 {
2635 *is_timeout = 0;
2636 *is_break = 0;
2637 if (ctrl->new_rx_flag)
2638 {
2639 ctrl->wait_target_state = NW_WAIT_EVENT;
2640 return 0;
2641 }
2642 if ((ctrl->need_close) || (ctrl->socket_id < 0) || (ctrl->state != NW_STATE_ONLINE))
2643 {
2644 return -1;
2645 }
2646 NW_LOCK;
2647 ctrl->auto_mode = 1;
2648 ctrl->wait_target_state = NW_WAIT_EVENT;
2649 NW_UNLOCK;
2650
2651 uint8_t finish = 0;
2652 OS_EVENT event;
2653 int result;
2654 //DBG_INFO("%s wait for active!,%u,%x", Net->Tag, To * SYS_TICK, Net->hTask);
2655 if (timeout_ms)
2656 {
2657 platform_start_timer(ctrl->timer, timeout_ms, 0);
2658 }
2659 while (!finish)
2660 {
2661 platform_wait_event(ctrl->task_handle, 0, &event, NULL, 0);
2662 switch (event.ID)
2663 {
2664 case EV_NW_RESULT_EVENT:
2665 result = (int)event.Param1;
2666 if (result)
2667 {
2668 result = -1;
2669 finish = 1;
2670 }
2671 else if (ctrl->new_rx_flag)
2672 {
2673 result = 0;
2674 finish = 1;
2675 }
2676 break;
2677 case EV_NW_TIMEOUT:
2678 *is_timeout = 1;
2679 result = 0;
2680 finish = 1;
2681 break;
2682 case EV_NW_BREAK_WAIT:
2683 *is_break = 1;
2684 result = 0;
2685 finish = 1;
2686 break;
2687 default:
2688 if (ctrl->user_callback)
2689 {
2690 ctrl->user_callback((void *)&event, ctrl->user_data);
2691 }
2692 break;
2693 }
2694 ctrl->wait_target_state = NW_WAIT_EVENT;
2695 }
2696 platform_stop_timer(ctrl->timer);
2697 return result;
2698 }
2699
2700 uint8_t network_check_ready(network_ctrl_t *ctrl, uint8_t adapter_index)
2701 {
2702 network_adapter_t *adapter;
2703 if (ctrl)
2704 {
2705 adapter = &prv_adapter_table[ctrl->adapter_index];
2706 }
2707 else if (adapter_index < NW_ADAPTER_QTY)
2708 {
2709 adapter = &prv_adapter_table[adapter_index];
2710 }
2711 else
2712 {
2713 return 0;
2714 }
2715 if (adapter->opt)
2716 {
2717 return adapter->opt->check_ready(adapter->user_data);
2718 }
2719 else
2720 {
2721 return 0;
2722 }
2723 }
2724
2725 //将IP设置成无效状态
2726 void network_set_ip_invaild(luat_ip_addr_t *ip)
2727 {
2728 #ifdef LUAT_USE_LWIP
2729 #if LWIP_IPV6
2730 ip->type = 0xff;
2731 #else
2732 ip->addr = 0;
2733 #endif
2734 #else
2735 ip->is_ipv6 = 0xff;
2736 #endif
2737 }
2738 //检测IP是不是无效的，无效返回0
2739 uint8_t network_ip_is_vaild(luat_ip_addr_t *ip)
2740 {
2741 #ifdef LUAT_USE_LWIP
2742 #if LWIP_IPV6
2743 return (ip->type != 0xff);
2744 #else
2745 return (ip->addr != 0);
2746 #endif
2747 #else
2748 return (ip->is_ipv6 != 0xff);
2749 #endif
2750 }
2751
2752 uint8_t network_ip_is_ipv6(luat_ip_addr_t *ip)
2753 {
2754 #ifdef LUAT_USE_LWIP
2755 #if LWIP_IPV6
2756 return (IPADDR_TYPE_V6 == ip->type);
2757 #else
2758 return 0;
2759 #endif
2760 #else
2761 return (ip->is_ipv6 && (ip->is_ipv6 != 0xff));
2762 #endif
2763 }
2764
2765 //检测IP是不是有效的IPV4类型，不是返回0
2766 uint8_t network_ip_is_vaild_ipv4(luat_ip_addr_t *ip)
2767 {
2768 #ifdef LUAT_USE_LWIP
2769 #if LWIP_IPV6
2770 return (IPADDR_TYPE_V4 == ip->type);
2771 #else
2772 return (ip->addr != 0);
2773 #endif
2774 #else
2775 return !ip->is_ipv6;
2776 #endif
2777 }
2778
2779 void network_set_ip_ipv4(luat_ip_addr_t *ip, uint32_t ipv4)
2780 {
2781 #ifdef LUAT_USE_LWIP
2782 #if LWIP_IPV6
2783 ip->type = IPADDR_TYPE_V4;
2784 ip->u_addr.ip4.addr = ipv4;
2785 #else
2786 ip->addr = ipv4;
2787 #endif
2788 #else
2789 ip->is_ipv6 = 0;
2790 ip->ipv4 = ipv4;
2791 #endif
2792 }
2793 #endif