Lines Matching refs:conn
62 #define SET_NONBLOCKING_CONNECT(conn, val) do { if (val) { \ argument
63 (conn)->flags |= NETCONN_FLAG_IN_NONBLOCKING_CONNECT; \
65 (conn)->flags &= ~ NETCONN_FLAG_IN_NONBLOCKING_CONNECT; }} while(0)
66 #define IN_NONBLOCKING_CONNECT(conn) (((conn)->flags & NETCONN_FLAG_IN_NONBLOCKING_CONNECT) != 0) argument
77 static err_t lwip_netconn_do_writemore(struct netconn *conn WRITE_DELAYED_PARAM);
78 static err_t lwip_netconn_do_close_internal(struct netconn *conn WRITE_DELAYED_PARAM);
82 #define TCPIP_APIMSG_ACK(m) NETCONN_SET_SAFE_ERR((m)->conn, (m)->err)
84 #define TCPIP_APIMSG_ACK(m) do { NETCONN_SET_SAFE_ERR((m)->conn, (m)->err); sys_sem_signal(LWIP_A…
105 struct netconn *conn; in recv_raw() local
108 conn = (struct netconn *)arg; in recv_raw()
110 if ((conn != NULL) && sys_mbox_valid(&conn->recvmbox)) { in recv_raw()
113 SYS_ARCH_GET(conn->recv_avail, recv_avail); in recv_raw()
114 if ((recv_avail + (int)(p->tot_len)) > conn->recv_bufsize) { in recv_raw()
141 if (sys_mbox_trypost(&conn->recvmbox, buf) != ERR_OK) { in recv_raw()
146 SYS_ARCH_INC(conn->recv_avail, len); in recv_raw()
149 API_EVENT(conn, NETCONN_EVT_RCVPLUS, len); in recv_raw()
170 struct netconn *conn; local
179 conn = (struct netconn *)arg;
181 if (conn == NULL) {
186 LWIP_ASSERT("recv_udp: recv for wrong pcb!", conn->pcb.udp == pcb);
189 SYS_ARCH_GET(conn->recv_avail, recv_avail);
190 if (!sys_mbox_valid(&conn->recvmbox) ||
191 ((recv_avail + (int)(p->tot_len)) > conn->recv_bufsize)) {
193 if (!sys_mbox_valid(&conn->recvmbox)) {
222 if (sys_mbox_trypost(&conn->recvmbox, buf) != ERR_OK) {
227 SYS_ARCH_INC(conn->recv_avail, len);
230 API_EVENT(conn, NETCONN_EVT_RCVPLUS, len);
245 struct netconn *conn; local
251 conn = (struct netconn *)arg;
253 if (conn == NULL) {
256 LWIP_ASSERT("recv_tcp: recv for wrong pcb!", conn->pcb.tcp == pcb);
258 if (!sys_mbox_valid(&conn->recvmbox)) {
272 NETCONN_SET_SAFE_ERR(conn, err);
281 if (sys_mbox_trypost(&conn->recvmbox, p) != ERR_OK) {
286 SYS_ARCH_INC(conn->recv_avail, len);
289 API_EVENT(conn, NETCONN_EVT_RCVPLUS, len);
309 struct netconn *conn = (struct netconn *)arg; local
312 LWIP_ASSERT("conn != NULL", (conn != NULL));
314 if (conn->state == NETCONN_WRITE) {
315 lwip_netconn_do_writemore(conn WRITE_DELAYED);
316 } else if (conn->state == NETCONN_CLOSE) {
318 if (conn->current_msg && conn->current_msg->msg.sd.polls_left) {
319 conn->current_msg->msg.sd.polls_left--;
322 lwip_netconn_do_close_internal(conn WRITE_DELAYED);
327 if (conn->flags & NETCONN_FLAG_CHECK_WRITESPACE) {
330 if ((conn->pcb.tcp != NULL) && (tcp_sndbuf(conn->pcb.tcp) > TCP_SNDLOWAT) &&
331 (tcp_sndqueuelen(conn->pcb.tcp) < TCP_SNDQUEUELOWAT)) {
332 conn->flags &= ~NETCONN_FLAG_CHECK_WRITESPACE;
333 API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0);
350 struct netconn *conn = (struct netconn *)arg; local
353 LWIP_ASSERT("conn != NULL", (conn != NULL));
355 if (conn) {
356 if (conn->state == NETCONN_WRITE) {
357 lwip_netconn_do_writemore(conn WRITE_DELAYED);
358 } else if (conn->state == NETCONN_CLOSE) {
359 lwip_netconn_do_close_internal(conn WRITE_DELAYED);
364 if ((conn->pcb.tcp != NULL) && (tcp_sndbuf(conn->pcb.tcp) > TCP_SNDLOWAT) &&
365 (tcp_sndqueuelen(conn->pcb.tcp) < TCP_SNDQUEUELOWAT)) {
366 conn->flags &= ~NETCONN_FLAG_CHECK_WRITESPACE;
367 API_EVENT(conn, NETCONN_EVT_SENDPLUS, len);
384 struct netconn *conn; local
387 conn = (struct netconn *)arg;
388 LWIP_ASSERT("conn != NULL", (conn != NULL));
390 conn->pcb.tcp = NULL;
393 old_state = conn->state;
394 conn->state = NETCONN_NONE;
399 NETCONN_SET_SAFE_ERR(conn, ERR_OK);
402 SYS_ARCH_SET(conn->last_err, err);
408 API_EVENT(conn, NETCONN_EVT_ERROR, 0);
411 API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0);
412 API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0);
415 if (sys_mbox_valid(&conn->recvmbox)) {
417 sys_mbox_trypost(&conn->recvmbox, NULL);
420 if (sys_mbox_valid(&conn->acceptmbox)) {
422 sys_mbox_trypost(&conn->acceptmbox, NULL);
429 int was_nonblocking_connect = IN_NONBLOCKING_CONNECT(conn);
430 SET_NONBLOCKING_CONNECT(conn, 0);
435 LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL);
436 conn->current_msg->err = err;
437 op_completed_sem = LWIP_API_MSG_SEM(conn->current_msg);
439 conn->current_msg = NULL;
441 NETCONN_SET_SAFE_ERR(conn, err);
445 LWIP_ASSERT("conn->current_msg == NULL", conn->current_msg == NULL);
456 setup_tcp(struct netconn *conn) argument
460 pcb = conn->pcb.tcp;
461 tcp_arg(pcb, conn);
478 struct netconn *conn = (struct netconn *)arg; local
480 if (conn == NULL) {
483 if (!sys_mbox_valid(&conn->acceptmbox)) {
490 if (sys_mbox_trypost(&conn->acceptmbox, &netconn_aborted) == ERR_OK) {
492 API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0);
501 newconn = netconn_alloc(conn->type, conn->callback);
504 if (sys_mbox_trypost(&conn->acceptmbox, &netconn_aborted) == ERR_OK) {
506 API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0);
519 if (sys_mbox_trypost(&conn->acceptmbox, newconn) != ERR_OK) {
538 API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0);
556 LWIP_ASSERT("pcb_new: pcb already allocated", msg->conn->pcb.tcp == NULL);
560 if(NETCONNTYPE_ISIPV6(netconn_type(msg->conn))) {
566 switch(NETCONNTYPE_GROUP(msg->conn->type)) {
569 msg->conn->pcb.raw = raw_new_ip_type(iptype, msg->msg.n.proto);
570 if (msg->conn->pcb.raw != NULL) {
573 if (NETCONNTYPE_ISIPV6(msg->conn->type) && msg->conn->pcb.raw->protocol == IP6_NEXTH_ICMP6) {
574 msg->conn->pcb.raw->chksum_reqd = 1;
575 msg->conn->pcb.raw->chksum_offset = 2;
578 raw_recv(msg->conn->pcb.raw, recv_raw, msg->conn);
584 msg->conn->pcb.udp = udp_new_ip_type(iptype);
585 if (msg->conn->pcb.udp != NULL) {
587 if (NETCONNTYPE_ISUDPLITE(msg->conn->type)) {
588 udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_UDPLITE);
591 if (NETCONNTYPE_ISUDPNOCHKSUM(msg->conn->type)) {
592 udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_NOCHKSUM);
594 udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
600 msg->conn->pcb.tcp = tcp_new_ip_type(iptype);
601 if (msg->conn->pcb.tcp != NULL) {
602 setup_tcp(msg->conn);
611 if (msg->conn->pcb.ip == NULL) {
628 if (msg->conn->pcb.tcp == NULL) {
650 struct netconn *conn; local
653 conn = (struct netconn *)memp_malloc(MEMP_NETCONN);
654 if (conn == NULL) {
658 conn->last_err = ERR_OK;
659 conn->type = t;
660 conn->pcb.tcp = NULL;
684 if (sys_mbox_new(&conn->recvmbox, size) != ERR_OK) {
688 if (sys_sem_new(&conn->op_completed, 0) != ERR_OK) {
689 sys_mbox_free(&conn->recvmbox);
695 sys_mbox_set_invalid(&conn->acceptmbox);
697 conn->state = NETCONN_NONE;
700 conn->socket = -1;
702 conn->callback = callback;
704 conn->current_msg = NULL;
705 conn->write_offset = 0;
708 conn->send_timeout = 0;
711 conn->recv_timeout = 0;
714 conn->recv_bufsize = RECV_BUFSIZE_DEFAULT;
715 conn->recv_avail = 0;
718 conn->linger = -1;
720 conn->flags = 0;
721 return conn;
723 memp_free(MEMP_NETCONN, conn);
734 netconn_free(struct netconn *conn) argument
736 LWIP_ASSERT("PCB must be deallocated outside this function", conn->pcb.tcp == NULL);
738 !sys_mbox_valid(&conn->recvmbox));
741 !sys_mbox_valid(&conn->acceptmbox));
745 sys_sem_free(&conn->op_completed);
746 sys_sem_set_invalid(&conn->op_completed);
749 memp_free(MEMP_NETCONN, conn);
761 netconn_drain(struct netconn *conn) argument
771 if (sys_mbox_valid(&conn->recvmbox)) {
772 while (sys_mbox_tryfetch(&conn->recvmbox, &mem) != SYS_MBOX_EMPTY) {
774 if (NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP) {
778 if (conn->pcb.tcp != NULL) {
779 tcp_recved(conn->pcb.tcp, p->tot_len);
789 sys_mbox_free(&conn->recvmbox);
790 sys_mbox_set_invalid(&conn->recvmbox);
795 if (sys_mbox_valid(&conn->acceptmbox)) {
796 while (sys_mbox_tryfetch(&conn->acceptmbox, &mem) != SYS_MBOX_EMPTY) {
810 sys_mbox_free(&conn->acceptmbox);
811 sys_mbox_set_invalid(&conn->acceptmbox);
825 lwip_netconn_do_close_internal(struct netconn *conn WRITE_DELAYED_PARAM)
835 LWIP_ASSERT("invalid conn", (conn != NULL));
836 LWIP_ASSERT("this is for tcp netconns only", (NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP));
837 LWIP_ASSERT("conn must be in state NETCONN_CLOSE", (conn->state == NETCONN_CLOSE));
838 LWIP_ASSERT("pcb already closed", (conn->pcb.tcp != NULL));
839 LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL);
841 tpcb = conn->pcb.tcp;
842 shut = conn->current_msg->msg.sd.shut;
886 if ((conn->linger >= 0) && (conn->pcb.tcp->unsent || conn->pcb.tcp->unacked)) {
887 if ((conn->linger == 0)) {
891 } else if (conn->linger > 0) {
893 if (netconn_is_nonblocking(conn)) {
896 } else if ((s32_t)(sys_now() - conn->current_msg->msg.sd.time_started) >=
897 (conn->linger * 1000)) {
935 if (conn->send_timeout > 0) {
936 close_timeout = conn->send_timeout;
940 if (conn->linger >= 0) {
942 close_timeout = conn->linger * 1000U;
945 if ((s32_t)(sys_now() - conn->current_msg->msg.sd.time_started) >= close_timeout) {
947 if (conn->current_msg->msg.sd.polls_left == 0) {
963 sys_sem_t* op_completed_sem = LWIP_API_MSG_SEM(conn->current_msg);
964 conn->current_msg->err = err;
965 conn->current_msg = NULL;
966 conn->state = NETCONN_NONE;
970 conn->pcb.tcp = NULL;
973 API_EVENT(conn, NETCONN_EVT_ERROR, 0);
976 API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0);
979 API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0);
982 NETCONN_SET_SAFE_ERR(conn, err);
1002 tcp_arg(tpcb, conn);
1023 enum netconn_state state = msg->conn->state;
1025 (state == NETCONN_NONE) || (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP));
1030 ((state == NETCONN_CONNECT) && !IN_NONBLOCKING_CONNECT(msg->conn))) {
1033 LWIP_ASSERT("msg->conn->current_msg != NULL", msg->conn->current_msg != NULL);
1034 op_completed_sem = LWIP_API_MSG_SEM(msg->conn->current_msg);
1035 msg->conn->current_msg->err = ERR_CLSD;
1036 msg->conn->current_msg = NULL;
1037 msg->conn->write_offset = 0;
1038 msg->conn->state = NETCONN_NONE;
1039 NETCONN_SET_SAFE_ERR(msg->conn, ERR_CLSD);
1047 ((state == NETCONN_CONNECT) && !IN_NONBLOCKING_CONNECT(msg->conn))) {
1055 (state != NETCONN_CONNECT) || IN_NONBLOCKING_CONNECT(msg->conn));
1058 netconn_drain(msg->conn);
1060 if (msg->conn->pcb.tcp != NULL) {
1062 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
1065 raw_remove(msg->conn->pcb.raw);
1070 msg->conn->pcb.udp->recv_arg = NULL;
1071 udp_remove(msg->conn->pcb.udp);
1076 LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL &&
1077 msg->conn->write_offset == 0);
1078 msg->conn->state = NETCONN_CLOSE;
1080 msg->conn->current_msg = msg;
1082 if (lwip_netconn_do_close_internal(msg->conn, 0) != ERR_OK) {
1083 LWIP_ASSERT("state!", msg->conn->state == NETCONN_CLOSE);
1087 LWIP_ASSERT("state!", msg->conn->state == NETCONN_NONE);
1090 lwip_netconn_do_close_internal(msg->conn);
1099 msg->conn->pcb.tcp = NULL;
1105 API_EVENT(msg->conn, NETCONN_EVT_RCVPLUS, 0);
1106 API_EVENT(msg->conn, NETCONN_EVT_SENDPLUS, 0);
1125 if (ERR_IS_FATAL(msg->conn->last_err)) {
1126 msg->err = msg->conn->last_err;
1129 if (msg->conn->pcb.tcp != NULL) {
1130 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
1133 msg->err = raw_bind(msg->conn->pcb.raw, API_EXPR_REF(msg->msg.bc.ipaddr));
1138 msg->err = udp_bind(msg->conn->pcb.udp, API_EXPR_REF(msg->msg.bc.ipaddr), msg->msg.bc.port);
1143 msg->err = tcp_bind(msg->conn->pcb.tcp, API_EXPR_REF(msg->msg.bc.ipaddr), msg->msg.bc.port);
1164 struct netconn *conn; local
1170 conn = (struct netconn *)arg;
1172 if (conn == NULL) {
1176 LWIP_ASSERT("conn->state == NETCONN_CONNECT", conn->state == NETCONN_CONNECT);
1178 (conn->current_msg != NULL) || IN_NONBLOCKING_CONNECT(conn));
1180 if (conn->current_msg != NULL) {
1181 conn->current_msg->err = err;
1182 op_completed_sem = LWIP_API_MSG_SEM(conn->current_msg);
1184 if ((NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP) && (err == ERR_OK)) {
1185 setup_tcp(conn);
1187 was_blocking = !IN_NONBLOCKING_CONNECT(conn);
1188 SET_NONBLOCKING_CONNECT(conn, 0);
1192 conn->current_msg = NULL;
1193 conn->state = NETCONN_NONE;
1194 NETCONN_SET_SAFE_ERR(conn, ERR_OK);
1195 API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0);
1216 if (msg->conn->pcb.tcp == NULL) {
1220 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
1223 msg->err = raw_connect(msg->conn->pcb.raw, API_EXPR_REF(msg->msg.bc.ipaddr));
1228 … msg->err = udp_connect(msg->conn->pcb.udp, API_EXPR_REF(msg->msg.bc.ipaddr), msg->msg.bc.port);
1234 if (msg->conn->state == NETCONN_CONNECT) {
1236 } else if (msg->conn->state != NETCONN_NONE) {
1239 setup_tcp(msg->conn);
1240 msg->err = tcp_connect(msg->conn->pcb.tcp, API_EXPR_REF(msg->msg.bc.ipaddr),
1243 u8_t non_blocking = netconn_is_nonblocking(msg->conn);
1244 msg->conn->state = NETCONN_CONNECT;
1245 SET_NONBLOCKING_CONNECT(msg->conn, non_blocking);
1249 msg->conn->current_msg = msg;
1253 LWIP_ASSERT("state!", msg->conn->state == NETCONN_CONNECT);
1257 LWIP_ASSERT("state!", msg->conn->state != NETCONN_CONNECT);
1288 if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_UDP) {
1289 udp_disconnect(msg->conn->pcb.udp);
1311 if (ERR_IS_FATAL(msg->conn->last_err)) {
1312 msg->err = msg->conn->last_err;
1315 if (msg->conn->pcb.tcp != NULL) {
1316 if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) {
1317 if (msg->conn->state == NETCONN_NONE) {
1319 if (msg->conn->pcb.tcp->state != CLOSED) {
1334 if (ip_addr_cmp(&msg->conn->pcb.ip->local_ip, IP6_ADDR_ANY) &&
1335 (netconn_get_ipv6only(msg->conn) == 0)) {
1337 IP_SET_TYPE_VAL(msg->conn->pcb.tcp->local_ip, IPADDR_TYPE_ANY);
1338 IP_SET_TYPE_VAL(msg->conn->pcb.tcp->remote_ip, IPADDR_TYPE_ANY);
1342 lpcb = tcp_listen_with_backlog_and_err(msg->conn->pcb.tcp, backlog, &err);
1349 if (sys_mbox_valid(&msg->conn->recvmbox)) {
1351 sys_mbox_free(&msg->conn->recvmbox);
1352 sys_mbox_set_invalid(&msg->conn->recvmbox);
1355 if (!sys_mbox_valid(&msg->conn->acceptmbox)) {
1356 msg->err = sys_mbox_new(&msg->conn->acceptmbox, DEFAULT_ACCEPTMBOX_SIZE);
1359 msg->conn->state = NETCONN_LISTEN;
1360 msg->conn->pcb.tcp = lpcb;
1361 tcp_arg(msg->conn->pcb.tcp, msg->conn);
1362 tcp_accept(msg->conn->pcb.tcp, accept_function);
1366 msg->conn->pcb.tcp = NULL;
1370 } else if (msg->conn->state == NETCONN_LISTEN) {
1373 tcp_backlog_set(msg->conn->pcb.tcp, msg->msg.lb.backlog);
1395 if (ERR_IS_FATAL(msg->conn->last_err)) {
1396 msg->err = msg->conn->last_err;
1399 if (msg->conn->pcb.tcp != NULL) {
1400 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
1404 msg->err = raw_send(msg->conn->pcb.raw, msg->msg.b->p);
1406 msg->err = raw_sendto(msg->conn->pcb.raw, msg->msg.b->p, &msg->msg.b->addr);
1414 msg->err = udp_send_chksum(msg->conn->pcb.udp, msg->msg.b->p,
1417 msg->err = udp_sendto_chksum(msg->conn->pcb.udp, msg->msg.b->p,
1423 msg->err = udp_send(msg->conn->pcb.udp, msg->msg.b->p);
1425 … msg->err = udp_sendto(msg->conn->pcb.udp, msg->msg.b->p, &msg->msg.b->addr, msg->msg.b->port);
1451 if (msg->conn->pcb.tcp != NULL) {
1452 if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) {
1456 tcp_recved(msg->conn->pcb.tcp, recved);
1476 if (msg->conn->pcb.tcp != NULL) {
1477 if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) {
1478 tcp_backlog_accepted(msg->conn->pcb.tcp);
1497 lwip_netconn_do_writemore(struct netconn *conn WRITE_DELAYED_PARAM)
1507 LWIP_ASSERT("conn != NULL", conn != NULL);
1508 LWIP_ASSERT("conn->state == NETCONN_WRITE", (conn->state == NETCONN_WRITE));
1509 LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL);
1510 LWIP_ASSERT("conn->pcb.tcp != NULL", conn->pcb.tcp != NULL);
1512 conn->write_offset < conn->current_msg->msg.w.len);
1514 apiflags = conn->current_msg->msg.w.apiflags;
1515 dontblock = netconn_is_nonblocking(conn) || (apiflags & NETCONN_DONTBLOCK);
1518 if ((conn->send_timeout != 0) &&
1519 ((s32_t)(sys_now() - conn->current_msg->msg.w.time_started) >= conn->send_timeout)) {
1521 if (conn->write_offset == 0) {
1524 conn->current_msg->msg.w.len = 0;
1528 conn->current_msg->msg.w.len = conn->write_offset;
1529 conn->write_offset = 0;
1534 dataptr = (const u8_t*)conn->current_msg->msg.w.dataptr + conn->write_offset;
1535 diff = conn->current_msg->msg.w.len - conn->write_offset;
1542 available = tcp_sndbuf(conn->pcb.tcp);
1555 …LWIP_ASSERT("lwip_netconn_do_writemore: invalid length!", ((conn->write_offset + len) <= conn->cur…
1556 err = tcp_write(conn->pcb.tcp, dataptr, len, apiflags);
1560 if (dontblock && (len < conn->current_msg->msg.w.len)) {
1563 API_EVENT(conn, NETCONN_EVT_SENDMINUS, len);
1564 conn->flags |= NETCONN_FLAG_CHECK_WRITESPACE;
1565 } else if ((tcp_sndbuf(conn->pcb.tcp) <= TCP_SNDLOWAT) ||
1566 (tcp_sndqueuelen(conn->pcb.tcp) >= TCP_SNDQUEUELOWAT)) {
1569 API_EVENT(conn, NETCONN_EVT_SENDMINUS, len);
1575 conn->write_offset += len;
1576 if ((conn->write_offset == conn->current_msg->msg.w.len) || dontblock) {
1578 conn->current_msg->msg.w.len = conn->write_offset;
1582 out_err = tcp_output(conn->pcb.tcp);
1589 conn->current_msg->msg.w.len = 0;
1598 err_t out_err = tcp_output(conn->pcb.tcp);
1605 conn->current_msg->msg.w.len = 0;
1610 conn->current_msg->msg.w.len = 0;
1616 conn->current_msg->msg.w.len = 0;
1622 sys_sem_t* op_completed_sem = LWIP_API_MSG_SEM(conn->current_msg);
1623 conn->current_msg->err = err;
1624 conn->current_msg = NULL;
1625 conn->write_offset = 0;
1626 conn->state = NETCONN_NONE;
1627 NETCONN_SET_SAFE_ERR(conn, err);
1655 if (ERR_IS_FATAL(msg->conn->last_err)) {
1656 msg->err = msg->conn->last_err;
1658 if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) {
1660 if (msg->conn->state != NETCONN_NONE) {
1663 } else if (msg->conn->pcb.tcp != NULL) {
1664 msg->conn->state = NETCONN_WRITE;
1666 LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL &&
1667 msg->conn->write_offset == 0);
1669 msg->conn->current_msg = msg;
1670 msg->conn->write_offset = 0;
1672 if (lwip_netconn_do_writemore(msg->conn, 0) != ERR_OK) {
1673 LWIP_ASSERT("state!", msg->conn->state == NETCONN_WRITE);
1677 LWIP_ASSERT("state!", msg->conn->state != NETCONN_WRITE);
1680 lwip_netconn_do_writemore(msg->conn);
1711 if (msg->conn->pcb.ip != NULL) {
1714 msg->conn->pcb.ip->local_ip);
1717 msg->conn->pcb.ip->remote_ip);
1721 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
1725 API_EXPR_DEREF(msg->msg.ad.port) = msg->conn->pcb.raw->protocol;
1735 API_EXPR_DEREF(msg->msg.ad.port) = msg->conn->pcb.udp->local_port;
1737 if ((msg->conn->pcb.udp->flags & UDP_FLAGS_CONNECTED) == 0) {
1740 API_EXPR_DEREF(msg->msg.ad.port) = msg->conn->pcb.udp->remote_port;
1748 ((msg->conn->pcb.tcp->state == CLOSED) || (msg->conn->pcb.tcp->state == LISTEN))) {
1752 …_EXPR_DEREF(msg->msg.ad.port) = (msg->msg.ad.local ? msg->conn->pcb.tcp->local_port : msg->conn->p…
1779 enum netconn_state state = msg->conn->state;
1782 if ((msg->conn->pcb.tcp != NULL) &&
1783 (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) &&
1794 LWIP_ASSERT("msg->conn->current_msg != NULL", msg->conn->current_msg != NULL);
1795 write_completed_sem = LWIP_API_MSG_SEM(msg->conn->current_msg);
1796 msg->conn->current_msg->err = ERR_CLSD;
1797 msg->conn->current_msg = NULL;
1798 msg->conn->write_offset = 0;
1799 msg->conn->state = NETCONN_NONE;
1801 NETCONN_SET_SAFE_ERR(msg->conn, ERR_CLSD);
1807 msg->err = tcp_shutdown(msg->conn->pcb.tcp, 1, 0);
1817 netconn_drain(msg->conn);
1819 LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL &&
1820 msg->conn->write_offset == 0);
1821 msg->conn->state = NETCONN_CLOSE;
1822 msg->conn->current_msg = msg;
1824 if (lwip_netconn_do_close_internal(msg->conn, 0) != ERR_OK) {
1825 LWIP_ASSERT("state!", msg->conn->state == NETCONN_CLOSE);
1829 LWIP_ASSERT("state!", msg->conn->state == NETCONN_NONE);
1832 lwip_netconn_do_close_internal(msg->conn);
1857 if (ERR_IS_FATAL(msg->conn->last_err)) {
1858 msg->err = msg->conn->last_err;
1860 if (msg->conn->pcb.tcp != NULL) {
1861 if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_UDP) {
1864 if (NETCONNTYPE_ISIPV6(msg->conn->type)) {