经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » 程序设计 » 编程经验 » 查看文章
【lwip】15-NETCONN接口
来源:cnblogs  作者:李柱明  时间:2023/5/30 12:46:31  对本文有异议

前言

终于到接口层了。

原文:李柱明博客:https://www.cnblogs.com/lizhuming/p/17442931.html

?

框架描述

前面我们已经学完了,都知道raw接口了,其实也可以直接用,就是麻烦点。

这里NETCONN就是封装了raw接口,让用户使用更加简单。

socket接口是封装NETconn接口的,让用户使用更加标准,方便应用程序移植。

?

NETCONN的接口框架:

解耦:编写回调函数xxx_tcp()、xxx_udp(),注册到协议栈里面。协议栈通过回调函数告知接口层,当前PCB的状态信息。接口层根据当前PCB的状态信息做相应处理即可。

?

文件:

  • api_msg.c?:构建api msg,被netconn调用,发送到内核锁或tcpip内核线程执行指定的回调函数。
  • api_lib.c?:netconn API。
  • sockets.c?:socket套接字接口层,封装netconn接口。供用户使用。

?

NETCONN重要组成

内核回调接口

在raw/callback API编程时,用户编程的方法就是向内核注册各种自定义的回调函数,回调函数是与内核实现交互的唯一方式

协议栈API NETCONN是基于raw/callback API实现的。

?

内核通过调用注册到TCP/UDP内核的回调函数,把接收到的数据或可发送数据的事件发送回netconn对应的邮箱中,上层检查这些邮箱即可和内核协议栈交互。

netbuf:数据缓冲

netbuf是应用层描述待发送数据和已接收数据的基本结构。当然,最基本的粒度数据结构还是pbuf。

应用层接收数据:

  • 当协议栈收到数据包后,会将数据封装在一个netbuf?中,并递交给应用层。

应用层发送数据:

  • TCP:用户只需要提供待发数据的起始地址和长度,内核会根据实际情况封装在合适大小的数据包中。
  • UDP:需要用户自行将数据封装在netbuf??结构中。

?

netbuf数据结构:

  1. /** "Network buffer" - contains data and addressing info */
  2. struct netbuf {
  3. struct pbuf *p, *ptr; /* 包缓冲区。p:pbuf链。ptr:pbuf链中当前pbuf游标。 */
  4. ip_addr_t addr; /* 发送方IP */
  5. u16_t port; /* 发送方端口 */
  6. #if LWIP_NETBUF_RECVINFO || LWIP_CHECKSUM_ON_COPY
  7. u8_t flags; /* 标志位 */
  8. u16_t toport_chksum; /* 目的端口号。用于checksum */
  9. #if LWIP_NETBUF_RECVINFO
  10. ip_addr_t toaddr; /* 目的地址 */
  11. #endif /* LWIP_NETBUF_RECVINFO */
  12. #endif /* LWIP_NETBUF_RECVINFO || LWIP_CHECKSUM_ON_COPY */
  13. };

?

netconn:接口数据结构

代表一个连接,TCP或UDP等。

相关文件:api.h

分析完UDP和TCP协议实现后,会分析他们的原生接口udp_xxx()和tcp_xxx()都是互相独立的。

而连接结构netconn就是为了统一这些接口。

?

netconn控制块:

  1. /** A netconn descriptor */
  2. struct netconn {
  3. /** type of the netconn (TCP, UDP or RAW) */
  4. enum netconn_type type; /* 连接类型 */
  5. enum netconn_state state; /* netconn当前状态。即是当前netconn被哪些netconn API占用 */
  6. union {
  7. struct ip_pcb *ip; /* IP控制块 */
  8. struct tcp_pcb *tcp; /* TCP控制块 */
  9. struct udp_pcb *udp; /* UDP控制块 */
  10. struct raw_pcb *raw; /* TCP控制块 */
  11. } pcb; /* 内核中与连接相关的控制块指针 */
  12. /* 此netconn的最新未报告的异步错误 */
  13. err_t pending_err;
  14. #if !LWIP_NETCONN_SEM_PER_THREAD /* 只能每个netconn数据结构占用一个信号量 */
  15. /* 信号量。是对一个API完成两部分线程的同步。如用户调用API,API调用内核API,并等待内核API完成后通过该信号量通知当前API。 */
  16. sys_sem_t op_completed;
  17. #endif
  18. /* 接收数据的邮箱。数据缓冲队列。 */
  19. sys_mbox_t recvmbox;
  20. #if LWIP_TCP
  21. /* 用于TCP服务器端。连接请求的缓冲队列。 */
  22. sys_mbox_t acceptmbox;
  23. #endif /* LWIP_TCP */
  24. #if LWIP_NETCONN_FULLDUPLEX /* 全功率 */
  25. /* mbox的读阻塞线程数。当线程在waiting时closing,需要解除所有线程的阻塞。 */
  26. int mbox_threads_waiting;
  27. #endif
  28. union {
  29. int socket; /* socket */
  30. void *ptr; /* 指针 */
  31. } callback_arg; /* 回调参数 */
  32. #if LWIP_SO_SNDTIMEO /* 发送超时 */
  33. /* 等待发送数据超时值,单位ms。 */
  34. s32_t send_timeout;
  35. #endif /* LWIP_SO_RCVTIMEO */
  36. #if LWIP_SO_RCVTIMEO /* 接收超时 */
  37. /* 等待接收新数据的超时时间,单位ms。 */
  38. u32_t recv_timeout;
  39. #endif /* LWIP_SO_RCVTIMEO */
  40. #if LWIP_SO_RCVBUF /* 接收缓冲区 */
  41. /* 应用层的接收缓冲区size。限制recvmbox上所有数据的size。 */
  42. int recv_bufsize;
  43. /* recvmbox 当前接收到的数据size,用于FIONREAD。 */
  44. int recv_avail;
  45. #endif /* LWIP_SO_RCVBUF */
  46. #if LWIP_SO_LINGER /* SO_LINGER选项 */
  47. /* < 0: 关闭该功能。
  48. = 0: 立即关闭。发送缓冲区残留有数据时,RST给对端。
  49. > 0: 超时值。单位:秒。超时前尽量把发送缓冲区中的数据发送出去。 */
  50. s16_t linger;
  51. #endif /* LWIP_SO_LINGER */
  52. /* 包含更多的netconn-internal状态。参考NETCONN_FLAG_x宏 */
  53. u8_t flags;
  54. #if LWIP_TCP
  55. /* 当调用netconn_write()函数发送的数据不适合发送到缓冲区时,
  56. 数据会暂时存储在current_msg中,等待数据合适的时候进行发送。 */
  57. struct api_msg *current_msg;
  58. #endif /* LWIP_TCP */
  59. /* netconn相关的回调函数。socket API时使用。 */
  60. netconn_callback callback;
  61. };

