Lines Matching refs:conn
57 #define SET_NONBLOCKING_CONNECT(conn, val) do { if(val) { \
58 (conn)->flags |= NETCONN_FLAG_IN_NONBLOCKING_CONNECT; \
60 (conn)->flags &= ~ NETCONN_FLAG_IN_NONBLOCKING_CONNECT; }} while(0)
61 #define IN_NONBLOCKING_CONNECT(conn) (((conn)->flags & NETCONN_FLAG_IN_NONBLOCKING_CONNECT) != 0)
65 static err_t do_writemore(struct netconn *conn);
66 static void do_close_internal(struct netconn *conn);
73 * conn->recvmbox
83 struct netconn *conn;
86 conn = (struct netconn *)arg;
88 if ((conn != NULL) && sys_mbox_valid(&conn->recvmbox)) {
91 SYS_ARCH_GET(conn->recv_avail, recv_avail);
92 if ((recv_avail + (int)(p->tot_len)) > conn->recv_bufsize) {
119 if (sys_mbox_trypost(&conn->recvmbox, buf) != ERR_OK) {
124 SYS_ARCH_INC(conn->recv_avail, len);
127 API_EVENT(conn, NETCONN_EVT_RCVPLUS, len);
139 * Posts the packet to conn->recvmbox or deletes it on memory error.
148 struct netconn *conn;
157 conn = (struct netconn *)arg;
158 LWIP_ASSERT("recv_udp: recv for wrong pcb!", conn->pcb.udp == pcb);
161 SYS_ARCH_GET(conn->recv_avail, recv_avail);
162 if ((conn == NULL) || !sys_mbox_valid(&conn->recvmbox) ||
163 ((recv_avail + (int)(p->tot_len)) > conn->recv_bufsize)) {
165 if ((conn == NULL) || !sys_mbox_valid(&conn->recvmbox)) {
195 if (sys_mbox_trypost(&conn->recvmbox, buf) != ERR_OK) {
200 SYS_ARCH_INC(conn->recv_avail, len);
203 API_EVENT(conn, NETCONN_EVT_RCVPLUS, len);
211 * Posts the packet to conn->recvmbox, but doesn't delete it on errors.
218 struct netconn *conn;
224 conn = (struct netconn *)arg;
225 LWIP_ASSERT("recv_tcp: recv for wrong pcb!", conn->pcb.tcp == pcb);
227 if (conn == NULL) {
230 if (!sys_mbox_valid(&conn->recvmbox)) {
243 NETCONN_SET_SAFE_ERR(conn, err);
251 if (sys_mbox_trypost(&conn->recvmbox, p) != ERR_OK) {
256 SYS_ARCH_INC(conn->recv_avail, len);
259 API_EVENT(conn, NETCONN_EVT_RCVPLUS, len);
271 * Signals the conn->sem.
272 * netconn_close waits for conn->sem if closing failed.
279 struct netconn *conn = (struct netconn *)arg;
282 LWIP_ASSERT("conn != NULL", (conn != NULL));
284 if (conn->state == NETCONN_WRITE) {
285 do_writemore(conn);
286 } else if (conn->state == NETCONN_CLOSE) {
287 do_close_internal(conn);
292 if (conn->flags & NETCONN_FLAG_CHECK_WRITESPACE) {
295 if ((conn->pcb.tcp != NULL) && (tcp_sndbuf(conn->pcb.tcp) > TCP_SNDLOWAT) &&
296 (tcp_sndqueuelen(conn->pcb.tcp) < TCP_SNDQUEUELOWAT)) {
297 conn->flags &= ~NETCONN_FLAG_CHECK_WRITESPACE;
298 API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0);
307 * Signals the conn->sem and calls API_EVENT.
308 * netconn_write waits for conn->sem if send buffer is low.
315 struct netconn *conn = (struct netconn *)arg;
318 LWIP_ASSERT("conn != NULL", (conn != NULL));
320 if (conn->state == NETCONN_WRITE) {
321 do_writemore(conn);
322 } else if (conn->state == NETCONN_CLOSE) {
323 do_close_internal(conn);
326 if (conn) {
329 if ((conn->pcb.tcp != NULL) && (tcp_sndbuf(conn->pcb.tcp) > TCP_SNDLOWAT) &&
330 (tcp_sndqueuelen(conn->pcb.tcp) < TCP_SNDQUEUELOWAT)) {
331 conn->flags &= ~NETCONN_FLAG_CHECK_WRITESPACE;
332 API_EVENT(conn, NETCONN_EVT_SENDPLUS, len);
341 * Signals conn->sem, posts to all conn mboxes and calls API_EVENT.
349 struct netconn *conn;
353 conn = (struct netconn *)arg;
354 LWIP_ASSERT("conn != NULL", (conn != NULL));
356 conn->pcb.tcp = NULL;
360 conn->last_err = err;
363 /* reset conn->state now before waking up other threads */
364 old_state = conn->state;
365 conn->state = NETCONN_NONE;
369 API_EVENT(conn, NETCONN_EVT_ERROR, 0);
372 API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0);
373 API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0);
376 if (sys_mbox_valid(&conn->recvmbox)) {
378 sys_mbox_trypost(&conn->recvmbox, NULL);
381 if (sys_mbox_valid(&conn->acceptmbox)) {
383 sys_mbox_trypost(&conn->acceptmbox, NULL);
390 int was_nonblocking_connect = IN_NONBLOCKING_CONNECT(conn);
391 SET_NONBLOCKING_CONNECT(conn, 0);
395 LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL);
396 conn->current_msg->err = err;
397 conn->current_msg = NULL;
399 sys_sem_signal(&conn->op_completed);
402 LWIP_ASSERT("conn->current_msg == NULL", conn->current_msg == NULL);
410 * @param conn the TCP netconn to setup
413 setup_tcp(struct netconn *conn)
417 pcb = conn->pcb.tcp;
418 tcp_arg(pcb, conn);
427 * Allocates a new netconn and posts that to conn->acceptmbox.
435 struct netconn *conn = (struct netconn *)arg;
439 if (!sys_mbox_valid(&conn->acceptmbox)) {
445 * the new socket is unknown. conn->socket is marked as -1. */
446 newconn = netconn_alloc(conn->type, conn->callback);
456 if (sys_mbox_trypost(&conn->acceptmbox, newconn) != ERR_OK) {
475 API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0);
487 * @return msg->conn->err, but the return value is currently ignored
492 LWIP_ASSERT("pcb_new: pcb already allocated", msg->conn->pcb.tcp == NULL);
495 switch(NETCONNTYPE_GROUP(msg->conn->type)) {
498 msg->conn->pcb.raw = raw_new(msg->msg.n.proto);
499 if(msg->conn->pcb.raw == NULL) {
503 raw_recv(msg->conn->pcb.raw, recv_raw, msg->conn);
508 msg->conn->pcb.udp = udp_new();
509 if(msg->conn->pcb.udp == NULL) {
514 if (msg->conn->type==NETCONN_UDPLITE) {
515 udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_UDPLITE);
518 if (msg->conn->type==NETCONN_UDPNOCHKSUM) {
519 udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_NOCHKSUM);
521 udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn);
526 msg->conn->pcb.tcp = tcp_new();
527 if(msg->conn->pcb.tcp == NULL) {
531 setup_tcp(msg->conn);
551 if(msg->conn->pcb.tcp == NULL) {
574 struct netconn *conn;
577 conn = (struct netconn *)memp_malloc(MEMP_NETCONN);
578 if (conn == NULL) {
582 conn->last_err = ERR_OK;
583 conn->type = t;
584 conn->pcb.tcp = NULL;
612 if (sys_sem_new(&conn->op_completed, 0) != ERR_OK) {
615 if (sys_mbox_new(&conn->recvmbox, size) != ERR_OK) {
616 sys_sem_free(&conn->op_completed);
621 sys_mbox_set_invalid(&conn->acceptmbox);
623 conn->state = NETCONN_NONE;
626 conn->socket = -1;
628 conn->callback = callback;
630 conn->current_msg = NULL;
631 conn->write_offset = 0;
634 conn->send_timeout = 0;
637 conn->recv_timeout = 0;
640 conn->recv_bufsize = RECV_BUFSIZE_DEFAULT;
641 conn->recv_avail = 0;
643 conn->flags = 0;
644 return conn;
646 memp_free(MEMP_NETCONN, conn);
654 * @param conn the netconn to free
657 netconn_free(struct netconn *conn)
659 LWIP_ASSERT("PCB must be deallocated outside this function", conn->pcb.tcp == NULL);
661 !sys_mbox_valid(&conn->recvmbox));
664 !sys_mbox_valid(&conn->acceptmbox));
667 sys_sem_free(&conn->op_completed);
668 sys_sem_set_invalid(&conn->op_completed);
670 memp_free(MEMP_NETCONN, conn);
677 * @param conn the netconn to free
682 netconn_drain(struct netconn *conn)
692 if (sys_mbox_valid(&conn->recvmbox)) {
693 while (sys_mbox_tryfetch(&conn->recvmbox, &mem) != SYS_MBOX_EMPTY) {
695 if (conn->type == NETCONN_TCP) {
699 if (conn->pcb.tcp != NULL) {
700 tcp_recved(conn->pcb.tcp, p->tot_len);
710 sys_mbox_free(&conn->recvmbox);
711 sys_mbox_set_invalid(&conn->recvmbox);
716 if (sys_mbox_valid(&conn->acceptmbox)) {
717 while (sys_mbox_tryfetch(&conn->acceptmbox, &mem) != SYS_MBOX_EMPTY) {
719 /* Only tcp pcbs have an acceptmbox, so no need to check conn->type */
721 if (conn->pcb.tcp != NULL) {
722 tcp_accepted(conn->pcb.tcp);
732 sys_mbox_free(&conn->acceptmbox);
733 sys_mbox_set_invalid(&conn->acceptmbox);
744 * @param conn the TCP netconn to close
747 do_close_internal(struct netconn *conn)
752 LWIP_ASSERT("invalid conn", (conn != NULL));
753 LWIP_ASSERT("this is for tcp netconns only", (conn->type == NETCONN_TCP));
754 LWIP_ASSERT("conn must be in state NETCONN_CLOSE", (conn->state == NETCONN_CLOSE));
755 LWIP_ASSERT("pcb already closed", (conn->pcb.tcp != NULL));
756 LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL);
758 shut = conn->current_msg->msg.sd.shut;
766 tcp_arg(conn->pcb.tcp, NULL);
768 if (conn->pcb.tcp->state == LISTEN) {
769 tcp_accept(conn->pcb.tcp, NULL);
773 tcp_recv(conn->pcb.tcp, NULL);
774 tcp_accept(conn->pcb.tcp, NULL);
777 tcp_sent(conn->pcb.tcp, NULL);
780 tcp_poll(conn->pcb.tcp, NULL, 4);
781 tcp_err(conn->pcb.tcp, NULL);
786 err = tcp_close(conn->pcb.tcp);
788 err = tcp_shutdown(conn->pcb.tcp, shut_rx, shut_tx);
792 conn->current_msg->err = ERR_OK;
793 conn->current_msg = NULL;
794 conn->state = NETCONN_NONE;
796 /* Set back some callback pointers as conn is going away */
797 conn->pcb.tcp = NULL;
800 API_EVENT(conn, NETCONN_EVT_ERROR, 0);
803 API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0);
806 API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0);
809 sys_sem_signal(&conn->op_completed);
813 LWIP_ASSERT("Closing a listen pcb may not fail!", (conn->pcb.tcp->state != LISTEN));
814 tcp_sent(conn->pcb.tcp, sent_tcp);
815 tcp_poll(conn->pcb.tcp, poll_tcp, 4);
816 tcp_err(conn->pcb.tcp, err_tcp);
817 tcp_arg(conn->pcb.tcp, conn);
835 if ((msg->conn->state != NETCONN_NONE) &&
836 (msg->conn->state != NETCONN_LISTEN) &&
837 (msg->conn->state != NETCONN_CONNECT)) {
839 LWIP_ASSERT("msg->conn->type == NETCONN_TCP", msg->conn->type == NETCONN_TCP);
843 (msg->conn->state != NETCONN_CONNECT) || IN_NONBLOCKING_CONNECT(msg->conn));
845 netconn_drain(msg->conn);
847 if (msg->conn->pcb.tcp != NULL) {
849 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
852 raw_remove(msg->conn->pcb.raw);
857 msg->conn->pcb.udp->recv_arg = NULL;
858 udp_remove(msg->conn->pcb.udp);
863 LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL &&
864 msg->conn->write_offset == 0);
865 msg->conn->state = NETCONN_CLOSE;
867 msg->conn->current_msg = msg;
868 do_close_internal(msg->conn);
876 msg->conn->pcb.tcp = NULL;
882 API_EVENT(msg->conn, NETCONN_EVT_RCVPLUS, 0);
883 API_EVENT(msg->conn, NETCONN_EVT_SENDPLUS, 0);
885 if (sys_sem_valid(&msg->conn->op_completed)) {
886 sys_sem_signal(&msg->conn->op_completed);
900 if (ERR_IS_FATAL(msg->conn->last_err)) {
901 msg->err = msg->conn->last_err;
904 if (msg->conn->pcb.tcp != NULL) {
905 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
908 msg->err = raw_bind(msg->conn->pcb.raw, msg->msg.bc.ipaddr);
913 msg->err = udp_bind(msg->conn->pcb.udp, msg->msg.bc.ipaddr, msg->msg.bc.port);
918 msg->err = tcp_bind(msg->conn->pcb.tcp, msg->msg.bc.ipaddr, msg->msg.bc.port);
939 struct netconn *conn;
944 conn = (struct netconn *)arg;
946 if (conn == NULL) {
950 LWIP_ASSERT("conn->state == NETCONN_CONNECT", conn->state == NETCONN_CONNECT);
951 LWIP_ASSERT("(conn->current_msg != NULL) || conn->in_non_blocking_connect",
952 (conn->current_msg != NULL) || IN_NONBLOCKING_CONNECT(conn));
954 if (conn->current_msg != NULL) {
955 conn->current_msg->err = err;
957 if ((conn->type == NETCONN_TCP) && (err == ERR_OK)) {
958 setup_tcp(conn);
960 was_blocking = !IN_NONBLOCKING_CONNECT(conn);
961 SET_NONBLOCKING_CONNECT(conn, 0);
962 conn->current_msg = NULL;
963 conn->state = NETCONN_NONE;
965 NETCONN_SET_SAFE_ERR(conn, ERR_OK);
967 API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0);
970 sys_sem_signal(&conn->op_completed);
986 if (msg->conn->pcb.tcp == NULL) {
990 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
993 msg->err = raw_connect(msg->conn->pcb.raw, msg->msg.bc.ipaddr);
998 msg->err = udp_connect(msg->conn->pcb.udp, msg->msg.bc.ipaddr, msg->msg.bc.port);
1004 if (msg->conn->state != NETCONN_NONE) {
1007 setup_tcp(msg->conn);
1008 msg->err = tcp_connect(msg->conn->pcb.tcp, msg->msg.bc.ipaddr,
1011 u8_t non_blocking = netconn_is_nonblocking(msg->conn);
1012 msg->conn->state = NETCONN_CONNECT;
1013 SET_NONBLOCKING_CONNECT(msg->conn, non_blocking);
1017 msg->conn->current_msg = msg;
1031 sys_sem_signal(&msg->conn->op_completed);
1045 if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_UDP) {
1046 udp_disconnect(msg->conn->pcb.udp);
1066 if (ERR_IS_FATAL(msg->conn->last_err)) {
1067 msg->err = msg->conn->last_err;
1070 if (msg->conn->pcb.tcp != NULL) {
1071 if (msg->conn->type == NETCONN_TCP) {
1072 if (msg->conn->state == NETCONN_NONE) {
1074 struct tcp_pcb* lpcb = tcp_listen_with_backlog(msg->conn->pcb.tcp, msg->msg.lb.backlog);
1076 struct tcp_pcb* lpcb = tcp_listen(msg->conn->pcb.tcp);
1083 if (sys_mbox_valid(&msg->conn->recvmbox)) {
1085 sys_mbox_free(&msg->conn->recvmbox);
1086 sys_mbox_set_invalid(&msg->conn->recvmbox);
1089 if (!sys_mbox_valid(&msg->conn->acceptmbox)) {
1090 msg->err = sys_mbox_new(&msg->conn->acceptmbox, DEFAULT_ACCEPTMBOX_SIZE);
1093 msg->conn->state = NETCONN_LISTEN;
1094 msg->conn->pcb.tcp = lpcb;
1095 tcp_arg(msg->conn->pcb.tcp, msg->conn);
1096 tcp_accept(msg->conn->pcb.tcp, accept_function);
1100 msg->conn->pcb.tcp = NULL;
1122 if (ERR_IS_FATAL(msg->conn->last_err)) {
1123 msg->err = msg->conn->last_err;
1126 if (msg->conn->pcb.tcp != NULL) {
1127 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
1131 msg->err = raw_send(msg->conn->pcb.raw, msg->msg.b->p);
1133 msg->err = raw_sendto(msg->conn->pcb.raw, msg->msg.b->p, &msg->msg.b->addr);
1141 msg->err = udp_send_chksum(msg->conn->pcb.udp, msg->msg.b->p,
1144 msg->err = udp_sendto_chksum(msg->conn->pcb.udp, msg->msg.b->p,
1150 msg->err = udp_send(msg->conn->pcb.udp, msg->msg.b->p);
1152 msg->err = udp_sendto(msg->conn->pcb.udp, msg->msg.b->p, &msg->msg.b->addr, msg->msg.b->port);
1176 if (msg->conn->pcb.tcp != NULL) {
1177 if (msg->conn->type == NETCONN_TCP) {
1179 if (msg->conn->pcb.tcp->state == LISTEN) {
1180 tcp_accepted(msg->conn->pcb.tcp);
1187 tcp_recved(msg->conn->pcb.tcp, recved);
1203 * @param conn netconn (that is currently in state NETCONN_WRITE) to process
1208 do_writemore(struct netconn *conn)
1215 u8_t dontblock = netconn_is_nonblocking(conn) ||
1216 (conn->current_msg->msg.w.apiflags & NETCONN_DONTBLOCK);
1217 u8_t apiflags = conn->current_msg->msg.w.apiflags;
1219 LWIP_ASSERT("conn != NULL", conn != NULL);
1220 LWIP_ASSERT("conn->state == NETCONN_WRITE", (conn->state == NETCONN_WRITE));
1221 LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL);
1222 LWIP_ASSERT("conn->pcb.tcp != NULL", conn->pcb.tcp != NULL);
1223 LWIP_ASSERT("conn->write_offset < conn->current_msg->msg.w.len",
1224 conn->write_offset < conn->current_msg->msg.w.len);
1227 if ((conn->send_timeout != 0) &&
1228 ((s32_t)(sys_now() - conn->current_msg->msg.w.time_started) >= conn->send_timeout)) {
1230 if (conn->write_offset == 0) {
1233 conn->current_msg->msg.w.len = 0;
1237 conn->current_msg->msg.w.len = conn->write_offset;
1242 dataptr = (u8_t*)conn->current_msg->msg.w.dataptr + conn->write_offset;
1243 diff = conn->current_msg->msg.w.len - conn->write_offset;
1247 conn->flags |= NETCONN_FLAG_WRITE_DELAYED;
1253 available = tcp_sndbuf(conn->pcb.tcp);
1264 conn->flags |= NETCONN_FLAG_WRITE_DELAYED;
1269 LWIP_ASSERT("do_writemore: invalid length!", ((conn->write_offset + len) <= conn->current_msg->msg.w.len));
1270 err = tcp_write(conn->pcb.tcp, dataptr, len, apiflags);
1274 if (dontblock && (len < conn->current_msg->msg.w.len)) {
1277 API_EVENT(conn, NETCONN_EVT_SENDMINUS, len);
1278 conn->flags |= NETCONN_FLAG_CHECK_WRITESPACE;
1279 } else if ((tcp_sndbuf(conn->pcb.tcp) <= TCP_SNDLOWAT) ||
1280 (tcp_sndqueuelen(conn->pcb.tcp) >= TCP_SNDQUEUELOWAT)) {
1283 API_EVENT(conn, NETCONN_EVT_SENDMINUS, len);
1288 conn->write_offset += len;
1289 if ((conn->write_offset == conn->current_msg->msg.w.len) || dontblock) {
1291 conn->current_msg->msg.w.len = conn->write_offset;
1294 conn->write_offset = 0;
1296 tcp_output(conn->pcb.tcp);
1303 tcp_output(conn->pcb.tcp);
1306 conn->flags |= NETCONN_FLAG_WRITE_DELAYED;
1312 conn->current_msg->msg.w.len = 0;
1318 conn->current_msg->err = err;
1319 conn->current_msg = NULL;
1320 conn->state = NETCONN_NONE;
1322 if ((conn->flags & NETCONN_FLAG_WRITE_DELAYED) != 0)
1325 sys_sem_signal(&conn->op_completed);
1345 if (ERR_IS_FATAL(msg->conn->last_err)) {
1346 msg->err = msg->conn->last_err;
1348 if (msg->conn->type == NETCONN_TCP) {
1350 if (msg->conn->state != NETCONN_NONE) {
1353 } else if (msg->conn->pcb.tcp != NULL) {
1354 msg->conn->state = NETCONN_WRITE;
1356 LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL &&
1357 msg->conn->write_offset == 0);
1359 msg->conn->current_msg = msg;
1360 msg->conn->write_offset = 0;
1362 msg->conn->flags &= ~NETCONN_FLAG_WRITE_DELAYED;
1363 if (do_writemore(msg->conn) != ERR_OK) {
1364 LWIP_ASSERT("state!", msg->conn->state == NETCONN_WRITE);
1366 sys_arch_sem_wait(&msg->conn->op_completed, 0);
1368 LWIP_ASSERT("state!", msg->conn->state == NETCONN_NONE);
1371 do_writemore(msg->conn);
1400 if (msg->conn->pcb.ip != NULL) {
1401 *(msg->msg.ad.ipaddr) = (msg->msg.ad.local ? msg->conn->pcb.ip->local_ip :
1402 msg->conn->pcb.ip->remote_ip);
1405 switch (NETCONNTYPE_GROUP(msg->conn->type)) {
1409 *(msg->msg.ad.port) = msg->conn->pcb.raw->protocol;
1419 *(msg->msg.ad.port) = msg->conn->pcb.udp->local_port;
1421 if ((msg->conn->pcb.udp->flags & UDP_FLAGS_CONNECTED) == 0) {
1424 *(msg->msg.ad.port) = msg->conn->pcb.udp->remote_port;
1431 *(msg->msg.ad.port) = (msg->msg.ad.local?msg->conn->pcb.tcp->local_port:msg->conn->pcb.tcp->remote_port);
1455 if ((msg->conn->state != NETCONN_NONE) && (msg->conn->state != NETCONN_LISTEN)) {
1457 LWIP_ASSERT("msg->conn->type == NETCONN_TCP", msg->conn->type == NETCONN_TCP);
1459 } else if ((msg->conn->pcb.tcp != NULL) && (msg->conn->type == NETCONN_TCP)) {
1460 if ((msg->msg.sd.shut != NETCONN_SHUT_RDWR) && (msg->conn->state == NETCONN_LISTEN)) {
1466 netconn_drain(msg->conn);
1468 LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL &&
1469 msg->conn->write_offset == 0);
1470 msg->conn->state = NETCONN_CLOSE;
1471 msg->conn->current_msg = msg;
1472 do_close_internal(msg->conn);
1481 sys_sem_signal(&msg->conn->op_completed);
1494 if (ERR_IS_FATAL(msg->conn->last_err)) {
1495 msg->err = msg->conn->last_err;
1497 if (msg->conn->pcb.tcp != NULL) {
1498 if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_UDP) {