Lines Matching refs:conn
62 #define SET_NONBLOCKING_CONNECT(conn, val) do { if (val) { \
63 netconn_set_flags(conn, NETCONN_FLAG_IN_NONBLOCKING_CONNECT); \
65 netconn_clear_flags(conn, NETCONN_FLAG_IN_NONBLOCKING_CONNECT); }} while(0)
66 #define IN_NONBLOCKING_CONNECT(conn) netconn_is_flag_set(conn, NETCONN_FLAG_IN_NONBLOCKING_CONNECT)
69 #define NETCONN_MBOX_VALID(conn, mbox) (sys_mbox_valid(mbox) && ((conn->flags & NETCONN_FLAG_MBOXINVALID) == 0))
71 #define NETCONN_MBOX_VALID(conn, mbox) sys_mbox_valid(mbox)
83 static err_t lwip_netconn_do_writemore(struct netconn *conn WRITE_DELAYED_PARAM);
84 static err_t lwip_netconn_do_close_internal(struct netconn *conn WRITE_DELAYED_PARAM);
87 static void netconn_drain(struct netconn *conn);
154 * conn->recvmbox
164 struct netconn *conn;
167 conn = (struct netconn *)arg;
169 if ((conn != NULL) && NETCONN_MBOX_VALID(conn, &conn->recvmbox)) {
172 SYS_ARCH_GET(conn->recv_avail, recv_avail);
173 if ((recv_avail + (int)(p->tot_len)) > conn->recv_bufsize) {
193 if (sys_mbox_trypost(&conn->recvmbox, buf) != ERR_OK) {
198 SYS_ARCH_INC(conn->recv_avail, len);
201 API_EVENT(conn, NETCONN_EVT_RCVPLUS, len);
213 * Posts the packet to conn->recvmbox or deletes it on memory error.
222 struct netconn *conn;
231 conn = (struct netconn *)arg;
233 if (conn == NULL) {
238 LWIP_ASSERT("recv_udp: recv for wrong pcb!", conn->pcb.udp == pcb);
241 SYS_ARCH_GET(conn->recv_avail, recv_avail);
242 if (!NETCONN_MBOX_VALID(conn, &conn->recvmbox) ||
243 ((recv_avail + (int)(p->tot_len)) > conn->recv_bufsize)) {
245 if (!NETCONN_MBOX_VALID(conn, &conn->recvmbox)) {
261 if (conn->flags & NETCONN_FLAG_PKTINFO) {
272 if (sys_mbox_trypost(&conn->recvmbox, buf) != ERR_OK) {
277 SYS_ARCH_INC(conn->recv_avail, len);
280 API_EVENT(conn, NETCONN_EVT_RCVPLUS, len);
288 * Posts the packet to conn->recvmbox, but doesn't delete it on errors.
295 struct netconn *conn;
304 conn = (struct netconn *)arg;
306 if (conn == NULL) {
309 LWIP_ASSERT("recv_tcp: recv for wrong pcb!", conn->pcb.tcp == pcb);
311 if (!NETCONN_MBOX_VALID(conn, &conn->recvmbox)) {
331 if (sys_mbox_trypost(&conn->recvmbox, msg) != ERR_OK) {
336 SYS_ARCH_INC(conn->recv_avail, len);
339 API_EVENT(conn, NETCONN_EVT_RCVPLUS, len);
351 * Signals the conn->sem.
352 * netconn_close waits for conn->sem if closing failed.
359 struct netconn *conn = (struct netconn *)arg;
362 LWIP_ASSERT("conn != NULL", (conn != NULL));
364 if (conn->state == NETCONN_WRITE) {
365 lwip_netconn_do_writemore(conn WRITE_DELAYED);
366 } else if (conn->state == NETCONN_CLOSE) {
368 if (conn->current_msg && conn->current_msg->msg.sd.polls_left) {
369 conn->current_msg->msg.sd.polls_left--;
372 lwip_netconn_do_close_internal(conn WRITE_DELAYED);
377 if (conn->flags & NETCONN_FLAG_CHECK_WRITESPACE) {
380 if ((conn->pcb.tcp != NULL) && (tcp_sndbuf(conn->pcb.tcp) > TCP_SNDLOWAT) &&
381 (tcp_sndqueuelen(conn->pcb.tcp) < TCP_SNDQUEUELOWAT)) {
382 netconn_clear_flags(conn, NETCONN_FLAG_CHECK_WRITESPACE);
383 API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0);
395 struct netconn *conn = (struct netconn *)arg;
399 if (conn == NULL) {
402 if ((conn->state == NETCONN_WRITE) || (conn->state == NETCONN_CLOSE)) {
407 if ((conn->flags & NETCONN_FLAG_CHECK_WRITESPACE) != 0) {
410 if ((conn->pcb.tcp != NULL) && (tcp_sndbuf(conn->pcb.tcp) > TCP_SNDLOWAT) &&
411 (tcp_sndqueuelen(conn->pcb.tcp) < TCP_SNDQUEUELOWAT)) {
421 * Signals the conn->sem and calls API_EVENT.
422 * netconn_write waits for conn->sem if send buffer is low.
429 struct netconn *conn = (struct netconn *)arg;
432 LWIP_ASSERT("conn != NULL", (conn != NULL));
434 if (conn) {
435 if (conn->state == NETCONN_WRITE) {
436 lwip_netconn_do_writemore(conn WRITE_DELAYED);
437 } else if (conn->state == NETCONN_CLOSE) {
438 lwip_netconn_do_close_internal(conn WRITE_DELAYED);
443 if ((conn->pcb.tcp != NULL) && (tcp_sndbuf(conn->pcb.tcp) > TCP_SNDLOWAT) &&
444 (tcp_sndqueuelen(conn->pcb.tcp) < TCP_SNDQUEUELOWAT)) {
445 netconn_clear_flags(conn, NETCONN_FLAG_CHECK_WRITESPACE);
446 API_EVENT(conn, NETCONN_EVT_SENDPLUS, len);
455 * Signals conn->sem, posts to all conn mboxes and calls API_EVENT.
463 struct netconn *conn;
468 conn = (struct netconn *)arg;
469 LWIP_ASSERT("conn != NULL", (conn != NULL));
474 conn->pcb.tcp = NULL;
476 conn->pending_err = err;
478 conn->flags |= NETCONN_FLAG_MBOXCLOSED;
480 /* reset conn->state now before waking up other threads */
481 old_state = conn->state;
482 conn->state = NETCONN_NONE;
487 API_EVENT(conn, NETCONN_EVT_ERROR, 0);
490 API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0);
491 API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0);
495 if (NETCONN_MBOX_VALID(conn, &conn->recvmbox)) {
497 sys_mbox_trypost(&conn->recvmbox, mbox_msg);
500 if (NETCONN_MBOX_VALID(conn, &conn->acceptmbox)) {
502 sys_mbox_trypost(&conn->acceptmbox, mbox_msg);
509 int was_nonblocking_connect = IN_NONBLOCKING_CONNECT(conn);
510 SET_NONBLOCKING_CONNECT(conn, 0);
515 LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL);
518 conn->current_msg->err = ERR_OK;
521 conn->current_msg->err = err;
523 op_completed_sem = LWIP_API_MSG_SEM(conn->current_msg);
525 conn->current_msg = NULL;
532 LWIP_ASSERT("conn->current_msg == NULL", conn->current_msg == NULL);
540 * @param conn the TCP netconn to setup
543 setup_tcp(struct netconn *conn)
547 pcb = conn->pcb.tcp;
548 tcp_arg(pcb, conn);
557 * Allocates a new netconn and posts that to conn->acceptmbox.
565 struct netconn *conn = (struct netconn *)arg;
567 if (conn == NULL) {
570 if (!NETCONN_MBOX_VALID(conn, &conn->acceptmbox)) {
577 if (sys_mbox_trypost(&conn->acceptmbox, lwip_netconn_err_to_msg(ERR_ABRT)) == ERR_OK) {
579 API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0);
590 newconn = netconn_alloc(conn->type, conn->callback);
593 if (sys_mbox_trypost(&conn->acceptmbox, lwip_netconn_err_to_msg(ERR_ABRT)) == ERR_OK) {
595 API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0);
605 if (sys_mbox_trypost(&conn->acceptmbox, newconn) != ERR_OK) {
624 API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0);
646 LWIP_ASSERT("pcb_new: pcb already allocated", msg->conn->pcb.tcp == NULL);
650 if (NETCONNTYPE_ISIPV6(netconn_type(msg->conn))) {
656 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
659 msg->conn->pcb.raw = raw_new_ip_type(iptype, msg->msg.n.proto);
660 if (msg->conn->pcb.raw != NULL) {
662 set_raw_pcb_net_group(msg->conn->pcb.raw, group);
666 if (NETCONNTYPE_ISIPV6(msg->conn->type) && msg->conn->pcb.raw->protocol == IP6_NEXTH_ICMP6) {
667 msg->conn->pcb.raw->chksum_reqd = 1;
668 msg->conn->pcb.raw->chksum_offset = 2;
671 raw_recv(msg->conn->pcb.raw, recv_raw, msg->conn);
677 msg->conn->pcb.udp = udp_new_ip_type(iptype);
678 if (msg->conn->pcb.udp != NULL) {
680 set_udp_pcb_net_group(msg->conn->pcb.udp, group);
683 if (NETCONNTYPE_ISUDPLITE(msg->conn->type)) {
684 udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_UDPLITE);
687 if (NETCONNTYPE_ISUDPNOCHKSUM(msg->conn->type)) {
688 udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_NOCHKSUM);
690 udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
696 msg->conn->pcb.tcp = tcp_new_ip_type(iptype);
697 if (msg->conn->pcb.tcp != NULL) {
699 set_tcp_pcb_net_group(msg->conn->pcb.tcp, group);
701 setup_tcp(msg->conn);
710 if (msg->conn->pcb.ip == NULL) {
727 if (msg->conn->pcb.tcp == NULL) {
753 struct netconn *conn;
757 conn = (struct netconn *)memp_malloc(MEMP_NETCONN);
758 if (conn == NULL) {
762 conn->pending_err = ERR_OK;
763 conn->type = t;
764 conn->pcb.tcp = NULL;
766 conn->mbox_threads_waiting = 0;
794 if (sys_mbox_new(&conn->recvmbox, size) != ERR_OK) {
798 if (sys_sem_new(&conn->op_completed, 0) != ERR_OK) {
799 sys_mbox_free(&conn->recvmbox);
805 sys_mbox_set_invalid(&conn->acceptmbox);
807 conn->state = NETCONN_NONE;
810 conn->socket = -1;
812 conn->callback = callback;
814 conn->current_msg = NULL;
817 conn->send_timeout = 0;
820 conn->recv_timeout = 0;
823 conn->recv_bufsize = RECV_BUFSIZE_DEFAULT;
824 conn->recv_avail = 0;
827 conn->linger = -1;
829 conn->flags = init_flags;
830 return conn;
832 memp_free(MEMP_NETCONN, conn);
840 * @param conn the netconn to free
843 netconn_free(struct netconn *conn)
845 LWIP_ASSERT("PCB must be deallocated outside this function", conn->pcb.tcp == NULL);
849 netconn_drain(conn);
853 !sys_mbox_valid(&conn->recvmbox));
856 !sys_mbox_valid(&conn->acceptmbox));
860 sys_sem_free(&conn->op_completed);
861 sys_sem_set_invalid(&conn->op_completed);
864 memp_free(MEMP_NETCONN, conn);
871 * @param conn the netconn to free
876 netconn_drain(struct netconn *conn)
883 LWIP_ASSERT("netconn marked closed", conn->flags & NETCONN_FLAG_MBOXINVALID);
887 if (sys_mbox_valid(&conn->recvmbox)) {
888 while (sys_mbox_tryfetch(&conn->recvmbox, &mem) != SYS_MBOX_EMPTY) {
894 if (NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP) {
906 sys_mbox_free(&conn->recvmbox);
907 sys_mbox_set_invalid(&conn->recvmbox);
912 if (sys_mbox_valid(&conn->acceptmbox)) {
913 while (sys_mbox_tryfetch(&conn->acceptmbox, &mem) != SYS_MBOX_EMPTY) {
921 /* Only tcp pcbs have an acceptmbox, so no need to check conn->type */
933 sys_mbox_free(&conn->acceptmbox);
934 sys_mbox_set_invalid(&conn->acceptmbox);
941 netconn_mark_mbox_invalid(struct netconn *conn)
947 conn->flags |= NETCONN_FLAG_MBOXINVALID;
949 SYS_ARCH_LOCKED(num_waiting = conn->mbox_threads_waiting);
951 if (sys_mbox_valid_val(conn->recvmbox)) {
952 sys_mbox_trypost(&conn->recvmbox, msg);
954 sys_mbox_trypost(&conn->acceptmbox, msg);
966 * @param conn the TCP netconn to close
969 lwip_netconn_do_close_internal(struct netconn *conn WRITE_DELAYED_PARAM)
979 LWIP_ASSERT("invalid conn", (conn != NULL));
980 LWIP_ASSERT("this is for tcp netconns only", (NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP));
981 LWIP_ASSERT("conn must be in state NETCONN_CLOSE", (conn->state == NETCONN_CLOSE));
982 LWIP_ASSERT("pcb already closed", (conn->pcb.tcp != NULL));
983 LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL);
985 tpcb = conn->pcb.tcp;
986 shut = conn->current_msg->msg.sd.shut;
1030 if ((conn->linger >= 0) && (conn->pcb.tcp->unsent || conn->pcb.tcp->unacked)) {
1031 if ((conn->linger == 0)) {
1035 } else if (conn->linger > 0) {
1037 if (netconn_is_nonblocking(conn)) {
1040 } else if ((s32_t)(sys_now() - conn->current_msg->msg.sd.time_started) >=
1041 (conn->linger * 1000)) {
1079 if (conn->send_timeout > 0) {
1080 close_timeout = conn->send_timeout;
1084 if (conn->linger >= 0) {
1086 close_timeout = conn->linger * 1000U;
1089 if ((s32_t)(sys_now() - conn->current_msg->msg.sd.time_started) >= close_timeout) {
1091 if (conn->current_msg->msg.sd.polls_left == 0) {
1107 sys_sem_t *op_completed_sem = LWIP_API_MSG_SEM(conn->current_msg);
1108 conn->current_msg->err = err;
1109 conn->current_msg = NULL;
1110 conn->state = NETCONN_NONE;
1113 /* Set back some callback pointers as conn is going away */
1114 conn->pcb.tcp = NULL;
1117 API_EVENT(conn, NETCONN_EVT_ERROR, 0);
1120 API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0);
1123 API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0);
1145 tcp_arg(tpcb, conn);
1166 enum netconn_state state = msg->conn->state;
1168 (state == NETCONN_NONE) || (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP));
1173 ((state == NETCONN_CONNECT) && !IN_NONBLOCKING_CONNECT(msg->conn))) {
1176 LWIP_ASSERT("msg->conn->current_msg != NULL", msg->conn->current_msg != NULL);
1177 op_completed_sem = LWIP_API_MSG_SEM(msg->conn->current_msg);
1178 msg->conn->current_msg->err = ERR_CLSD;
1179 msg->conn->current_msg = NULL;
1180 msg->conn->state = NETCONN_NONE;
1188 ((state == NETCONN_CONNECT) && !IN_NONBLOCKING_CONNECT(msg->conn))) {
1196 (state != NETCONN_CONNECT) || IN_NONBLOCKING_CONNECT(msg->conn));
1200 netconn_mark_mbox_invalid(msg->conn);
1202 netconn_drain(msg->conn);
1205 if (msg->conn->pcb.tcp != NULL) {
1207 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
1210 raw_remove(msg->conn->pcb.raw);
1215 msg->conn->pcb.udp->recv_arg = NULL;
1216 udp_remove(msg->conn->pcb.udp);
1221 LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL);
1222 msg->conn->state = NETCONN_CLOSE;
1224 msg->conn->current_msg = msg;
1226 if (lwip_netconn_do_close_internal(msg->conn, 0) != ERR_OK) {
1227 LWIP_ASSERT("state!", msg->conn->state == NETCONN_CLOSE);
1231 LWIP_ASSERT("state!", msg->conn->state == NETCONN_NONE);
1234 lwip_netconn_do_close_internal(msg->conn);
1243 msg->conn->pcb.tcp = NULL;
1249 API_EVENT(msg->conn, NETCONN_EVT_RCVPLUS, 0);
1250 API_EVENT(msg->conn, NETCONN_EVT_SENDPLUS, 0);
1270 if (msg->conn->pcb.tcp != NULL) {
1271 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
1274 err = raw_bind(msg->conn->pcb.raw, API_EXPR_REF(msg->msg.bc.ipaddr));
1279 err = udp_bind(msg->conn->pcb.udp, API_EXPR_REF(msg->msg.bc.ipaddr), msg->msg.bc.port);
1284 err = tcp_bind(msg->conn->pcb.tcp, API_EXPR_REF(msg->msg.bc.ipaddr), msg->msg.bc.port);
1312 struct net_group *group = get_net_group_from_ippcb(msg->conn->pcb.ip);
1323 if ((netif != NULL) && (msg->conn->pcb.tcp != NULL)) {
1325 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
1328 raw_bind_netif(msg->conn->pcb.raw, netif);
1333 udp_bind_netif(msg->conn->pcb.udp, netif);
1338 tcp_bind_netif(msg->conn->pcb.tcp, netif);
1362 struct netconn *conn;
1368 conn = (struct netconn *)arg;
1370 if (conn == NULL) {
1374 LWIP_ASSERT("conn->state == NETCONN_CONNECT", conn->state == NETCONN_CONNECT);
1375 LWIP_ASSERT("(conn->current_msg != NULL) || conn->in_non_blocking_connect",
1376 (conn->current_msg != NULL) || IN_NONBLOCKING_CONNECT(conn));
1378 if (conn->current_msg != NULL) {
1379 conn->current_msg->err = err;
1380 op_completed_sem = LWIP_API_MSG_SEM(conn->current_msg);
1382 if ((NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP) && (err == ERR_OK)) {
1383 setup_tcp(conn);
1385 was_blocking = !IN_NONBLOCKING_CONNECT(conn);
1386 SET_NONBLOCKING_CONNECT(conn, 0);
1390 conn->current_msg = NULL;
1391 conn->state = NETCONN_NONE;
1392 API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0);
1414 if (msg->conn->pcb.tcp == NULL) {
1418 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
1421 err = raw_connect(msg->conn->pcb.raw, API_EXPR_REF(msg->msg.bc.ipaddr));
1426 err = udp_connect(msg->conn->pcb.udp, API_EXPR_REF(msg->msg.bc.ipaddr), msg->msg.bc.port);
1432 if (msg->conn->state == NETCONN_CONNECT) {
1434 } else if (msg->conn->state != NETCONN_NONE) {
1437 setup_tcp(msg->conn);
1438 err = tcp_connect(msg->conn->pcb.tcp, API_EXPR_REF(msg->msg.bc.ipaddr),
1441 u8_t non_blocking = netconn_is_nonblocking(msg->conn);
1442 msg->conn->state = NETCONN_CONNECT;
1443 SET_NONBLOCKING_CONNECT(msg->conn, non_blocking);
1447 msg->conn->current_msg = msg;
1451 LWIP_ASSERT("state!", msg->conn->state == NETCONN_CONNECT);
1455 LWIP_ASSERT("state!", msg->conn->state != NETCONN_CONNECT);
1489 if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_UDP) {
1490 udp_disconnect(msg->conn->pcb.udp);
1513 if (msg->conn->pcb.tcp != NULL) {
1514 if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) {
1515 if (msg->conn->state == NETCONN_NONE) {
1517 if (msg->conn->pcb.tcp->state != CLOSED) {
1531 if (ip_addr_cmp(&msg->conn->pcb.ip->local_ip, IP6_ADDR_ANY) &&
1532 (netconn_get_ipv6only(msg->conn) == 0)) {
1534 IP_SET_TYPE_VAL(msg->conn->pcb.tcp->local_ip, IPADDR_TYPE_ANY);
1535 IP_SET_TYPE_VAL(msg->conn->pcb.tcp->remote_ip, IPADDR_TYPE_ANY);
1539 lpcb = tcp_listen_with_backlog_and_err(msg->conn->pcb.tcp, backlog, &err);
1545 if (sys_mbox_valid(&msg->conn->recvmbox)) {
1547 sys_mbox_free(&msg->conn->recvmbox);
1548 sys_mbox_set_invalid(&msg->conn->recvmbox);
1551 if (!sys_mbox_valid(&msg->conn->acceptmbox)) {
1552 err = sys_mbox_new(&msg->conn->acceptmbox, DEFAULT_ACCEPTMBOX_SIZE);
1555 msg->conn->state = NETCONN_LISTEN;
1556 msg->conn->pcb.tcp = lpcb;
1557 tcp_arg(msg->conn->pcb.tcp, msg->conn);
1558 tcp_accept(msg->conn->pcb.tcp, accept_function);
1562 msg->conn->pcb.tcp = NULL;
1566 } else if (msg->conn->state == NETCONN_LISTEN) {
1569 tcp_backlog_set(msg->conn->pcb.tcp, msg->msg.lb.backlog);
1595 err_t err = netconn_err(msg->conn);
1597 if (msg->conn->pcb.tcp != NULL) {
1598 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
1602 err = raw_send(msg->conn->pcb.raw, msg->msg.b->p);
1604 err = raw_sendto(msg->conn->pcb.raw, msg->msg.b->p, &msg->msg.b->addr);
1612 err = udp_send_chksum(msg->conn->pcb.udp, msg->msg.b->p,
1615 err = udp_sendto_chksum(msg->conn->pcb.udp, msg->msg.b->p,
1621 err = udp_send(msg->conn->pcb.udp, msg->msg.b->p);
1623 err = udp_sendto(msg->conn->pcb.udp, msg->msg.b->p, &msg->msg.b->addr, msg->msg.b->port);
1653 if (msg->conn->pcb.tcp != NULL) {
1654 if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) {
1658 tcp_recved(msg->conn->pcb.tcp, recved);
1678 if (msg->conn->pcb.tcp != NULL) {
1679 if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) {
1680 tcp_backlog_accepted(msg->conn->pcb.tcp);
1694 * @param conn netconn (that is currently in state NETCONN_WRITE) to process
1699 lwip_netconn_do_writemore(struct netconn *conn WRITE_DELAYED_PARAM)
1710 LWIP_ASSERT("conn != NULL", conn != NULL);
1711 LWIP_ASSERT("conn->state == NETCONN_WRITE", (conn->state == NETCONN_WRITE));
1712 LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL);
1713 LWIP_ASSERT("conn->pcb.tcp != NULL", conn->pcb.tcp != NULL);
1714 LWIP_ASSERT("conn->current_msg->msg.w.offset < conn->current_msg->msg.w.len",
1715 conn->current_msg->msg.w.offset < conn->current_msg->msg.w.len);
1716 LWIP_ASSERT("conn->current_msg->msg.w.vector_cnt > 0", conn->current_msg->msg.w.vector_cnt > 0);
1718 apiflags = conn->current_msg->msg.w.apiflags;
1719 dontblock = netconn_is_nonblocking(conn) || (apiflags & NETCONN_DONTBLOCK);
1722 if ((conn->send_timeout != 0) &&
1723 ((s32_t)(sys_now() - conn->current_msg->msg.w.time_started) >= conn->send_timeout)) {
1725 if (conn->current_msg->msg.w.offset == 0) {
1736 dataptr = (const u8_t *)conn->current_msg->msg.w.vector->ptr + conn->current_msg->msg.w.vector_off;
1737 diff = conn->current_msg->msg.w.vector->len - conn->current_msg->msg.w.vector_off;
1744 available = tcp_sndbuf(conn->pcb.tcp);
1751 err = (conn->current_msg->msg.w.offset == 0) ? ERR_WOULDBLOCK : ERR_OK;
1759 ((conn->current_msg->msg.w.vector_off + len) <= conn->current_msg->msg.w.vector->len));
1765 (len == (u16_t)diff && conn->current_msg->msg.w.vector_cnt > 1)) {
1771 err = tcp_write(conn->pcb.tcp, dataptr, len, apiflags);
1773 conn->current_msg->msg.w.offset += len;
1774 conn->current_msg->msg.w.vector_off += len;
1776 if (conn->current_msg->msg.w.vector_off == conn->current_msg->msg.w.vector->len) {
1777 conn->current_msg->msg.w.vector_cnt--;
1779 if (conn->current_msg->msg.w.vector_cnt > 0) {
1780 conn->current_msg->msg.w.vector++;
1781 conn->current_msg->msg.w.vector_off = 0;
1789 if (dontblock && (conn->current_msg->msg.w.offset < conn->current_msg->msg.w.len)) {
1792 API_EVENT(conn, NETCONN_EVT_SENDMINUS, 0);
1793 conn->flags |= NETCONN_FLAG_CHECK_WRITESPACE;
1794 } else if ((tcp_sndbuf(conn->pcb.tcp) <= TCP_SNDLOWAT) ||
1795 (tcp_sndqueuelen(conn->pcb.tcp) >= TCP_SNDQUEUELOWAT)) {
1798 API_EVENT(conn, NETCONN_EVT_SENDMINUS, 0);
1804 if ((conn->current_msg->msg.w.offset == conn->current_msg->msg.w.len) || dontblock) {
1808 out_err = tcp_output(conn->pcb.tcp);
1823 err_t out_err = tcp_output(conn->pcb.tcp);
1833 err = (conn->current_msg->msg.w.offset == 0) ? ERR_WOULDBLOCK : ERR_OK;
1845 sys_sem_t *op_completed_sem = LWIP_API_MSG_SEM(conn->current_msg);
1846 conn->current_msg->err = err;
1847 conn->current_msg = NULL;
1848 conn->state = NETCONN_NONE;
1876 err_t err = netconn_err(msg->conn);
1878 if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) {
1880 if (msg->conn->state != NETCONN_NONE) {
1883 } else if (msg->conn->pcb.tcp != NULL) {
1884 msg->conn->state = NETCONN_WRITE;
1886 LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL);
1888 msg->conn->current_msg = msg;
1890 if (lwip_netconn_do_writemore(msg->conn, 0) != ERR_OK) {
1891 LWIP_ASSERT("state!", msg->conn->state == NETCONN_WRITE);
1895 LWIP_ASSERT("state!", msg->conn->state != NETCONN_WRITE);
1898 lwip_netconn_do_writemore(msg->conn);
1930 if (msg->conn->pcb.ip != NULL) {
1933 msg->conn->pcb.ip->local_ip);
1936 msg->conn->pcb.ip->remote_ip);
1940 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
1944 API_EXPR_DEREF(msg->msg.ad.port) = msg->conn->pcb.raw->protocol;
1954 API_EXPR_DEREF(msg->msg.ad.port) = msg->conn->pcb.udp->local_port;
1956 if ((msg->conn->pcb.udp->flags & UDP_FLAGS_CONNECTED) == 0) {
1959 API_EXPR_DEREF(msg->msg.ad.port) = msg->conn->pcb.udp->remote_port;
1967 ((msg->conn->pcb.tcp->state == CLOSED) || (msg->conn->pcb.tcp->state == LISTEN))) {
1971 API_EXPR_DEREF(msg->msg.ad.port) = (msg->msg.ad.local ? msg->conn->pcb.tcp->local_port : msg->conn->pcb.tcp->remote_port);
1998 enum netconn_state state = msg->conn->state;
2001 if ((msg->conn->pcb.tcp != NULL) &&
2002 (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) &&
2013 LWIP_ASSERT("msg->conn->current_msg != NULL", msg->conn->current_msg != NULL);
2014 write_completed_sem = LWIP_API_MSG_SEM(msg->conn->current_msg);
2015 msg->conn->current_msg->err = ERR_CLSD;
2016 msg->conn->current_msg = NULL;
2017 msg->conn->state = NETCONN_NONE;
2023 conn->current_msg or conn->state! */
2024 msg->err = tcp_shutdown(msg->conn->pcb.tcp, 1, 0);
2035 netconn_mark_mbox_invalid(msg->conn);
2037 netconn_drain(msg->conn);
2040 LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL);
2041 msg->conn->state = NETCONN_CLOSE;
2042 msg->conn->current_msg = msg;
2044 if (lwip_netconn_do_close_internal(msg->conn, 0) != ERR_OK) {
2045 LWIP_ASSERT("state!", msg->conn->state == NETCONN_CLOSE);
2049 LWIP_ASSERT("state!", msg->conn->state == NETCONN_NONE);
2052 lwip_netconn_do_close_internal(msg->conn);
2078 if (msg->conn->pcb.tcp != NULL) {
2079 if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_UDP) {
2082 if (NETCONNTYPE_ISIPV6(msg->conn->type)) {
2124 struct net_group *group = get_net_group_from_ippcb(msg->conn->pcb.ip);
2141 if (msg->conn->pcb.tcp != NULL) {
2142 if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_UDP) {
2145 if (NETCONNTYPE_ISIPV6(msg->conn->type)) {