部分变量描述:

  • type?:连接类型:TCP、UDP、RAW。
  • state?:当前连接状态。
  • pcb?:协议栈内核连接控制块:TCP控制块、UDP控制块等等。
  • err?:记录当前连接上函数调用的执行结果。
  • op_completed?:是上下两部分API实现同步的重要字段,netconn_xxx()?函数在投递完消息后,便会阻塞在连接的这个信号量上,当内核的do_xxx()?执行完成后便释放信号量。
  • recvmbox?:该连接的数据接收邮箱,也是缓冲队列。内核接收到属于该连接的数据包(封装在netbuf中)投递到该邮箱。应用程序调用数据接收函数,就是从该队列中读取数据。
  • recv_avail?:记录当前接收邮箱中已经缓冲好的数据总长度。
  • acceptmbox?:该连接作为TCP服务器时使用到,内核会把所有新建立好的连接结构netconn?投递到该邮箱,服务器程序调用netconn_accept()?函数便会得到一个新的连接结构。
  • mbox_threads_waiting?:表示读阻塞在当前连接的应用程序数量,在关闭连接时,需要往recvmbox?邮箱发送mbox_threads_waiting?个邮件来解除这些应用层的阻塞。

?

NETCONN支持的协议类型

  1. /** @ingroup netconn_common
  2. * 协议族和netconn类型。
  3. *
  4. */
  5. enum netconn_type {
  6. NETCONN_INVALID = 0, /* 无效类型 */
  7. /** TCP IPv4 */
  8. NETCONN_TCP = 0x10,
  9. #if LWIP_IPV6
  10. /** TCP IPv6 */
  11. NETCONN_TCP_IPV6 = NETCONN_TCP | NETCONN_TYPE_IPV6 /* 0x18 */,
  12. #endif /* LWIP_IPV6 */
  13. /** UDP IPv4 */
  14. NETCONN_UDP = 0x20,
  15. /** UDP IPv4 lite */
  16. NETCONN_UDPLITE = 0x21,
  17. /** UDP IPv4 no checksum */
  18. NETCONN_UDPNOCHKSUM = 0x22,
  19. #if LWIP_IPV6
  20. /** UDP IPv6 (dual-stack by default, unless you call @ref netconn_set_ipv6only) */
  21. NETCONN_UDP_IPV6 = NETCONN_UDP | NETCONN_TYPE_IPV6 /* 0x28 */,
  22. /** UDP IPv6 lite (dual-stack by default, unless you call @ref netconn_set_ipv6only) */
  23. NETCONN_UDPLITE_IPV6 = NETCONN_UDPLITE | NETCONN_TYPE_IPV6 /* 0x29 */,
  24. /** UDP IPv6 no checksum (dual-stack by default, unless you call @ref netconn_set_ipv6only) */
  25. NETCONN_UDPNOCHKSUM_IPV6 = NETCONN_UDPNOCHKSUM | NETCONN_TYPE_IPV6 /* 0x2a */,
  26. #endif /* LWIP_IPV6 */
  27. /** Raw connection IPv4 */
  28. /* RAW ipv4 连接 */
  29. NETCONN_RAW = 0x40
  30. #if LWIP_IPV6
  31. /** Raw connection IPv6 (dual-stack by default, unless you call @ref netconn_set_ipv6only) */
  32. , NETCONN_RAW_IPV6 = NETCONN_RAW | NETCONN_TYPE_IPV6 /* 0x48 */
  33. #endif /* LWIP_IPV6 */
  34. };

?

NETCONN状态

  1. /* 当前netconn接口数据结构所处的状态。
  2. 如当前netconn被netconn_write()接口调用,就处于WRITE状态。
  3. 也可以理解为当前netconn被哪些netconn API占用 */
  4. enum netconn_state {
  5. NETCONN_NONE, /* 空闲状态 */
  6. NETCONN_WRITE, /* 正在发送数据 */
  7. NETCONN_LISTEN, /* 侦听状态 */
  8. NETCONN_CONNECT, /* 连接状态 */
  9. NETCONN_CLOSE /* 关闭状态 */
  10. };

