mirror
/
devilutionX-lwip
mirror of https://github.com/diasurgical/lwip.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Add non-blocking support for connect (partly from patch #6860) plus many cleanups in socket & netconn API

STABLE-2_1_x
goldsimon 16 years ago
parent
1dd8300e69
commit
e58f4c567a
8 changed files with 204 additions and 133 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 5
      CHANGELOG
  2. 4
      src/api/api_lib.c
  3. 229
      src/api/api_msg.c
  4. 22
      src/api/err.c
  5. 38
      src/api/sockets.c
  6. 11
      src/include/lwip/api.h
  7. 24
      src/include/lwip/err.h
  8. 4
      src/include/lwip/sockets.h

5
CHANGELOG
Unescape View File

@ -19,6 +19,11 @@ HISTORY
++ New features:
2010-01-29: Simon Goldschmidt (patch by Laura Garrett)
* api.h, sockets.h, err.h, api_lib.c, api_msg.c, sockets.c, err.c:
Add non-blocking support for connect (partly from patch #6860),
plus many cleanups in socket & netconn API.
2010-01-27: Simon Goldschmidt
* opt.h, tcp.h, init.c, api_msg.c: Added TCP_SNDQUEUELOWAT corresponding
to TCP_SNDLOWAT and added tcp_sndqueuelen() - this fixes bug #28605

4
src/api/api_lib.c
Unescape View File

@ -111,7 +111,6 @@ netconn_delete(struct netconn *conn)
msg.msg.conn = conn;
tcpip_apimsg(&msg);
conn->pcb.tcp = NULL;
netconn_free(conn);
/* don't care for return value of do_delconn since it only calls void functions */
@ -493,6 +492,9 @@ netconn_write(struct netconn *conn, const void *dataptr, size_t size, u8_t apifl
LWIP_ERROR("netconn_write: invalid conn", (conn != NULL), return ERR_ARG;);
LWIP_ERROR("netconn_write: invalid conn->type", (conn->type == NETCONN_TCP), return ERR_VAL;);
if (size == 0) {
return ERR_OK;
}
msg.function = do_write;
msg.msg.conn = conn;

229
src/api/api_msg.c
Unescape View File

@ -98,7 +98,8 @@ recv_raw(void *arg, struct raw_pcb *pcb, struct pbuf *p,
}
}
if(q != NULL) {
if (q != NULL) {
u16_t len;
buf = (struct netbuf *)memp_malloc(MEMP_NETBUF);
if (buf == NULL) {
pbuf_free(q);
@ -110,13 +111,14 @@ recv_raw(void *arg, struct raw_pcb *pcb, struct pbuf *p,
buf->addr = &(((struct ip_hdr*)(q->payload))->src);
buf->port = pcb->protocol;
len = q->tot_len;
if (sys_mbox_trypost(conn->recvmbox, buf) != ERR_OK) {
netbuf_delete(buf);
return 0;
} else {
SYS_ARCH_INC(conn->recv_avail, q->tot_len);
SYS_ARCH_INC(conn->recv_avail, len);
/* Register event with callback */
API_EVENT(conn, NETCONN_EVT_RCVPLUS, q->tot_len);
API_EVENT(conn, NETCONN_EVT_RCVPLUS, len);
}
}
}
@ -138,6 +140,7 @@ recv_udp(void *arg, struct udp_pcb *pcb, struct pbuf *p,
{
struct netbuf *buf;
struct netconn *conn;
u16_t len;
#if LWIP_SO_RCVBUF
int recv_avail;
#endif /* LWIP_SO_RCVBUF */
@ -179,13 +182,14 @@ recv_udp(void *arg, struct udp_pcb *pcb, struct pbuf *p,
#endif /* LWIP_NETBUF_RECVINFO */
}
len = p->tot_len;
if (sys_mbox_trypost(conn->recvmbox, buf) != ERR_OK) {
netbuf_delete(buf);
return;
} else {
SYS_ARCH_INC(conn->recv_avail, p->tot_len);
SYS_ARCH_INC(conn->recv_avail, len);
/* Register event with callback */
API_EVENT(conn, NETCONN_EVT_RCVPLUS, p->tot_len);
API_EVENT(conn, NETCONN_EVT_RCVPLUS, len);
}
}
#endif /* LWIP_UDP */
@ -220,20 +224,24 @@ recv_tcp(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err)
}
return ERR_OK;
}
/* Unlike for UDP or RAW pcbs, don't check for available space
using recv_avail since that could break the connection
(data is already ACKed) */
/* don't overwrite fatal errors! */
NETCONN_SET_SAFE_ERR(conn, err);
if (p != NULL) {
len = p->tot_len;
SYS_ARCH_INC(conn->recv_avail, len);
} else {
len = 0;
}
if (sys_mbox_trypost(conn->recvmbox, p) != ERR_OK) {
/* don't deallocate p: it is presented to us later again from tcp_fasttmr! */
return ERR_MEM;
} else {
SYS_ARCH_INC(conn->recv_avail, len);
/* Register event with callback */
API_EVENT(conn, NETCONN_EVT_RCVPLUS, len);
}
@ -265,6 +273,7 @@ poll_tcp(void *arg, struct tcp_pcb *pcb)
} else if (conn->state == NETCONN_CLOSE) {
do_close_internal(conn);
}
/* @todo: implement connect timeout here? */
return ERR_OK;
}
@ -285,7 +294,6 @@ sent_tcp(void *arg, struct tcp_pcb *pcb, u16_t len)
LWIP_ASSERT("conn != NULL", (conn != NULL));
if (conn->state == NETCONN_WRITE) {
LWIP_ASSERT("conn->pcb.tcp != NULL", conn->pcb.tcp != NULL);
do_writemore(conn);
} else if (conn->state == NETCONN_CLOSE) {
do_close_internal(conn);
@ -327,7 +335,7 @@ err_tcp(void *arg, err_t err)
conn->last_err = err;
SYS_ARCH_UNPROTECT(lev);
/* API_EVENT might call tcp_tmr, so reset conn->state now */
/* reset conn->state now before waking up other threads */
old_state = conn->state;
conn->state = NETCONN_NONE;
@ -347,13 +355,17 @@ err_tcp(void *arg, err_t err)
(old_state == NETCONN_CONNECT)) {
/* calling do_writemore/do_close_internal is not necessary
since the pcb has already been deleted! */
/* set error return code */
LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL);
conn->current_msg->err = err;
conn->current_msg = NULL;
/* wake up the waiting task */
sys_sem_signal(conn->op_completed);
int was_nonblocking_connect = conn->in_non_blocking_connect;
conn->in_non_blocking_connect = 0;
if (!was_nonblocking_connect) {
/* set error return code */
LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL);
conn->current_msg->err = err;
conn->current_msg = NULL;
/* wake up the waiting task */
sys_sem_signal(conn->op_completed);
}
} else {
LWIP_ASSERT("conn->current_msg == NULL", conn->current_msg == NULL);
}
@ -415,7 +427,7 @@ accept_function(void *arg, struct tcp_pcb *newpcb, err_t err)
newconn->last_err = err;
if (sys_mbox_trypost(conn->acceptmbox, newconn) != ERR_OK) {
/* When returning != ERR_OK, the connection is aborted in tcp_process(),
/* When returning != ERR_OK, the pcb is aborted in tcp_process(),
so do nothing here! */
newconn->pcb.tcp = NULL;
/* no need to drain since we know the recvmbox is empty. */
@ -591,6 +603,8 @@ netconn_alloc(enum netconn_type t, netconn_callback callback)
#if LWIP_SO_RCVBUF
conn->recv_bufsize = RECV_BUFSIZE_DEFAULT;
#endif /* LWIP_SO_RCVBUF */
conn->non_blocking = 0;
conn->in_non_blocking_connect = 0;
return conn;
}
@ -707,8 +721,8 @@ do_close_internal(struct netconn *conn)
conn->state = NETCONN_NONE;
/* Set back some callback pointers as conn is going away */
conn->pcb.tcp = NULL;
/* Trigger select() in socket layer. This send should something else so the
errorfd is set, not the read and write fd! */
/* @todo: this lets select make the socket readable and writable,
which is wrong! errfd instead? */
API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0);
API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0);
/* wake up the application task */
@ -736,45 +750,52 @@ do_close_internal(struct netconn *conn)
void
do_delconn(struct api_msg_msg *msg)
{
/* Drain and delete mboxes */
netconn_drain(msg->conn);
/* @todo TCP: abort running write/connect? */
if ((msg->conn->state != NETCONN_NONE) && (msg->conn->state != NETCONN_LISTEN)) {
/* this only happens for TCP netconns */
LWIP_ASSERT("msg->conn->type == NETCONN_TCP", msg->conn->type == NETCONN_TCP);
msg->err = ERR_INPROGRESS;
} else {
/* Drain and delete mboxes */
netconn_drain(msg->conn);
if (msg->conn->pcb.tcp != NULL) {
if (msg->conn->pcb.tcp != NULL) {
switch (NETCONNTYPE_GROUP(msg->conn->type)) {
switch (NETCONNTYPE_GROUP(msg->conn->type)) {
#if LWIP_RAW
case NETCONN_RAW:
raw_remove(msg->conn->pcb.raw);
break;
case NETCONN_RAW:
raw_remove(msg->conn->pcb.raw);
break;
#endif /* LWIP_RAW */
#if LWIP_UDP
case NETCONN_UDP:
msg->conn->pcb.udp->recv_arg = NULL;
udp_remove(msg->conn->pcb.udp);
break;
case NETCONN_UDP:
msg->conn->pcb.udp->recv_arg = NULL;
udp_remove(msg->conn->pcb.udp);
break;
#endif /* LWIP_UDP */
#if LWIP_TCP
case NETCONN_TCP:
LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL &&
msg->conn->write_offset == 0);
msg->conn->state = NETCONN_CLOSE;
msg->conn->current_msg = msg;
do_close_internal(msg->conn);
/* API_EVENT is called inside do_close_internal, before releasing
the application thread, so we can return at this point! */
return;
case NETCONN_TCP:
LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL &&
msg->conn->write_offset == 0);
msg->conn->state = NETCONN_CLOSE;
msg->conn->current_msg = msg;
do_close_internal(msg->conn);
/* API_EVENT is called inside do_close_internal, before releasing
the application thread, so we can return at this point! */
return;
#endif /* LWIP_TCP */
default:
break;
default:
break;
}
msg->conn->pcb.tcp = NULL;
}
}
/* tcp netconns don't come here! */
/* Trigger select() in socket layer. This send should something else so the
errorfd is set, not the read and write fd! */
API_EVENT(msg->conn, NETCONN_EVT_RCVPLUS, 0);
API_EVENT(msg->conn, NETCONN_EVT_SENDPLUS, 0);
/* tcp netconns don't come here! */
/* @todo: this lets select make the socket readable and writable,
which is wrong! errfd instead? */
API_EVENT(msg->conn, NETCONN_EVT_RCVPLUS, 0);
API_EVENT(msg->conn, NETCONN_EVT_SENDPLUS, 0);
}
if (msg->conn->op_completed != SYS_SEM_NULL) {
sys_sem_signal(msg->conn->op_completed);
}
@ -830,6 +851,7 @@ static err_t
do_connected(void *arg, struct tcp_pcb *pcb, err_t err)
{
struct netconn *conn;
int was_blocking;
LWIP_UNUSED_ARG(pcb);
@ -840,15 +862,32 @@ do_connected(void *arg, struct tcp_pcb *pcb, err_t err)
}
LWIP_ASSERT("conn->state == NETCONN_CONNECT", conn->state == NETCONN_CONNECT);
LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL);
LWIP_ASSERT("(conn->current_msg != NULL) || conn->in_non_blocking_connect",
(conn->current_msg != NULL) || conn->in_non_blocking_connect);
conn->current_msg->err = err;
if (conn->current_msg != NULL) {
conn->current_msg->err = err;
}
if ((conn->type == NETCONN_TCP) && (err == ERR_OK)) {
setup_tcp(conn);
}
was_blocking = !conn->in_non_blocking_connect;
conn->in_non_blocking_connect = 0;
conn->current_msg = NULL;
conn->state = NETCONN_NONE;
sys_sem_signal(conn->op_completed);
if (!was_blocking) {
SYS_ARCH_DECL_PROTECT(lev);
SYS_ARCH_PROTECT(lev);
if (conn->last_err == ERR_INPROGRESS) {
conn->last_err = ERR_OK;
}
SYS_ARCH_UNPROTECT(lev);
}
API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0);
if (was_blocking) {
sys_sem_signal(conn->op_completed);
}
return ERR_OK;
}
#endif /* LWIP_TCP */
@ -866,44 +905,48 @@ do_connect(struct api_msg_msg *msg)
if (msg->conn->pcb.tcp == NULL) {
/* This may happen when calling netconn_connect() a second time */
msg->err = ERR_CLSD;
sys_sem_signal(msg->conn->op_completed);
return;
}
switch (NETCONNTYPE_GROUP(msg->conn->type)) {
} else {
switch (NETCONNTYPE_GROUP(msg->conn->type)) {
#if LWIP_RAW
case NETCONN_RAW:
msg->err = raw_connect(msg->conn->pcb.raw, msg->msg.bc.ipaddr);
sys_sem_signal(msg->conn->op_completed);
break;
#endif /* LWIP_RAW */
#if LWIP_UDP
case NETCONN_UDP:
msg->err = udp_connect(msg->conn->pcb.udp, msg->msg.bc.ipaddr, msg->msg.bc.port);
sys_sem_signal(msg->conn->op_completed);
break;
#endif /* LWIP_UDP */
#if LWIP_TCP
case NETCONN_TCP:
setup_tcp(msg->conn);
msg->err = tcp_connect(msg->conn->pcb.tcp, msg->msg.bc.ipaddr, msg->msg.bc.port,
do_connected);
/* sys_sem_signal() is called from do_connected (or err_tcp()),
* when the connection is established! */
if (msg->err == ERR_OK) {
msg->conn->state = NETCONN_CONNECT;
msg->conn->current_msg = msg;
/* Prevent connect while doing any other action. */
if (msg->conn->state != NETCONN_NONE) {
msg->err = ERR_ISCONN;
} else {
/* tcp_connect failed, so do_connected will not be called: return now */
sys_sem_signal(msg->conn->op_completed);
setup_tcp(msg->conn);
msg->err = tcp_connect(msg->conn->pcb.tcp, msg->msg.bc.ipaddr,
msg->msg.bc.port, do_connected);
if (msg->err == ERR_OK) {
msg->conn->state = NETCONN_CONNECT;
msg->conn->in_non_blocking_connect = msg->conn->non_blocking;
if (msg->conn->non_blocking) {
msg->err = ERR_INPROGRESS;
} else {
msg->conn->current_msg = msg;
/* sys_sem_signal() is called from do_connected (or err_tcp()),
* when the connection is established! */
return;
}
}
}
break;
#endif /* LWIP_TCP */
default:
LWIP_ERROR("Invalid netconn type", 0, do{ msg->err = ERR_VAL;
sys_sem_signal(msg->conn->op_completed); }while(0));
LWIP_ERROR("Invalid netconn type", 0, do{ msg->err = ERR_VAL; }while(0));
break;
}
}
sys_sem_signal(msg->conn->op_completed);
}
/**
@ -944,13 +987,14 @@ do_listen(struct api_msg_msg *msg)
msg->err = ERR_CONN;
if (msg->conn->pcb.tcp != NULL) {
if (msg->conn->type == NETCONN_TCP) {
if (msg->conn->pcb.tcp->state == CLOSED) {
if (msg->conn->state == NETCONN_NONE) {
#if TCP_LISTEN_BACKLOG
struct tcp_pcb* lpcb = tcp_listen_with_backlog(msg->conn->pcb.tcp, msg->msg.lb.backlog);
#else /* TCP_LISTEN_BACKLOG */
struct tcp_pcb* lpcb = tcp_listen(msg->conn->pcb.tcp);
#endif /* TCP_LISTEN_BACKLOG */
if (lpcb == NULL) {
/* in this case, the old pcb is still allocated */
msg->err = ERR_MEM;
} else {
/* delete the recvmbox and allocate the acceptmbox */
@ -970,6 +1014,10 @@ do_listen(struct api_msg_msg *msg)
msg->conn->pcb.tcp = lpcb;
tcp_arg(msg->conn->pcb.tcp, msg->conn);
tcp_accept(msg->conn->pcb.tcp, accept_function);
} else {
/* since the old pcb is already deallocated, free lpcb now */
tcp_close(lpcb);
msg->conn->pcb.tcp = NULL;
}
}
}
@ -1072,6 +1120,9 @@ do_writemore(struct netconn *conn)
LWIP_ASSERT("conn != NULL", conn != NULL);
LWIP_ASSERT("conn->state == NETCONN_WRITE", (conn->state == NETCONN_WRITE));
LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL);
LWIP_ASSERT("conn->pcb.tcp != NULL", conn->pcb.tcp != NULL);
LWIP_ASSERT("conn->write_offset < conn->current_msg->msg.w.len",
conn->write_offset < conn->current_msg->msg.w.len);
dataptr = (u8_t*)conn->current_msg->msg.w.dataptr + conn->write_offset;
diff = conn->current_msg->msg.w.len - conn->write_offset;
@ -1094,29 +1145,31 @@ do_writemore(struct netconn *conn)
err = tcp_write(conn->pcb.tcp, dataptr, len, conn->current_msg->msg.w.apiflags);
LWIP_ASSERT("do_writemore: invalid length!", ((conn->write_offset + len) <= conn->current_msg->msg.w.len));
/* if OK or memory error, check available space */
if (((err == ERR_OK) || (err == ERR_MEM)) &&
((tcp_sndbuf(conn->pcb.tcp) <= TCP_SNDLOWAT) ||
(tcp_sndqueuelen(conn->pcb.tcp) >= TCP_SNDQUEUELOWAT))) {
/* The queued byte- or pbuf-count exceeds the configured low-water limit,
let select mark this pcb as non-writable. */
API_EVENT(conn, NETCONN_EVT_SENDMINUS, len);
}
if (err == ERR_OK) {
conn->write_offset += len;
if (conn->write_offset == conn->current_msg->msg.w.len) {
/* everything was written */
write_finished = 1;
conn->write_offset = 0;
/* API_EVENT might call tcp_tmr, so reset conn->state now */
conn->state = NETCONN_NONE;
}
err = tcp_output_nagle(conn->pcb.tcp);
/* If the queued byte- or pbuf-count exceeds the configured low-water limit,
let select mark this pcb as non-writable. */
if ((err == ERR_OK) && (tcp_sndbuf(conn->pcb.tcp) <= TCP_SNDLOWAT) ||
(tcp_sndqueuelen(conn->pcb.tcp) >= TCP_SNDQUEUELOWAT)) {
API_EVENT(conn, NETCONN_EVT_SENDMINUS, len);
}
tcp_output_nagle(conn->pcb.tcp);
} else if (err == ERR_MEM) {
/* If ERR_MEM, we wait for sent_tcp or poll_tcp to be called
we do NOT return to the application thread, since ERR_MEM is
only a temporary error! */
/* tcp_enqueue returned ERR_MEM, try tcp_output anyway */
err = tcp_output(conn->pcb.tcp);
tcp_output(conn->pcb.tcp);
#if LWIP_TCPIP_CORE_LOCKING
conn->write_delayed = 1;
@ -1162,11 +1215,14 @@ do_write(struct api_msg_msg *msg)
} else {
if (msg->conn->type == NETCONN_TCP) {
#if LWIP_TCP
if (msg->conn->pcb.tcp != NULL) {
if (msg->conn->state != NETCONN_NONE) {
msg->err = ERR_INPROGRESS;
} else if (msg->conn->pcb.tcp != NULL) {
msg->conn->state = NETCONN_WRITE;
/* set all the variables used by do_writemore */
LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL &&
msg->conn->write_offset == 0);
LWIP_ASSERT("msg->msg.w.len != 0", msg->msg.w.len != 0);
msg->conn->current_msg = msg;
msg->conn->write_offset = 0;
#if LWIP_TCPIP_CORE_LOCKING
@ -1258,7 +1314,13 @@ void
do_close(struct api_msg_msg *msg)
{
#if LWIP_TCP
if ((msg->conn->pcb.tcp != NULL) && (msg->conn->type == NETCONN_TCP)) {
/* @todo: abort running write/connect? */
if ((msg->conn->state != NETCONN_NONE) && (msg->conn->state != NETCONN_LISTEN)) {
/* this only happens for TCP netconns */
LWIP_ASSERT("msg->conn->type == NETCONN_TCP", msg->conn->type == NETCONN_TCP);
msg->err = ERR_INPROGRESS;
} else if ((msg->conn->pcb.tcp != NULL) && (msg->conn->type == NETCONN_TCP)) {
/* Drain and delete mboxes */
netconn_drain(msg->conn);
LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL &&
msg->conn->write_offset == 0);
@ -1266,12 +1328,13 @@ do_close(struct api_msg_msg *msg)
msg->conn->current_msg = msg;
do_close_internal(msg->conn);
/* for tcp netconns, do_close_internal ACKs the message */
return;
} else
#endif /* LWIP_TCP */
{
msg->err = ERR_VAL;
sys_sem_signal(msg->conn->op_completed);
}
sys_sem_signal(msg->conn->op_completed);
}
#if LWIP_IGMP

22
src/api/err.c
Unescape View File

@ -44,18 +44,18 @@ static const char *err_strerr[] = {
"Ok.", /* ERR_OK 0 */
"Out of memory error.", /* ERR_MEM -1 */
"Buffer error.", /* ERR_BUF -2 */
"Timeout.", /* ERR_TIMEOUT -3 */
"Timeout.", /* ERR_TIMEOUT -3 */
"Routing problem.", /* ERR_RTE -4 */
"Connection aborted.", /* ERR_ABRT -5 */
"Connection reset.", /* ERR_RST -6 */
"Connection closed.", /* ERR_CLSD -7 */
"Not connected.", /* ERR_CONN -8 */
"Illegal value.", /* ERR_VAL -9 */
"Illegal argument.", /* ERR_ARG -10 */
"Address in use.", /* ERR_USE -11 */
"Low-level netif error.", /* ERR_IF -12 */
"Already connected.", /* ERR_ISCONN -13 */
"Operation in progress." /* ERR_INPROGRESS -14 */
"Operation in progress.", /* ERR_INPROGRESS -5 */
"Illegal value.", /* ERR_VAL -6 */
"Connection aborted.", /* ERR_ABRT -7 */
"Connection reset.", /* ERR_RST -8 */
"Connection closed.", /* ERR_CLSD -9 */
"Not connected.", /* ERR_CONN -10 */
"Illegal argument.", /* ERR_ARG -11 */
"Address in use.", /* ERR_USE -12 */
"Low-level netif error.", /* ERR_IF -13 */
"Already connected.", /* ERR_ISCONN -14 */
};
/**

38
src/api/sockets.c
Unescape View File

@ -67,11 +67,9 @@ struct lwip_socket {
/** number of times data was received, set by event_callback(),
tested by the receive and select functions */
s16_t rcvevent;
/** number of times data was received, set by event_callback(),
/** number of times data was ACKed (free send buffer), set by event_callback(),
tested by select */
u16_t sendevent;
/** socket flags (currently, only used for O_NONBLOCK) */
u16_t flags;
/** last error that occurred on this socket */
int err;
};
@ -130,16 +128,16 @@ static const int err_to_errno_table[] = {
ENOBUFS, /* ERR_BUF -2 Buffer error. */
ETIMEDOUT, /* ERR_TIMEOUT -3 Timeout */
EHOSTUNREACH, /* ERR_RTE -4 Routing problem. */
ECONNABORTED, /* ERR_ABRT -5 Connection aborted. */
ECONNRESET, /* ERR_RST -6 Connection reset. */
ESHUTDOWN, /* ERR_CLSD -7 Connection closed. */
ENOTCONN, /* ERR_CONN -8 Not connected. */
EINVAL, /* ERR_VAL -9 Illegal value. */
EIO, /* ERR_ARG -10 Illegal argument. */
EADDRINUSE, /* ERR_USE -11 Address in use. */
-1, /* ERR_IF -12 Low-level netif error */
-1, /* ERR_ISCONN -13 Already connected. */
EINPROGRESS /* ERR_INPROGRESS -14 Operation in progress */
EINPROGRESS, /* ERR_INPROGRESS -5 Operation in progress */
EINVAL, /* ERR_VAL -6 Illegal value. */
ECONNABORTED, /* ERR_ABRT -7 Connection aborted. */
ECONNRESET, /* ERR_RST -8 Connection reset. */
ESHUTDOWN, /* ERR_CLSD -9 Connection closed. */
ENOTCONN, /* ERR_CONN -10 Not connected. */
EIO, /* ERR_ARG -11 Illegal argument. */
EADDRINUSE, /* ERR_USE -12 Address in use. */
-1, /* ERR_IF -13 Low-level netif error */
-1, /* ERR_ISCONN -14 Already connected. */
};
#define ERR_TO_ERRNO_TABLE_SIZE \
@ -227,8 +225,8 @@ alloc_socket(struct netconn *newconn)
sockets[i].lastdata = NULL;
sockets[i].lastoffset = 0;
sockets[i].rcvevent = 0;
sockets[i].sendevent = 1; /* TCP send buf is empty */
sockets[i].flags = 0;
/* TCP sendbuf is empty, but not connected yet, so not yet writable */
sockets[i].sendevent = (newconn->type == NETCONN_TCP ? 0 : 1);
sockets[i].err = 0;
sys_sem_signal(socksem);
return i;
@ -260,7 +258,7 @@ lwip_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
if (!sock)
return -1;
if ((sock->flags & O_NONBLOCK) && (sock->rcvevent <= 0)) {
if ((sock->conn->non_blocking) && (sock->rcvevent <= 0)) {
LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d): returning EWOULDBLOCK\n", s));
sock_set_errno(sock, EWOULDBLOCK);
return -1;
@ -494,7 +492,7 @@ lwip_recvfrom(int s, void *mem, size_t len, int flags,
buf = sock->lastdata;
} else {
/* If this is non-blocking call, then check first */
if (((flags & MSG_DONTWAIT) || (sock->flags & O_NONBLOCK)) &&
if (((flags & MSG_DONTWAIT) || (sock->conn->non_blocking)) &&
(sock->rcvevent <= 0)) {
if (off > 0) {
/* already received data, return that */
@ -1958,10 +1956,10 @@ lwip_ioctl(int s, long cmd, void *argp)
case FIONBIO:
if (argp && *(u32_t*)argp)
sock->flags |= O_NONBLOCK;
sock->conn->non_blocking = 1;
else
sock->flags &= ~O_NONBLOCK;
LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(%d, FIONBIO, %d)\n", s, !!(sock->flags & O_NONBLOCK)));
sock->conn->non_blocking = 0;
LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(%d, FIONBIO, %d)\n", s, sock->conn->non_blocking));
sock_set_errno(sock, 0);
return 0;

11
src/include/lwip/api.h
Unescape View File

@ -61,6 +61,7 @@ extern "C" {
#define NETCONNTYPE_GROUP(t) (t&0xF0)
#define NETCONNTYPE_DATAGRAM(t) (t&0xE0)
/** Protocol family and type of the netconn */
enum netconn_type {
NETCONN_INVALID = 0,
/* NETCONN_TCP Group */
@ -73,6 +74,8 @@ enum netconn_type {
NETCONN_RAW = 0x40
};
/** Current state of the netconn. Non-TCP netconns are always
* in state NETCONN_NONE! */
enum netconn_state {
NETCONN_NONE,
NETCONN_WRITE,
@ -81,6 +84,7 @@ enum netconn_state {
NETCONN_CLOSE
};
/** Use to inform the callback function about changes */
enum netconn_evt {
NETCONN_EVT_RCVPLUS,
NETCONN_EVT_RCVMINUS,
@ -89,6 +93,7 @@ enum netconn_evt {
};
#if LWIP_IGMP
/** Used for netconn_join_leave_group() */
enum netconn_igmp {
NETCONN_JOIN,
NETCONN_LEAVE
@ -152,10 +157,14 @@ struct netconn {
#if LWIP_TCPIP_CORE_LOCKING
/** TCP: when data passed to netconn_write doesn't fit into the send buffer,
this temporarily stores whether to wake up the original application task
if data couldn't be sent in the first try. */
if data couldn't be sent in the first try. @todo: combine in 'flags' */
u8_t write_delayed;
#endif /* LWIP_TCPIP_CORE_LOCKING */
#endif /* LWIP_TCP */
/** Should this netconn avoid blocking? @todo: combine in 'flags' */
u8_t non_blocking;
/** Was the last connect action a non-blocking one? @todo: combine in 'flags' */
u8_t in_non_blocking_connect;
/** A callback function that is informed about events for this netconn */
netconn_callback callback;
};

24
src/include/lwip/err.h
Unescape View File

@ -54,24 +54,22 @@ typedef LWIP_ERR_T err_t;
#define ERR_BUF -2 /* Buffer error. */
#define ERR_TIMEOUT -3 /* Timeout. */
#define ERR_RTE -4 /* Routing problem. */
#define ERR_INPROGRESS -5 /* Operation in progress */
#define ERR_VAL -6 /* Illegal value. */
#define ERR_IS_FATAL(e) ((e) < ERR_RTE)
#define ERR_IS_FATAL(e) ((e) < ERR_VAL)
#define ERR_ABRT -5 /* Connection aborted. */
#define ERR_RST -6 /* Connection reset. */
#define ERR_CLSD -7 /* Connection closed. */
#define ERR_CONN -8 /* Not connected. */
#define ERR_ABRT -7 /* Connection aborted. */
#define ERR_RST -8 /* Connection reset. */
#define ERR_CLSD -9 /* Connection closed. */
#define ERR_CONN -10 /* Not connected. */
#define ERR_VAL -9 /* Illegal value. */
#define ERR_ARG -11 /* Illegal argument. */
#define ERR_ARG -10 /* Illegal argument. */
#define ERR_USE -12 /* Address in use. */
#define ERR_USE -11 /* Address in use. */
#define ERR_IF -12 /* Low-level netif error */
#define ERR_ISCONN -13 /* Already connected. */
#define ERR_INPROGRESS -14 /* Operation in progress */
#define ERR_IF -13 /* Low-level netif error */
#define ERR_ISCONN -14 /* Already connected. */
#ifdef LWIP_DEBUG

4
src/include/lwip/sockets.h
Unescape View File

@ -262,10 +262,6 @@ typedef struct ip_mreq {
#define SIOCATMARK _IOR('s', 7, unsigned long) /* at oob mark? */
#endif
/* Socket flags: */
#ifndef O_NONBLOCK
#define O_NONBLOCK 04000U
#endif
/* FD_SET used for lwip_select */
#ifndef FD_SET

Write Preview
Loading…
Cancel
Save