[TCPIP]
[reactos.git] / reactos / lib / drivers / lwip / src / api / sockets.c
1 /**
2 * @file
3 * Sockets BSD-Like API module
4 *
5 */
6
7 /*
8 * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without modification,
12 * are permitted provided that the following conditions are met:
13 *
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.
21 *
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
31 * OF SUCH DAMAGE.
32 *
33 * This file is part of the lwIP TCP/IP stack.
34 *
35 * Author: Adam Dunkels <adam@sics.se>
36 *
37 * Improved by Marc Boucher <marc@mbsi.ca> and David Haas <dhaas@alum.rpi.edu>
38 *
39 */
40
41 #include "lwip/opt.h"
42
43 #if LWIP_SOCKET /* don't build if not configured for use in lwipopts.h */
44
45 #include "lwip/sockets.h"
46 #include "lwip/api.h"
47 #include "lwip/sys.h"
48 #include "lwip/igmp.h"
49 #include "lwip/inet.h"
50 #include "lwip/tcp.h"
51 #include "lwip/raw.h"
52 #include "lwip/udp.h"
53 #include "lwip/tcpip.h"
54 #include "lwip/pbuf.h"
55 #if LWIP_CHECKSUM_ON_COPY
56 #include "lwip/inet_chksum.h"
57 #endif
58
59 #include <string.h>
60
61 #define NUM_SOCKETS MEMP_NUM_NETCONN
62
63 /** Contains all internal pointers and states used for a socket */
64 struct lwip_sock {
65 /** sockets currently are built on netconns, each socket has one netconn */
66 struct netconn *conn;
67 /** data that was left from the previous read */
68 void *lastdata;
69 /** offset in the data that was left from the previous read */
70 u16_t lastoffset;
71 /** number of times data was received, set by event_callback(),
72 tested by the receive and select functions */
73 s16_t rcvevent;
74 /** number of times data was ACKed (free send buffer), set by event_callback(),
75 tested by select */
76 u16_t sendevent;
77 /** error happened for this socket, set by event_callback(), tested by select */
78 u16_t errevent;
79 /** last error that occurred on this socket */
80 int err;
81 /** counter of how many threads are waiting for this socket using select */
82 int select_waiting;
83 };
84
85 /** Description for a task waiting in select */
86 struct lwip_select_cb {
87 /** Pointer to the next waiting task */
88 struct lwip_select_cb *next;
89 /** Pointer to the previous waiting task */
90 struct lwip_select_cb *prev;
91 /** readset passed to select */
92 fd_set *readset;
93 /** writeset passed to select */
94 fd_set *writeset;
95 /** unimplemented: exceptset passed to select */
96 fd_set *exceptset;
97 /** don't signal the same semaphore twice: set to 1 when signalled */
98 int sem_signalled;
99 /** semaphore to wake up a task waiting for select */
100 sys_sem_t sem;
101 };
102
103 /** This struct is used to pass data to the set/getsockopt_internal
104 * functions running in tcpip_thread context (only a void* is allowed) */
105 struct lwip_setgetsockopt_data {
106 /** socket struct for which to change options */
107 struct lwip_sock *sock;
108 #ifdef LWIP_DEBUG
109 /** socket index for which to change options */
110 int s;
111 #endif /* LWIP_DEBUG */
112 /** level of the option to process */
113 int level;
114 /** name of the option to process */
115 int optname;
116 /** set: value to set the option to
117 * get: value of the option is stored here */
118 void *optval;
119 /** size of *optval */
120 socklen_t *optlen;
121 /** if an error occures, it is temporarily stored here */
122 err_t err;
123 };
124
125 /** The global array of available sockets */
126 static struct lwip_sock sockets[NUM_SOCKETS];
127 /** The global list of tasks waiting for select */
128 static struct lwip_select_cb *select_cb_list;
129 /** This counter is increased from lwip_select when the list is chagned
130 and checked in event_callback to see if it has changed. */
131 static volatile int select_cb_ctr;
132
133 /** Table to quickly map an lwIP error (err_t) to a socket error
134 * by using -err as an index */
135 static const int err_to_errno_table[] = {
136 0, /* ERR_OK 0 No error, everything OK. */
137 ENOMEM, /* ERR_MEM -1 Out of memory error. */
138 ENOBUFS, /* ERR_BUF -2 Buffer error. */
139 EWOULDBLOCK, /* ERR_TIMEOUT -3 Timeout */
140 EHOSTUNREACH, /* ERR_RTE -4 Routing problem. */
141 EINPROGRESS, /* ERR_INPROGRESS -5 Operation in progress */
142 EINVAL, /* ERR_VAL -6 Illegal value. */
143 EWOULDBLOCK, /* ERR_WOULDBLOCK -7 Operation would block. */
144 EADDRINUSE, /* ERR_USE -8 Address in use. */
145 EALREADY, /* ERR_ISCONN -9 Already connected. */
146 ECONNABORTED, /* ERR_ABRT -10 Connection aborted. */
147 ECONNRESET, /* ERR_RST -11 Connection reset. */
148 ENOTCONN, /* ERR_CLSD -12 Connection closed. */
149 ENOTCONN, /* ERR_CONN -13 Not connected. */
150 EIO, /* ERR_ARG -14 Illegal argument. */
151 -1, /* ERR_IF -15 Low-level netif error */
152 };
153
154 #define ERR_TO_ERRNO_TABLE_SIZE \
155 (sizeof(err_to_errno_table)/sizeof(err_to_errno_table[0]))
156
157 #define err_to_errno(err) \
158 ((unsigned)(-(err)) < ERR_TO_ERRNO_TABLE_SIZE ? \
159 err_to_errno_table[-(err)] : EIO)
160
161 #ifdef ERRNO
162 #ifndef set_errno
163 #define set_errno(err) errno = (err)
164 #endif
165 #else /* ERRNO */
166 #define set_errno(err)
167 #endif /* ERRNO */
168
169 #define sock_set_errno(sk, e) do { \
170 sk->err = (e); \
171 set_errno(sk->err); \
172 } while (0)
173
174 /* Forward delcaration of some functions */
175 static void event_callback(struct netconn *conn, enum netconn_evt evt, u16_t len);
176 static void lwip_getsockopt_internal(void *arg);
177 static void lwip_setsockopt_internal(void *arg);
178
179 /**
180 * Initialize this module. This function has to be called before any other
181 * functions in this module!
182 */
183 void
184 lwip_socket_init(void)
185 {
186 }
187
188 /**
189 * Map a externally used socket index to the internal socket representation.
190 *
191 * @param s externally used socket index
192 * @return struct lwip_sock for the socket or NULL if not found
193 */
194 static struct lwip_sock *
195 get_socket(int s)
196 {
197 struct lwip_sock *sock;
198
199 if ((s < 0) || (s >= NUM_SOCKETS)) {
200 LWIP_DEBUGF(SOCKETS_DEBUG, ("get_socket(%d): invalid\n", s));
201 set_errno(EBADF);
202 return NULL;
203 }
204
205 sock = &sockets[s];
206
207 if (!sock->conn) {
208 LWIP_DEBUGF(SOCKETS_DEBUG, ("get_socket(%d): not active\n", s));
209 set_errno(EBADF);
210 return NULL;
211 }
212
213 return sock;
214 }
215
216 /**
217 * Same as get_socket but doesn't set errno
218 *
219 * @param s externally used socket index
220 * @return struct lwip_sock for the socket or NULL if not found
221 */
222 static struct lwip_sock *
223 tryget_socket(int s)
224 {
225 if ((s < 0) || (s >= NUM_SOCKETS)) {
226 return NULL;
227 }
228 if (!sockets[s].conn) {
229 return NULL;
230 }
231 return &sockets[s];
232 }
233
234 /**
235 * Allocate a new socket for a given netconn.
236 *
237 * @param newconn the netconn for which to allocate a socket
238 * @param accepted 1 if socket has been created by accept(),
239 * 0 if socket has been created by socket()
240 * @return the index of the new socket; -1 on error
241 */
242 static int
243 alloc_socket(struct netconn *newconn, int accepted)
244 {
245 int i;
246 SYS_ARCH_DECL_PROTECT(lev);
247
248 /* allocate a new socket identifier */
249 for (i = 0; i < NUM_SOCKETS; ++i) {
250 /* Protect socket array */
251 SYS_ARCH_PROTECT(lev);
252 if (!sockets[i].conn) {
253 sockets[i].conn = newconn;
254 /* The socket is not yet known to anyone, so no need to protect
255 after having marked it as used. */
256 SYS_ARCH_UNPROTECT(lev);
257 sockets[i].lastdata = NULL;
258 sockets[i].lastoffset = 0;
259 sockets[i].rcvevent = 0;
260 /* TCP sendbuf is empty, but the socket is not yet writable until connected
261 * (unless it has been created by accept()). */
262 sockets[i].sendevent = (newconn->type == NETCONN_TCP ? (accepted != 0) : 1);
263 sockets[i].errevent = 0;
264 sockets[i].err = 0;
265 sockets[i].select_waiting = 0;
266 return i;
267 }
268 SYS_ARCH_UNPROTECT(lev);
269 }
270 return -1;
271 }
272
273 /** Free a socket. The socket's netconn must have been
274 * delete before!
275 *
276 * @param sock the socket to free
277 * @param is_tcp != 0 for TCP sockets, used to free lastdata
278 */
279 static void
280 free_socket(struct lwip_sock *sock, int is_tcp)
281 {
282 void *lastdata;
283 SYS_ARCH_DECL_PROTECT(lev);
284
285 lastdata = sock->lastdata;
286 sock->lastdata = NULL;
287 sock->lastoffset = 0;
288 sock->err = 0;
289
290 /* Protect socket array */
291 SYS_ARCH_PROTECT(lev);
292 sock->conn = NULL;
293 SYS_ARCH_UNPROTECT(lev);
294 /* don't use 'sock' after this line, as another task might have allocated it */
295
296 if (lastdata != NULL) {
297 if (is_tcp) {
298 pbuf_free((struct pbuf *)lastdata);
299 } else {
300 netbuf_delete((struct netbuf *)lastdata);
301 }
302 }
303 }
304
305 /* Below this, the well-known socket functions are implemented.
306 * Use google.com or opengroup.org to get a good description :-)
307 *
308 * Exceptions are documented!
309 */
310
311 int
312 lwip_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
313 {
314 struct lwip_sock *sock, *nsock;
315 struct netconn *newconn;
316 ip_addr_t naddr;
317 u16_t port;
318 int newsock;
319 struct sockaddr_in sin;
320 err_t err;
321 SYS_ARCH_DECL_PROTECT(lev);
322
323 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d)...\n", s));
324 sock = get_socket(s);
325 if (!sock) {
326 return -1;
327 }
328
329 if (netconn_is_nonblocking(sock->conn) && (sock->rcvevent <= 0)) {
330 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d): returning EWOULDBLOCK\n", s));
331 sock_set_errno(sock, EWOULDBLOCK);
332 return -1;
333 }
334
335 /* wait for a new connection */
336 err = netconn_accept(sock->conn, &newconn);
337 if (err != ERR_OK) {
338 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d): netconn_acept failed, err=%d\n", s, err));
339 sock_set_errno(sock, err_to_errno(err));
340 return -1;
341 }
342 LWIP_ASSERT("newconn != NULL", newconn != NULL);
343 /* Prevent automatic window updates, we do this on our own! */
344 netconn_set_noautorecved(newconn, 1);
345
346 /* get the IP address and port of the remote host */
347 err = netconn_peer(newconn, &naddr, &port);
348 if (err != ERR_OK) {
349 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d): netconn_peer failed, err=%d\n", s, err));
350 netconn_delete(newconn);
351 sock_set_errno(sock, err_to_errno(err));
352 return -1;
353 }
354
355 /* Note that POSIX only requires us to check addr is non-NULL. addrlen must
356 * not be NULL if addr is valid.
357 */
358 if (NULL != addr) {
359 LWIP_ASSERT("addr valid but addrlen NULL", addrlen != NULL);
360 memset(&sin, 0, sizeof(sin));
361 sin.sin_len = sizeof(sin);
362 sin.sin_family = AF_INET;
363 sin.sin_port = htons(port);
364 inet_addr_from_ipaddr(&sin.sin_addr, &naddr);
365
366 if (*addrlen > sizeof(sin))
367 *addrlen = sizeof(sin);
368
369 MEMCPY(addr, &sin, *addrlen);
370 }
371
372 newsock = alloc_socket(newconn, 1);
373 if (newsock == -1) {
374 netconn_delete(newconn);
375 sock_set_errno(sock, ENFILE);
376 return -1;
377 }
378 LWIP_ASSERT("invalid socket index", (newsock >= 0) && (newsock < NUM_SOCKETS));
379 LWIP_ASSERT("newconn->callback == event_callback", newconn->callback == event_callback);
380 nsock = &sockets[newsock];
381
382 /* See event_callback: If data comes in right away after an accept, even
383 * though the server task might not have created a new socket yet.
384 * In that case, newconn->socket is counted down (newconn->socket--),
385 * so nsock->rcvevent is >= 1 here!
386 */
387 SYS_ARCH_PROTECT(lev);
388 nsock->rcvevent += (s16_t)(-1 - newconn->socket);
389 newconn->socket = newsock;
390 SYS_ARCH_UNPROTECT(lev);
391
392 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d) returning new sock=%d addr=", s, newsock));
393 ip_addr_debug_print(SOCKETS_DEBUG, &naddr);
394 LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%"U16_F"\n", port));
395
396 sock_set_errno(sock, 0);
397 return newsock;
398 }
399
400 int
401 lwip_bind(int s, const struct sockaddr *name, socklen_t namelen)
402 {
403 struct lwip_sock *sock;
404 ip_addr_t local_addr;
405 u16_t local_port;
406 err_t err;
407 const struct sockaddr_in *name_in;
408
409 sock = get_socket(s);
410 if (!sock) {
411 return -1;
412 }
413
414 /* check size, familiy and alignment of 'name' */
415 LWIP_ERROR("lwip_bind: invalid address", ((namelen == sizeof(struct sockaddr_in)) &&
416 ((name->sa_family) == AF_INET) && ((((mem_ptr_t)name) % 4) == 0)),
417 sock_set_errno(sock, err_to_errno(ERR_ARG)); return -1;);
418 name_in = (const struct sockaddr_in *)(void*)name;
419
420 inet_addr_to_ipaddr(&local_addr, &name_in->sin_addr);
421 local_port = name_in->sin_port;
422
423 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_bind(%d, addr=", s));
424 ip_addr_debug_print(SOCKETS_DEBUG, &local_addr);
425 LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%"U16_F")\n", ntohs(local_port)));
426
427 err = netconn_bind(sock->conn, &local_addr, ntohs(local_port));
428
429 if (err != ERR_OK) {
430 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_bind(%d) failed, err=%d\n", s, err));
431 sock_set_errno(sock, err_to_errno(err));
432 return -1;
433 }
434
435 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_bind(%d) succeeded\n", s));
436 sock_set_errno(sock, 0);
437 return 0;
438 }
439
440 int
441 lwip_close(int s)
442 {
443 struct lwip_sock *sock;
444 int is_tcp = 0;
445
446 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_close(%d)\n", s));
447
448 sock = get_socket(s);
449 if (!sock) {
450 return -1;
451 }
452
453 if(sock->conn != NULL) {
454 is_tcp = netconn_type(sock->conn) == NETCONN_TCP;
455 } else {
456 LWIP_ASSERT("sock->lastdata == NULL", sock->lastdata == NULL);
457 }
458
459 netconn_delete(sock->conn);
460
461 free_socket(sock, is_tcp);
462 set_errno(0);
463 return 0;
464 }
465
466 int
467 lwip_connect(int s, const struct sockaddr *name, socklen_t namelen)
468 {
469 struct lwip_sock *sock;
470 err_t err;
471 const struct sockaddr_in *name_in;
472
473 sock = get_socket(s);
474 if (!sock) {
475 return -1;
476 }
477
478 /* check size, familiy and alignment of 'name' */
479 LWIP_ERROR("lwip_connect: invalid address", ((namelen == sizeof(struct sockaddr_in)) &&
480 ((name->sa_family) == AF_INET) && ((((mem_ptr_t)name) % 4) == 0)),
481 sock_set_errno(sock, err_to_errno(ERR_ARG)); return -1;);
482 name_in = (const struct sockaddr_in *)(void*)name;
483
484 if (name_in->sin_family == AF_UNSPEC) {
485 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d, AF_UNSPEC)\n", s));
486 err = netconn_disconnect(sock->conn);
487 } else {
488 ip_addr_t remote_addr;
489 u16_t remote_port;
490
491 inet_addr_to_ipaddr(&remote_addr, &name_in->sin_addr);
492 remote_port = name_in->sin_port;
493
494 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d, addr=", s));
495 ip_addr_debug_print(SOCKETS_DEBUG, &remote_addr);
496 LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%"U16_F")\n", ntohs(remote_port)));
497
498 err = netconn_connect(sock->conn, &remote_addr, ntohs(remote_port));
499 }
500
501 if (err != ERR_OK) {
502 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d) failed, err=%d\n", s, err));
503 sock_set_errno(sock, err_to_errno(err));
504 return -1;
505 }
506
507 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d) succeeded\n", s));
508 sock_set_errno(sock, 0);
509 return 0;
510 }
511
512 /**
513 * Set a socket into listen mode.
514 * The socket may not have been used for another connection previously.
515 *
516 * @param s the socket to set to listening mode
517 * @param backlog (ATTENTION: needs TCP_LISTEN_BACKLOG=1)
518 * @return 0 on success, non-zero on failure
519 */
520 int
521 lwip_listen(int s, int backlog)
522 {
523 struct lwip_sock *sock;
524 err_t err;
525
526 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_listen(%d, backlog=%d)\n", s, backlog));
527
528 sock = get_socket(s);
529 if (!sock) {
530 return -1;
531 }
532
533 /* limit the "backlog" parameter to fit in an u8_t */
534 backlog = LWIP_MIN(LWIP_MAX(backlog, 0), 0xff);
535
536 err = netconn_listen_with_backlog(sock->conn, (u8_t)backlog);
537
538 if (err != ERR_OK) {
539 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_listen(%d) failed, err=%d\n", s, err));
540 sock_set_errno(sock, err_to_errno(err));
541 return -1;
542 }
543
544 sock_set_errno(sock, 0);
545 return 0;
546 }
547
548 int
549 lwip_recvfrom(int s, void *mem, size_t len, int flags,
550 struct sockaddr *from, socklen_t *fromlen)
551 {
552 struct lwip_sock *sock;
553 void *buf = NULL;
554 struct pbuf *p;
555 u16_t buflen, copylen;
556 int off = 0;
557 ip_addr_t *addr;
558 u16_t port;
559 u8_t done = 0;
560 err_t err;
561
562 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d, %p, %"SZT_F", 0x%x, ..)\n", s, mem, len, flags));
563 sock = get_socket(s);
564 if (!sock) {
565 return -1;
566 }
567
568 do {
569 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom: top while sock->lastdata=%p\n", sock->lastdata));
570 /* Check if there is data left from the last recv operation. */
571 if (sock->lastdata) {
572 buf = sock->lastdata;
573 } else {
574 /* If this is non-blocking call, then check first */
575 if (((flags & MSG_DONTWAIT) || netconn_is_nonblocking(sock->conn)) &&
576 (sock->rcvevent <= 0)) {
577 if (off > 0) {
578 /* update receive window */
579 netconn_recved(sock->conn, (u32_t)off);
580 /* already received data, return that */
581 sock_set_errno(sock, 0);
582 return off;
583 }
584 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d): returning EWOULDBLOCK\n", s));
585 sock_set_errno(sock, EWOULDBLOCK);
586 return -1;
587 }
588
589 /* No data was left from the previous operation, so we try to get
590 some from the network. */
591 if (netconn_type(sock->conn) == NETCONN_TCP) {
592 err = netconn_recv_tcp_pbuf(sock->conn, (struct pbuf **)&buf);
593 } else {
594 err = netconn_recv(sock->conn, (struct netbuf **)&buf);
595 }
596 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom: netconn_recv err=%d, netbuf=%p\n",
597 err, buf));
598
599 if (err != ERR_OK) {
600 if (off > 0) {
601 /* update receive window */
602 netconn_recved(sock->conn, (u32_t)off);
603 /* already received data, return that */
604 sock_set_errno(sock, 0);
605 return off;
606 }
607 /* We should really do some error checking here. */
608 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d): buf == NULL, error is \"%s\"!\n",
609 s, lwip_strerr(err)));
610 sock_set_errno(sock, err_to_errno(err));
611 if (err == ERR_CLSD) {
612 return 0;
613 } else {
614 return -1;
615 }
616 }
617 LWIP_ASSERT("buf != NULL", buf != NULL);
618 sock->lastdata = buf;
619 }
620
621 if (netconn_type(sock->conn) == NETCONN_TCP) {
622 p = (struct pbuf *)buf;
623 } else {
624 p = ((struct netbuf *)buf)->p;
625 }
626 buflen = p->tot_len;
627 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom: buflen=%"U16_F" len=%"SZT_F" off=%d sock->lastoffset=%"U16_F"\n",
628 buflen, len, off, sock->lastoffset));
629
630 buflen -= sock->lastoffset;
631
632 if (len > buflen) {
633 copylen = buflen;
634 } else {
635 copylen = (u16_t)len;
636 }
637
638 /* copy the contents of the received buffer into
639 the supplied memory pointer mem */
640 pbuf_copy_partial(p, (u8_t*)mem + off, copylen, sock->lastoffset);
641
642 off += copylen;
643
644 if (netconn_type(sock->conn) == NETCONN_TCP) {
645 LWIP_ASSERT("invalid copylen, len would underflow", len >= copylen);
646 len -= copylen;
647 if ( (len <= 0) ||
648 (p->flags & PBUF_FLAG_PUSH) ||
649 (sock->rcvevent <= 0) ||
650 ((flags & MSG_PEEK)!=0)) {
651 done = 1;
652 }
653 } else {
654 done = 1;
655 }
656
657 /* Check to see from where the data was.*/
658 if (done) {
659 ip_addr_t fromaddr;
660 if (from && fromlen) {
661 struct sockaddr_in sin;
662
663 if (netconn_type(sock->conn) == NETCONN_TCP) {
664 addr = &fromaddr;
665 netconn_getaddr(sock->conn, addr, &port, 0);
666 } else {
667 addr = netbuf_fromaddr((struct netbuf *)buf);
668 port = netbuf_fromport((struct netbuf *)buf);
669 }
670
671 memset(&sin, 0, sizeof(sin));
672 sin.sin_len = sizeof(sin);
673 sin.sin_family = AF_INET;
674 sin.sin_port = htons(port);
675 inet_addr_from_ipaddr(&sin.sin_addr, addr);
676
677 if (*fromlen > sizeof(sin)) {
678 *fromlen = sizeof(sin);
679 }
680
681 MEMCPY(from, &sin, *fromlen);
682
683 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d): addr=", s));
684 ip_addr_debug_print(SOCKETS_DEBUG, addr);
685 LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%"U16_F" len=%d\n", port, off));
686 } else {
687 #if SOCKETS_DEBUG
688 if (netconn_type(sock->conn) == NETCONN_TCP) {
689 addr = &fromaddr;
690 netconn_getaddr(sock->conn, addr, &port, 0);
691 } else {
692 addr = netbuf_fromaddr((struct netbuf *)buf);
693 port = netbuf_fromport((struct netbuf *)buf);
694 }
695
696 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d): addr=", s));
697 ip_addr_debug_print(SOCKETS_DEBUG, addr);
698 LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%"U16_F" len=%d\n", port, off));
699 #endif /* SOCKETS_DEBUG */
700 }
701 }
702
703 /* If we don't peek the incoming message... */
704 if ((flags & MSG_PEEK) == 0) {
705 /* If this is a TCP socket, check if there is data left in the
706 buffer. If so, it should be saved in the sock structure for next
707 time around. */
708 if ((netconn_type(sock->conn) == NETCONN_TCP) && (buflen - copylen > 0)) {
709 sock->lastdata = buf;
710 sock->lastoffset += copylen;
711 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom: lastdata now netbuf=%p\n", buf));
712 } else {
713 sock->lastdata = NULL;
714 sock->lastoffset = 0;
715 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom: deleting netbuf=%p\n", buf));
716 if (netconn_type(sock->conn) == NETCONN_TCP) {
717 pbuf_free((struct pbuf *)buf);
718 } else {
719 netbuf_delete((struct netbuf *)buf);
720 }
721 }
722 }
723 } while (!done);
724
725 if (off > 0) {
726 /* update receive window */
727 netconn_recved(sock->conn, (u32_t)off);
728 }
729 sock_set_errno(sock, 0);
730 return off;
731 }
732
733 int
734 lwip_read(int s, void *mem, size_t len)
735 {
736 return lwip_recvfrom(s, mem, len, 0, NULL, NULL);
737 }
738
739 int
740 lwip_recv(int s, void *mem, size_t len, int flags)
741 {
742 return lwip_recvfrom(s, mem, len, flags, NULL, NULL);
743 }
744
745 int
746 lwip_send(int s, const void *data, size_t size, int flags)
747 {
748 struct lwip_sock *sock;
749 err_t err;
750 u8_t write_flags;
751
752 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_send(%d, data=%p, size=%"SZT_F", flags=0x%x)\n",
753 s, data, size, flags));
754
755 sock = get_socket(s);
756 if (!sock) {
757 return -1;
758 }
759
760 if (sock->conn->type != NETCONN_TCP) {
761 #if (LWIP_UDP || LWIP_RAW)
762 return lwip_sendto(s, data, size, flags, NULL, 0);
763 #else /* (LWIP_UDP || LWIP_RAW) */
764 sock_set_errno(sock, err_to_errno(ERR_ARG));
765 return -1;
766 #endif /* (LWIP_UDP || LWIP_RAW) */
767 }
768
769 if ((flags & MSG_DONTWAIT) || netconn_is_nonblocking(sock->conn)) {
770 if ((size > TCP_SND_BUF) || ((size / TCP_MSS) > TCP_SND_QUEUELEN)) {
771 /* too much data to ever send nonblocking! */
772 sock_set_errno(sock, EMSGSIZE);
773 return -1;
774 }
775 }
776
777 write_flags = NETCONN_COPY |
778 ((flags & MSG_MORE) ? NETCONN_MORE : 0) |
779 ((flags & MSG_DONTWAIT) ? NETCONN_DONTBLOCK : 0);
780 err = netconn_write(sock->conn, data, size, write_flags);
781
782 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_send(%d) err=%d size=%"SZT_F"\n", s, err, size));
783 sock_set_errno(sock, err_to_errno(err));
784 return (err == ERR_OK ? (int)size : -1);
785 }
786
787 int
788 lwip_sendto(int s, const void *data, size_t size, int flags,
789 const struct sockaddr *to, socklen_t tolen)
790 {
791 struct lwip_sock *sock;
792 err_t err;
793 u16_t short_size;
794 const struct sockaddr_in *to_in;
795 u16_t remote_port;
796 #if !LWIP_TCPIP_CORE_LOCKING
797 struct netbuf buf;
798 #endif
799
800 sock = get_socket(s);
801 if (!sock) {
802 return -1;
803 }
804
805 if (sock->conn->type == NETCONN_TCP) {
806 #if LWIP_TCP
807 return lwip_send(s, data, size, flags);
808 #else /* LWIP_TCP */
809 LWIP_UNUSED_ARG(flags);
810 sock_set_errno(sock, err_to_errno(ERR_ARG));
811 return -1;
812 #endif /* LWIP_TCP */
813 }
814
815 /* @todo: split into multiple sendto's? */
816 LWIP_ASSERT("lwip_sendto: size must fit in u16_t", size <= 0xffff);
817 short_size = (u16_t)size;
818 LWIP_ERROR("lwip_sendto: invalid address", (((to == NULL) && (tolen == 0)) ||
819 ((tolen == sizeof(struct sockaddr_in)) &&
820 ((to->sa_family) == AF_INET) && ((((mem_ptr_t)to) % 4) == 0))),
821 sock_set_errno(sock, err_to_errno(ERR_ARG)); return -1;);
822 to_in = (const struct sockaddr_in *)(void*)to;
823
824 #if LWIP_TCPIP_CORE_LOCKING
825 /* Should only be consider like a sample or a simple way to experiment this option (no check of "to" field...) */
826 {
827 struct pbuf* p;
828 ip_addr_t *remote_addr;
829
830 #if LWIP_NETIF_TX_SINGLE_PBUF
831 p = pbuf_alloc(PBUF_TRANSPORT, short_size, PBUF_RAM);
832 if (p != NULL) {
833 #if LWIP_CHECKSUM_ON_COPY
834 u16_t chksum = 0;
835 if (sock->conn->type != NETCONN_RAW) {
836 chksum = LWIP_CHKSUM_COPY(p->payload, data, short_size);
837 } else
838 #endif /* LWIP_CHECKSUM_ON_COPY */
839 MEMCPY(p->payload, data, size);
840 #else /* LWIP_NETIF_TX_SINGLE_PBUF */
841 p = pbuf_alloc(PBUF_TRANSPORT, short_size, PBUF_REF);
842 if (p != NULL) {
843 p->payload = (void*)data;
844 #endif /* LWIP_NETIF_TX_SINGLE_PBUF */
845
846 if (to_in != NULL) {
847 inet_addr_to_ipaddr_p(remote_addr, &to_in->sin_addr);
848 remote_port = ntohs(to_in->sin_port);
849 } else {
850 remote_addr = &sock->conn->pcb.raw->remote_ip;
851 if (sock->conn->type == NETCONN_RAW) {
852 remote_port = 0;
853 } else {
854 remote_port = sock->conn->pcb.udp->remote_port;
855 }
856 }
857
858 LOCK_TCPIP_CORE();
859 if (sock->conn->type == NETCONN_RAW) {
860 err = sock->conn->last_err = raw_sendto(sock->conn->pcb.raw, p, remote_addr);
861 } else {
862 #if LWIP_UDP
863 #if LWIP_CHECKSUM_ON_COPY && LWIP_NETIF_TX_SINGLE_PBUF
864 err = sock->conn->last_err = udp_sendto_chksum(sock->conn->pcb.udp, p,
865 remote_addr, remote_port, 1, chksum);
866 #else /* LWIP_CHECKSUM_ON_COPY && LWIP_NETIF_TX_SINGLE_PBUF */
867 err = sock->conn->last_err = udp_sendto(sock->conn->pcb.udp, p,
868 remote_addr, remote_port);
869 #endif /* LWIP_CHECKSUM_ON_COPY && LWIP_NETIF_TX_SINGLE_PBUF */
870 #else /* LWIP_UDP */
871 err = ERR_ARG;
872 #endif /* LWIP_UDP */
873 }
874 UNLOCK_TCPIP_CORE();
875
876 pbuf_free(p);
877 } else {
878 err = ERR_MEM;
879 }
880 }
881 #else /* LWIP_TCPIP_CORE_LOCKING */
882 /* initialize a buffer */
883 buf.p = buf.ptr = NULL;
884 #if LWIP_CHECKSUM_ON_COPY
885 buf.flags = 0;
886 #endif /* LWIP_CHECKSUM_ON_COPY */
887 if (to) {
888 inet_addr_to_ipaddr(&buf.addr, &to_in->sin_addr);
889 remote_port = ntohs(to_in->sin_port);
890 netbuf_fromport(&buf) = remote_port;
891 } else {
892 remote_port = 0;
893 ip_addr_set_any(&buf.addr);
894 netbuf_fromport(&buf) = 0;
895 }
896
897 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_sendto(%d, data=%p, short_size=%"U16_F", flags=0x%x to=",
898 s, data, short_size, flags));
899 ip_addr_debug_print(SOCKETS_DEBUG, &buf.addr);
900 LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%"U16_F"\n", remote_port));
901
902 /* make the buffer point to the data that should be sent */
903 #if LWIP_NETIF_TX_SINGLE_PBUF
904 /* Allocate a new netbuf and copy the data into it. */
905 if (netbuf_alloc(&buf, short_size) == NULL) {
906 err = ERR_MEM;
907 } else {
908 #if LWIP_CHECKSUM_ON_COPY
909 if (sock->conn->type != NETCONN_RAW) {
910 u16_t chksum = LWIP_CHKSUM_COPY(buf.p->payload, data, short_size);
911 netbuf_set_chksum(&buf, chksum);
912 err = ERR_OK;
913 } else
914 #endif /* LWIP_CHECKSUM_ON_COPY */
915 {
916 err = netbuf_take(&buf, data, short_size);
917 }
918 }
919 #else /* LWIP_NETIF_TX_SINGLE_PBUF */
920 err = netbuf_ref(&buf, data, short_size);
921 #endif /* LWIP_NETIF_TX_SINGLE_PBUF */
922 if (err == ERR_OK) {
923 /* send the data */
924 err = netconn_send(sock->conn, &buf);
925 }
926
927 /* deallocated the buffer */
928 netbuf_free(&buf);
929 #endif /* LWIP_TCPIP_CORE_LOCKING */
930 sock_set_errno(sock, err_to_errno(err));
931 return (err == ERR_OK ? short_size : -1);
932 }
933
934 int
935 lwip_socket(int domain, int type, int protocol)
936 {
937 struct netconn *conn;
938 int i;
939
940 LWIP_UNUSED_ARG(domain);
941
942 /* create a netconn */
943 switch (type) {
944 case SOCK_RAW:
945 conn = netconn_new_with_proto_and_callback(NETCONN_RAW, (u8_t)protocol, event_callback);
946 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%s, SOCK_RAW, %d) = ",
947 domain == PF_INET ? "PF_INET" : "UNKNOWN", protocol));
948 break;
949 case SOCK_DGRAM:
950 conn = netconn_new_with_callback( (protocol == IPPROTO_UDPLITE) ?
951 NETCONN_UDPLITE : NETCONN_UDP, event_callback);
952 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%s, SOCK_DGRAM, %d) = ",
953 domain == PF_INET ? "PF_INET" : "UNKNOWN", protocol));
954 break;
955 case SOCK_STREAM:
956 conn = netconn_new_with_callback(NETCONN_TCP, event_callback);
957 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%s, SOCK_STREAM, %d) = ",
958 domain == PF_INET ? "PF_INET" : "UNKNOWN", protocol));
959 if (conn != NULL) {
960 /* Prevent automatic window updates, we do this on our own! */
961 netconn_set_noautorecved(conn, 1);
962 }
963 break;
964 default:
965 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%d, %d/UNKNOWN, %d) = -1\n",
966 domain, type, protocol));
967 set_errno(EINVAL);
968 return -1;
969 }
970
971 if (!conn) {
972 LWIP_DEBUGF(SOCKETS_DEBUG, ("-1 / ENOBUFS (could not create netconn)\n"));
973 set_errno(ENOBUFS);
974 return -1;
975 }
976
977 i = alloc_socket(conn, 0);
978
979 if (i == -1) {
980 netconn_delete(conn);
981 set_errno(ENFILE);
982 return -1;
983 }
984 conn->socket = i;
985 LWIP_DEBUGF(SOCKETS_DEBUG, ("%d\n", i));
986 set_errno(0);
987 return i;
988 }
989
990 int
991 lwip_write(int s, const void *data, size_t size)
992 {
993 return lwip_send(s, data, size, 0);
994 }
995
996 /**
997 * Go through the readset and writeset lists and see which socket of the sockets
998 * set in the sets has events. On return, readset, writeset and exceptset have
999 * the sockets enabled that had events.
1000 *
1001 * exceptset is not used for now!!!
1002 *
1003 * @param maxfdp1 the highest socket index in the sets
1004 * @param readset_in: set of sockets to check for read events
1005 * @param writeset_in: set of sockets to check for write events
1006 * @param exceptset_in: set of sockets to check for error events
1007 * @param readset_out: set of sockets that had read events
1008 * @param writeset_out: set of sockets that had write events
1009 * @param exceptset_out: set os sockets that had error events
1010 * @return number of sockets that had events (read/write/exception) (>= 0)
1011 */
1012 static int
1013 lwip_selscan(int maxfdp1, fd_set *readset_in, fd_set *writeset_in, fd_set *exceptset_in,
1014 fd_set *readset_out, fd_set *writeset_out, fd_set *exceptset_out)
1015 {
1016 int i, nready = 0;
1017 fd_set lreadset, lwriteset, lexceptset;
1018 struct lwip_sock *sock;
1019 SYS_ARCH_DECL_PROTECT(lev);
1020
1021 FD_ZERO(&lreadset);
1022 FD_ZERO(&lwriteset);
1023 FD_ZERO(&lexceptset);
1024
1025 /* Go through each socket in each list to count number of sockets which
1026 currently match */
1027 for(i = 0; i < maxfdp1; i++) {
1028 void* lastdata = NULL;
1029 s16_t rcvevent = 0;
1030 u16_t sendevent = 0;
1031 u16_t errevent = 0;
1032 /* First get the socket's status (protected)... */
1033 SYS_ARCH_PROTECT(lev);
1034 sock = tryget_socket(i);
1035 if (sock != NULL) {
1036 lastdata = sock->lastdata;
1037 rcvevent = sock->rcvevent;
1038 sendevent = sock->sendevent;
1039 errevent = sock->errevent;
1040 }
1041 SYS_ARCH_UNPROTECT(lev);
1042 /* ... then examine it: */
1043 /* See if netconn of this socket is ready for read */
1044 if (readset_in && FD_ISSET(i, readset_in) && ((lastdata != NULL) || (rcvevent > 0))) {
1045 FD_SET(i, &lreadset);
1046 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_selscan: fd=%d ready for reading\n", i));
1047 nready++;
1048 }
1049 /* See if netconn of this socket is ready for write */
1050 if (writeset_in && FD_ISSET(i, writeset_in) && (sendevent != 0)) {
1051 FD_SET(i, &lwriteset);
1052 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_selscan: fd=%d ready for writing\n", i));
1053 nready++;
1054 }
1055 /* See if netconn of this socket had an error */
1056 if (exceptset_in && FD_ISSET(i, exceptset_in) && (errevent != 0)) {
1057 FD_SET(i, &lexceptset);
1058 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_selscan: fd=%d ready for exception\n", i));
1059 nready++;
1060 }
1061 }
1062 /* copy local sets to the ones provided as arguments */
1063 *readset_out = lreadset;
1064 *writeset_out = lwriteset;
1065 *exceptset_out = lexceptset;
1066
1067 LWIP_ASSERT("nready >= 0", nready >= 0);
1068 return nready;
1069 }
1070
1071 /**
1072 * Processing exceptset is not yet implemented.
1073 */
1074 int
1075 lwip_select(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset,
1076 struct timeval *timeout)
1077 {
1078 u32_t waitres = 0;
1079 int nready;
1080 fd_set lreadset, lwriteset, lexceptset;
1081 u32_t msectimeout;
1082 struct lwip_select_cb select_cb;
1083 err_t err;
1084 int i;
1085 SYS_ARCH_DECL_PROTECT(lev);
1086
1087 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_select(%d, %p, %p, %p, tvsec=%"S32_F" tvusec=%"S32_F")\n",
1088 maxfdp1, (void *)readset, (void *) writeset, (void *) exceptset,
1089 timeout ? (s32_t)timeout->tv_sec : (s32_t)-1,
1090 timeout ? (s32_t)timeout->tv_usec : (s32_t)-1));
1091
1092 /* Go through each socket in each list to count number of sockets which
1093 currently match */
1094 nready = lwip_selscan(maxfdp1, readset, writeset, exceptset, &lreadset, &lwriteset, &lexceptset);
1095
1096 /* If we don't have any current events, then suspend if we are supposed to */
1097 if (!nready) {
1098 if (timeout && timeout->tv_sec == 0 && timeout->tv_usec == 0) {
1099 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_select: no timeout, returning 0\n"));
1100 /* This is OK as the local fdsets are empty and nready is zero,
1101 or we would have returned earlier. */
1102 goto return_copy_fdsets;
1103 }
1104
1105 /* None ready: add our semaphore to list:
1106 We don't actually need any dynamic memory. Our entry on the
1107 list is only valid while we are in this function, so it's ok
1108 to use local variables. */
1109
1110 select_cb.next = NULL;
1111 select_cb.prev = NULL;
1112 select_cb.readset = readset;
1113 select_cb.writeset = writeset;
1114 select_cb.exceptset = exceptset;
1115 select_cb.sem_signalled = 0;
1116 err = sys_sem_new(&select_cb.sem, 0);
1117 if (err != ERR_OK) {
1118 /* failed to create semaphore */
1119 set_errno(ENOMEM);
1120 return -1;
1121 }
1122
1123 /* Protect the select_cb_list */
1124 SYS_ARCH_PROTECT(lev);
1125
1126 /* Put this select_cb on top of list */
1127 select_cb.next = select_cb_list;
1128 if (select_cb_list != NULL) {
1129 select_cb_list->prev = &select_cb;
1130 }
1131 select_cb_list = &select_cb;
1132 /* Increasing this counter tells even_callback that the list has changed. */
1133 select_cb_ctr++;
1134
1135 /* Now we can safely unprotect */
1136 SYS_ARCH_UNPROTECT(lev);
1137
1138 /* Increase select_waiting for each socket we are interested in */
1139 for(i = 0; i < maxfdp1; i++) {
1140 if ((readset && FD_ISSET(i, readset)) ||
1141 (writeset && FD_ISSET(i, writeset)) ||
1142 (exceptset && FD_ISSET(i, exceptset))) {
1143 struct lwip_sock *sock = tryget_socket(i);
1144 LWIP_ASSERT("sock != NULL", sock != NULL);
1145 SYS_ARCH_PROTECT(lev);
1146 sock->select_waiting++;
1147 LWIP_ASSERT("sock->select_waiting > 0", sock->select_waiting > 0);
1148 SYS_ARCH_UNPROTECT(lev);
1149 }
1150 }
1151
1152 /* Call lwip_selscan again: there could have been events between
1153 the last scan (whithout us on the list) and putting us on the list! */
1154 nready = lwip_selscan(maxfdp1, readset, writeset, exceptset, &lreadset, &lwriteset, &lexceptset);
1155 if (!nready) {
1156 /* Still none ready, just wait to be woken */
1157 if (timeout == 0) {
1158 /* Wait forever */
1159 msectimeout = 0;
1160 } else {
1161 msectimeout = ((timeout->tv_sec * 1000) + ((timeout->tv_usec + 500)/1000));
1162 if (msectimeout == 0) {
1163 /* Wait 1ms at least (0 means wait forever) */
1164 msectimeout = 1;
1165 }
1166 }
1167
1168 waitres = sys_arch_sem_wait(&select_cb.sem, msectimeout);
1169 }
1170 /* Increase select_waiting for each socket we are interested in */
1171 for(i = 0; i < maxfdp1; i++) {
1172 if ((readset && FD_ISSET(i, readset)) ||
1173 (writeset && FD_ISSET(i, writeset)) ||
1174 (exceptset && FD_ISSET(i, exceptset))) {
1175 struct lwip_sock *sock = tryget_socket(i);
1176 LWIP_ASSERT("sock != NULL", sock != NULL);
1177 SYS_ARCH_PROTECT(lev);
1178 sock->select_waiting--;
1179 LWIP_ASSERT("sock->select_waiting >= 0", sock->select_waiting >= 0);
1180 SYS_ARCH_UNPROTECT(lev);
1181 }
1182 }
1183 /* Take us off the list */
1184 SYS_ARCH_PROTECT(lev);
1185 if (select_cb.next != NULL) {
1186 select_cb.next->prev = select_cb.prev;
1187 }
1188 if (select_cb_list == &select_cb) {
1189 LWIP_ASSERT("select_cb.prev == NULL", select_cb.prev == NULL);
1190 select_cb_list = select_cb.next;
1191 } else {
1192 LWIP_ASSERT("select_cb.prev != NULL", select_cb.prev != NULL);
1193 select_cb.prev->next = select_cb.next;
1194 }
1195 /* Increasing this counter tells even_callback that the list has changed. */
1196 select_cb_ctr++;
1197 SYS_ARCH_UNPROTECT(lev);
1198
1199 sys_sem_free(&select_cb.sem);
1200 if (waitres == SYS_ARCH_TIMEOUT) {
1201 /* Timeout */
1202 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_select: timeout expired\n"));
1203 /* This is OK as the local fdsets are empty and nready is zero,
1204 or we would have returned earlier. */
1205 goto return_copy_fdsets;
1206 }
1207
1208 /* See what's set */
1209 nready = lwip_selscan(maxfdp1, readset, writeset, exceptset, &lreadset, &lwriteset, &lexceptset);
1210 }
1211
1212 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_select: nready=%d\n", nready));
1213 return_copy_fdsets:
1214 set_errno(0);
1215 if (readset) {
1216 *readset = lreadset;
1217 }
1218 if (writeset) {
1219 *writeset = lwriteset;
1220 }
1221 if (exceptset) {
1222 *exceptset = lexceptset;
1223 }
1224
1225
1226 return nready;
1227 }
1228
1229 /**
1230 * Callback registered in the netconn layer for each socket-netconn.
1231 * Processes recvevent (data available) and wakes up tasks waiting for select.
1232 */
1233 static void
1234 event_callback(struct netconn *conn, enum netconn_evt evt, u16_t len)
1235 {
1236 int s;
1237 struct lwip_sock *sock;
1238 struct lwip_select_cb *scb;
1239 int last_select_cb_ctr;
1240 SYS_ARCH_DECL_PROTECT(lev);
1241
1242 LWIP_UNUSED_ARG(len);
1243
1244 /* Get socket */
1245 if (conn) {
1246 s = conn->socket;
1247 if (s < 0) {
1248 /* Data comes in right away after an accept, even though
1249 * the server task might not have created a new socket yet.
1250 * Just count down (or up) if that's the case and we
1251 * will use the data later. Note that only receive events
1252 * can happen before the new socket is set up. */
1253 SYS_ARCH_PROTECT(lev);
1254 if (conn->socket < 0) {
1255 if (evt == NETCONN_EVT_RCVPLUS) {
1256 conn->socket--;
1257 }
1258 SYS_ARCH_UNPROTECT(lev);
1259 return;
1260 }
1261 s = conn->socket;
1262 SYS_ARCH_UNPROTECT(lev);
1263 }
1264
1265 sock = get_socket(s);
1266 if (!sock) {
1267 return;
1268 }
1269 } else {
1270 return;
1271 }
1272
1273 SYS_ARCH_PROTECT(lev);
1274 /* Set event as required */
1275 switch (evt) {
1276 case NETCONN_EVT_RCVPLUS:
1277 sock->rcvevent++;
1278 break;
1279 case NETCONN_EVT_RCVMINUS:
1280 sock->rcvevent--;
1281 break;
1282 case NETCONN_EVT_SENDPLUS:
1283 sock->sendevent = 1;
1284 break;
1285 case NETCONN_EVT_SENDMINUS:
1286 sock->sendevent = 0;
1287 break;
1288 case NETCONN_EVT_ERROR:
1289 sock->errevent = 1;
1290 break;
1291 default:
1292 LWIP_ASSERT("unknown event", 0);
1293 break;
1294 }
1295
1296 if (sock->select_waiting == 0) {
1297 /* noone is waiting for this socket, no need to check select_cb_list */
1298 SYS_ARCH_UNPROTECT(lev);
1299 return;
1300 }
1301
1302 /* Now decide if anyone is waiting for this socket */
1303 /* NOTE: This code goes through the select_cb_list list multiple times
1304 ONLY IF a select was actually waiting. We go through the list the number
1305 of waiting select calls + 1. This list is expected to be small. */
1306
1307 /* At this point, SYS_ARCH is still protected! */
1308 again:
1309 for (scb = select_cb_list; scb != NULL; scb = scb->next) {
1310 if (scb->sem_signalled == 0) {
1311 /* semaphore not signalled yet */
1312 int do_signal = 0;
1313 /* Test this select call for our socket */
1314 if (sock->rcvevent > 0) {
1315 if (scb->readset && FD_ISSET(s, scb->readset)) {
1316 do_signal = 1;
1317 }
1318 }
1319 if (sock->sendevent != 0) {
1320 if (!do_signal && scb->writeset && FD_ISSET(s, scb->writeset)) {
1321 do_signal = 1;
1322 }
1323 }
1324 if (sock->errevent != 0) {
1325 if (!do_signal && scb->exceptset && FD_ISSET(s, scb->exceptset)) {
1326 do_signal = 1;
1327 }
1328 }
1329 if (do_signal) {
1330 scb->sem_signalled = 1;
1331 /* Don't call SYS_ARCH_UNPROTECT() before signaling the semaphore, as this might
1332 lead to the select thread taking itself off the list, invalidagin the semaphore. */
1333 sys_sem_signal(&scb->sem);
1334 }
1335 }
1336 /* unlock interrupts with each step */
1337 last_select_cb_ctr = select_cb_ctr;
1338 SYS_ARCH_UNPROTECT(lev);
1339 /* this makes sure interrupt protection time is short */
1340 SYS_ARCH_PROTECT(lev);
1341 if (last_select_cb_ctr != select_cb_ctr) {
1342 /* someone has changed select_cb_list, restart at the beginning */
1343 goto again;
1344 }
1345 }
1346 SYS_ARCH_UNPROTECT(lev);
1347 }
1348
1349 /**
1350 * Unimplemented: Close one end of a full-duplex connection.
1351 * Currently, the full connection is closed.
1352 */
1353 int
1354 lwip_shutdown(int s, int how)
1355 {
1356 struct lwip_sock *sock;
1357 err_t err;
1358 u8_t shut_rx = 0, shut_tx = 0;
1359
1360 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_shutdown(%d, how=%d)\n", s, how));
1361
1362 sock = get_socket(s);
1363 if (!sock) {
1364 return -1;
1365 }
1366
1367 if (sock->conn != NULL) {
1368 if (netconn_type(sock->conn) != NETCONN_TCP) {
1369 sock_set_errno(sock, EOPNOTSUPP);
1370 return EOPNOTSUPP;
1371 }
1372 } else {
1373 sock_set_errno(sock, ENOTCONN);
1374 return ENOTCONN;
1375 }
1376
1377 if (how == SHUT_RD) {
1378 shut_rx = 1;
1379 } else if (how == SHUT_WR) {
1380 shut_tx = 1;
1381 } else if(how == SHUT_RDWR) {
1382 shut_rx = 1;
1383 shut_tx = 1;
1384 } else {
1385 sock_set_errno(sock, EINVAL);
1386 return EINVAL;
1387 }
1388 err = netconn_shutdown(sock->conn, shut_rx, shut_tx);
1389
1390 sock_set_errno(sock, err_to_errno(err));
1391 return (err == ERR_OK ? 0 : -1);
1392 }
1393
1394 static int
1395 lwip_getaddrname(int s, struct sockaddr *name, socklen_t *namelen, u8_t local)
1396 {
1397 struct lwip_sock *sock;
1398 struct sockaddr_in sin;
1399 ip_addr_t naddr;
1400
1401 sock = get_socket(s);
1402 if (!sock) {
1403 return -1;
1404 }
1405
1406 memset(&sin, 0, sizeof(sin));
1407 sin.sin_len = sizeof(sin);
1408 sin.sin_family = AF_INET;
1409
1410 /* get the IP address and port */
1411 netconn_getaddr(sock->conn, &naddr, &sin.sin_port, local);
1412
1413 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getaddrname(%d, addr=", s));
1414 ip_addr_debug_print(SOCKETS_DEBUG, &naddr);
1415 LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%"U16_F")\n", sin.sin_port));
1416
1417 sin.sin_port = htons(sin.sin_port);
1418 inet_addr_from_ipaddr(&sin.sin_addr, &naddr);
1419
1420 if (*namelen > sizeof(sin)) {
1421 *namelen = sizeof(sin);
1422 }
1423
1424 MEMCPY(name, &sin, *namelen);
1425 sock_set_errno(sock, 0);
1426 return 0;
1427 }
1428
1429 int
1430 lwip_getpeername(int s, struct sockaddr *name, socklen_t *namelen)
1431 {
1432 return lwip_getaddrname(s, name, namelen, 0);
1433 }
1434
1435 int
1436 lwip_getsockname(int s, struct sockaddr *name, socklen_t *namelen)
1437 {
1438 return lwip_getaddrname(s, name, namelen, 1);
1439 }
1440
1441 int
1442 lwip_getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen)
1443 {
1444 err_t err = ERR_OK;
1445 struct lwip_sock *sock = get_socket(s);
1446 struct lwip_setgetsockopt_data data;
1447
1448 if (!sock) {
1449 return -1;
1450 }
1451
1452 if ((NULL == optval) || (NULL == optlen)) {
1453 sock_set_errno(sock, EFAULT);
1454 return -1;
1455 }
1456
1457 /* Do length and type checks for the various options first, to keep it readable. */
1458 switch (level) {
1459
1460 /* Level: SOL_SOCKET */
1461 case SOL_SOCKET:
1462 switch (optname) {
1463
1464 case SO_ACCEPTCONN:
1465 case SO_BROADCAST:
1466 /* UNIMPL case SO_DEBUG: */
1467 /* UNIMPL case SO_DONTROUTE: */
1468 case SO_ERROR:
1469 case SO_KEEPALIVE:
1470 /* UNIMPL case SO_CONTIMEO: */
1471 /* UNIMPL case SO_SNDTIMEO: */
1472 #if LWIP_SO_RCVTIMEO
1473 case SO_RCVTIMEO:
1474 #endif /* LWIP_SO_RCVTIMEO */
1475 #if LWIP_SO_RCVBUF
1476 case SO_RCVBUF:
1477 #endif /* LWIP_SO_RCVBUF */
1478 /* UNIMPL case SO_OOBINLINE: */
1479 /* UNIMPL case SO_SNDBUF: */
1480 /* UNIMPL case SO_RCVLOWAT: */
1481 /* UNIMPL case SO_SNDLOWAT: */
1482 #if SO_REUSE
1483 case SO_REUSEADDR:
1484 case SO_REUSEPORT:
1485 #endif /* SO_REUSE */
1486 case SO_TYPE:
1487 /* UNIMPL case SO_USELOOPBACK: */
1488 if (*optlen < sizeof(int)) {
1489 err = EINVAL;
1490 }
1491 break;
1492
1493 case SO_NO_CHECK:
1494 if (*optlen < sizeof(int)) {
1495 err = EINVAL;
1496 }
1497 #if LWIP_UDP
1498 if ((sock->conn->type != NETCONN_UDP) ||
1499 ((udp_flags(sock->conn->pcb.udp) & UDP_FLAGS_UDPLITE) != 0)) {
1500 /* this flag is only available for UDP, not for UDP lite */
1501 err = EAFNOSUPPORT;
1502 }
1503 #endif /* LWIP_UDP */
1504 break;
1505
1506 default:
1507 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, UNIMPL: optname=0x%x, ..)\n",
1508 s, optname));
1509 err = ENOPROTOOPT;
1510 } /* switch (optname) */
1511 break;
1512
1513 /* Level: IPPROTO_IP */
1514 case IPPROTO_IP:
1515 switch (optname) {
1516 /* UNIMPL case IP_HDRINCL: */
1517 /* UNIMPL case IP_RCVDSTADDR: */
1518 /* UNIMPL case IP_RCVIF: */
1519 case IP_TTL:
1520 case IP_TOS:
1521 if (*optlen < sizeof(int)) {
1522 err = EINVAL;
1523 }
1524 break;
1525 #if LWIP_IGMP
1526 case IP_MULTICAST_TTL:
1527 if (*optlen < sizeof(u8_t)) {
1528 err = EINVAL;
1529 }
1530 break;
1531 case IP_MULTICAST_IF:
1532 if (*optlen < sizeof(struct in_addr)) {
1533 err = EINVAL;
1534 }
1535 break;
1536 case IP_MULTICAST_LOOP:
1537 if (*optlen < sizeof(u8_t)) {
1538 err = EINVAL;
1539 }
1540 if (NETCONNTYPE_GROUP(sock->conn->type) != NETCONN_UDP) {
1541 err = EAFNOSUPPORT;
1542 }
1543 break;
1544 #endif /* LWIP_IGMP */
1545
1546 default:
1547 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, UNIMPL: optname=0x%x, ..)\n",
1548 s, optname));
1549 err = ENOPROTOOPT;
1550 } /* switch (optname) */
1551 break;
1552
1553 #if LWIP_TCP
1554 /* Level: IPPROTO_TCP */
1555 case IPPROTO_TCP:
1556 if (*optlen < sizeof(int)) {
1557 err = EINVAL;
1558 break;
1559 }
1560
1561 /* If this is no TCP socket, ignore any options. */
1562 if (sock->conn->type != NETCONN_TCP)
1563 return 0;
1564
1565 switch (optname) {
1566 case TCP_NODELAY:
1567 case TCP_KEEPALIVE:
1568 #if LWIP_TCP_KEEPALIVE
1569 case TCP_KEEPIDLE:
1570 case TCP_KEEPINTVL:
1571 case TCP_KEEPCNT:
1572 #endif /* LWIP_TCP_KEEPALIVE */
1573 break;
1574
1575 default:
1576 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_TCP, UNIMPL: optname=0x%x, ..)\n",
1577 s, optname));
1578 err = ENOPROTOOPT;
1579 } /* switch (optname) */
1580 break;
1581 #endif /* LWIP_TCP */
1582 #if LWIP_UDP && LWIP_UDPLITE
1583 /* Level: IPPROTO_UDPLITE */
1584 case IPPROTO_UDPLITE:
1585 if (*optlen < sizeof(int)) {
1586 err = EINVAL;
1587 break;
1588 }
1589
1590 /* If this is no UDP lite socket, ignore any options. */
1591 if (sock->conn->type != NETCONN_UDPLITE) {
1592 return 0;
1593 }
1594
1595 switch (optname) {
1596 case UDPLITE_SEND_CSCOV:
1597 case UDPLITE_RECV_CSCOV:
1598 break;
1599
1600 default:
1601 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_UDPLITE, UNIMPL: optname=0x%x, ..)\n",
1602 s, optname));
1603 err = ENOPROTOOPT;
1604 } /* switch (optname) */
1605 break;
1606 #endif /* LWIP_UDP && LWIP_UDPLITE*/
1607 /* UNDEFINED LEVEL */
1608 default:
1609 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, level=0x%x, UNIMPL: optname=0x%x, ..)\n",
1610 s, level, optname));
1611 err = ENOPROTOOPT;
1612 } /* switch */
1613
1614
1615 if (err != ERR_OK) {
1616 sock_set_errno(sock, err);
1617 return -1;
1618 }
1619
1620 /* Now do the actual option processing */
1621 data.sock = sock;
1622 #ifdef LWIP_DEBUG
1623 data.s = s;
1624 #endif /* LWIP_DEBUG */
1625 data.level = level;
1626 data.optname = optname;
1627 data.optval = optval;
1628 data.optlen = optlen;
1629 data.err = err;
1630 tcpip_callback(lwip_getsockopt_internal, &data);
1631 sys_arch_sem_wait(&sock->conn->op_completed, 0);
1632 /* maybe lwip_getsockopt_internal has changed err */
1633 err = data.err;
1634
1635 sock_set_errno(sock, err);
1636 return err ? -1 : 0;
1637 }
1638
1639 static void
1640 lwip_getsockopt_internal(void *arg)
1641 {
1642 struct lwip_sock *sock;
1643 #ifdef LWIP_DEBUG
1644 int s;
1645 #endif /* LWIP_DEBUG */
1646 int level, optname;
1647 void *optval;
1648 struct lwip_setgetsockopt_data *data;
1649
1650 LWIP_ASSERT("arg != NULL", arg != NULL);
1651
1652 data = (struct lwip_setgetsockopt_data*)arg;
1653 sock = data->sock;
1654 #ifdef LWIP_DEBUG
1655 s = data->s;
1656 #endif /* LWIP_DEBUG */
1657 level = data->level;
1658 optname = data->optname;
1659 optval = data->optval;
1660
1661 switch (level) {
1662
1663 /* Level: SOL_SOCKET */
1664 case SOL_SOCKET:
1665 switch (optname) {
1666
1667 /* The option flags */
1668 case SO_ACCEPTCONN:
1669 case SO_BROADCAST:
1670 /* UNIMPL case SO_DEBUG: */
1671 /* UNIMPL case SO_DONTROUTE: */
1672 case SO_KEEPALIVE:
1673 /* UNIMPL case SO_OOBINCLUDE: */
1674 #if SO_REUSE
1675 case SO_REUSEADDR:
1676 case SO_REUSEPORT:
1677 #endif /* SO_REUSE */
1678 /*case SO_USELOOPBACK: UNIMPL */
1679 *(int*)optval = sock->conn->pcb.ip->so_options & optname;
1680 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, optname=0x%x, ..) = %s\n",
1681 s, optname, (*(int*)optval?"on":"off")));
1682 break;
1683
1684 case SO_TYPE:
1685 switch (NETCONNTYPE_GROUP(sock->conn->type)) {
1686 case NETCONN_RAW:
1687 *(int*)optval = SOCK_RAW;
1688 break;
1689 case NETCONN_TCP:
1690 *(int*)optval = SOCK_STREAM;
1691 break;
1692 case NETCONN_UDP:
1693 *(int*)optval = SOCK_DGRAM;
1694 break;
1695 default: /* unrecognized socket type */
1696 *(int*)optval = sock->conn->type;
1697 LWIP_DEBUGF(SOCKETS_DEBUG,
1698 ("lwip_getsockopt(%d, SOL_SOCKET, SO_TYPE): unrecognized socket type %d\n",
1699 s, *(int *)optval));
1700 } /* switch (sock->conn->type) */
1701 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, SO_TYPE) = %d\n",
1702 s, *(int *)optval));
1703 break;
1704
1705 case SO_ERROR:
1706 /* only overwrite ERR_OK or tempoary errors */
1707 if ((sock->err == 0) || (sock->err == EINPROGRESS)) {
1708 sock_set_errno(sock, err_to_errno(sock->conn->last_err));
1709 }
1710 *(int *)optval = sock->err;
1711 sock->err = 0;
1712 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, SO_ERROR) = %d\n",
1713 s, *(int *)optval));
1714 break;
1715
1716 #if LWIP_SO_RCVTIMEO
1717 case SO_RCVTIMEO:
1718 *(int *)optval = netconn_get_recvtimeout(sock->conn);
1719 break;
1720 #endif /* LWIP_SO_RCVTIMEO */
1721 #if LWIP_SO_RCVBUF
1722 case SO_RCVBUF:
1723 *(int *)optval = netconn_get_recvbufsize(sock->conn);
1724 break;
1725 #endif /* LWIP_SO_RCVBUF */
1726 #if LWIP_UDP
1727 case SO_NO_CHECK:
1728 *(int*)optval = (udp_flags(sock->conn->pcb.udp) & UDP_FLAGS_NOCHKSUM) ? 1 : 0;
1729 break;
1730 #endif /* LWIP_UDP*/
1731 default:
1732 LWIP_ASSERT("unhandled optname", 0);
1733 break;
1734 } /* switch (optname) */
1735 break;
1736
1737 /* Level: IPPROTO_IP */
1738 case IPPROTO_IP:
1739 switch (optname) {
1740 case IP_TTL:
1741 *(int*)optval = sock->conn->pcb.ip->ttl;
1742 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_TTL) = %d\n",
1743 s, *(int *)optval));
1744 break;
1745 case IP_TOS:
1746 *(int*)optval = sock->conn->pcb.ip->tos;
1747 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_TOS) = %d\n",
1748 s, *(int *)optval));
1749 break;
1750 #if LWIP_IGMP
1751 case IP_MULTICAST_TTL:
1752 *(u8_t*)optval = sock->conn->pcb.ip->ttl;
1753 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_MULTICAST_TTL) = %d\n",
1754 s, *(int *)optval));
1755 break;
1756 case IP_MULTICAST_IF:
1757 inet_addr_from_ipaddr((struct in_addr*)optval, &sock->conn->pcb.udp->multicast_ip);
1758 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_MULTICAST_IF) = 0x%"X32_F"\n",
1759 s, *(u32_t *)optval));
1760 break;
1761 case IP_MULTICAST_LOOP:
1762 if ((sock->conn->pcb.udp->flags & UDP_FLAGS_MULTICAST_LOOP) != 0) {
1763 *(u8_t*)optval = 1;
1764 } else {
1765 *(u8_t*)optval = 0;
1766 }
1767 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_MULTICAST_LOOP) = %d\n",
1768 s, *(int *)optval));
1769 break;
1770 #endif /* LWIP_IGMP */
1771 default:
1772 LWIP_ASSERT("unhandled optname", 0);
1773 break;
1774 } /* switch (optname) */
1775 break;
1776
1777 #if LWIP_TCP
1778 /* Level: IPPROTO_TCP */
1779 case IPPROTO_TCP:
1780 switch (optname) {
1781 case TCP_NODELAY:
1782 *(int*)optval = tcp_nagle_disabled(sock->conn->pcb.tcp);
1783 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_TCP, TCP_NODELAY) = %s\n",
1784 s, (*(int*)optval)?"on":"off") );
1785 break;
1786 case TCP_KEEPALIVE:
1787 *(int*)optval = (int)sock->conn->pcb.tcp->keep_idle;
1788 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, TCP_KEEPALIVE) = %d\n",
1789 s, *(int *)optval));
1790 break;
1791
1792 #if LWIP_TCP_KEEPALIVE
1793 case TCP_KEEPIDLE:
1794 *(int*)optval = (int)(sock->conn->pcb.tcp->keep_idle/1000);
1795 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, TCP_KEEPIDLE) = %d\n",
1796 s, *(int *)optval));
1797 break;
1798 case TCP_KEEPINTVL:
1799 *(int*)optval = (int)(sock->conn->pcb.tcp->keep_intvl/1000);
1800 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, TCP_KEEPINTVL) = %d\n",
1801 s, *(int *)optval));
1802 break;
1803 case TCP_KEEPCNT:
1804 *(int*)optval = (int)sock->conn->pcb.tcp->keep_cnt;
1805 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, TCP_KEEPCNT) = %d\n",
1806 s, *(int *)optval));
1807 break;
1808 #endif /* LWIP_TCP_KEEPALIVE */
1809 default:
1810 LWIP_ASSERT("unhandled optname", 0);
1811 break;
1812 } /* switch (optname) */
1813 break;
1814 #endif /* LWIP_TCP */
1815 #if LWIP_UDP && LWIP_UDPLITE
1816 /* Level: IPPROTO_UDPLITE */
1817 case IPPROTO_UDPLITE:
1818 switch (optname) {
1819 case UDPLITE_SEND_CSCOV:
1820 *(int*)optval = sock->conn->pcb.udp->chksum_len_tx;
1821 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_UDPLITE, UDPLITE_SEND_CSCOV) = %d\n",
1822 s, (*(int*)optval)) );
1823 break;
1824 case UDPLITE_RECV_CSCOV:
1825 *(int*)optval = sock->conn->pcb.udp->chksum_len_rx;
1826 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_UDPLITE, UDPLITE_RECV_CSCOV) = %d\n",
1827 s, (*(int*)optval)) );
1828 break;
1829 default:
1830 LWIP_ASSERT("unhandled optname", 0);
1831 break;
1832 } /* switch (optname) */
1833 break;
1834 #endif /* LWIP_UDP */
1835 default:
1836 LWIP_ASSERT("unhandled level", 0);
1837 break;
1838 } /* switch (level) */
1839 sys_sem_signal(&sock->conn->op_completed);
1840 }
1841
1842 int
1843 lwip_setsockopt(int s, int level, int optname, const void *optval, socklen_t optlen)
1844 {
1845 struct lwip_sock *sock = get_socket(s);
1846 err_t err = ERR_OK;
1847 struct lwip_setgetsockopt_data data;
1848
1849 if (!sock) {
1850 return -1;
1851 }
1852
1853 if (NULL == optval) {
1854 sock_set_errno(sock, EFAULT);
1855 return -1;
1856 }
1857
1858 /* Do length and type checks for the various options first, to keep it readable. */
1859 switch (level) {
1860
1861 /* Level: SOL_SOCKET */
1862 case SOL_SOCKET:
1863 switch (optname) {
1864
1865 case SO_BROADCAST:
1866 /* UNIMPL case SO_DEBUG: */
1867 /* UNIMPL case SO_DONTROUTE: */
1868 case SO_KEEPALIVE:
1869 /* UNIMPL case case SO_CONTIMEO: */
1870 /* UNIMPL case case SO_SNDTIMEO: */
1871 #if LWIP_SO_RCVTIMEO
1872 case SO_RCVTIMEO:
1873 #endif /* LWIP_SO_RCVTIMEO */
1874 #if LWIP_SO_RCVBUF
1875 case SO_RCVBUF:
1876 #endif /* LWIP_SO_RCVBUF */
1877 /* UNIMPL case SO_OOBINLINE: */
1878 /* UNIMPL case SO_SNDBUF: */
1879 /* UNIMPL case SO_RCVLOWAT: */
1880 /* UNIMPL case SO_SNDLOWAT: */
1881 #if SO_REUSE
1882 case SO_REUSEADDR:
1883 case SO_REUSEPORT:
1884 #endif /* SO_REUSE */
1885 /* UNIMPL case SO_USELOOPBACK: */
1886 if (optlen < sizeof(int)) {
1887 err = EINVAL;
1888 }
1889 break;
1890 case SO_NO_CHECK:
1891 if (optlen < sizeof(int)) {
1892 err = EINVAL;
1893 }
1894 #if LWIP_UDP
1895 if ((sock->conn->type != NETCONN_UDP) ||
1896 ((udp_flags(sock->conn->pcb.udp) & UDP_FLAGS_UDPLITE) != 0)) {
1897 /* this flag is only available for UDP, not for UDP lite */
1898 err = EAFNOSUPPORT;
1899 }
1900 #endif /* LWIP_UDP */
1901 break;
1902 default:
1903 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, SOL_SOCKET, UNIMPL: optname=0x%x, ..)\n",
1904 s, optname));
1905 err = ENOPROTOOPT;
1906 } /* switch (optname) */
1907 break;
1908
1909 /* Level: IPPROTO_IP */
1910 case IPPROTO_IP:
1911 switch (optname) {
1912 /* UNIMPL case IP_HDRINCL: */
1913 /* UNIMPL case IP_RCVDSTADDR: */
1914 /* UNIMPL case IP_RCVIF: */
1915 case IP_TTL:
1916 case IP_TOS:
1917 if (optlen < sizeof(int)) {
1918 err = EINVAL;
1919 }
1920 break;
1921 #if LWIP_IGMP
1922 case IP_MULTICAST_TTL:
1923 if (optlen < sizeof(u8_t)) {
1924 err = EINVAL;
1925 }
1926 if (NETCONNTYPE_GROUP(sock->conn->type) != NETCONN_UDP) {
1927 err = EAFNOSUPPORT;
1928 }
1929 break;
1930 case IP_MULTICAST_IF:
1931 if (optlen < sizeof(struct in_addr)) {
1932 err = EINVAL;
1933 }
1934 if (NETCONNTYPE_GROUP(sock->conn->type) != NETCONN_UDP) {
1935 err = EAFNOSUPPORT;
1936 }
1937 break;
1938 case IP_MULTICAST_LOOP:
1939 if (optlen < sizeof(u8_t)) {
1940 err = EINVAL;
1941 }
1942 if (NETCONNTYPE_GROUP(sock->conn->type) != NETCONN_UDP) {
1943 err = EAFNOSUPPORT;
1944 }
1945 break;
1946 case IP_ADD_MEMBERSHIP:
1947 case IP_DROP_MEMBERSHIP:
1948 if (optlen < sizeof(struct ip_mreq)) {
1949 err = EINVAL;
1950 }
1951 if (NETCONNTYPE_GROUP(sock->conn->type) != NETCONN_UDP) {
1952 err = EAFNOSUPPORT;
1953 }
1954 break;
1955 #endif /* LWIP_IGMP */
1956 default:
1957 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_IP, UNIMPL: optname=0x%x, ..)\n",
1958 s, optname));
1959 err = ENOPROTOOPT;
1960 } /* switch (optname) */
1961 break;
1962
1963 #if LWIP_TCP
1964 /* Level: IPPROTO_TCP */
1965 case IPPROTO_TCP:
1966 if (optlen < sizeof(int)) {
1967 err = EINVAL;
1968 break;
1969 }
1970
1971 /* If this is no TCP socket, ignore any options. */
1972 if (sock->conn->type != NETCONN_TCP)
1973 return 0;
1974
1975 switch (optname) {
1976 case TCP_NODELAY:
1977 case TCP_KEEPALIVE:
1978 #if LWIP_TCP_KEEPALIVE
1979 case TCP_KEEPIDLE:
1980 case TCP_KEEPINTVL:
1981 case TCP_KEEPCNT:
1982 #endif /* LWIP_TCP_KEEPALIVE */
1983 break;
1984
1985 default:
1986 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, UNIMPL: optname=0x%x, ..)\n",
1987 s, optname));
1988 err = ENOPROTOOPT;
1989 } /* switch (optname) */
1990 break;
1991 #endif /* LWIP_TCP */
1992 #if LWIP_UDP && LWIP_UDPLITE
1993 /* Level: IPPROTO_UDPLITE */
1994 case IPPROTO_UDPLITE:
1995 if (optlen < sizeof(int)) {
1996 err = EINVAL;
1997 break;
1998 }
1999
2000 /* If this is no UDP lite socket, ignore any options. */
2001 if (sock->conn->type != NETCONN_UDPLITE)
2002 return 0;
2003
2004 switch (optname) {
2005 case UDPLITE_SEND_CSCOV:
2006 case UDPLITE_RECV_CSCOV:
2007 break;
2008
2009 default:
2010 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_UDPLITE, UNIMPL: optname=0x%x, ..)\n",
2011 s, optname));
2012 err = ENOPROTOOPT;
2013 } /* switch (optname) */
2014 break;
2015 #endif /* LWIP_UDP && LWIP_UDPLITE */
2016 /* UNDEFINED LEVEL */
2017 default:
2018 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, level=0x%x, UNIMPL: optname=0x%x, ..)\n",
2019 s, level, optname));
2020 err = ENOPROTOOPT;
2021 } /* switch (level) */
2022
2023
2024 if (err != ERR_OK) {
2025 sock_set_errno(sock, err);
2026 return -1;
2027 }
2028
2029
2030 /* Now do the actual option processing */
2031 data.sock = sock;
2032 #ifdef LWIP_DEBUG
2033 data.s = s;
2034 #endif /* LWIP_DEBUG */
2035 data.level = level;
2036 data.optname = optname;
2037 data.optval = (void*)optval;
2038 data.optlen = &optlen;
2039 data.err = err;
2040 tcpip_callback(lwip_setsockopt_internal, &data);
2041 sys_arch_sem_wait(&sock->conn->op_completed, 0);
2042 /* maybe lwip_setsockopt_internal has changed err */
2043 err = data.err;
2044
2045 sock_set_errno(sock, err);
2046 return err ? -1 : 0;
2047 }
2048
2049 static void
2050 lwip_setsockopt_internal(void *arg)
2051 {
2052 struct lwip_sock *sock;
2053 #ifdef LWIP_DEBUG
2054 int s;
2055 #endif /* LWIP_DEBUG */
2056 int level, optname;
2057 const void *optval;
2058 struct lwip_setgetsockopt_data *data;
2059
2060 LWIP_ASSERT("arg != NULL", arg != NULL);
2061
2062 data = (struct lwip_setgetsockopt_data*)arg;
2063 sock = data->sock;
2064 #ifdef LWIP_DEBUG
2065 s = data->s;
2066 #endif /* LWIP_DEBUG */
2067 level = data->level;
2068 optname = data->optname;
2069 optval = data->optval;
2070
2071 switch (level) {
2072
2073 /* Level: SOL_SOCKET */
2074 case SOL_SOCKET:
2075 switch (optname) {
2076
2077 /* The option flags */
2078 case SO_BROADCAST:
2079 /* UNIMPL case SO_DEBUG: */
2080 /* UNIMPL case SO_DONTROUTE: */
2081 case SO_KEEPALIVE:
2082 /* UNIMPL case SO_OOBINCLUDE: */
2083 #if SO_REUSE
2084 case SO_REUSEADDR:
2085 case SO_REUSEPORT:
2086 #endif /* SO_REUSE */
2087 /* UNIMPL case SO_USELOOPBACK: */
2088 if (*(int*)optval) {
2089 sock->conn->pcb.ip->so_options |= optname;
2090 } else {
2091 sock->conn->pcb.ip->so_options &= ~optname;
2092 }
2093 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, SOL_SOCKET, optname=0x%x, ..) -> %s\n",
2094 s, optname, (*(int*)optval?"on":"off")));
2095 break;
2096 #if LWIP_SO_RCVTIMEO
2097 case SO_RCVTIMEO:
2098 netconn_set_recvtimeout(sock->conn, *(int*)optval);
2099 break;
2100 #endif /* LWIP_SO_RCVTIMEO */
2101 #if LWIP_SO_RCVBUF
2102 case SO_RCVBUF:
2103 netconn_set_recvbufsize(sock->conn, *(int*)optval);
2104 break;
2105 #endif /* LWIP_SO_RCVBUF */
2106 #if LWIP_UDP
2107 case SO_NO_CHECK:
2108 if (*(int*)optval) {
2109 udp_setflags(sock->conn->pcb.udp, udp_flags(sock->conn->pcb.udp) | UDP_FLAGS_NOCHKSUM);
2110 } else {
2111 udp_setflags(sock->conn->pcb.udp, udp_flags(sock->conn->pcb.udp) & ~UDP_FLAGS_NOCHKSUM);
2112 }
2113 break;
2114 #endif /* LWIP_UDP */
2115 default:
2116 LWIP_ASSERT("unhandled optname", 0);
2117 break;
2118 } /* switch (optname) */
2119 break;
2120
2121 /* Level: IPPROTO_IP */
2122 case IPPROTO_IP:
2123 switch (optname) {
2124 case IP_TTL:
2125 sock->conn->pcb.ip->ttl = (u8_t)(*(int*)optval);
2126 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_IP, IP_TTL, ..) -> %d\n",
2127 s, sock->conn->pcb.ip->ttl));
2128 break;
2129 case IP_TOS:
2130 sock->conn->pcb.ip->tos = (u8_t)(*(int*)optval);
2131 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_IP, IP_TOS, ..)-> %d\n",
2132 s, sock->conn->pcb.ip->tos));
2133 break;
2134 #if LWIP_IGMP
2135 case IP_MULTICAST_TTL:
2136 sock->conn->pcb.udp->ttl = (u8_t)(*(u8_t*)optval);
2137 break;
2138 case IP_MULTICAST_IF:
2139 inet_addr_to_ipaddr(&sock->conn->pcb.udp->multicast_ip, (struct in_addr*)optval);
2140 break;
2141 case IP_MULTICAST_LOOP:
2142 if (*(u8_t*)optval) {
2143 udp_setflags(sock->conn->pcb.udp, udp_flags(sock->conn->pcb.udp) | UDP_FLAGS_MULTICAST_LOOP);
2144 } else {
2145 udp_setflags(sock->conn->pcb.udp, udp_flags(sock->conn->pcb.udp) & ~UDP_FLAGS_MULTICAST_LOOP);
2146 }
2147 break;
2148 case IP_ADD_MEMBERSHIP:
2149 case IP_DROP_MEMBERSHIP:
2150 {
2151 /* If this is a TCP or a RAW socket, ignore these options. */
2152 struct ip_mreq *imr = (struct ip_mreq *)optval;
2153 ip_addr_t if_addr;
2154 ip_addr_t multi_addr;
2155 inet_addr_to_ipaddr(&if_addr, &imr->imr_interface);
2156 inet_addr_to_ipaddr(&multi_addr, &imr->imr_multiaddr);
2157 if(optname == IP_ADD_MEMBERSHIP){
2158 data->err = igmp_joingroup(&if_addr, &multi_addr);
2159 } else {
2160 data->err = igmp_leavegroup(&if_addr, &multi_addr);
2161 }
2162 if(data->err != ERR_OK) {
2163 data->err = EADDRNOTAVAIL;
2164 }
2165 }
2166 break;
2167 #endif /* LWIP_IGMP */
2168 default:
2169 LWIP_ASSERT("unhandled optname", 0);
2170 break;
2171 } /* switch (optname) */
2172 break;
2173
2174 #if LWIP_TCP
2175 /* Level: IPPROTO_TCP */
2176 case IPPROTO_TCP:
2177 switch (optname) {
2178 case TCP_NODELAY:
2179 if (*(int*)optval) {
2180 tcp_nagle_disable(sock->conn->pcb.tcp);
2181 } else {
2182 tcp_nagle_enable(sock->conn->pcb.tcp);
2183 }
2184 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_NODELAY) -> %s\n",
2185 s, (*(int *)optval)?"on":"off") );
2186 break;
2187 case TCP_KEEPALIVE:
2188 sock->conn->pcb.tcp->keep_idle = (u32_t)(*(int*)optval);
2189 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_KEEPALIVE) -> %"U32_F"\n",
2190 s, sock->conn->pcb.tcp->keep_idle));
2191 break;
2192
2193 #if LWIP_TCP_KEEPALIVE
2194 case TCP_KEEPIDLE:
2195 sock->conn->pcb.tcp->keep_idle = 1000*(u32_t)(*(int*)optval);
2196 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_KEEPIDLE) -> %"U32_F"\n",
2197 s, sock->conn->pcb.tcp->keep_idle));
2198 break;
2199 case TCP_KEEPINTVL:
2200 sock->conn->pcb.tcp->keep_intvl = 1000*(u32_t)(*(int*)optval);
2201 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_KEEPINTVL) -> %"U32_F"\n",
2202 s, sock->conn->pcb.tcp->keep_intvl));
2203 break;
2204 case TCP_KEEPCNT:
2205 sock->conn->pcb.tcp->keep_cnt = (u32_t)(*(int*)optval);
2206 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_KEEPCNT) -> %"U32_F"\n",
2207 s, sock->conn->pcb.tcp->keep_cnt));
2208 break;
2209 #endif /* LWIP_TCP_KEEPALIVE */
2210 default:
2211 LWIP_ASSERT("unhandled optname", 0);
2212 break;
2213 } /* switch (optname) */
2214 break;
2215 #endif /* LWIP_TCP*/
2216 #if LWIP_UDP && LWIP_UDPLITE
2217 /* Level: IPPROTO_UDPLITE */
2218 case IPPROTO_UDPLITE:
2219 switch (optname) {
2220 case UDPLITE_SEND_CSCOV:
2221 if ((*(int*)optval != 0) && ((*(int*)optval < 8)) || (*(int*)optval > 0xffff)) {
2222 /* don't allow illegal values! */
2223 sock->conn->pcb.udp->chksum_len_tx = 8;
2224 } else {
2225 sock->conn->pcb.udp->chksum_len_tx = (u16_t)*(int*)optval;
2226 }
2227 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_UDPLITE, UDPLITE_SEND_CSCOV) -> %d\n",
2228 s, (*(int*)optval)) );
2229 break;
2230 case UDPLITE_RECV_CSCOV:
2231 if ((*(int*)optval != 0) && ((*(int*)optval < 8)) || (*(int*)optval > 0xffff)) {
2232 /* don't allow illegal values! */
2233 sock->conn->pcb.udp->chksum_len_rx = 8;
2234 } else {
2235 sock->conn->pcb.udp->chksum_len_rx = (u16_t)*(int*)optval;
2236 }
2237 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_UDPLITE, UDPLITE_RECV_CSCOV) -> %d\n",
2238 s, (*(int*)optval)) );
2239 break;
2240 default:
2241 LWIP_ASSERT("unhandled optname", 0);
2242 break;
2243 } /* switch (optname) */
2244 break;
2245 #endif /* LWIP_UDP */
2246 default:
2247 LWIP_ASSERT("unhandled level", 0);
2248 break;
2249 } /* switch (level) */
2250 sys_sem_signal(&sock->conn->op_completed);
2251 }
2252
2253 int
2254 lwip_ioctl(int s, long cmd, void *argp)
2255 {
2256 struct lwip_sock *sock = get_socket(s);
2257 u8_t val;
2258 #if LWIP_SO_RCVBUF
2259 u16_t buflen = 0;
2260 s16_t recv_avail;
2261 #endif /* LWIP_SO_RCVBUF */
2262
2263 if (!sock) {
2264 return -1;
2265 }
2266
2267 switch (cmd) {
2268 #if LWIP_SO_RCVBUF
2269 case FIONREAD:
2270 if (!argp) {
2271 sock_set_errno(sock, EINVAL);
2272 return -1;
2273 }
2274
2275 SYS_ARCH_GET(sock->conn->recv_avail, recv_avail);
2276 if (recv_avail < 0) {
2277 recv_avail = 0;
2278 }
2279 *((u16_t*)argp) = (u16_t)recv_avail;
2280
2281 /* Check if there is data left from the last recv operation. /maq 041215 */
2282 if (sock->lastdata) {
2283 struct pbuf *p = (struct pbuf *)sock->lastdata;
2284 if (netconn_type(sock->conn) != NETCONN_TCP) {
2285 p = ((struct netbuf *)p)->p;
2286 }
2287 buflen = p->tot_len;
2288 buflen -= sock->lastoffset;
2289
2290 *((u16_t*)argp) += buflen;
2291 }
2292
2293 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(%d, FIONREAD, %p) = %"U16_F"\n", s, argp, *((u16_t*)argp)));
2294 sock_set_errno(sock, 0);
2295 return 0;
2296 #endif /* LWIP_SO_RCVBUF */
2297
2298 case FIONBIO:
2299 val = 0;
2300 if (argp && *(u32_t*)argp) {
2301 val = 1;
2302 }
2303 netconn_set_nonblocking(sock->conn, val);
2304 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(%d, FIONBIO, %d)\n", s, val));
2305 sock_set_errno(sock, 0);
2306 return 0;
2307
2308 default:
2309 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(%d, UNIMPL: 0x%lx, %p)\n", s, cmd, argp));
2310 sock_set_errno(sock, ENOSYS); /* not yet implemented */
2311 return -1;
2312 } /* switch (cmd) */
2313 }
2314
2315 /** A minimal implementation of fcntl.
2316 * Currently only the commands F_GETFL and F_SETFL are implemented.
2317 * Only the flag O_NONBLOCK is implemented.
2318 */
2319 int
2320 lwip_fcntl(int s, int cmd, int val)
2321 {
2322 struct lwip_sock *sock = get_socket(s);
2323 int ret = -1;
2324
2325 if (!sock || !sock->conn) {
2326 return -1;
2327 }
2328
2329 switch (cmd) {
2330 case F_GETFL:
2331 ret = netconn_is_nonblocking(sock->conn) ? O_NONBLOCK : 0;
2332 break;
2333 case F_SETFL:
2334 if ((val & ~O_NONBLOCK) == 0) {
2335 /* only O_NONBLOCK, all other bits are zero */
2336 netconn_set_nonblocking(sock->conn, val & O_NONBLOCK);
2337 ret = 0;
2338 }
2339 break;
2340 default:
2341 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_fcntl(%d, UNIMPL: %d, %d)\n", s, cmd, val));
2342 break;
2343 }
2344 return ret;
2345 }
2346
2347 #endif /* LWIP_SOCKET */