?

NETCONN北向事件

上层收:按次数统计。NETCONN中有多少个可被上层接收。

上层发:按是否有无统计。NETCONN中是否可写。

  1. /*
  2. * netconn_x()API 通知更上层(如socket)的事件。
  3. *
  4. * 事件说明:
  5. * 在netconn实现中,有三种方法来阻塞客户端:
  6. * - accept mbox:netconn_accept()函数中的sys_arch_mbox_fetch()
  7. * - receive mbox:netconn_recv_data()函数中的sys_arch_mbox_fetch()
  8. * - send queue if full:lwip_netconn_do_write()函数中的sys_arch_sem_wait()
  9. *
  10. * 这些事件都是给这些mboxes/semaphores标记状态的事件。
  11. * 对于非阻塞式的连接,我们可以通过这些事件,提前知道调用netconn API是否会阻塞。
  12. *
  13. * NETCONN_EVT_RCVPLUS: 加。mboxes/semaphores 对象,可安全调用相关netconn API不会被阻塞的次数+1。
  14. * 如在sockets中是按次计数:如accept mbox连续收到三个NETCONN_EVT_RCVPLUS事件,
  15. * 则可以连续三次调用netconn_accept()不会被阻塞。receive mbox也一样。
  16. *
  17. * NETCONN_EVT_RCVMINUS: 减。mboxes/semaphores 对象,可安全调用相关netconn API不会被阻塞的次数-1。
  18. * 一般在调用对应函数成功后,统计一次。
  19. *
  20. * 而对于TX,没有次数统计,只是一个标志。
  21. *
  22. * NETCONN_EVT_SENDPLUS: 表示调用netconn_send()发送数据不会阻塞。
  23. * 一般发生在发送缓冲区中的数据被ACK了,缓冲区空闲空间增加时会回调该事件到上层。
  24. *
  25. * NETCONN_EVT_SENDMINUS: 表示调用netconn_send()会阻塞。
  26. * 一般发生在协议栈内部PCB不可发送数据时会通过该事件通知上层,此时调用netconn_send()会阻塞,如发送缓冲区不足,内存不足等等。
  27. * 触发该事件后,内部PCB会在pcb->poll()函数会检查PCB是否可发送数据,如果可发,就会触发NETCONN_EVT_SENDPLUS事件通知上层。
  28. *
  29. */
  30. enum netconn_evt {
  31. NETCONN_EVT_RCVPLUS, /* 收到数据。可安全调用API不会被阻塞次数+1 */
  32. NETCONN_EVT_RCVMINUS, /* 可安全调用API不会被阻塞次数-1 */
  33. NETCONN_EVT_SENDPLUS, /* PCB可发送数据事件 */
  34. NETCONN_EVT_SENDMINUS,/* PCB不可发送事件 */
  35. NETCONN_EVT_ERROR /* 错误事件 */
  36. };

?

?

NETBUF相关接口

前提实现可以自行看源码。

netbuf?操作接口:

  1. /* Network buffer functions: */
  2. struct netbuf * netbuf_new (void);
  3. void netbuf_delete (struct netbuf *buf);
  4. void * netbuf_alloc (struct netbuf *buf, u16_t size);
  5. void netbuf_free (struct netbuf *buf);
  6. err_t netbuf_ref (struct netbuf *buf,
  7. const void *dataptr, u16_t size);
  8. void netbuf_chain (struct netbuf *head, struct netbuf *tail);
  9. err_t netbuf_data (struct netbuf *buf,
  10. void **dataptr, u16_t *len);
  11. s8_t netbuf_next (struct netbuf *buf);
  12. void netbuf_first (struct netbuf *buf);

?

?

内核回调接口

在学完TCP、UDP内核实现后,就知道我们需要往这些内核里注册回调函数,用于内核和上层交互。如tcp的tcp_recv()?就是往内核注册接收回调函数。

所以在实现NETCONN接口时,需要编写这些回调函数,并注册到内核中。

?

注册NETCONN相关回调到内核

TCP:setup_tcp()?:

  1. /**
  2. * 注册netconn tcp基础接口相关的回调到TCP层
  3. *
  4. */
  5. static void
  6. setup_tcp(struct netconn *conn)
  7. {
  8. struct tcp_pcb *pcb;
  9. pcb = conn->pcb.tcp;
  10. tcp_arg(pcb, conn); // PCB绑定NETCONN接口控制块
  11. tcp_recv(pcb, recv_tcp); // 注册接收回调
  12. tcp_sent(pcb, sent_tcp); // 注册发送回调
  13. tcp_poll(pcb, poll_tcp, NETCONN_TCP_POLL_INTERVAL); // 注册poll
  14. tcp_err(pcb, err_tcp); // 注册异常回调
  15. }

?

recv_tcp:TCP接收回调

recv_tcp()?是TCP netconn注册到tcp的tcp_pcb->recv()?接收回调函数。

TCP内核收到数据后会通过当前回调函数发送数据包到conn->recvmbox?,如果投递失败,则不能删除这些pbuf?,因为tcp_fasttmr()?会在后面再次通知我们上层接收。

这里发送失败但是不能删除这些pbuf?的原因:我们TCP已经ACK了这些数据,对端不会再发这些数据了的,所以我们不能完全删除,只能晚点上交给应用层。

