Lines Matching refs:conn
62 #define SET_NONBLOCKING_CONNECT(conn, val) do { if (val) { \ argument
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) argument
69 #define NETCONN_MBOX_VALID(conn, mbox) (sys_mbox_valid(mbox) && ((conn->flags & NETCONN_FLAG_MBOXIN… argument
71 #define NETCONN_MBOX_VALID(conn, mbox) sys_mbox_valid(mbox) argument
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);
164 struct netconn *conn; in recv_raw() local
167 conn = (struct netconn *)arg; in recv_raw()
169 if ((conn != NULL) && NETCONN_MBOX_VALID(conn, &conn->recvmbox)) { in recv_raw()
172 SYS_ARCH_GET(conn->recv_avail, recv_avail); in recv_raw()
173 if ((recv_avail + (int)(p->tot_len)) > conn->recv_bufsize) { in recv_raw()
193 if (sys_mbox_trypost(&conn->recvmbox, buf) != ERR_OK) { in recv_raw()
198 SYS_ARCH_INC(conn->recv_avail, len); in recv_raw()
201 API_EVENT(conn, NETCONN_EVT_RCVPLUS, len); in recv_raw()
222 struct netconn *conn; local
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);
295 struct netconn *conn; local
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);
359 struct netconn *conn = (struct netconn *)arg; local
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);
400 struct netconn *conn = (struct netconn *)arg; local
403 LWIP_ASSERT("conn != NULL", (conn != NULL));
405 if (conn) {
406 if (conn->state == NETCONN_WRITE) {
407 lwip_netconn_do_writemore(conn WRITE_DELAYED);
408 } else if (conn->state == NETCONN_CLOSE) {
409 lwip_netconn_do_close_internal(conn WRITE_DELAYED);
414 if ((conn->pcb.tcp != NULL) && (tcp_sndbuf(conn->pcb.tcp) > TCP_SNDLOWAT) &&
415 (tcp_sndqueuelen(conn->pcb.tcp) < TCP_SNDQUEUELOWAT)) {
416 netconn_clear_flags(conn, NETCONN_FLAG_CHECK_WRITESPACE);
417 API_EVENT(conn, NETCONN_EVT_SENDPLUS, len);
434 struct netconn *conn; local
439 conn = (struct netconn *)arg;
440 LWIP_ASSERT("conn != NULL", (conn != NULL));
445 conn->pcb.tcp = NULL;
447 conn->pending_err = err;
449 conn->flags |= NETCONN_FLAG_MBOXCLOSED;
452 old_state = conn->state;
453 conn->state = NETCONN_NONE;
458 API_EVENT(conn, NETCONN_EVT_ERROR, 0);
461 API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0);
462 API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0);
466 if (NETCONN_MBOX_VALID(conn, &conn->recvmbox)) {
468 sys_mbox_trypost(&conn->recvmbox, mbox_msg);
471 if (NETCONN_MBOX_VALID(conn, &conn->acceptmbox)) {
473 sys_mbox_trypost(&conn->acceptmbox, mbox_msg);
480 int was_nonblocking_connect = IN_NONBLOCKING_CONNECT(conn);
481 SET_NONBLOCKING_CONNECT(conn, 0);
486 LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL);
489 conn->current_msg->err = ERR_OK;
492 conn->current_msg->err = err;
494 op_completed_sem = LWIP_API_MSG_SEM(conn->current_msg);
496 conn->current_msg = NULL;
503 LWIP_ASSERT("conn->current_msg == NULL", conn->current_msg == NULL);
514 setup_tcp(struct netconn *conn) argument
518 pcb = conn->pcb.tcp;
519 tcp_arg(pcb, conn);
536 struct netconn *conn = (struct netconn *)arg; local
538 if (conn == NULL) {
541 if (!NETCONN_MBOX_VALID(conn, &conn->acceptmbox)) {
548 if (sys_mbox_trypost(&conn->acceptmbox, lwip_netconn_err_to_msg(ERR_ABRT)) == ERR_OK) {
550 API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0);
561 newconn = netconn_alloc(conn->type, conn->callback);
564 if (sys_mbox_trypost(&conn->acceptmbox, lwip_netconn_err_to_msg(ERR_ABRT)) == ERR_OK) {
566 API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0);
576 if (sys_mbox_trypost(&conn->acceptmbox, newconn) != ERR_OK) {
595 API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0);
613 LWIP_ASSERT("pcb_new: pcb already allocated", msg->conn->pcb.tcp == NULL);
617 if (NETCONNTYPE_ISIPV6(netconn_type(msg->conn))) {
623 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
626 msg->conn->pcb.raw = raw_new_ip_type(iptype, msg->msg.n.proto);
627 if (msg->conn->pcb.raw != NULL) {
630 … if (NETCONNTYPE_ISIPV6(msg->conn->type) && msg->conn->pcb.raw->protocol == IP6_NEXTH_ICMP6) {
631 msg->conn->pcb.raw->chksum_reqd = 1;
632 msg->conn->pcb.raw->chksum_offset = 2;
635 raw_recv(msg->conn->pcb.raw, recv_raw, msg->conn);
641 msg->conn->pcb.udp = udp_new_ip_type(iptype);
642 if (msg->conn->pcb.udp != NULL) {
644 if (NETCONNTYPE_ISUDPLITE(msg->conn->type)) {
645 udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_UDPLITE);
648 if (NETCONNTYPE_ISUDPNOCHKSUM(msg->conn->type)) {
649 udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_NOCHKSUM);
651 udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
657 msg->conn->pcb.tcp = tcp_new_ip_type(iptype);
658 if (msg->conn->pcb.tcp != NULL) {
659 setup_tcp(msg->conn);
668 if (msg->conn->pcb.ip == NULL) {
685 if (msg->conn->pcb.tcp == NULL) {
707 struct netconn *conn; local
711 conn = (struct netconn *)memp_malloc(MEMP_NETCONN);
712 if (conn == NULL) {
716 conn->pending_err = ERR_OK;
717 conn->type = t;
718 conn->pcb.tcp = NULL;
745 if (sys_mbox_new(&conn->recvmbox, size) != ERR_OK) {
749 if (sys_sem_new(&conn->op_completed, 0) != ERR_OK) {
750 sys_mbox_free(&conn->recvmbox);
756 sys_mbox_set_invalid(&conn->acceptmbox);
758 conn->state = NETCONN_NONE;
761 conn->socket = -1;
763 conn->callback = callback;
765 conn->current_msg = NULL;
768 conn->send_timeout = 0;
771 conn->recv_timeout = 0;
774 conn->recv_bufsize = RECV_BUFSIZE_DEFAULT;
775 conn->recv_avail = 0;
778 conn->linger = -1;
780 conn->flags = init_flags;
781 return conn;
783 memp_free(MEMP_NETCONN, conn);
794 netconn_free(struct netconn *conn) argument
796 LWIP_ASSERT("PCB must be deallocated outside this function", conn->pcb.tcp == NULL);
800 netconn_drain(conn);
804 !sys_mbox_valid(&conn->recvmbox));
807 !sys_mbox_valid(&conn->acceptmbox));
811 sys_sem_free(&conn->op_completed);
812 sys_sem_set_invalid(&conn->op_completed);
815 memp_free(MEMP_NETCONN, conn);
827 netconn_drain(struct netconn *conn) argument
834 LWIP_ASSERT("netconn marked closed", conn->flags & NETCONN_FLAG_MBOXINVALID);
838 if (sys_mbox_valid(&conn->recvmbox)) {
839 while (sys_mbox_tryfetch(&conn->recvmbox, &mem) != SYS_MBOX_EMPTY) {
845 if (NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP) {
857 sys_mbox_free(&conn->recvmbox);
858 sys_mbox_set_invalid(&conn->recvmbox);
863 if (sys_mbox_valid(&conn->acceptmbox)) {
864 while (sys_mbox_tryfetch(&conn->acceptmbox, &mem) != SYS_MBOX_EMPTY) {
884 sys_mbox_free(&conn->acceptmbox);
885 sys_mbox_set_invalid(&conn->acceptmbox);
892 netconn_mark_mbox_invalid(struct netconn *conn) argument
898 conn->flags |= NETCONN_FLAG_MBOXINVALID;
900 SYS_ARCH_LOCKED(num_waiting = conn->mbox_threads_waiting);
902 if (sys_mbox_valid_val(conn->recvmbox)) {
903 sys_mbox_trypost(&conn->recvmbox, msg);
905 sys_mbox_trypost(&conn->acceptmbox, msg);
920 lwip_netconn_do_close_internal(struct netconn *conn WRITE_DELAYED_PARAM)
930 LWIP_ASSERT("invalid conn", (conn != NULL));
931 LWIP_ASSERT("this is for tcp netconns only", (NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP));
932 LWIP_ASSERT("conn must be in state NETCONN_CLOSE", (conn->state == NETCONN_CLOSE));
933 LWIP_ASSERT("pcb already closed", (conn->pcb.tcp != NULL));
934 LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL);
936 tpcb = conn->pcb.tcp;
937 shut = conn->current_msg->msg.sd.shut;
981 if ((conn->linger >= 0) && (conn->pcb.tcp->unsent || conn->pcb.tcp->unacked)) {
982 if ((conn->linger == 0)) {
986 } else if (conn->linger > 0) {
988 if (netconn_is_nonblocking(conn)) {
991 } else if ((s32_t)(sys_now() - conn->current_msg->msg.sd.time_started) >=
992 (conn->linger * 1000)) {
1030 if (conn->send_timeout > 0) {
1031 close_timeout = conn->send_timeout;
1035 if (conn->linger >= 0) {
1037 close_timeout = conn->linger * 1000U;
1040 if ((s32_t)(sys_now() - conn->current_msg->msg.sd.time_started) >= close_timeout) {
1042 if (conn->current_msg->msg.sd.polls_left == 0) {
1058 sys_sem_t *op_completed_sem = LWIP_API_MSG_SEM(conn->current_msg);
1059 conn->current_msg->err = err;
1060 conn->current_msg = NULL;
1061 conn->state = NETCONN_NONE;
1065 conn->pcb.tcp = NULL;
1068 API_EVENT(conn, NETCONN_EVT_ERROR, 0);
1071 API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0);
1074 API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0);
1096 tcp_arg(tpcb, conn);
1117 enum netconn_state state = msg->conn->state;
1119 (state == NETCONN_NONE) || (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP));
1124 ((state == NETCONN_CONNECT) && !IN_NONBLOCKING_CONNECT(msg->conn))) {
1127 LWIP_ASSERT("msg->conn->current_msg != NULL", msg->conn->current_msg != NULL);
1128 op_completed_sem = LWIP_API_MSG_SEM(msg->conn->current_msg);
1129 msg->conn->current_msg->err = ERR_CLSD;
1130 msg->conn->current_msg = NULL;
1131 msg->conn->state = NETCONN_NONE;
1139 ((state == NETCONN_CONNECT) && !IN_NONBLOCKING_CONNECT(msg->conn))) {
1147 (state != NETCONN_CONNECT) || IN_NONBLOCKING_CONNECT(msg->conn));
1151 netconn_mark_mbox_invalid(msg->conn);
1153 netconn_drain(msg->conn);
1156 if (msg->conn->pcb.tcp != NULL) {
1158 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
1161 raw_remove(msg->conn->pcb.raw);
1166 msg->conn->pcb.udp->recv_arg = NULL;
1167 udp_remove(msg->conn->pcb.udp);
1172 LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL);
1173 msg->conn->state = NETCONN_CLOSE;
1175 msg->conn->current_msg = msg;
1177 if (lwip_netconn_do_close_internal(msg->conn, 0) != ERR_OK) {
1178 LWIP_ASSERT("state!", msg->conn->state == NETCONN_CLOSE);
1182 LWIP_ASSERT("state!", msg->conn->state == NETCONN_NONE);
1185 lwip_netconn_do_close_internal(msg->conn);
1194 msg->conn->pcb.tcp = NULL;
1200 API_EVENT(msg->conn, NETCONN_EVT_RCVPLUS, 0);
1201 API_EVENT(msg->conn, NETCONN_EVT_SENDPLUS, 0);
1221 if (msg->conn->pcb.tcp != NULL) {
1222 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
1225 err = raw_bind(msg->conn->pcb.raw, API_EXPR_REF(msg->msg.bc.ipaddr));
1230 err = udp_bind(msg->conn->pcb.udp, API_EXPR_REF(msg->msg.bc.ipaddr), msg->msg.bc.port);
1235 err = tcp_bind(msg->conn->pcb.tcp, API_EXPR_REF(msg->msg.bc.ipaddr), msg->msg.bc.port);
1264 if ((netif != NULL) && (msg->conn->pcb.tcp != NULL)) {
1266 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
1269 raw_bind_netif(msg->conn->pcb.raw, netif);
1274 udp_bind_netif(msg->conn->pcb.udp, netif);
1279 tcp_bind_netif(msg->conn->pcb.tcp, netif);
1303 struct netconn *conn; local
1309 conn = (struct netconn *)arg;
1311 if (conn == NULL) {
1315 LWIP_ASSERT("conn->state == NETCONN_CONNECT", conn->state == NETCONN_CONNECT);
1317 (conn->current_msg != NULL) || IN_NONBLOCKING_CONNECT(conn));
1319 if (conn->current_msg != NULL) {
1320 conn->current_msg->err = err;
1321 op_completed_sem = LWIP_API_MSG_SEM(conn->current_msg);
1323 if ((NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP) && (err == ERR_OK)) {
1324 setup_tcp(conn);
1326 was_blocking = !IN_NONBLOCKING_CONNECT(conn);
1327 SET_NONBLOCKING_CONNECT(conn, 0);
1331 conn->current_msg = NULL;
1332 conn->state = NETCONN_NONE;
1333 API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0);
1355 if (msg->conn->pcb.tcp == NULL) {
1359 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
1362 err = raw_connect(msg->conn->pcb.raw, API_EXPR_REF(msg->msg.bc.ipaddr));
1367 err = udp_connect(msg->conn->pcb.udp, API_EXPR_REF(msg->msg.bc.ipaddr), msg->msg.bc.port);
1373 if (msg->conn->state == NETCONN_CONNECT) {
1375 } else if (msg->conn->state != NETCONN_NONE) {
1378 setup_tcp(msg->conn);
1379 err = tcp_connect(msg->conn->pcb.tcp, API_EXPR_REF(msg->msg.bc.ipaddr),
1382 u8_t non_blocking = netconn_is_nonblocking(msg->conn);
1383 msg->conn->state = NETCONN_CONNECT;
1384 SET_NONBLOCKING_CONNECT(msg->conn, non_blocking);
1388 msg->conn->current_msg = msg;
1392 LWIP_ASSERT("state!", msg->conn->state == NETCONN_CONNECT);
1396 LWIP_ASSERT("state!", msg->conn->state != NETCONN_CONNECT);
1430 if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_UDP) {
1431 udp_disconnect(msg->conn->pcb.udp);
1454 if (msg->conn->pcb.tcp != NULL) {
1455 if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) {
1456 if (msg->conn->state == NETCONN_NONE) {
1458 if (msg->conn->pcb.tcp->state != CLOSED) {
1472 if (ip_addr_cmp(&msg->conn->pcb.ip->local_ip, IP6_ADDR_ANY) &&
1473 (netconn_get_ipv6only(msg->conn) == 0)) {
1475 IP_SET_TYPE_VAL(msg->conn->pcb.tcp->local_ip, IPADDR_TYPE_ANY);
1476 IP_SET_TYPE_VAL(msg->conn->pcb.tcp->remote_ip, IPADDR_TYPE_ANY);
1480 lpcb = tcp_listen_with_backlog_and_err(msg->conn->pcb.tcp, backlog, &err);
1486 if (sys_mbox_valid(&msg->conn->recvmbox)) {
1488 sys_mbox_free(&msg->conn->recvmbox);
1489 sys_mbox_set_invalid(&msg->conn->recvmbox);
1492 if (!sys_mbox_valid(&msg->conn->acceptmbox)) {
1493 err = sys_mbox_new(&msg->conn->acceptmbox, DEFAULT_ACCEPTMBOX_SIZE);
1496 msg->conn->state = NETCONN_LISTEN;
1497 msg->conn->pcb.tcp = lpcb;
1498 tcp_arg(msg->conn->pcb.tcp, msg->conn);
1499 tcp_accept(msg->conn->pcb.tcp, accept_function);
1503 msg->conn->pcb.tcp = NULL;
1507 } else if (msg->conn->state == NETCONN_LISTEN) {
1510 tcp_backlog_set(msg->conn->pcb.tcp, msg->msg.lb.backlog);
1536 err_t err = netconn_err(msg->conn);
1538 if (msg->conn->pcb.tcp != NULL) {
1539 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
1543 err = raw_send(msg->conn->pcb.raw, msg->msg.b->p);
1545 err = raw_sendto(msg->conn->pcb.raw, msg->msg.b->p, &msg->msg.b->addr);
1553 err = udp_send_chksum(msg->conn->pcb.udp, msg->msg.b->p,
1556 err = udp_sendto_chksum(msg->conn->pcb.udp, msg->msg.b->p,
1562 err = udp_send(msg->conn->pcb.udp, msg->msg.b->p);
1564 … err = udp_sendto(msg->conn->pcb.udp, msg->msg.b->p, &msg->msg.b->addr, msg->msg.b->port);
1594 if (msg->conn->pcb.tcp != NULL) {
1595 if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) {
1599 tcp_recved(msg->conn->pcb.tcp, recved);
1619 if (msg->conn->pcb.tcp != NULL) {
1620 if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) {
1621 tcp_backlog_accepted(msg->conn->pcb.tcp);
1640 lwip_netconn_do_writemore(struct netconn *conn WRITE_DELAYED_PARAM)
1651 LWIP_ASSERT("conn != NULL", conn != NULL);
1652 LWIP_ASSERT("conn->state == NETCONN_WRITE", (conn->state == NETCONN_WRITE));
1653 LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL);
1654 LWIP_ASSERT("conn->pcb.tcp != NULL", conn->pcb.tcp != NULL);
1656 conn->current_msg->msg.w.offset < conn->current_msg->msg.w.len);
1657 LWIP_ASSERT("conn->current_msg->msg.w.vector_cnt > 0", conn->current_msg->msg.w.vector_cnt > 0);
1659 apiflags = conn->current_msg->msg.w.apiflags;
1660 dontblock = netconn_is_nonblocking(conn) || (apiflags & NETCONN_DONTBLOCK);
1663 if ((conn->send_timeout != 0) &&
1664 ((s32_t)(sys_now() - conn->current_msg->msg.w.time_started) >= conn->send_timeout)) {
1666 if (conn->current_msg->msg.w.offset == 0) {
1677 …dataptr = (const u8_t *)conn->current_msg->msg.w.vector->ptr + conn->current_msg->msg.w.vector_off;
1678 diff = conn->current_msg->msg.w.vector->len - conn->current_msg->msg.w.vector_off;
1685 available = tcp_sndbuf(conn->pcb.tcp);
1692 err = (conn->current_msg->msg.w.offset == 0) ? ERR_WOULDBLOCK : ERR_OK;
1700 … ((conn->current_msg->msg.w.vector_off + len) <= conn->current_msg->msg.w.vector->len));
1706 (len == (u16_t)diff && conn->current_msg->msg.w.vector_cnt > 1)) {
1712 err = tcp_write(conn->pcb.tcp, dataptr, len, apiflags);
1714 conn->current_msg->msg.w.offset += len;
1715 conn->current_msg->msg.w.vector_off += len;
1717 if (conn->current_msg->msg.w.vector_off == conn->current_msg->msg.w.vector->len) {
1718 conn->current_msg->msg.w.vector_cnt--;
1720 if (conn->current_msg->msg.w.vector_cnt > 0) {
1721 conn->current_msg->msg.w.vector++;
1722 conn->current_msg->msg.w.vector_off = 0;
1730 if (dontblock && (conn->current_msg->msg.w.offset < conn->current_msg->msg.w.len)) {
1733 API_EVENT(conn, NETCONN_EVT_SENDMINUS, 0);
1734 conn->flags |= NETCONN_FLAG_CHECK_WRITESPACE;
1735 } else if ((tcp_sndbuf(conn->pcb.tcp) <= TCP_SNDLOWAT) ||
1736 (tcp_sndqueuelen(conn->pcb.tcp) >= TCP_SNDQUEUELOWAT)) {
1739 API_EVENT(conn, NETCONN_EVT_SENDMINUS, 0);
1745 if ((conn->current_msg->msg.w.offset == conn->current_msg->msg.w.len) || dontblock) {
1749 out_err = tcp_output(conn->pcb.tcp);
1764 err_t out_err = tcp_output(conn->pcb.tcp);
1774 err = (conn->current_msg->msg.w.offset == 0) ? ERR_WOULDBLOCK : ERR_OK;
1786 sys_sem_t *op_completed_sem = LWIP_API_MSG_SEM(conn->current_msg);
1787 conn->current_msg->err = err;
1788 conn->current_msg = NULL;
1789 conn->state = NETCONN_NONE;
1817 err_t err = netconn_err(msg->conn);
1819 if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) {
1821 if (msg->conn->state != NETCONN_NONE) {
1824 } else if (msg->conn->pcb.tcp != NULL) {
1825 msg->conn->state = NETCONN_WRITE;
1827 LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL);
1829 msg->conn->current_msg = msg;
1831 if (lwip_netconn_do_writemore(msg->conn, 0) != ERR_OK) {
1832 LWIP_ASSERT("state!", msg->conn->state == NETCONN_WRITE);
1836 LWIP_ASSERT("state!", msg->conn->state != NETCONN_WRITE);
1839 lwip_netconn_do_writemore(msg->conn);
1871 if (msg->conn->pcb.ip != NULL) {
1874 msg->conn->pcb.ip->local_ip);
1877 msg->conn->pcb.ip->remote_ip);
1881 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
1885 API_EXPR_DEREF(msg->msg.ad.port) = msg->conn->pcb.raw->protocol;
1895 API_EXPR_DEREF(msg->msg.ad.port) = msg->conn->pcb.udp->local_port;
1897 if ((msg->conn->pcb.udp->flags & UDP_FLAGS_CONNECTED) == 0) {
1900 API_EXPR_DEREF(msg->msg.ad.port) = msg->conn->pcb.udp->remote_port;
1908 ((msg->conn->pcb.tcp->state == CLOSED) || (msg->conn->pcb.tcp->state == LISTEN))) {
1912 …_EXPR_DEREF(msg->msg.ad.port) = (msg->msg.ad.local ? msg->conn->pcb.tcp->local_port : msg->conn->p…
1939 enum netconn_state state = msg->conn->state;
1942 if ((msg->conn->pcb.tcp != NULL) &&
1943 (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) &&
1954 LWIP_ASSERT("msg->conn->current_msg != NULL", msg->conn->current_msg != NULL);
1955 write_completed_sem = LWIP_API_MSG_SEM(msg->conn->current_msg);
1956 msg->conn->current_msg->err = ERR_CLSD;
1957 msg->conn->current_msg = NULL;
1958 msg->conn->state = NETCONN_NONE;
1965 msg->err = tcp_shutdown(msg->conn->pcb.tcp, 1, 0);
1976 netconn_mark_mbox_invalid(msg->conn);
1978 netconn_drain(msg->conn);
1981 LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL);
1982 msg->conn->state = NETCONN_CLOSE;
1983 msg->conn->current_msg = msg;
1985 if (lwip_netconn_do_close_internal(msg->conn, 0) != ERR_OK) {
1986 LWIP_ASSERT("state!", msg->conn->state == NETCONN_CLOSE);
1990 LWIP_ASSERT("state!", msg->conn->state == NETCONN_NONE);
1993 lwip_netconn_do_close_internal(msg->conn);
2019 if (msg->conn->pcb.tcp != NULL) {
2020 if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_UDP) {
2023 if (NETCONNTYPE_ISIPV6(msg->conn->type)) {
2072 if (msg->conn->pcb.tcp != NULL) {
2073 if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_UDP) {
2076 if (NETCONNTYPE_ISIPV6(msg->conn->type)) {