3 * Sockets BSD-Like API module
8 * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
11 * Redistribution and use in source and binary forms, with or without modification,
12 * are permitted provided that the following conditions are met:
14 * 1. Redistributions of source code must retain the above copyright notice,
15 * this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright notice,
17 * this list of conditions and the following disclaimer in the documentation
18 * and/or other materials provided with the distribution.
19 * 3. The name of the author may not be used to endorse or promote products
20 * derived from this software without specific prior written permission.
22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
23 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
24 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
25 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
26 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
27 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
30 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
33 * This file is part of the lwIP TCP/IP stack.
35 * Author: Adam Dunkels <adam@sics.se>
37 * Improved by Marc Boucher <marc@mbsi.ca> and David Haas <dhaas@alum.rpi.edu>
43 #if LWIP_SOCKET /* don't build if not configured for use in lwipopts.h */
45 #include "lwip/sockets.h"
48 #include "lwip/igmp.h"
49 #include "lwip/inet.h"
53 #include "lwip/tcpip.h"
55 #include "lwip/arch.h"
59 #define NUM_SOCKETS MEMP_NUM_NETCONN
61 /** Contains all internal pointers and states used for a socket */
63 /** sockets currently are built on netconns, each socket has one netconn */
65 /** data that was left from the previous read */
66 struct netbuf *lastdata;
67 /** offset in the data that was left from the previous read */
69 /** number of times data was received, set by event_callback(),
70 tested by the receive and select functions */
72 /** number of times data was received, set by event_callback(),
75 /** socket flags (currently, only used for O_NONBLOCK) */
77 /** last error that occurred on this socket */
81 /** Description for a task waiting in select */
82 struct lwip_select_cb {
83 /** Pointer to the next waiting task */
84 struct lwip_select_cb *next;
85 /** readset passed to select */
87 /** writeset passed to select */
89 /** unimplemented: exceptset passed to select */
91 /** don't signal the same semaphore twice: set to 1 when signalled */
93 /** semaphore to wake up a task waiting for select */
97 /** This struct is used to pass data to the set/getsockopt_internal
98 * functions running in tcpip_thread context (only a void* is allowed) */
99 struct lwip_setgetsockopt_data {
100 /** socket struct for which to change options */
101 struct lwip_socket *sock;
102 /** socket index for which to change options */
104 /** level of the option to process */
106 /** name of the option to process */
108 /** set: value to set the option to
109 * get: value of the option is stored here */
111 /** size of *optval */
113 /** if an error occures, it is temporarily stored here */
117 /** The global array of available sockets */
118 static struct lwip_socket sockets[NUM_SOCKETS];
119 /** The global list of tasks waiting for select */
120 static struct lwip_select_cb *select_cb_list;
122 /** Semaphore protecting the sockets array */
123 static sys_sem_t socksem;
124 /** Semaphore protecting select_cb_list */
125 static sys_sem_t selectsem;
127 /** Table to quickly map an lwIP error (err_t) to a socket error
128 * by using -err as an index */
129 static const int err_to_errno_table[] = {
130 0, /* ERR_OK 0 No error, everything OK. */
131 ENOMEM, /* ERR_MEM -1 Out of memory error. */
132 ENOBUFS, /* ERR_BUF -2 Buffer error. */
133 EHOSTUNREACH, /* ERR_RTE -3 Routing problem. */
134 ECONNABORTED, /* ERR_ABRT -4 Connection aborted. */
135 ECONNRESET, /* ERR_RST -5 Connection reset. */
136 ESHUTDOWN, /* ERR_CLSD -6 Connection closed. */
137 ENOTCONN, /* ERR_CONN -7 Not connected. */
138 EINVAL, /* ERR_VAL -8 Illegal value. */
139 EIO, /* ERR_ARG -9 Illegal argument. */
140 EADDRINUSE, /* ERR_USE -10 Address in use. */
141 -1, /* ERR_IF -11 Low-level netif error */
142 -1, /* ERR_ISCONN -12 Already connected. */
143 ETIMEDOUT, /* ERR_TIMEOUT -13 Timeout */
144 EINPROGRESS /* ERR_INPROGRESS -14 Operation in progress */
147 #define ERR_TO_ERRNO_TABLE_SIZE \
148 (sizeof(err_to_errno_table)/sizeof(err_to_errno_table[0]))
150 #define err_to_errno(err) \
151 ((unsigned)(-(err)) < ERR_TO_ERRNO_TABLE_SIZE ? \
152 err_to_errno_table[-(err)] : EIO)
155 #define set_errno(err) errno = (err)
157 #define set_errno(err)
160 #define sock_set_errno(sk, e) do { \
162 set_errno(sk->err); \
165 /* Forward delcaration of some functions */
166 static void event_callback(struct netconn *conn, enum netconn_evt evt, u16_t len);
167 static void lwip_getsockopt_internal(void *arg);
168 static void lwip_setsockopt_internal(void *arg);
171 * Initialize this module. This function has to be called before any other
172 * functions in this module!
175 lwip_socket_init(void)
177 socksem = sys_sem_new(1);
178 selectsem = sys_sem_new(1);
182 * Map a externally used socket index to the internal socket representation.
184 * @param s externally used socket index
185 * @return struct lwip_socket for the socket or NULL if not found
187 static struct lwip_socket *
190 struct lwip_socket *sock;
192 if ((s < 0) || (s >= NUM_SOCKETS)) {
193 LWIP_DEBUGF(SOCKETS_DEBUG, ("get_socket(%d): invalid\n", s));
201 LWIP_DEBUGF(SOCKETS_DEBUG, ("get_socket(%d): not active\n", s));
210 * Allocate a new socket for a given netconn.
212 * @param newconn the netconn for which to allocate a socket
213 * @return the index of the new socket; -1 on error
216 alloc_socket(struct netconn *newconn)
220 /* Protect socket array */
221 sys_sem_wait(socksem);
223 /* allocate a new socket identifier */
224 for (i = 0; i < NUM_SOCKETS; ++i) {
225 if (!sockets[i].conn) {
226 sockets[i].conn = newconn;
227 sockets[i].lastdata = NULL;
228 sockets[i].lastoffset = 0;
229 sockets[i].rcvevent = 0;
230 sockets[i].sendevent = 1; /* TCP send buf is empty */
231 sockets[i].flags = 0;
233 sys_sem_signal(socksem);
237 sys_sem_signal(socksem);
241 /* Below this, the well-known socket functions are implemented.
242 * Use google.com or opengroup.org to get a good description :-)
244 * Exceptions are documented!
248 lwip_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
250 struct lwip_socket *sock, *nsock;
251 struct netconn *newconn;
252 struct ip_addr naddr;
255 struct sockaddr_in sin;
258 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d)...\n", s));
259 sock = get_socket(s);
263 newconn = netconn_accept(sock->conn);
265 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d) failed, err=%d\n", s, sock->conn->err));
266 sock_set_errno(sock, err_to_errno(sock->conn->err));
270 /* get the IP address and port of the remote host */
271 err = netconn_peer(newconn, &naddr, &port);
273 netconn_delete(newconn);
274 sock_set_errno(sock, err_to_errno(err));
278 memset(&sin, 0, sizeof(sin));
279 sin.sin_len = sizeof(sin);
280 sin.sin_family = AF_INET;
281 sin.sin_port = htons(port);
282 sin.sin_addr.s_addr = naddr.addr;
284 if (*addrlen > sizeof(sin))
285 *addrlen = sizeof(sin);
287 SMEMCPY(addr, &sin, *addrlen);
289 newsock = alloc_socket(newconn);
291 netconn_delete(newconn);
292 sock_set_errno(sock, ENFILE);
295 LWIP_ASSERT("invalid socket index", (newsock >= 0) && (newsock < NUM_SOCKETS));
296 newconn->callback = event_callback;
297 nsock = &sockets[newsock];
298 LWIP_ASSERT("invalid socket pointer", nsock != NULL);
300 sys_sem_wait(socksem);
301 /* See event_callback: If data comes in right away after an accept, even
302 * though the server task might not have created a new socket yet.
303 * In that case, newconn->socket is counted down (newconn->socket--),
304 * so nsock->rcvevent is >= 1 here!
306 nsock->rcvevent += -1 - newconn->socket;
307 newconn->socket = newsock;
308 sys_sem_signal(socksem);
310 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d) returning new sock=%d addr=", s, newsock));
311 ip_addr_debug_print(SOCKETS_DEBUG, &naddr);
312 LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u\n", port));
314 sock_set_errno(sock, 0);
319 lwip_bind(int s, struct sockaddr *name, socklen_t namelen)
321 struct lwip_socket *sock;
322 struct ip_addr local_addr;
326 sock = get_socket(s);
330 LWIP_ERROR("lwip_bind: invalid address", ((namelen == sizeof(struct sockaddr_in)) &&
331 ((((struct sockaddr_in *)name)->sin_family) == AF_INET)),
332 sock_set_errno(sock, err_to_errno(ERR_ARG)); return -1;);
334 local_addr.addr = ((struct sockaddr_in *)name)->sin_addr.s_addr;
335 local_port = ((struct sockaddr_in *)name)->sin_port;
337 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_bind(%d, addr=", s));
338 ip_addr_debug_print(SOCKETS_DEBUG, &local_addr);
339 LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u)\n", ntohs(local_port)));
341 err = netconn_bind(sock->conn, &local_addr, ntohs(local_port));
344 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_bind(%d) failed, err=%d\n", s, err));
345 sock_set_errno(sock, err_to_errno(err));
349 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_bind(%d) succeeded\n", s));
350 sock_set_errno(sock, 0);
357 struct lwip_socket *sock;
359 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_close(%d)\n", s));
361 sock = get_socket(s);
366 netconn_delete(sock->conn);
368 sys_sem_wait(socksem);
369 if (sock->lastdata) {
370 netbuf_delete(sock->lastdata);
372 sock->lastdata = NULL;
373 sock->lastoffset = 0;
375 sock_set_errno(sock, 0);
376 sys_sem_signal(socksem);
381 lwip_connect(int s, const struct sockaddr *name, socklen_t namelen)
383 struct lwip_socket *sock;
386 sock = get_socket(s);
390 LWIP_ERROR("lwip_connect: invalid address", ((namelen == sizeof(struct sockaddr_in)) &&
391 ((((struct sockaddr_in *)name)->sin_family) == AF_INET)),
392 sock_set_errno(sock, err_to_errno(ERR_ARG)); return -1;);
394 if (((struct sockaddr_in *)name)->sin_family == AF_UNSPEC) {
395 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d, AF_UNSPEC)\n", s));
396 err = netconn_disconnect(sock->conn);
398 struct ip_addr remote_addr;
401 remote_addr.addr = ((struct sockaddr_in *)name)->sin_addr.s_addr;
402 remote_port = ((struct sockaddr_in *)name)->sin_port;
404 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d, addr=", s));
405 ip_addr_debug_print(SOCKETS_DEBUG, &remote_addr);
406 LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u)\n", ntohs(remote_port)));
408 err = netconn_connect(sock->conn, &remote_addr, ntohs(remote_port));
412 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d) failed, err=%d\n", s, err));
413 sock_set_errno(sock, err_to_errno(err));
417 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d) succeeded\n", s));
418 sock_set_errno(sock, 0);
423 * Set a socket into listen mode.
424 * The socket may not have been used for another connection previously.
426 * @param s the socket to set to listening mode
427 * @param backlog (ATTENTION: need TCP_LISTEN_BACKLOG=1)
428 * @return 0 on success, non-zero on failure
431 lwip_listen(int s, int backlog)
433 struct lwip_socket *sock;
436 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_listen(%d, backlog=%d)\n", s, backlog));
438 sock = get_socket(s);
442 /* limit the "backlog" parameter to fit in an u8_t */
446 if (backlog > 0xff) {
450 err = netconn_listen_with_backlog(sock->conn, backlog);
453 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_listen(%d) failed, err=%d\n", s, err));
454 sock_set_errno(sock, err_to_errno(err));
458 sock_set_errno(sock, 0);
463 lwip_recvfrom(int s, void *mem, int len, unsigned int flags,
464 struct sockaddr *from, socklen_t *fromlen)
466 struct lwip_socket *sock;
468 u16_t buflen, copylen, off = 0;
469 struct ip_addr *addr;
473 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d, %p, %d, 0x%x, ..)\n", s, mem, len, flags));
474 sock = get_socket(s);
479 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom: top while sock->lastdata=%p\n", (void*)sock->lastdata));
480 /* Check if there is data left from the last recv operation. */
481 if (sock->lastdata) {
482 buf = sock->lastdata;
484 /* If this is non-blocking call, then check first */
485 if (((flags & MSG_DONTWAIT) || (sock->flags & O_NONBLOCK)) && !sock->rcvevent) {
486 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d): returning EWOULDBLOCK\n", s));
487 sock_set_errno(sock, EWOULDBLOCK);
491 /* No data was left from the previous operation, so we try to get
492 some from the network. */
493 sock->lastdata = buf = netconn_recv(sock->conn);
494 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom: netconn_recv netbuf=%p\n", (void*)buf));
497 /* We should really do some error checking here. */
498 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d): buf == NULL!\n", s));
499 sock_set_errno(sock, (((sock->conn->pcb.ip!=NULL) && (sock->conn->err==ERR_OK))?ETIMEDOUT:err_to_errno(sock->conn->err)));
504 buflen = netbuf_len(buf);
505 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom: buflen=%d len=%d off=%d sock->lastoffset=%d\n", buflen, len, off, sock->lastoffset));
507 buflen -= sock->lastoffset;
515 /* copy the contents of the received buffer into
516 the supplied memory pointer mem */
517 netbuf_copy_partial(buf, (u8_t*)mem + off, copylen, sock->lastoffset);
521 if (netconn_type(sock->conn) == NETCONN_TCP) {
523 if ( (len <= 0) || (buf->p->flags & PBUF_FLAG_PUSH) || !sock->rcvevent) {
530 /* If we don't peek the incoming message... */
531 if ((flags & MSG_PEEK)==0) {
532 /* If this is a TCP socket, check if there is data left in the
533 buffer. If so, it should be saved in the sock structure for next
535 if ((sock->conn->type == NETCONN_TCP) && (buflen - copylen > 0)) {
536 sock->lastdata = buf;
537 sock->lastoffset += copylen;
538 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom: lastdata now netbuf=%p\n", (void*)buf));
540 sock->lastdata = NULL;
541 sock->lastoffset = 0;
542 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom: deleting netbuf=%p\n", (void*)buf));
550 /* Check to see from where the data was.*/
551 if (from && fromlen) {
552 struct sockaddr_in sin;
554 if (netconn_type(sock->conn) == NETCONN_TCP) {
555 addr = (struct ip_addr*)&(sin.sin_addr.s_addr);
556 netconn_getaddr(sock->conn, addr, &port, 0);
558 addr = netbuf_fromaddr(buf);
559 port = netbuf_fromport(buf);
562 memset(&sin, 0, sizeof(sin));
563 sin.sin_len = sizeof(sin);
564 sin.sin_family = AF_INET;
565 sin.sin_port = htons(port);
566 sin.sin_addr.s_addr = addr->addr;
568 if (*fromlen > sizeof(sin))
569 *fromlen = sizeof(sin);
571 SMEMCPY(from, &sin, *fromlen);
573 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d): addr=", s));
574 ip_addr_debug_print(SOCKETS_DEBUG, addr);
575 LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u len=%u\n", port, off));
578 struct sockaddr_in sin;
580 if (netconn_type(sock->conn) == NETCONN_TCP) {
581 addr = (struct ip_addr*)&(sin.sin_addr.s_addr);
582 netconn_getaddr(sock->conn, addr, &port, 0);
584 addr = netbuf_fromaddr(buf);
585 port = netbuf_fromport(buf);
588 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d): addr=", s));
589 ip_addr_debug_print(SOCKETS_DEBUG, addr);
590 LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u len=%u\n", port, off));
591 #endif /* SOCKETS_DEBUG */
594 sock_set_errno(sock, 0);
599 lwip_read(int s, void *mem, int len)
601 return lwip_recvfrom(s, mem, len, 0, NULL, NULL);
605 lwip_recv(int s, void *mem, int len, unsigned int flags)
607 return lwip_recvfrom(s, mem, len, flags, NULL, NULL);
611 lwip_send(int s, const void *data, int size, unsigned int flags)
613 struct lwip_socket *sock;
616 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_send(%d, data=%p, size=%d, flags=0x%x)\n",
617 s, data, size, flags));
619 sock = get_socket(s);
623 if (sock->conn->type!=NETCONN_TCP) {
624 #if (LWIP_UDP || LWIP_RAW)
625 return lwip_sendto(s, data, size, flags, NULL, 0);
627 sock_set_errno(sock, err_to_errno(ERR_ARG));
629 #endif /* (LWIP_UDP || LWIP_RAW) */
632 err = netconn_write(sock->conn, data, size, NETCONN_COPY | ((flags & MSG_MORE)?NETCONN_MORE:0));
634 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_send(%d) err=%d size=%d\n", s, err, size));
635 sock_set_errno(sock, err_to_errno(err));
636 return (err==ERR_OK?size:-1);
640 lwip_sendto(int s, const void *data, int size, unsigned int flags,
641 struct sockaddr *to, socklen_t tolen)
643 struct lwip_socket *sock;
644 struct ip_addr remote_addr;
646 #if !LWIP_TCPIP_CORE_LOCKING
651 sock = get_socket(s);
655 if (sock->conn->type==NETCONN_TCP) {
657 return lwip_send(s, data, size, flags);
659 sock_set_errno(sock, err_to_errno(ERR_ARG));
661 #endif /* LWIP_TCP */
664 LWIP_ASSERT("lwip_sendto: size must fit in u16_t",
665 ((size >= 0) && (size <= 0xffff)));
666 LWIP_ERROR("lwip_sendto: invalid address", (((to == NULL) && (tolen == 0)) ||
667 ((tolen == sizeof(struct sockaddr_in)) &&
668 ((((struct sockaddr_in *)to)->sin_family) == AF_INET))),
669 sock_set_errno(sock, err_to_errno(ERR_ARG)); return -1;);
671 #if LWIP_TCPIP_CORE_LOCKING
672 /* Should only be consider like a sample or a simple way to experiment this option (no check of "to" field...) */
675 p = pbuf_alloc(PBUF_TRANSPORT, 0, PBUF_REF);
679 p->payload = (void*)data;
680 p->len = p->tot_len = size;
682 remote_addr.addr = ((struct sockaddr_in *)to)->sin_addr.s_addr;
685 if (sock->conn->type==NETCONN_RAW) {
686 err = sock->conn->err = raw_sendto(sock->conn->pcb.raw, p, &remote_addr);
688 err = sock->conn->err = udp_sendto(sock->conn->pcb.udp, p, &remote_addr, ntohs(((struct sockaddr_in *)to)->sin_port));
696 /* initialize a buffer */
697 buf.p = buf.ptr = NULL;
699 remote_addr.addr = ((struct sockaddr_in *)to)->sin_addr.s_addr;
700 remote_port = ntohs(((struct sockaddr_in *)to)->sin_port);
701 buf.addr = &remote_addr;
702 buf.port = remote_port;
704 remote_addr.addr = 0;
710 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_sendto(%d, data=%p, size=%d, flags=0x%x to=",
711 s, data, size, flags));
712 ip_addr_debug_print(SOCKETS_DEBUG, &remote_addr);
713 LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u\n", remote_port));
715 /* make the buffer point to the data that should be sent */
716 if ((err = netbuf_ref(&buf, data, size)) == ERR_OK) {
718 err = netconn_send(sock->conn, &buf);
721 /* deallocated the buffer */
725 #endif /* LWIP_TCPIP_CORE_LOCKING */
726 sock_set_errno(sock, err_to_errno(err));
727 return (err==ERR_OK?size:-1);
731 lwip_socket(int domain, int type, int protocol)
733 struct netconn *conn;
736 LWIP_UNUSED_ARG(domain);
738 /* create a netconn */
741 conn = netconn_new_with_proto_and_callback(NETCONN_RAW, (u8_t)protocol, event_callback);
742 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%s, SOCK_RAW, %d) = ",
743 domain == PF_INET ? "PF_INET" : "UNKNOWN", protocol));
746 conn = netconn_new_with_callback( (protocol == IPPROTO_UDPLITE) ?
747 NETCONN_UDPLITE : NETCONN_UDP, event_callback);
748 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%s, SOCK_DGRAM, %d) = ",
749 domain == PF_INET ? "PF_INET" : "UNKNOWN", protocol));
752 conn = netconn_new_with_callback(NETCONN_TCP, event_callback);
753 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%s, SOCK_STREAM, %d) = ",
754 domain == PF_INET ? "PF_INET" : "UNKNOWN", protocol));
757 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%d, %d/UNKNOWN, %d) = -1\n",
758 domain, type, protocol));
764 LWIP_DEBUGF(SOCKETS_DEBUG, ("-1 / ENOBUFS (could not create netconn)\n"));
769 i = alloc_socket(conn);
772 netconn_delete(conn);
777 LWIP_DEBUGF(SOCKETS_DEBUG, ("%d\n", i));
783 lwip_write(int s, const void *data, int size)
785 return lwip_send(s, data, size, 0);
789 * Go through the readset and writeset lists and see which socket of the sockets
790 * set in the sets has events. On return, readset, writeset and exceptset have
791 * the sockets enabled that had events.
793 * exceptset is not used for now!!!
795 * @param maxfdp1 the highest socket index in the sets
796 * @param readset in: set of sockets to check for read events;
797 * out: set of sockets that had read events
798 * @param writeset in: set of sockets to check for write events;
799 * out: set of sockets that had write events
800 * @param exceptset not yet implemented
801 * @return number of sockets that had events (read+write)
804 lwip_selscan(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset)
807 fd_set lreadset, lwriteset, lexceptset;
808 struct lwip_socket *p_sock;
812 FD_ZERO(&lexceptset);
814 /* Go through each socket in each list to count number of sockets which
816 for(i = 0; i < maxfdp1; i++) {
817 if (FD_ISSET(i, readset)) {
818 /* See if netconn of this socket is ready for read */
819 p_sock = get_socket(i);
820 if (p_sock && (p_sock->lastdata || p_sock->rcvevent)) {
821 FD_SET(i, &lreadset);
822 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_selscan: fd=%d ready for reading\n", i));
826 if (FD_ISSET(i, writeset)) {
827 /* See if netconn of this socket is ready for write */
828 p_sock = get_socket(i);
829 if (p_sock && p_sock->sendevent) {
830 FD_SET(i, &lwriteset);
831 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_selscan: fd=%d ready for writing\n", i));
837 *writeset = lwriteset;
845 * Processing exceptset is not yet implemented.
848 lwip_select(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset,
849 struct timeval *timeout)
853 fd_set lreadset, lwriteset, lexceptset;
855 struct lwip_select_cb select_cb;
856 struct lwip_select_cb *p_selcb;
858 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_select(%d, %p, %p, %p, tvsec=%ld tvusec=%ld)\n",
859 maxfdp1, (void *)readset, (void *) writeset, (void *) exceptset,
860 timeout ? timeout->tv_sec : -1L, timeout ? timeout->tv_usec : -1L));
863 select_cb.readset = readset;
864 select_cb.writeset = writeset;
865 select_cb.exceptset = exceptset;
866 select_cb.sem_signalled = 0;
868 /* Protect ourselves searching through the list */
869 sys_sem_wait(selectsem);
876 lwriteset = *writeset;
880 lexceptset = *exceptset;
882 FD_ZERO(&lexceptset);
884 /* Go through each socket in each list to count number of sockets which
886 nready = lwip_selscan(maxfdp1, &lreadset, &lwriteset, &lexceptset);
888 /* If we don't have any current events, then suspend if we are supposed to */
890 if (timeout && timeout->tv_sec == 0 && timeout->tv_usec == 0) {
891 sys_sem_signal(selectsem);
899 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_select: no timeout, returning 0\n"));
905 /* add our semaphore to list */
906 /* We don't actually need any dynamic memory. Our entry on the
907 * list is only valid while we are in this function, so it's ok
908 * to use local variables */
910 select_cb.sem = sys_sem_new(0);
911 /* Note that we are still protected */
912 /* Put this select_cb on top of list */
913 select_cb.next = select_cb_list;
914 select_cb_list = &select_cb;
916 /* Now we can safely unprotect */
917 sys_sem_signal(selectsem);
919 /* Now just wait to be woken */
924 msectimeout = ((timeout->tv_sec * 1000) + ((timeout->tv_usec + 500)/1000));
929 i = sys_sem_wait_timeout(select_cb.sem, msectimeout);
931 /* Take us off the list */
932 sys_sem_wait(selectsem);
933 if (select_cb_list == &select_cb)
934 select_cb_list = select_cb.next;
936 for (p_selcb = select_cb_list; p_selcb; p_selcb = p_selcb->next) {
937 if (p_selcb->next == &select_cb) {
938 p_selcb->next = select_cb.next;
943 sys_sem_signal(selectsem);
945 sys_sem_free(select_cb.sem);
955 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_select: timeout expired\n"));
966 lwriteset = *writeset;
970 lexceptset = *exceptset;
972 FD_ZERO(&lexceptset);
975 nready = lwip_selscan(maxfdp1, &lreadset, &lwriteset, &lexceptset);
977 sys_sem_signal(selectsem);
982 *writeset = lwriteset;
984 *exceptset = lexceptset;
986 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_select: nready=%d\n", nready));
993 * Callback registered in the netconn layer for each socket-netconn.
994 * Processes recvevent (data available) and wakes up tasks waiting for select.
997 event_callback(struct netconn *conn, enum netconn_evt evt, u16_t len)
1000 struct lwip_socket *sock;
1001 struct lwip_select_cb *scb;
1003 LWIP_UNUSED_ARG(len);
1009 /* Data comes in right away after an accept, even though
1010 * the server task might not have created a new socket yet.
1011 * Just count down (or up) if that's the case and we
1012 * will use the data later. Note that only receive events
1013 * can happen before the new socket is set up. */
1014 sys_sem_wait(socksem);
1015 if (conn->socket < 0) {
1016 if (evt == NETCONN_EVT_RCVPLUS) {
1019 sys_sem_signal(socksem);
1022 sys_sem_signal(socksem);
1025 sock = get_socket(s);
1033 sys_sem_wait(selectsem);
1034 /* Set event as required */
1036 case NETCONN_EVT_RCVPLUS:
1039 case NETCONN_EVT_RCVMINUS:
1042 case NETCONN_EVT_SENDPLUS:
1043 sock->sendevent = 1;
1045 case NETCONN_EVT_SENDMINUS:
1046 sock->sendevent = 0;
1049 LWIP_ASSERT("unknown event", 0);
1052 sys_sem_signal(selectsem);
1054 /* Now decide if anyone is waiting for this socket */
1055 /* NOTE: This code is written this way to protect the select link list
1056 but to avoid a deadlock situation by releasing socksem before
1057 signalling for the select. This means we need to go through the list
1058 multiple times ONLY IF a select was actually waiting. We go through
1059 the list the number of waiting select calls + 1. This list is
1060 expected to be small. */
1062 sys_sem_wait(selectsem);
1063 for (scb = select_cb_list; scb; scb = scb->next) {
1064 if (scb->sem_signalled == 0) {
1065 /* Test this select call for our socket */
1066 if (scb->readset && FD_ISSET(s, scb->readset))
1069 if (scb->writeset && FD_ISSET(s, scb->writeset))
1070 if (sock->sendevent)
1075 scb->sem_signalled = 1;
1076 sys_sem_signal(selectsem);
1077 sys_sem_signal(scb->sem);
1079 sys_sem_signal(selectsem);
1086 * Unimplemented: Close one end of a full-duplex connection.
1087 * Currently, the full connection is closed.
1090 lwip_shutdown(int s, int how)
1092 LWIP_UNUSED_ARG(how);
1093 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_shutdown(%d, how=%d)\n", s, how));
1094 return lwip_close(s); /* XXX temporary hack until proper implementation */
1098 lwip_getaddrname(int s, struct sockaddr *name, socklen_t *namelen, u8_t local)
1100 struct lwip_socket *sock;
1101 struct sockaddr_in sin;
1102 struct ip_addr naddr;
1104 sock = get_socket(s);
1108 memset(&sin, 0, sizeof(sin));
1109 sin.sin_len = sizeof(sin);
1110 sin.sin_family = AF_INET;
1112 /* get the IP address and port */
1113 netconn_getaddr(sock->conn, &naddr, &sin.sin_port, local);
1115 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getaddrname(%d, addr=", s));
1116 ip_addr_debug_print(SOCKETS_DEBUG, &naddr);
1117 LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%d)\n", sin.sin_port));
1119 sin.sin_port = htons(sin.sin_port);
1120 sin.sin_addr.s_addr = naddr.addr;
1122 if (*namelen > sizeof(sin))
1123 *namelen = sizeof(sin);
1125 SMEMCPY(name, &sin, *namelen);
1126 sock_set_errno(sock, 0);
1131 lwip_getpeername(int s, struct sockaddr *name, socklen_t *namelen)
1133 return lwip_getaddrname(s, name, namelen, 0);
1137 lwip_getsockname(int s, struct sockaddr *name, socklen_t *namelen)
1139 return lwip_getaddrname(s, name, namelen, 1);
1143 lwip_getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen)
1146 struct lwip_socket *sock = get_socket(s);
1147 struct lwip_setgetsockopt_data data;
1152 if ((NULL == optval) || (NULL == optlen)) {
1153 sock_set_errno(sock, EFAULT);
1157 /* Do length and type checks for the various options first, to keep it readable. */
1160 /* Level: SOL_SOCKET */
1166 /* UNIMPL case SO_DEBUG: */
1167 /* UNIMPL case SO_DONTROUTE: */
1170 /* UNIMPL case SO_CONTIMEO: */
1171 /* UNIMPL case SO_SNDTIMEO: */
1172 #if LWIP_SO_RCVTIMEO
1174 #endif /* LWIP_SO_RCVTIMEO */
1177 #endif /* LWIP_SO_RCVBUF */
1178 /* UNIMPL case SO_OOBINLINE: */
1179 /* UNIMPL case SO_SNDBUF: */
1180 /* UNIMPL case SO_RCVLOWAT: */
1181 /* UNIMPL case SO_SNDLOWAT: */
1185 #endif /* SO_REUSE */
1187 /* UNIMPL case SO_USELOOPBACK: */
1188 if (*optlen < sizeof(int)) {
1194 if (*optlen < sizeof(int)) {
1198 if ((sock->conn->type != NETCONN_UDP) ||
1199 ((udp_flags(sock->conn->pcb.udp) & UDP_FLAGS_UDPLITE) != 0)) {
1200 /* this flag is only available for UDP, not for UDP lite */
1203 #endif /* LWIP_UDP */
1207 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, UNIMPL: optname=0x%x, ..)\n",
1210 } /* switch (optname) */
1213 /* Level: IPPROTO_IP */
1216 /* UNIMPL case IP_HDRINCL: */
1217 /* UNIMPL case IP_RCVDSTADDR: */
1218 /* UNIMPL case IP_RCVIF: */
1221 if (*optlen < sizeof(int)) {
1226 case IP_MULTICAST_TTL:
1227 if (*optlen < sizeof(u8_t)) {
1231 case IP_MULTICAST_IF:
1232 if (*optlen < sizeof(struct in_addr)) {
1236 #endif /* LWIP_IGMP */
1239 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, UNIMPL: optname=0x%x, ..)\n",
1242 } /* switch (optname) */
1246 /* Level: IPPROTO_TCP */
1248 if (*optlen < sizeof(int)) {
1253 /* If this is no TCP socket, ignore any options. */
1254 if (sock->conn->type != NETCONN_TCP)
1260 #if LWIP_TCP_KEEPALIVE
1264 #endif /* LWIP_TCP_KEEPALIVE */
1268 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_TCP, UNIMPL: optname=0x%x, ..)\n",
1271 } /* switch (optname) */
1273 #endif /* LWIP_TCP */
1274 #if LWIP_UDP && LWIP_UDPLITE
1275 /* Level: IPPROTO_UDPLITE */
1276 case IPPROTO_UDPLITE:
1277 if (*optlen < sizeof(int)) {
1282 /* If this is no UDP lite socket, ignore any options. */
1283 if (sock->conn->type != NETCONN_UDPLITE)
1287 case UDPLITE_SEND_CSCOV:
1288 case UDPLITE_RECV_CSCOV:
1292 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_UDPLITE, UNIMPL: optname=0x%x, ..)\n",
1295 } /* switch (optname) */
1297 #endif /* LWIP_UDP && LWIP_UDPLITE*/
1298 /* UNDEFINED LEVEL */
1300 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, level=0x%x, UNIMPL: optname=0x%x, ..)\n",
1301 s, level, optname));
1306 if (err != ERR_OK) {
1307 sock_set_errno(sock, err);
1311 /* Now do the actual option processing */
1314 data.optname = optname;
1315 data.optval = optval;
1316 data.optlen = optlen;
1318 tcpip_callback(lwip_getsockopt_internal, &data);
1319 sys_arch_sem_wait(sock->conn->op_completed, 0);
1320 /* maybe lwip_getsockopt_internal has changed err */
1323 sock_set_errno(sock, err);
1324 return err ? -1 : 0;
1328 lwip_getsockopt_internal(void *arg)
1330 struct lwip_socket *sock;
1333 #endif /* LWIP_DEBUG */
1336 struct lwip_setgetsockopt_data *data;
1338 LWIP_ASSERT("arg != NULL", arg != NULL);
1340 data = (struct lwip_setgetsockopt_data*)arg;
1344 #endif /* LWIP_DEBUG */
1345 level = data->level;
1346 optname = data->optname;
1347 optval = data->optval;
1351 /* Level: SOL_SOCKET */
1355 /* The option flags */
1358 /* UNIMPL case SO_DEBUG: */
1359 /* UNIMPL case SO_DONTROUTE: */
1361 /* UNIMPL case SO_OOBINCLUDE: */
1365 #endif /* SO_REUSE */
1366 /*case SO_USELOOPBACK: UNIMPL */
1367 *(int*)optval = sock->conn->pcb.ip->so_options & optname;
1368 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, optname=0x%x, ..) = %s\n",
1369 s, optname, (*(int*)optval?"on":"off")));
1373 switch (NETCONNTYPE_GROUP(sock->conn->type)) {
1375 *(int*)optval = SOCK_RAW;
1378 *(int*)optval = SOCK_STREAM;
1381 *(int*)optval = SOCK_DGRAM;
1383 default: /* unrecognized socket type */
1384 *(int*)optval = sock->conn->type;
1385 LWIP_DEBUGF(SOCKETS_DEBUG,
1386 ("lwip_getsockopt(%d, SOL_SOCKET, SO_TYPE): unrecognized socket type %d\n",
1387 s, *(int *)optval));
1388 } /* switch (sock->conn->type) */
1389 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, SO_TYPE) = %d\n",
1390 s, *(int *)optval));
1394 if (sock->err == 0) {
1395 sock_set_errno(sock, err_to_errno(sock->conn->err));
1397 *(int *)optval = sock->err;
1399 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, SO_ERROR) = %d\n",
1400 s, *(int *)optval));
1403 #if LWIP_SO_RCVTIMEO
1405 *(int *)optval = sock->conn->recv_timeout;
1407 #endif /* LWIP_SO_RCVTIMEO */
1410 *(int *)optval = sock->conn->recv_bufsize;
1412 #endif /* LWIP_SO_RCVBUF */
1415 *(int*)optval = (udp_flags(sock->conn->pcb.udp) & UDP_FLAGS_NOCHKSUM) ? 1 : 0;
1417 #endif /* LWIP_UDP*/
1418 } /* switch (optname) */
1421 /* Level: IPPROTO_IP */
1425 *(int*)optval = sock->conn->pcb.ip->ttl;
1426 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_TTL) = %d\n",
1427 s, *(int *)optval));
1430 *(int*)optval = sock->conn->pcb.ip->tos;
1431 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_TOS) = %d\n",
1432 s, *(int *)optval));
1435 case IP_MULTICAST_TTL:
1436 *(u8_t*)optval = sock->conn->pcb.ip->ttl;
1437 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_MULTICAST_TTL) = %d\n",
1438 s, *(int *)optval));
1440 case IP_MULTICAST_IF:
1441 ((struct in_addr*) optval)->s_addr = sock->conn->pcb.udp->multicast_ip.addr;
1442 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_MULTICAST_IF) = 0x%x\n",
1443 s, *(u32_t *)optval));
1445 #endif /* LWIP_IGMP */
1446 } /* switch (optname) */
1450 /* Level: IPPROTO_TCP */
1454 *(int*)optval = (sock->conn->pcb.tcp->flags & TF_NODELAY);
1455 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_TCP, TCP_NODELAY) = %s\n",
1456 s, (*(int*)optval)?"on":"off") );
1459 *(int*)optval = (int)sock->conn->pcb.tcp->keep_idle;
1460 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, TCP_KEEPALIVE) = %d\n",
1461 s, *(int *)optval));
1464 #if LWIP_TCP_KEEPALIVE
1466 *(int*)optval = (int)(sock->conn->pcb.tcp->keep_idle/1000);
1467 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, TCP_KEEPIDLE) = %d\n",
1468 s, *(int *)optval));
1471 *(int*)optval = (int)(sock->conn->pcb.tcp->keep_intvl/1000);
1472 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, TCP_KEEPINTVL) = %d\n",
1473 s, *(int *)optval));
1476 *(int*)optval = (int)sock->conn->pcb.tcp->keep_cnt;
1477 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, TCP_KEEPCNT) = %d\n",
1478 s, *(int *)optval));
1480 #endif /* LWIP_TCP_KEEPALIVE */
1482 } /* switch (optname) */
1484 #endif /* LWIP_TCP */
1485 #if LWIP_UDP && LWIP_UDPLITE
1486 /* Level: IPPROTO_UDPLITE */
1487 case IPPROTO_UDPLITE:
1489 case UDPLITE_SEND_CSCOV:
1490 *(int*)optval = sock->conn->pcb.udp->chksum_len_tx;
1491 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_UDPLITE, UDPLITE_SEND_CSCOV) = %d\n",
1492 s, (*(int*)optval)) );
1494 case UDPLITE_RECV_CSCOV:
1495 *(int*)optval = sock->conn->pcb.udp->chksum_len_rx;
1496 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_UDPLITE, UDPLITE_RECV_CSCOV) = %d\n",
1497 s, (*(int*)optval)) );
1499 } /* switch (optname) */
1501 #endif /* LWIP_UDP */
1502 } /* switch (level) */
1503 sys_sem_signal(sock->conn->op_completed);
1507 lwip_setsockopt(int s, int level, int optname, const void *optval, socklen_t optlen)
1509 struct lwip_socket *sock = get_socket(s);
1511 struct lwip_setgetsockopt_data data;
1516 if (NULL == optval) {
1517 sock_set_errno(sock, EFAULT);
1521 /* Do length and type checks for the various options first, to keep it readable. */
1524 /* Level: SOL_SOCKET */
1529 /* UNIMPL case SO_DEBUG: */
1530 /* UNIMPL case SO_DONTROUTE: */
1532 /* UNIMPL case case SO_CONTIMEO: */
1533 /* UNIMPL case case SO_SNDTIMEO: */
1534 #if LWIP_SO_RCVTIMEO
1536 #endif /* LWIP_SO_RCVTIMEO */
1539 #endif /* LWIP_SO_RCVBUF */
1540 /* UNIMPL case SO_OOBINLINE: */
1541 /* UNIMPL case SO_SNDBUF: */
1542 /* UNIMPL case SO_RCVLOWAT: */
1543 /* UNIMPL case SO_SNDLOWAT: */
1547 #endif /* SO_REUSE */
1548 /* UNIMPL case SO_USELOOPBACK: */
1549 if (optlen < sizeof(int)) {
1554 if (optlen < sizeof(int)) {
1558 if ((sock->conn->type != NETCONN_UDP) ||
1559 ((udp_flags(sock->conn->pcb.udp) & UDP_FLAGS_UDPLITE) != 0)) {
1560 /* this flag is only available for UDP, not for UDP lite */
1563 #endif /* LWIP_UDP */
1566 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, SOL_SOCKET, UNIMPL: optname=0x%x, ..)\n",
1569 } /* switch (optname) */
1572 /* Level: IPPROTO_IP */
1575 /* UNIMPL case IP_HDRINCL: */
1576 /* UNIMPL case IP_RCVDSTADDR: */
1577 /* UNIMPL case IP_RCVIF: */
1580 if (optlen < sizeof(int)) {
1585 case IP_MULTICAST_TTL:
1586 if (optlen < sizeof(u8_t)) {
1589 if (NETCONNTYPE_GROUP(sock->conn->type) != NETCONN_UDP) {
1593 case IP_MULTICAST_IF:
1594 if (optlen < sizeof(struct in_addr)) {
1597 if (NETCONNTYPE_GROUP(sock->conn->type) != NETCONN_UDP) {
1601 case IP_ADD_MEMBERSHIP:
1602 case IP_DROP_MEMBERSHIP:
1603 if (optlen < sizeof(struct ip_mreq)) {
1606 if (NETCONNTYPE_GROUP(sock->conn->type) != NETCONN_UDP) {
1610 #endif /* LWIP_IGMP */
1612 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_IP, UNIMPL: optname=0x%x, ..)\n",
1615 } /* switch (optname) */
1619 /* Level: IPPROTO_TCP */
1621 if (optlen < sizeof(int)) {
1626 /* If this is no TCP socket, ignore any options. */
1627 if (sock->conn->type != NETCONN_TCP)
1633 #if LWIP_TCP_KEEPALIVE
1637 #endif /* LWIP_TCP_KEEPALIVE */
1641 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, UNIMPL: optname=0x%x, ..)\n",
1644 } /* switch (optname) */
1646 #endif /* LWIP_TCP */
1647 #if LWIP_UDP && LWIP_UDPLITE
1648 /* Level: IPPROTO_UDPLITE */
1649 case IPPROTO_UDPLITE:
1650 if (optlen < sizeof(int)) {
1655 /* If this is no UDP lite socket, ignore any options. */
1656 if (sock->conn->type != NETCONN_UDPLITE)
1660 case UDPLITE_SEND_CSCOV:
1661 case UDPLITE_RECV_CSCOV:
1665 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_UDPLITE, UNIMPL: optname=0x%x, ..)\n",
1668 } /* switch (optname) */
1670 #endif /* LWIP_UDP && LWIP_UDPLITE */
1671 /* UNDEFINED LEVEL */
1673 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, level=0x%x, UNIMPL: optname=0x%x, ..)\n",
1674 s, level, optname));
1676 } /* switch (level) */
1679 if (err != ERR_OK) {
1680 sock_set_errno(sock, err);
1685 /* Now do the actual option processing */
1688 data.optname = optname;
1689 data.optval = (void*)optval;
1690 data.optlen = &optlen;
1692 tcpip_callback(lwip_setsockopt_internal, &data);
1693 sys_arch_sem_wait(sock->conn->op_completed, 0);
1694 /* maybe lwip_setsockopt_internal has changed err */
1697 sock_set_errno(sock, err);
1698 return err ? -1 : 0;
1702 lwip_setsockopt_internal(void *arg)
1704 struct lwip_socket *sock;
1707 #endif /* LWIP_DEBUG */
1710 struct lwip_setgetsockopt_data *data;
1712 LWIP_ASSERT("arg != NULL", arg != NULL);
1714 data = (struct lwip_setgetsockopt_data*)arg;
1718 #endif /* LWIP_DEBUG */
1719 level = data->level;
1720 optname = data->optname;
1721 optval = data->optval;
1725 /* Level: SOL_SOCKET */
1729 /* The option flags */
1731 /* UNIMPL case SO_DEBUG: */
1732 /* UNIMPL case SO_DONTROUTE: */
1734 /* UNIMPL case SO_OOBINCLUDE: */
1738 #endif /* SO_REUSE */
1739 /* UNIMPL case SO_USELOOPBACK: */
1740 if (*(int*)optval) {
1741 sock->conn->pcb.ip->so_options |= optname;
1743 sock->conn->pcb.ip->so_options &= ~optname;
1745 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, SOL_SOCKET, optname=0x%x, ..) -> %s\n",
1746 s, optname, (*(int*)optval?"on":"off")));
1748 #if LWIP_SO_RCVTIMEO
1750 sock->conn->recv_timeout = ( *(int*)optval );
1752 #endif /* LWIP_SO_RCVTIMEO */
1755 sock->conn->recv_bufsize = ( *(int*)optval );
1757 #endif /* LWIP_SO_RCVBUF */
1760 if (*(int*)optval) {
1761 udp_setflags(sock->conn->pcb.udp, udp_flags(sock->conn->pcb.udp) | UDP_FLAGS_NOCHKSUM);
1763 udp_setflags(sock->conn->pcb.udp, udp_flags(sock->conn->pcb.udp) & ~UDP_FLAGS_NOCHKSUM);
1766 #endif /* LWIP_UDP */
1767 } /* switch (optname) */
1770 /* Level: IPPROTO_IP */
1774 sock->conn->pcb.ip->ttl = (u8_t)(*(int*)optval);
1775 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_IP, IP_TTL, ..) -> %u\n",
1776 s, sock->conn->pcb.ip->ttl));
1779 sock->conn->pcb.ip->tos = (u8_t)(*(int*)optval);
1780 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_IP, IP_TOS, ..)-> %u\n",
1781 s, sock->conn->pcb.ip->tos));
1784 case IP_MULTICAST_TTL:
1785 sock->conn->pcb.udp->ttl = (u8_t)(*(u8_t*)optval);
1787 case IP_MULTICAST_IF:
1788 sock->conn->pcb.udp->multicast_ip.addr = ((struct in_addr*) optval)->s_addr;
1790 case IP_ADD_MEMBERSHIP:
1791 case IP_DROP_MEMBERSHIP:
1793 /* If this is a TCP or a RAW socket, ignore these options. */
1794 struct ip_mreq *imr = (struct ip_mreq *)optval;
1795 if(optname == IP_ADD_MEMBERSHIP){
1796 data->err = igmp_joingroup((struct ip_addr*)&(imr->imr_interface.s_addr), (struct ip_addr*)&(imr->imr_multiaddr.s_addr));
1798 data->err = igmp_leavegroup((struct ip_addr*)&(imr->imr_interface.s_addr), (struct ip_addr*)&(imr->imr_multiaddr.s_addr));
1800 if(data->err != ERR_OK) {
1801 data->err = EADDRNOTAVAIL;
1805 #endif /* LWIP_IGMP */
1806 } /* switch (optname) */
1810 /* Level: IPPROTO_TCP */
1814 if (*(int*)optval) {
1815 sock->conn->pcb.tcp->flags |= TF_NODELAY;
1817 sock->conn->pcb.tcp->flags &= ~TF_NODELAY;
1819 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_NODELAY) -> %s\n",
1820 s, (*(int *)optval)?"on":"off") );
1823 sock->conn->pcb.tcp->keep_idle = (u32_t)(*(int*)optval);
1824 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_KEEPALIVE) -> %lu\n",
1825 s, sock->conn->pcb.tcp->keep_idle));
1828 #if LWIP_TCP_KEEPALIVE
1830 sock->conn->pcb.tcp->keep_idle = 1000*(u32_t)(*(int*)optval);
1831 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_KEEPIDLE) -> %lu\n",
1832 s, sock->conn->pcb.tcp->keep_idle));
1835 sock->conn->pcb.tcp->keep_intvl = 1000*(u32_t)(*(int*)optval);
1836 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_KEEPINTVL) -> %lu\n",
1837 s, sock->conn->pcb.tcp->keep_intvl));
1840 sock->conn->pcb.tcp->keep_cnt = (u32_t)(*(int*)optval);
1841 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_KEEPCNT) -> %lu\n",
1842 s, sock->conn->pcb.tcp->keep_cnt));
1844 #endif /* LWIP_TCP_KEEPALIVE */
1846 } /* switch (optname) */
1848 #endif /* LWIP_TCP*/
1849 #if LWIP_UDP && LWIP_UDPLITE
1850 /* Level: IPPROTO_UDPLITE */
1851 case IPPROTO_UDPLITE:
1853 case UDPLITE_SEND_CSCOV:
1854 if ((*(int*)optval != 0) && (*(int*)optval < 8)) {
1855 /* don't allow illegal values! */
1856 sock->conn->pcb.udp->chksum_len_tx = 8;
1858 sock->conn->pcb.udp->chksum_len_tx = *(int*)optval;
1860 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_UDPLITE, UDPLITE_SEND_CSCOV) -> %d\n",
1861 s, (*(int*)optval)) );
1863 case UDPLITE_RECV_CSCOV:
1864 if ((*(int*)optval != 0) && (*(int*)optval < 8)) {
1865 /* don't allow illegal values! */
1866 sock->conn->pcb.udp->chksum_len_rx = 8;
1868 sock->conn->pcb.udp->chksum_len_rx = *(int*)optval;
1870 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_UDPLITE, UDPLITE_RECV_CSCOV) -> %d\n",
1871 s, (*(int*)optval)) );
1873 } /* switch (optname) */
1875 #endif /* LWIP_UDP */
1876 } /* switch (level) */
1877 sys_sem_signal(sock->conn->op_completed);
1881 lwip_ioctl(int s, long cmd, void *argp)
1883 struct lwip_socket *sock = get_socket(s);
1892 sock_set_errno(sock, EINVAL);
1896 SYS_ARCH_GET(sock->conn->recv_avail, *((u16_t*)argp));
1898 /* Check if there is data left from the last recv operation. /maq 041215 */
1899 if (sock->lastdata) {
1900 buflen = netbuf_len(sock->lastdata);
1901 buflen -= sock->lastoffset;
1903 *((u16_t*)argp) += buflen;
1906 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(%d, FIONREAD, %p) = %u\n", s, argp, *((u16_t*)argp)));
1907 sock_set_errno(sock, 0);
1911 if (argp && *(u32_t*)argp)
1912 sock->flags |= O_NONBLOCK;
1914 sock->flags &= ~O_NONBLOCK;
1915 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(%d, FIONBIO, %d)\n", s, !!(sock->flags & O_NONBLOCK)));
1916 sock_set_errno(sock, 0);
1920 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(%d, UNIMPL: 0x%lx, %p)\n", s, cmd, argp));
1921 sock_set_errno(sock, ENOSYS); /* not yet implemented */
1923 } /* switch (cmd) */
1926 #endif /* LWIP_SOCKET */