recv_udp()?略有区别,这里不封装netbuf?,在调用上层调用netconn_recv()?函数中再把pbuf?装成netbuf?。

这样做的目的是因为TCP数据包的封装、处理设计其它很多额外的操作,而当前函数却是一个回调函数,不适合多做业务及长时间占有。

  1. static err_t
  2. recv_tcp(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err)
  3. {
  4. struct netconn *conn;
  5. u16_t len;
  6. void *msg;
  7. LWIP_UNUSED_ARG(pcb);
  8. LWIP_ASSERT("recv_tcp must have a pcb argument", pcb != NULL);
  9. LWIP_ASSERT("recv_tcp must have an argument", arg != NULL);
  10. LWIP_ASSERT("err != ERR_OK unhandled", err == ERR_OK);
  11. LWIP_UNUSED_ARG(err); /* for LWIP_NOASSERT */
  12. conn = (struct netconn *)arg;
  13. if (conn == NULL) {
  14. return ERR_VAL;
  15. }
  16. LWIP_ASSERT("recv_tcp: recv for wrong pcb!", conn->pcb.tcp == pcb);
  17. if (!NETCONN_MBOX_VALID(conn, &conn->recvmbox)) {
  18. /* recvmbox已经被删除了。如shutdown RX */
  19. if (p != NULL) {
  20. tcp_recved(pcb, p->tot_len); /* 把这些数据从TCP接收缓冲区中全部读走,并更新接收窗口 */
  21. pbuf_free(p); /* 然后释放这些pbuf */
  22. }
  23. return ERR_OK; /* 算是接收成功 */
  24. }
  25. /* 与UDP或RAW pcb不同,不要使用recv_avail检查可用空间,因为这可能会破坏连接。
  26. (这些数据都是已经被我们ACK了的) */
  27. if (p != NULL) { /* 有数据 */
  28. msg = p;
  29. len = p->tot_len;
  30. } else { /* 没数据也触发当前回调,说明TCP协议栈底层是想表示连接已断开 */
  31. msg = LWIP_CONST_CAST(void *, &netconn_closed);
  32. len = 0;
  33. }
  34. if (sys_mbox_trypost(&conn->recvmbox, msg) != ERR_OK) {
  35. /* 不要释放p:它稍后会从tcp_fasttmr再次给我们! */
  36. return ERR_MEM;
  37. } else {
  38. #if LWIP_SO_RCVBUF
  39. SYS_ARCH_INC(conn->recv_avail, len);
  40. #endif /* LWIP_SO_RCVBUF */
  41. /* 通知上层,有数据可读 */
  42. API_EVENT(conn, NETCONN_EVT_RCVPLUS, len);
  43. }
  44. return ERR_OK;
  45. }

?

sent_tcp:TCP发送回调

sent_tcp()?是TCP netconn注册到tcp的tcp_pcb->sent()?发送回调函数。

当TCP收到更多ACK,发送缓冲区可用空间增大了,就会调用当前回调函数。

主要是唤醒阻塞等待连接关闭或数据发送的应用程序线程。

检查和通知接口层(netconn、socket),有更多缓冲空间了,如果有数据,可以发过来。

  1. static err_t
  2. sent_tcp(void *arg, struct tcp_pcb *pcb, u16_t len)
  3. {
  4. struct netconn *conn = (struct netconn *)arg;
  5. LWIP_UNUSED_ARG(pcb);
  6. LWIP_ASSERT("conn != NULL", (conn != NULL));
  7. if (conn) { /* 接口连接还存在 */
  8. if (conn->state == NETCONN_WRITE) { /* 接口层需要发送数据 */
  9. lwip_netconn_do_writemore(conn WRITE_DELAYED); /* 把数据写入TCP发送缓冲区 */
  10. } else if (conn->state == NETCONN_CLOSE) { /* 接口层已经关闭了当前连接 */
  11. lwip_netconn_do_close_internal(conn WRITE_DELAYED); /* TCP内部资源也关闭 */
  12. }
  13. /* 检查水位线:TCP发送缓冲区 可用空间size在水位线上 && 当前pbuf数量在水位线下
  14. 即可通知上层,可往TCP发送缓冲区写入数据。 */
  15. if ((conn->pcb.tcp != NULL) && (tcp_sndbuf(conn->pcb.tcp) > TCP_SNDLOWAT) &&
  16. (tcp_sndqueuelen(conn->pcb.tcp) < TCP_SNDQUEUELOWAT)) {
  17. netconn_clear_flags(conn, NETCONN_FLAG_CHECK_WRITESPACE); /* 清除 检查缓冲区可写 标志 */
  18. API_EVENT(conn, NETCONN_EVT_SENDPLUS, len); /* 通知接口层,当前TCP发送缓冲区可写 */
  19. }
  20. }
  21. return ERR_OK;
  22. }

?

poll_tcp:TCP poll函数

poll_tcp()?是TCP netconn注册到tcp的tcp_pcb->poll()?周期函数。

tcp_pcb->poll()?被TCP慢时钟tcp_slowtmr()?时钟调用。

NETCONN_TCP_POLL_INTERVAL==2?,表示每秒会轮询一次该函数。

主要是唤醒阻塞等待连接关闭或数据发送的应用程序线程。

解除应用程序线程阻塞的方式:发送信号量conn->sem。

如果关闭失败,netconn_close()等待conn->sem。

  1. static err_t
  2. poll_tcp(void *arg, struct tcp_pcb *pcb)
  3. {
  4. struct netconn *conn = (struct netconn *)arg;
  5. LWIP_UNUSED_ARG(pcb);
  6. LWIP_ASSERT("conn != NULL", (conn != NULL));
  7. if (conn->state == NETCONN_WRITE) { /* 如果netconn处于正在发送数据状态,那tcp层就继续从netconn取数据发出去 */
  8. lwip_netconn_do_writemore(conn WRITE_DELAYED);
  9. } else if (conn->state == NETCONN_CLOSE) { /* netconn已经close当前连接了,内部tcp层也要close */
  10. #if !LWIP_SO_SNDTIMEO && !LWIP_SO_LINGER /* 没开socket发送超时 && 没开close()后残留数据超时 */
  11. if (conn->current_msg && conn->current_msg->msg.sd.polls_left) {
  12. conn->current_msg->msg.sd.polls_left--;
  13. }
  14. #endif /* !LWIP_SO_SNDTIMEO && !LWIP_SO_LINGER */
  15. lwip_netconn_do_close_internal(conn WRITE_DELAYED);
  16. }
  17. /* 之前是否有非阻塞的写操作失败?有就检查写缓冲区是否有可用空间 */
  18. if (conn->flags & NETCONN_FLAG_CHECK_WRITESPACE) { /* 之前存在非阻塞写入失败 */
  19. /* 检查发送缓冲区:缓冲区可用size是否足够 和 pbuf数量是否超限 */
  20. if ((conn->pcb.tcp != NULL) && (tcp_sndbuf(conn->pcb.tcp) > TCP_SNDLOWAT) &&
  21. (tcp_sndqueuelen(conn->pcb.tcp) < TCP_SNDQUEUELOWAT)) {
  22. netconn_clear_flags(conn, NETCONN_FLAG_CHECK_WRITESPACE); /* tcp层有更多的发送缓冲区空间可用,则清除该标记 */
  23. API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0); /* 触发一个可写事件到netconn的上层(如socket层) */
  24. }
  25. }
  26. return ERR_OK;
  27. }

?

err_tcp:TCP 异常回调函数

poll_tcp()?是TCP netconn注册到tcp的tcp_pcb->errf()?异常回调函数。

TCP PCB出现错误时,会调用当前函数回调到接口层处理:

  • 向netconn数据结构中的回调函数发送ERROR?、RCVPLUS?、SENDPLUS?事件;
  • 向netconn数据结构中的所有邮箱recv_mboxes?、accept_mboxes?发送异常事件;

这种做法的目的就是唤醒因各种情况而阻塞的应用程序,告知当前连接发生错误,需要处理。

  1. static void
  2. err_tcp(void *arg, err_t err)
  3. {
  4. struct netconn *conn;
  5. enum netconn_state old_state;
  6. void *mbox_msg;
  7. SYS_ARCH_DECL_PROTECT(lev);
  8. conn = (struct netconn *)arg;
  9. LWIP_ASSERT("conn != NULL", (conn != NULL));
  10. SYS_ARCH_PROTECT(lev); /* 系统保护:进入临界 */
  11. /* 发生错误,PCB就会被释放,所以可在接口层解除绑定 */
  12. conn->pcb.tcp = NULL;
  13. /* 保存错误码 */
  14. conn->pending_err = err;
  15. /* 防止应用程序线程在'recvmbox'/'acceptmbox'上阻塞 */
  16. conn->flags |= NETCONN_FLAG_MBOXCLOSED;
  17. /* 在唤醒其它线程前,重置当前状态 */
  18. old_state = conn->state;
  19. conn->state = NETCONN_NONE;
  20. SYS_ARCH_UNPROTECT(lev); /* 退出临界 */
  21. /* 通知socket层,当前连接异常。 */
  22. API_EVENT(conn, NETCONN_EVT_ERROR, 0);
  23. /* 给socket层一个可读、可写事件,可让应用层不会阻塞于读、写。 */
  24. API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0);
  25. API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0);
  26. mbox_msg = lwip_netconn_err_to_msg(err); /* err翻译成msg */
  27. /* 通过error message到recvmbox来唤醒阻塞于recv的应用层线程 */
  28. if (NETCONN_MBOX_VALID(conn, &conn->recvmbox)) {
  29. /* use trypost to prevent deadlock */
  30. /* 使用trypost,可以防止死锁 */
  31. sys_mbox_trypost(&conn->recvmbox, mbox_msg);
  32. }
  33. /* 通过error message到acceptmbox来唤醒阻塞于accept的应用层线程 */
  34. if (NETCONN_MBOX_VALID(conn, &conn->acceptmbox)) {
  35. /* 使用trypost,可以防止死锁 */
  36. sys_mbox_trypost(&conn->acceptmbox, mbox_msg);
  37. }
  38. if ((old_state == NETCONN_WRITE) || (old_state == NETCONN_CLOSE) ||
  39. (old_state == NETCONN_CONNECT)) { /* 处于非监听的所有有效态 */
  40. /* PCB已经被干掉了,所以没必要调用lwip_netconn_do_writemore()、lwip_netconn_do_close_internal()这些函数了 */
  41. int was_nonblocking_connect = IN_NONBLOCKING_CONNECT(conn); /* 获取当前netconn是否处于非阻塞连接 */
  42. SET_NONBLOCKING_CONNECT(conn, 0); /* 清除netconn中该标记 */
  43. if (!was_nonblocking_connect) { /* 不处于非阻塞连接状态 */
  44. sys_sem_t *op_completed_sem;
  45. /* set error return code */
  46. LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL);
  47. if (old_state == NETCONN_CLOSE) {
  48. /* netconn处于close状态,则返回OK,表示close成功 */
  49. conn->current_msg->err = ERR_OK;
  50. } else {
  51. /* 如果处于写或连接状态,则返回对应ERR,表示当前连接异常。 */
  52. conn->current_msg->err = err;
  53. }
  54. /* 获取当前netconn的同步信号量 */
  55. op_completed_sem = LWIP_API_MSG_SEM(conn->current_msg);
  56. LWIP_ASSERT("invalid op_completed_sem", sys_sem_valid(op_completed_sem));
  57. conn->current_msg = NULL; /* 解绑netconn中的当前的同步信号量 */
  58. /* 唤醒阻塞与写或连接的应用程序线程 */
  59. sys_sem_signal(op_completed_sem);
  60. } else { /* 应用程序线程是非阻塞连接 */
  61. /* @todo: 测试非阻塞连接的错误情况 */
  62. }
  63. } else {
  64. /* netconn处于监听态或空闲态 */
  65. LWIP_ASSERT("conn->current_msg == NULL", conn->current_msg == NULL);
  66. }
  67. }

?

accept_function:TCP accept回调函数

accept_function()?是TCP netconn注册到tcp的lpcb->accept()?accept回调函数。

  • 使用tcp_accept()?API注册。
  • lpcb->accept()?,用于TCP服务器,监听类型的pcb。
  • TCP层收到客户端连接,分配PCB,并握手成功后会调用当前回调。(tcp申请新的客户端PCB失败时也会回调)

?

其他需要注册到协议栈内核的回调函数

recv_udp()?:

  • udp的接收回调函数,该函数会被udp_recv()函数注册到UDP PCB中。在UDP收到数据时被调用,用于回调数据到上层。
  • 是UDP收到的数据包pbuf,组装成一个上层数据包格式netbuf。
  • 然后把这个netbuf投递到连接netconn->recvmbox接收邮箱中。
  • 应用层可以通过调用API函数netconn_recv()从该邮箱中获取netbuf格式的数据包,然后提取出pbuf,再提取出UDP数据即可。

?

?

NETCONN接口线程安全实现(重要)

NETCONN接口线程安全原理

通过lwip内核实现的学习,我们知道,lwip内核实现是需要线程安全的。

目前有两种方式:

  1. 开启LWIP_TCPIP_CORE_LOCKING?内核安全锁功能,使用该锁来实现lwip内核的线程安全。
  2. 如果没有开启内核安全锁,则可以把需要执行的lwip内核API通过API消息发送到LWIP内核线程去执行。

?

?

netconn用户接口形式:netconn_xxx()?

netconn内核接口形式:lwip_netconn_xxx()?

用户调用netconn用户接口时,用户接口的目的就是把netconn的内核接口通过安全锁或api消息发送到wlip内核线程执行。

?

NETCONN接口线程安全具体实现

netconn用户接口使用netconn_apimsg()?-->tcpip_send_msg_wait_sem()?来共同实现。

?

netconn_apimsg()?:

  • tcpip_callback_fn fn?:需要线程安全的netconn内核API。
  • struct api_msg *apimsg?:API的指针形参(既然形参是指针,说明是双向参数)
  1. static err_t
  2. netconn_apimsg(tcpip_callback_fn fn, struct api_msg *apimsg)
  3. {
  4. err_t err;
  5. #ifdef LWIP_DEBUG
  6. /* 捕获不设置错误的函数 */
  7. apimsg->err = ERR_VAL;
  8. #endif /* LWIP_DEBUG */
  9. #if LWIP_NETCONN_SEM_PER_THREAD
  10. apimsg->op_completed_sem = LWIP_NETCONN_THREAD_SEM_GET(); /* 获取同步信号量 */
  11. #endif /* LWIP_NETCONN_SEM_PER_THREAD */
  12. /* 把fn()搞到tcpip内核锁内执行 */
  13. err = tcpip_send_msg_wait_sem(fn, apimsg, LWIP_API_MSG_SEM(apimsg));
  14. if (err == ERR_OK) {
  15. return apimsg->err;
  16. }
  17. return err;
  18. }

?

tcpip_send_msg_wait_sem()?:

  • tcpip_callback_fn fn?:需要线程安全的netconn内核API。
  • void *apimsg?:API的指针形参。
  • sys_sem_t *sem?:同步信号量。用于阻塞。
  • 发送一个回调函数到TCPIP线程执行的步骤:构建tcpip_msg?,发送到tcpip_mbox?,由TCPIP内核线程监测、执行。
  • 调用者线程阻塞在自己指定的同步信号量上,函数执行完毕后,由回调函数fn?释放该同步信号量来解除调用者线程阻塞。
  • 建议:使用LWIP_TCPIP_CORE_LOCKING?内核安全锁,因为这是运行时开销最小的方法。
  1. err_t
  2. tcpip_send_msg_wait_sem(tcpip_callback_fn fn, void *apimsg, sys_sem_t *sem)
  3. {
  4. #if LWIP_TCPIP_CORE_LOCKING /* 开启了内核锁,直接在当前线程调用即可 */
  5. LWIP_UNUSED_ARG(sem);
  6. LOCK_TCPIP_CORE(); /* 内核锁上锁 */
  7. fn(apimsg); /* 执行回调 */
  8. UNLOCK_TCPIP_CORE(); /* 释放内核锁 */
  9. return ERR_OK;
  10. #else /* LWIP_TCPIP_CORE_LOCKING */ /* 没有开启内核锁,需要把回调函数外包到TCPIP内核线程 */
  11. TCPIP_MSG_VAR_DECLARE(msg); /* 定义一个tcpip_msg */
  12. LWIP_ASSERT("semaphore not initialized", sys_sem_valid(sem));
  13. LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(tcpip_mbox));
  14. TCPIP_MSG_VAR_ALLOC(msg); /* 开了MPU,这个就为NULL了 */
  15. TCPIP_MSG_VAR_REF(msg).type = TCPIP_MSG_API; /* 无回传的API消息类型 */
  16. TCPIP_MSG_VAR_REF(msg).msg.api_msg.function = fn; /* API */
  17. TCPIP_MSG_VAR_REF(msg).msg.api_msg.msg = apimsg; /* apimsg */
  18. sys_mbox_post(&tcpip_mbox, &TCPIP_MSG_VAR_REF(msg)); /* 往tcpip_mbox发送一个tcpip_msg */
  19. sys_arch_sem_wait(sem, 0); /* 等待同步信号量被回调函数fn()释放 */
  20. TCPIP_MSG_VAR_FREE(msg); /* 释放tcpip_msg */
  21. return ERR_OK;
  22. #endif /* LWIP_TCPIP_CORE_LOCKING */
  23. }

?

这个同步信号量,就是用于阻塞的,具体是:netconn接口控制块中的op_completed?信号量。

  1. #define LWIP_API_MSG_SEM(msg) (&(msg)->conn->op_completed)

?

接口实现例子

通过一个API例子来实例化线程安全的使用。

用户调用netconn用户接口netconn_new()?,其实就是netconn_new_with_proto_and_callback()?:

  1. #define netconn_new(t) netconn_new_with_proto_and_callback(t, 0, NULL)

netconn_new_with_proto_and_callback()?源码实现如下:

  • 主要内容就是申请api_msg?资源,把需要内核执行的netconn内核接口和该接口需要的数据打包到api_msg?。然后将该msg发送到lwip内核(或上锁)执行。如果是发送到lwip内核,则当前线程会等待同步信号量conn->op_completed?,如果内核执行了netconn内核接口,这个接口会释放该信号量,表示内核已经执行了对应API。
  1. struct netconn *
  2. netconn_new_with_proto_and_callback(enum netconn_type t, u8_t proto, netconn_callback callback)
  3. {
  4. struct netconn *conn;
  5. API_MSG_VAR_DECLARE(msg); // 定义一个api_msg数据结构
  6. API_MSG_VAR_ALLOC_RETURN_NULL(msg); // 申请api_msg数据结构资源,指定错误时返回NULL
  7. conn = netconn_alloc(t, callback); // 申请netconn控制块资源
  8. if (conn != NULL) {
  9. err_t err;
  10. API_MSG_VAR_REF(msg).msg.n.proto = proto; // 把用户连接协议记录到api_msg中
  11. API_MSG_VAR_REF(msg).conn = conn; // 把netconn控制块记录到api_msg中
  12. // 把这个api_msg资源和lwip_netconn_do_newconn()函数封装好,在线程安全下跑(上锁或发送到lwip内核)
  13. err = netconn_apimsg(lwip_netconn_do_newconn, &API_MSG_VAR_REF(msg));
  14. if (err != ERR_OK) {
  15. LWIP_ASSERT("freeing conn without freeing pcb", conn->pcb.tcp == NULL);
  16. LWIP_ASSERT("conn has no recvmbox", sys_mbox_valid(&conn->recvmbox));
  17. #if LWIP_TCP
  18. LWIP_ASSERT("conn->acceptmbox shouldn't exist", !sys_mbox_valid(&conn->acceptmbox));
  19. #endif /* LWIP_TCP */
  20. #if !LWIP_NETCONN_SEM_PER_THREAD
  21. LWIP_ASSERT("conn has no op_completed", sys_sem_valid(&conn->op_completed));
  22. sys_sem_free(&conn->op_completed);
  23. #endif /* !LWIP_NETCONN_SEM_PER_THREAD */
  24. sys_mbox_free(&conn->recvmbox);
  25. memp_free(MEMP_NETCONN, conn);
  26. API_MSG_VAR_FREE(msg);
  27. return NULL;
  28. }
  29. }
  30. API_MSG_VAR_FREE(msg); // 释放api_msg资源
  31. return conn;
  32. }

?

lwip_netconn_do_newconn()?:

  • 创建一个新的特定类型的PCB。
  • 执行完毕,释放信号量,解除调用者线程阻塞。
  1. void
  2. lwip_netconn_do_newconn(void *m)
  3. {
  4. struct api_msg *msg = (struct api_msg *)m;
  5. msg->err = ERR_OK;
  6. if (msg->conn->pcb.tcp == NULL) {
  7. pcb_new(msg); // 创建一个新的特定类型的PCB。
  8. }
  9. /* 释放信号量 */
  10. TCPIP_APIMSG_ACK(msg);
  11. }

?

NETCONN内核接口

参考./src/include/lwip/priv/api_msg.h

?

netconn内核接口是在LWIP线程安全的下运行的,要么上lwip内核资源锁,要么发送到lwip内核线程去执行,这些操作俊友netconn用户接口去实现。

netconn内核接口主要封装各个协议栈的RAW接口实现,如果线程安全是发送到lwip内核实现,则需要在业务执行完毕后调用TCPIP_APIMSG_ACK(msg);?来解除调用者线程的阻塞。

?

部分接口列表:

  1. void lwip_netconn_do_newconn (void *m);
  2. void lwip_netconn_do_delconn (void *m);
  3. void lwip_netconn_do_bind (void *m);
  4. void lwip_netconn_do_bind_if (void *m);
  5. void lwip_netconn_do_connect (void *m);
  6. void lwip_netconn_do_disconnect (void *m);
  7. void lwip_netconn_do_listen (void *m);
  8. void lwip_netconn_do_send (void *m);
  9. void lwip_netconn_do_recv (void *m);
  10. #if TCP_LISTEN_BACKLOG
  11. void lwip_netconn_do_accepted (void *m);
  12. #endif /* TCP_LISTEN_BACKLOG */
  13. void lwip_netconn_do_write (void *m);
  14. void lwip_netconn_do_getaddr (void *m);
  15. void lwip_netconn_do_close (void *m);
  16. void lwip_netconn_do_shutdown (void *m);
  17. #if LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD)
  18. void lwip_netconn_do_join_leave_group(void *m);
  19. void lwip_netconn_do_join_leave_group_netif(void *m);
  20. #endif /* LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) */
  21. #if LWIP_DNS
  22. void lwip_netconn_do_gethostbyname(void *arg);
  23. #endif /* LWIP_DNS */

NETCONN用户接口

netconn接口就不分析源码了,直接描述功能。

这些接口在./src/include/lwip/api.h?路径中。

?

下面只列出部分API,这些API都有兄嘚API,可以查看上述路径。

?

这些接口都是把netconn内核接口封装到api_msg?中,然后将其转发到lwip内核线程(或上锁)执行。

netconn_new():新建一个netconn接口控制块

是一个宏,实际是netconn_new_with_proto_and_callback()?:

  1. #define netconn_new(t) netconn_new_with_proto_and_callback(t, 0, NULL)
  2. struct netconn *
  3. netconn_new_with_proto_and_callback(enum netconn_type t, u8_t proto, netconn_callback callback)
  4. {}

创建一个新的netconn,指定协议,指定回调函数。

协议类型查看netconn_type?。

回调函数查看netconn_callback:

  1. /* 通知netconn事件的回调原型 */
  2. typedef void (* netconn_callback)(struct netconn *, enum netconn_evt, u16_t len);

?

netconn_delete():删除一个netconn接口控制块

netconn_delete()?函数关闭一个netconn“连接”并释放它的资源。

UDP和RAW连接是完全关闭的,TCP pcb可能仍然在等待状态后返回。

?

netconn_getaddr():获取地址信息

获取netconn的local或remote的IP地址和端口号。

对于RAW类型的netconn,返回的不是端口号,而是协议。

?

netconn_bind():绑定本地IP&PORT

netconn绑定指定的local IP地址和端口号。

一个netconn连续两次绑定同一个IP(注意任意IP)和端口号,第二次会响应绑定失败。

?

netconn_connect():连接远端

netconn连接到指定的remote IP和端口号。

?

netconn_disconnect():断开连接

netconn断开当前连接(仅对UDP netconn有效)

?

netconn_listen():监听

设置一个TCP netconn进入监听模式,设置backlog数量上限。

  1. #define netconn_listen(conn) netconn_listen_with_backlog(conn, TCP_DEFAULT_LISTEN_BACKLOG)

TCP_DEFAULT_LISTEN_BACKLOG?默认0xff。

?

netconn_accept():接受连接

accept()一个新的TCP客户端连接。

服务器调用该函数可以从conn->acceptmbox?邮箱中获取一个新的连接,如果邮箱为空,该函数会一直阻塞,直至有新的连接到来。

在调用次函数之前,先调用netconn_listen()?让服务器加入监听状态。

?

netconn_recv():接收数据

该函数是从conn->recvmbox?邮箱中等待数据消息:这些消息就是数据缓存队列:

  • 对于UDP连接:回调函数recv_udp()?会先将接收到的UDP数据封装在netbuf?结构中,然后将数据消息投递到邮箱中。
  • 对于TCP连接:投递到该邮箱中的数据依然是pbuf?封装的,在接收到数据包后,函数netconn_recv()?才将这些pbuf?封装成netbuf?。然后发送一个API消息lwip_netconn_do_recv()?到内核,告知TCP内核,本次已经从TCP缓存中接收了多少数据,让内核调用tcp_recved()?函数滑动接收窗口。

?

netconn_sent():UDP/RAW发送数据

通过过UDP或RAW网络(已经连接)发送数据。

大概内容就是从API消息中获取目的地址信息和数据报pbuf,然后调用udp_send()?或udp_sendto()?将数据放出去。

?

?

netconn_write():TCP发送数据

用于在稳定的TCP连接中发送数据。

?

netconn_close():关闭连接

原文链接:https://www.cnblogs.com/lizhuming/p/17442931.html

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号