mbed unsupported
A version of LWIP, provided for backwards compatibility.
Dependents: AA_DemoBoard DemoBoard HelloServerDemo DemoBoard_RangeIndicator ... more
Embed:
(wiki syntax)
Show/hide line numbers
sockets.c
Go to the documentation of this file.
00001 /** 00002 * @file 00003 * Sockets BSD-Like API module 00004 * 00005 */ 00006 00007 /* 00008 * Copyright (c) 2001-2004 Swedish Institute of Computer Science. 00009 * All rights reserved. 00010 * 00011 * Redistribution and use in source and binary forms, with or without modification, 00012 * are permitted provided that the following conditions are met: 00013 * 00014 * 1. Redistributions of source code must retain the above copyright notice, 00015 * this list of conditions and the following disclaimer. 00016 * 2. Redistributions in binary form must reproduce the above copyright notice, 00017 * this list of conditions and the following disclaimer in the documentation 00018 * and/or other materials provided with the distribution. 00019 * 3. The name of the author may not be used to endorse or promote products 00020 * derived from this software without specific prior written permission. 00021 * 00022 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 00023 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 00024 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 00025 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 00026 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 00027 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 00028 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 00029 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 00030 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 00031 * OF SUCH DAMAGE. 00032 * 00033 * This file is part of the lwIP TCP/IP stack. 00034 * 00035 * Author: Adam Dunkels <adam@sics.se> 00036 * 00037 * Improved by Marc Boucher <marc@mbsi.ca> and David Haas <dhaas@alum.rpi.edu> 00038 * 00039 */ 00040 00041 #include "lwip/opt.h" 00042 00043 #if LWIP_SOCKET /* don't build if not configured for use in lwipopts.h */ 00044 00045 #include "lwip/sockets.h" 00046 #include "lwip/api.h" 00047 #include "lwip/sys.h" 00048 #include "lwip/igmp.h" 00049 #include "lwip/inet.h" 00050 #include "lwip/tcp.h" 00051 #include "lwip/raw.h" 00052 #include "lwip/udp.h" 00053 #include "lwip/tcpip.h" 00054 00055 #include <string.h> 00056 00057 #define NUM_SOCKETS MEMP_NUM_NETCONN 00058 00059 /** Contains all internal pointers and states used for a socket */ 00060 struct lwip_socket { 00061 /** sockets currently are built on netconns, each socket has one netconn */ 00062 struct netconn *conn; 00063 /** data that was left from the previous read */ 00064 struct netbuf *lastdata; 00065 /** offset in the data that was left from the previous read */ 00066 u16_t lastoffset; 00067 /** number of times data was received, set by event_callback(), 00068 tested by the receive and select functions */ 00069 u16_t rcvevent; 00070 /** number of times data was received, set by event_callback(), 00071 tested by select */ 00072 u16_t sendevent; 00073 /** socket flags (currently, only used for O_NONBLOCK) */ 00074 u16_t flags; 00075 /** last error that occurred on this socket */ 00076 int err; 00077 }; 00078 00079 /** Description for a task waiting in select */ 00080 struct lwip_select_cb { 00081 /** Pointer to the next waiting task */ 00082 struct lwip_select_cb *next; 00083 /** readset passed to select */ 00084 fd_set *readset; 00085 /** writeset passed to select */ 00086 fd_set *writeset; 00087 /** unimplemented: exceptset passed to select */ 00088 fd_set *exceptset; 00089 /** don't signal the same semaphore twice: set to 1 when signalled */ 00090 int sem_signalled; 00091 /** semaphore to wake up a task waiting for select */ 00092 sys_sem_t sem; 00093 }; 00094 00095 /** This struct is used to pass data to the set/getsockopt_internal 00096 * functions running in tcpip_thread context (only a void* is allowed) */ 00097 struct lwip_setgetsockopt_data { 00098 /** socket struct for which to change options */ 00099 struct lwip_socket *sock; 00100 /** socket index for which to change options */ 00101 int s; 00102 /** level of the option to process */ 00103 int level; 00104 /** name of the option to process */ 00105 int optname; 00106 /** set: value to set the option to 00107 * get: value of the option is stored here */ 00108 void *optval; 00109 /** size of *optval */ 00110 socklen_t *optlen; 00111 /** if an error occures, it is temporarily stored here */ 00112 err_t err; 00113 }; 00114 00115 /** The global array of available sockets */ 00116 static struct lwip_socket sockets[NUM_SOCKETS]; 00117 /** The global list of tasks waiting for select */ 00118 static struct lwip_select_cb *select_cb_list; 00119 00120 /** Semaphore protecting the sockets array */ 00121 static sys_sem_t socksem; 00122 /** Semaphore protecting select_cb_list */ 00123 static sys_sem_t selectsem; 00124 00125 /** Table to quickly map an lwIP error (err_t) to a socket error 00126 * by using -err as an index */ 00127 static const int err_to_errno_table[] = { 00128 0, /* ERR_OK 0 No error, everything OK. */ 00129 ENOMEM, /* ERR_MEM -1 Out of memory error. */ 00130 ENOBUFS, /* ERR_BUF -2 Buffer error. */ 00131 EHOSTUNREACH, /* ERR_RTE -3 Routing problem. */ 00132 ECONNABORTED, /* ERR_ABRT -4 Connection aborted. */ 00133 ECONNRESET, /* ERR_RST -5 Connection reset. */ 00134 ESHUTDOWN, /* ERR_CLSD -6 Connection closed. */ 00135 ENOTCONN, /* ERR_CONN -7 Not connected. */ 00136 EINVAL, /* ERR_VAL -8 Illegal value. */ 00137 EIO, /* ERR_ARG -9 Illegal argument. */ 00138 EADDRINUSE, /* ERR_USE -10 Address in use. */ 00139 -1, /* ERR_IF -11 Low-level netif error */ 00140 -1, /* ERR_ISCONN -12 Already connected. */ 00141 ETIMEDOUT, /* ERR_TIMEOUT -13 Timeout */ 00142 EINPROGRESS /* ERR_INPROGRESS -14 Operation in progress */ 00143 }; 00144 00145 #define ERR_TO_ERRNO_TABLE_SIZE \ 00146 (sizeof(err_to_errno_table)/sizeof(err_to_errno_table[0])) 00147 00148 #define err_to_errno(err) \ 00149 ((unsigned)(-(err)) < ERR_TO_ERRNO_TABLE_SIZE ? \ 00150 err_to_errno_table[-(err)] : EIO) 00151 00152 #ifdef ERRNO 00153 #define set_errno(err) errno = (err) 00154 #else 00155 #define set_errno(err) 00156 #endif 00157 00158 #define sock_set_errno(sk, e) do { \ 00159 sk->err = (e); \ 00160 set_errno(sk->err); \ 00161 } while (0) 00162 00163 /* Forward delcaration of some functions */ 00164 static void event_callback(struct netconn *conn, enum netconn_evt evt, u16_t len); 00165 static void lwip_getsockopt_internal(void *arg); 00166 static void lwip_setsockopt_internal(void *arg); 00167 00168 /** 00169 * Initialize this module. This function has to be called before any other 00170 * functions in this module! 00171 */ 00172 void 00173 lwip_socket_init(void) 00174 { 00175 socksem = sys_sem_new(1); 00176 selectsem = sys_sem_new(1); 00177 } 00178 00179 /** 00180 * Map a externally used socket index to the internal socket representation. 00181 * 00182 * @param s externally used socket index 00183 * @return struct lwip_socket for the socket or NULL if not found 00184 */ 00185 static struct lwip_socket * 00186 get_socket(int s) 00187 { 00188 struct lwip_socket *sock; 00189 00190 if ((s < 0) || (s >= NUM_SOCKETS)) { 00191 LWIP_DEBUGF(SOCKETS_DEBUG, ("get_socket(%d): invalid\n", s)); 00192 set_errno(EBADF); 00193 return NULL; 00194 } 00195 00196 sock = &sockets[s]; 00197 00198 if (!sock->conn) { 00199 LWIP_DEBUGF(SOCKETS_DEBUG, ("get_socket(%d): not active\n", s)); 00200 set_errno(EBADF); 00201 return NULL; 00202 } 00203 00204 return sock; 00205 } 00206 00207 /** 00208 * Allocate a new socket for a given netconn. 00209 * 00210 * @param newconn the netconn for which to allocate a socket 00211 * @return the index of the new socket; -1 on error 00212 */ 00213 static int 00214 alloc_socket(struct netconn *newconn) 00215 { 00216 int i; 00217 00218 /* Protect socket array */ 00219 sys_sem_wait(socksem); 00220 00221 /* allocate a new socket identifier */ 00222 for (i = 0; i < NUM_SOCKETS; ++i) { 00223 if (!sockets[i].conn) { 00224 sockets[i].conn = newconn; 00225 sockets[i].lastdata = NULL; 00226 sockets[i].lastoffset = 0; 00227 sockets[i].rcvevent = 0; 00228 sockets[i].sendevent = 1; /* TCP send buf is empty */ 00229 sockets[i].flags = 0; 00230 sockets[i].err = 0; 00231 sys_sem_signal(socksem); 00232 return i; 00233 } 00234 } 00235 sys_sem_signal(socksem); 00236 return -1; 00237 } 00238 00239 /* Below this, the well-known socket functions are implemented. 00240 * Use google.com or opengroup.org to get a good description :-) 00241 * 00242 * Exceptions are documented! 00243 */ 00244 00245 int 00246 lwip_accept(int s, struct sockaddr *addr, socklen_t *addrlen) 00247 { 00248 struct lwip_socket *sock, *nsock; 00249 struct netconn *newconn; 00250 struct ip_addr naddr; 00251 u16_t port; 00252 int newsock; 00253 struct sockaddr_in sin; 00254 err_t err; 00255 00256 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d)...\n", s)); 00257 sock = get_socket(s); 00258 if (!sock) 00259 return -1; 00260 00261 newconn = netconn_accept(sock->conn); 00262 if (!newconn) { 00263 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d) failed, err=%d\n", s, sock->conn->err)); 00264 sock_set_errno(sock, err_to_errno(sock->conn->err)); 00265 return -1; 00266 } 00267 00268 /* get the IP address and port of the remote host */ 00269 err = netconn_peer(newconn, &naddr, &port); 00270 if (err != ERR_OK) { 00271 netconn_delete(newconn); 00272 sock_set_errno(sock, err_to_errno(err)); 00273 return -1; 00274 } 00275 00276 memset(&sin, 0, sizeof(sin)); 00277 sin.sin_len = sizeof(sin); 00278 sin.sin_family = AF_INET; 00279 sin.sin_port = htons(port); 00280 sin.sin_addr.s_addr = naddr.addr; 00281 00282 if (*addrlen > sizeof(sin)) 00283 *addrlen = sizeof(sin); 00284 00285 SMEMCPY(addr, &sin, *addrlen); 00286 00287 newsock = alloc_socket(newconn); 00288 if (newsock == -1) { 00289 netconn_delete(newconn); 00290 sock_set_errno(sock, ENFILE); 00291 return -1; 00292 } 00293 LWIP_ASSERT("invalid socket index", (newsock >= 0) && (newsock < NUM_SOCKETS)); 00294 newconn->callback = event_callback; 00295 nsock = &sockets[newsock]; 00296 LWIP_ASSERT("invalid socket pointer", nsock != NULL); 00297 00298 sys_sem_wait(socksem); 00299 /* See event_callback: If data comes in right away after an accept, even 00300 * though the server task might not have created a new socket yet. 00301 * In that case, newconn->socket is counted down (newconn->socket--), 00302 * so nsock->rcvevent is >= 1 here! 00303 */ 00304 nsock->rcvevent += -1 - newconn->socket; 00305 newconn->socket = newsock; 00306 sys_sem_signal(socksem); 00307 00308 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d) returning new sock=%d addr=", s, newsock)); 00309 ip_addr_debug_print(SOCKETS_DEBUG, &naddr); 00310 LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u\n", port)); 00311 00312 sock_set_errno(sock, 0); 00313 return newsock; 00314 } 00315 00316 int 00317 lwip_bind(int s, struct sockaddr *name, socklen_t namelen) 00318 { 00319 struct lwip_socket *sock; 00320 struct ip_addr local_addr; 00321 u16_t local_port; 00322 err_t err; 00323 00324 sock = get_socket(s); 00325 if (!sock) 00326 return -1; 00327 00328 LWIP_ERROR("lwip_bind: invalid address", ((namelen == sizeof(struct sockaddr_in)) && 00329 ((((struct sockaddr_in *)name)->sin_family) == AF_INET)), 00330 sock_set_errno(sock, err_to_errno(ERR_ARG)); return -1;); 00331 00332 local_addr.addr = ((struct sockaddr_in *)name)->sin_addr.s_addr; 00333 local_port = ((struct sockaddr_in *)name)->sin_port; 00334 00335 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_bind(%d, addr=", s)); 00336 ip_addr_debug_print(SOCKETS_DEBUG, &local_addr); 00337 LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u)\n", ntohs(local_port))); 00338 00339 err = netconn_bind(sock->conn, &local_addr, ntohs(local_port)); 00340 00341 if (err != ERR_OK) { 00342 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_bind(%d) failed, err=%d\n", s, err)); 00343 sock_set_errno(sock, err_to_errno(err)); 00344 return -1; 00345 } 00346 00347 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_bind(%d) succeeded\n", s)); 00348 sock_set_errno(sock, 0); 00349 return 0; 00350 } 00351 00352 int 00353 lwip_close(int s) 00354 { 00355 struct lwip_socket *sock; 00356 00357 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_close(%d)\n", s)); 00358 00359 sock = get_socket(s); 00360 if (!sock) { 00361 return -1; 00362 } 00363 00364 netconn_delete(sock->conn); 00365 00366 sys_sem_wait(socksem); 00367 if (sock->lastdata) { 00368 netbuf_delete(sock->lastdata); 00369 } 00370 sock->lastdata = NULL; 00371 sock->lastoffset = 0; 00372 sock->conn = NULL; 00373 sock_set_errno(sock, 0); 00374 sys_sem_signal(socksem); 00375 return 0; 00376 } 00377 00378 int 00379 lwip_connect(int s, const struct sockaddr *name, socklen_t namelen) 00380 { 00381 struct lwip_socket *sock; 00382 err_t err; 00383 00384 sock = get_socket(s); 00385 if (!sock) 00386 return -1; 00387 00388 LWIP_ERROR("lwip_connect: invalid address", ((namelen == sizeof(struct sockaddr_in)) && 00389 ((((struct sockaddr_in *)name)->sin_family) == AF_INET)), 00390 sock_set_errno(sock, err_to_errno(ERR_ARG)); return -1;); 00391 00392 if (((struct sockaddr_in *)name)->sin_family == AF_UNSPEC) { 00393 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d, AF_UNSPEC)\n", s)); 00394 err = netconn_disconnect(sock->conn); 00395 } else { 00396 struct ip_addr remote_addr; 00397 u16_t remote_port; 00398 00399 remote_addr.addr = ((struct sockaddr_in *)name)->sin_addr.s_addr; 00400 remote_port = ((struct sockaddr_in *)name)->sin_port; 00401 00402 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d, addr=", s)); 00403 ip_addr_debug_print(SOCKETS_DEBUG, &remote_addr); 00404 LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u)\n", ntohs(remote_port))); 00405 00406 err = netconn_connect(sock->conn, &remote_addr, ntohs(remote_port)); 00407 } 00408 00409 if (err != ERR_OK) { 00410 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d) failed, err=%d\n", s, err)); 00411 sock_set_errno(sock, err_to_errno(err)); 00412 return -1; 00413 } 00414 00415 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d) succeeded\n", s)); 00416 sock_set_errno(sock, 0); 00417 return 0; 00418 } 00419 00420 /** 00421 * Set a socket into listen mode. 00422 * The socket may not have been used for another connection previously. 00423 * 00424 * @param s the socket to set to listening mode 00425 * @param backlog (ATTENTION: need TCP_LISTEN_BACKLOG=1) 00426 * @return 0 on success, non-zero on failure 00427 */ 00428 int 00429 lwip_listen(int s, int backlog) 00430 { 00431 struct lwip_socket *sock; 00432 err_t err; 00433 00434 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_listen(%d, backlog=%d)\n", s, backlog)); 00435 00436 sock = get_socket(s); 00437 if (!sock) 00438 return -1; 00439 00440 /* limit the "backlog" parameter to fit in an u8_t */ 00441 if (backlog < 0) { 00442 backlog = 0; 00443 } 00444 if (backlog > 0xff) { 00445 backlog = 0xff; 00446 } 00447 00448 err = netconn_listen_with_backlog(sock->conn, backlog); 00449 00450 if (err != ERR_OK) { 00451 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_listen(%d) failed, err=%d\n", s, err)); 00452 sock_set_errno(sock, err_to_errno(err)); 00453 return -1; 00454 } 00455 00456 sock_set_errno(sock, 0); 00457 return 0; 00458 } 00459 00460 int 00461 lwip_recvfrom(int s, void *mem, int len, unsigned int flags, 00462 struct sockaddr *from, socklen_t *fromlen) 00463 { 00464 struct lwip_socket *sock; 00465 struct netbuf *buf; 00466 u16_t buflen, copylen, off = 0; 00467 struct ip_addr *addr; 00468 u16_t port; 00469 u8_t done = 0; 00470 00471 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d, %p, %d, 0x%x, ..)\n", s, mem, len, flags)); 00472 sock = get_socket(s); 00473 if (!sock) 00474 return -1; 00475 00476 do { 00477 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom: top while sock->lastdata=%p\n", (void*)sock->lastdata)); 00478 /* Check if there is data left from the last recv operation. */ 00479 if (sock->lastdata) { 00480 buf = sock->lastdata; 00481 } else { 00482 /* If this is non-blocking call, then check first */ 00483 if (((flags & MSG_DONTWAIT) || (sock->flags & O_NONBLOCK)) && !sock->rcvevent) { 00484 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d): returning EWOULDBLOCK\n", s)); 00485 sock_set_errno(sock, EWOULDBLOCK); 00486 return -1; 00487 } 00488 00489 /* No data was left from the previous operation, so we try to get 00490 some from the network. */ 00491 sock->lastdata = buf = netconn_recv(sock->conn); 00492 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom: netconn_recv netbuf=%p\n", (void*)buf)); 00493 00494 if (!buf) { 00495 /* We should really do some error checking here. */ 00496 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d): buf == NULL!\n", s)); 00497 sock_set_errno(sock, (((sock->conn->pcb.ip!=NULL) && (sock->conn->err==ERR_OK))?ETIMEDOUT:err_to_errno(sock->conn->err))); 00498 return 0; 00499 } 00500 } 00501 00502 buflen = netbuf_len(buf); 00503 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom: buflen=%d len=%d off=%d sock->lastoffset=%d\n", buflen, len, off, sock->lastoffset)); 00504 00505 buflen -= sock->lastoffset; 00506 00507 if (len > buflen) { 00508 copylen = buflen; 00509 } else { 00510 copylen = len; 00511 } 00512 00513 /* copy the contents of the received buffer into 00514 the supplied memory pointer mem */ 00515 netbuf_copy_partial(buf, (u8_t*)mem + off, copylen, sock->lastoffset); 00516 00517 off += copylen; 00518 00519 if (netconn_type(sock->conn) == NETCONN_TCP) { 00520 len -= copylen; 00521 if ( (len <= 0) || (buf->p->flags & PBUF_FLAG_PUSH) || !sock->rcvevent) { 00522 done = 1; 00523 } 00524 } else { 00525 done = 1; 00526 } 00527 00528 /* If we don't peek the incoming message... */ 00529 if ((flags & MSG_PEEK)==0) { 00530 /* If this is a TCP socket, check if there is data left in the 00531 buffer. If so, it should be saved in the sock structure for next 00532 time around. */ 00533 if ((sock->conn->type == NETCONN_TCP) && (buflen - copylen > 0)) { 00534 sock->lastdata = buf; 00535 sock->lastoffset += copylen; 00536 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom: lastdata now netbuf=%p\n", (void*)buf)); 00537 } else { 00538 sock->lastdata = NULL; 00539 sock->lastoffset = 0; 00540 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom: deleting netbuf=%p\n", (void*)buf)); 00541 netbuf_delete(buf); 00542 } 00543 } else { 00544 done = 1; 00545 } 00546 } while (!done); 00547 00548 /* Check to see from where the data was.*/ 00549 if (from && fromlen) { 00550 struct sockaddr_in sin; 00551 00552 if (netconn_type(sock->conn) == NETCONN_TCP) { 00553 addr = (struct ip_addr*)&(sin.sin_addr.s_addr); 00554 netconn_getaddr(sock->conn, addr, &port, 0); 00555 } else { 00556 addr = netbuf_fromaddr(buf); 00557 port = netbuf_fromport(buf); 00558 } 00559 00560 memset(&sin, 0, sizeof(sin)); 00561 sin.sin_len = sizeof(sin); 00562 sin.sin_family = AF_INET; 00563 sin.sin_port = htons(port); 00564 sin.sin_addr.s_addr = addr->addr; 00565 00566 if (*fromlen > sizeof(sin)) 00567 *fromlen = sizeof(sin); 00568 00569 SMEMCPY(from, &sin, *fromlen); 00570 00571 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d): addr=", s)); 00572 ip_addr_debug_print(SOCKETS_DEBUG, addr); 00573 LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u len=%u\n", port, off)); 00574 } else { 00575 #if SOCKETS_DEBUG 00576 struct sockaddr_in sin; 00577 00578 if (netconn_type(sock->conn) == NETCONN_TCP) { 00579 addr = (struct ip_addr*)&(sin.sin_addr.s_addr); 00580 netconn_getaddr(sock->conn, addr, &port, 0); 00581 } else { 00582 addr = netbuf_fromaddr(buf); 00583 port = netbuf_fromport(buf); 00584 } 00585 00586 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d): addr=", s)); 00587 ip_addr_debug_print(SOCKETS_DEBUG, addr); 00588 LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u len=%u\n", port, off)); 00589 #endif /* SOCKETS_DEBUG */ 00590 } 00591 00592 sock_set_errno(sock, 0); 00593 return off; 00594 } 00595 00596 int 00597 lwip_read(int s, void *mem, int len) 00598 { 00599 return lwip_recvfrom(s, mem, len, 0, NULL, NULL); 00600 } 00601 00602 int 00603 lwip_recv(int s, void *mem, int len, unsigned int flags) 00604 { 00605 return lwip_recvfrom(s, mem, len, flags, NULL, NULL); 00606 } 00607 00608 int 00609 lwip_send(int s, const void *data, int size, unsigned int flags) 00610 { 00611 struct lwip_socket *sock; 00612 err_t err; 00613 00614 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_send(%d, data=%p, size=%d, flags=0x%x)\n", 00615 s, data, size, flags)); 00616 00617 sock = get_socket(s); 00618 if (!sock) 00619 return -1; 00620 00621 if (sock->conn->type!=NETCONN_TCP) { 00622 #if (LWIP_UDP || LWIP_RAW) 00623 return lwip_sendto(s, data, size, flags, NULL, 0); 00624 #else 00625 sock_set_errno(sock, err_to_errno(ERR_ARG)); 00626 return -1; 00627 #endif /* (LWIP_UDP || LWIP_RAW) */ 00628 } 00629 00630 err = netconn_write(sock->conn, data, size, NETCONN_COPY | ((flags & MSG_MORE)?NETCONN_MORE:0)); 00631 00632 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_send(%d) err=%d size=%d\n", s, err, size)); 00633 sock_set_errno(sock, err_to_errno(err)); 00634 return (err==ERR_OK?size:-1); 00635 } 00636 00637 int 00638 lwip_sendto(int s, const void *data, int size, unsigned int flags, 00639 struct sockaddr *to, socklen_t tolen) 00640 { 00641 struct lwip_socket *sock; 00642 struct ip_addr remote_addr; 00643 int err; 00644 #if !LWIP_TCPIP_CORE_LOCKING 00645 struct netbuf buf; 00646 u16_t remote_port; 00647 #endif 00648 00649 sock = get_socket(s); 00650 if (!sock) 00651 return -1; 00652 00653 if (sock->conn->type==NETCONN_TCP) { 00654 #if LWIP_TCP 00655 return lwip_send(s, data, size, flags); 00656 #else 00657 sock_set_errno(sock, err_to_errno(ERR_ARG)); 00658 return -1; 00659 #endif /* LWIP_TCP */ 00660 } 00661 00662 LWIP_ASSERT("lwip_sendto: size must fit in u16_t", 00663 ((size >= 0) && (size <= 0xffff))); 00664 LWIP_ERROR("lwip_sendto: invalid address", (((to == NULL) && (tolen == 0)) || 00665 ((tolen == sizeof(struct sockaddr_in)) && 00666 ((((struct sockaddr_in *)to)->sin_family) == AF_INET))), 00667 sock_set_errno(sock, err_to_errno(ERR_ARG)); return -1;); 00668 00669 #if LWIP_TCPIP_CORE_LOCKING 00670 /* Should only be consider like a sample or a simple way to experiment this option (no check of "to" field...) */ 00671 { struct pbuf* p; 00672 00673 p = pbuf_alloc(PBUF_TRANSPORT, 0, PBUF_REF); 00674 if (p == NULL) { 00675 err = ERR_MEM; 00676 } else { 00677 p->payload = (void*)data; 00678 p->len = p->tot_len = size; 00679 00680 remote_addr.addr = ((struct sockaddr_in *)to)->sin_addr.s_addr; 00681 00682 LOCK_TCPIP_CORE(); 00683 if (sock->conn->type==NETCONN_RAW) { 00684 err = sock->conn->err = raw_sendto(sock->conn->pcb.raw, p, &remote_addr); 00685 } else { 00686 err = sock->conn->err = udp_sendto(sock->conn->pcb.udp, p, &remote_addr, ntohs(((struct sockaddr_in *)to)->sin_port)); 00687 } 00688 UNLOCK_TCPIP_CORE(); 00689 00690 pbuf_free(p); 00691 } 00692 } 00693 #else 00694 /* initialize a buffer */ 00695 buf.p = buf.ptr = NULL; 00696 if (to) { 00697 remote_addr.addr = ((struct sockaddr_in *)to)->sin_addr.s_addr; 00698 remote_port = ntohs(((struct sockaddr_in *)to)->sin_port); 00699 buf.addr = &remote_addr; 00700 buf.port = remote_port; 00701 } else { 00702 remote_addr.addr = 0; 00703 remote_port = 0; 00704 buf.addr = NULL; 00705 buf.port = 0; 00706 } 00707 00708 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_sendto(%d, data=%p, size=%d, flags=0x%x to=", 00709 s, data, size, flags)); 00710 ip_addr_debug_print(SOCKETS_DEBUG, &remote_addr); 00711 LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u\n", remote_port)); 00712 00713 /* make the buffer point to the data that should be sent */ 00714 if ((err = netbuf_ref(&buf, data, size)) == ERR_OK) { 00715 /* send the data */ 00716 err = netconn_send(sock->conn, &buf); 00717 } 00718 00719 /* deallocated the buffer */ 00720 if (buf.p != NULL) { 00721 pbuf_free(buf.p); 00722 } 00723 #endif /* LWIP_TCPIP_CORE_LOCKING */ 00724 sock_set_errno(sock, err_to_errno(err)); 00725 return (err==ERR_OK?size:-1); 00726 } 00727 00728 int 00729 lwip_socket(int domain, int type, int protocol) 00730 { 00731 struct netconn *conn; 00732 int i; 00733 00734 LWIP_UNUSED_ARG(domain); 00735 00736 /* create a netconn */ 00737 switch (type) { 00738 case SOCK_RAW: 00739 conn = netconn_new_with_proto_and_callback(NETCONN_RAW, (u8_t)protocol, event_callback); 00740 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%s, SOCK_RAW, %d) = ", 00741 domain == PF_INET ? "PF_INET" : "UNKNOWN", protocol)); 00742 break; 00743 case SOCK_DGRAM: 00744 conn = netconn_new_with_callback( (protocol == IPPROTO_UDPLITE) ? 00745 NETCONN_UDPLITE : NETCONN_UDP, event_callback); 00746 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%s, SOCK_DGRAM, %d) = ", 00747 domain == PF_INET ? "PF_INET" : "UNKNOWN", protocol)); 00748 break; 00749 case SOCK_STREAM: 00750 conn = netconn_new_with_callback(NETCONN_TCP, event_callback); 00751 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%s, SOCK_STREAM, %d) = ", 00752 domain == PF_INET ? "PF_INET" : "UNKNOWN", protocol)); 00753 break; 00754 default: 00755 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%d, %d/UNKNOWN, %d) = -1\n", 00756 domain, type, protocol)); 00757 set_errno(EINVAL); 00758 return -1; 00759 } 00760 00761 if (!conn) { 00762 LWIP_DEBUGF(SOCKETS_DEBUG, ("-1 / ENOBUFS (could not create netconn)\n")); 00763 set_errno(ENOBUFS); 00764 return -1; 00765 } 00766 00767 i = alloc_socket(conn); 00768 00769 if (i == -1) { 00770 netconn_delete(conn); 00771 set_errno(ENFILE); 00772 return -1; 00773 } 00774 conn->socket = i; 00775 LWIP_DEBUGF(SOCKETS_DEBUG, ("%d\n", i)); 00776 set_errno(0); 00777 return i; 00778 } 00779 00780 int 00781 lwip_write(int s, const void *data, int size) 00782 { 00783 return lwip_send(s, data, size, 0); 00784 } 00785 00786 /** 00787 * Go through the readset and writeset lists and see which socket of the sockets 00788 * set in the sets has events. On return, readset, writeset and exceptset have 00789 * the sockets enabled that had events. 00790 * 00791 * exceptset is not used for now!!! 00792 * 00793 * @param maxfdp1 the highest socket index in the sets 00794 * @param readset in: set of sockets to check for read events; 00795 * out: set of sockets that had read events 00796 * @param writeset in: set of sockets to check for write events; 00797 * out: set of sockets that had write events 00798 * @param exceptset not yet implemented 00799 * @return number of sockets that had events (read+write) 00800 */ 00801 static int 00802 lwip_selscan(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset) 00803 { 00804 int i, nready = 0; 00805 fd_set lreadset, lwriteset, lexceptset; 00806 struct lwip_socket *p_sock; 00807 00808 FD_ZERO(&lreadset); 00809 FD_ZERO(&lwriteset); 00810 FD_ZERO(&lexceptset); 00811 00812 /* Go through each socket in each list to count number of sockets which 00813 currently match */ 00814 for(i = 0; i < maxfdp1; i++) { 00815 if (FD_ISSET(i, readset)) { 00816 /* See if netconn of this socket is ready for read */ 00817 p_sock = get_socket(i); 00818 if (p_sock && (p_sock->lastdata || p_sock->rcvevent)) { 00819 FD_SET(i, &lreadset); 00820 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_selscan: fd=%d ready for reading\n", i)); 00821 nready++; 00822 } 00823 } 00824 if (FD_ISSET(i, writeset)) { 00825 /* See if netconn of this socket is ready for write */ 00826 p_sock = get_socket(i); 00827 if (p_sock && p_sock->sendevent) { 00828 FD_SET(i, &lwriteset); 00829 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_selscan: fd=%d ready for writing\n", i)); 00830 nready++; 00831 } 00832 } 00833 } 00834 *readset = lreadset; 00835 *writeset = lwriteset; 00836 FD_ZERO(exceptset); 00837 00838 return nready; 00839 } 00840 00841 00842 /** 00843 * Processing exceptset is not yet implemented. 00844 */ 00845 int 00846 lwip_select(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset, 00847 struct timeval *timeout) 00848 { 00849 int i; 00850 int nready; 00851 fd_set lreadset, lwriteset, lexceptset; 00852 u32_t msectimeout; 00853 struct lwip_select_cb select_cb; 00854 struct lwip_select_cb *p_selcb; 00855 00856 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_select(%d, %p, %p, %p, tvsec=%ld tvusec=%ld)\n", 00857 maxfdp1, (void *)readset, (void *) writeset, (void *) exceptset, 00858 timeout ? timeout->tv_sec : -1L, timeout ? timeout->tv_usec : -1L)); 00859 00860 select_cb.next = 0; 00861 select_cb.readset = readset; 00862 select_cb.writeset = writeset; 00863 select_cb.exceptset = exceptset; 00864 select_cb.sem_signalled = 0; 00865 00866 /* Protect ourselves searching through the list */ 00867 sys_sem_wait(selectsem); 00868 00869 if (readset) 00870 lreadset = *readset; 00871 else 00872 FD_ZERO(&lreadset); 00873 if (writeset) 00874 lwriteset = *writeset; 00875 else 00876 FD_ZERO(&lwriteset); 00877 if (exceptset) 00878 lexceptset = *exceptset; 00879 else 00880 FD_ZERO(&lexceptset); 00881 00882 /* Go through each socket in each list to count number of sockets which 00883 currently match */ 00884 nready = lwip_selscan(maxfdp1, &lreadset, &lwriteset, &lexceptset); 00885 00886 /* If we don't have any current events, then suspend if we are supposed to */ 00887 if (!nready) { 00888 if (timeout && timeout->tv_sec == 0 && timeout->tv_usec == 0) { 00889 sys_sem_signal(selectsem); 00890 if (readset) 00891 FD_ZERO(readset); 00892 if (writeset) 00893 FD_ZERO(writeset); 00894 if (exceptset) 00895 FD_ZERO(exceptset); 00896 00897 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_select: no timeout, returning 0\n")); 00898 set_errno(0); 00899 00900 return 0; 00901 } 00902 00903 /* add our semaphore to list */ 00904 /* We don't actually need any dynamic memory. Our entry on the 00905 * list is only valid while we are in this function, so it's ok 00906 * to use local variables */ 00907 00908 select_cb.sem = sys_sem_new(0); 00909 /* Note that we are still protected */ 00910 /* Put this select_cb on top of list */ 00911 select_cb.next = select_cb_list; 00912 select_cb_list = &select_cb; 00913 00914 /* Now we can safely unprotect */ 00915 sys_sem_signal(selectsem); 00916 00917 /* Now just wait to be woken */ 00918 if (timeout == 0) 00919 /* Wait forever */ 00920 msectimeout = 0; 00921 else { 00922 msectimeout = ((timeout->tv_sec * 1000) + ((timeout->tv_usec + 500)/1000)); 00923 if(msectimeout == 0) 00924 msectimeout = 1; 00925 } 00926 00927 i = sys_sem_wait_timeout(select_cb.sem, msectimeout); 00928 00929 /* Take us off the list */ 00930 sys_sem_wait(selectsem); 00931 if (select_cb_list == &select_cb) 00932 select_cb_list = select_cb.next; 00933 else 00934 for (p_selcb = select_cb_list; p_selcb; p_selcb = p_selcb->next) { 00935 if (p_selcb->next == &select_cb) { 00936 p_selcb->next = select_cb.next; 00937 break; 00938 } 00939 } 00940 00941 sys_sem_signal(selectsem); 00942 00943 sys_sem_free(select_cb.sem); 00944 if (i == 0) { 00945 /* Timeout */ 00946 if (readset) 00947 FD_ZERO(readset); 00948 if (writeset) 00949 FD_ZERO(writeset); 00950 if (exceptset) 00951 FD_ZERO(exceptset); 00952 00953 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_select: timeout expired\n")); 00954 set_errno(0); 00955 00956 return 0; 00957 } 00958 00959 if (readset) 00960 lreadset = *readset; 00961 else 00962 FD_ZERO(&lreadset); 00963 if (writeset) 00964 lwriteset = *writeset; 00965 else 00966 FD_ZERO(&lwriteset); 00967 if (exceptset) 00968 lexceptset = *exceptset; 00969 else 00970 FD_ZERO(&lexceptset); 00971 00972 /* See what's set */ 00973 nready = lwip_selscan(maxfdp1, &lreadset, &lwriteset, &lexceptset); 00974 } else 00975 sys_sem_signal(selectsem); 00976 00977 if (readset) 00978 *readset = lreadset; 00979 if (writeset) 00980 *writeset = lwriteset; 00981 if (exceptset) 00982 *exceptset = lexceptset; 00983 00984 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_select: nready=%d\n", nready)); 00985 set_errno(0); 00986 00987 return nready; 00988 } 00989 00990 /** 00991 * Callback registered in the netconn layer for each socket-netconn. 00992 * Processes recvevent (data available) and wakes up tasks waiting for select. 00993 */ 00994 static void 00995 event_callback(struct netconn *conn, enum netconn_evt evt, u16_t len) 00996 { 00997 int s; 00998 struct lwip_socket *sock; 00999 struct lwip_select_cb *scb; 01000 01001 LWIP_UNUSED_ARG(len); 01002 01003 /* Get socket */ 01004 if (conn) { 01005 s = conn->socket; 01006 if (s < 0) { 01007 /* Data comes in right away after an accept, even though 01008 * the server task might not have created a new socket yet. 01009 * Just count down (or up) if that's the case and we 01010 * will use the data later. Note that only receive events 01011 * can happen before the new socket is set up. */ 01012 sys_sem_wait(socksem); 01013 if (conn->socket < 0) { 01014 if (evt == NETCONN_EVT_RCVPLUS) { 01015 conn->socket--; 01016 } 01017 sys_sem_signal(socksem); 01018 return; 01019 } 01020 sys_sem_signal(socksem); 01021 } 01022 01023 sock = get_socket(s); 01024 if (!sock) { 01025 return; 01026 } 01027 } else { 01028 return; 01029 } 01030 01031 sys_sem_wait(selectsem); 01032 /* Set event as required */ 01033 switch (evt) { 01034 case NETCONN_EVT_RCVPLUS: 01035 sock->rcvevent++; 01036 break; 01037 case NETCONN_EVT_RCVMINUS: 01038 sock->rcvevent--; 01039 break; 01040 case NETCONN_EVT_SENDPLUS: 01041 sock->sendevent = 1; 01042 break; 01043 case NETCONN_EVT_SENDMINUS: 01044 sock->sendevent = 0; 01045 break; 01046 default: 01047 LWIP_ASSERT("unknown event", 0); 01048 break; 01049 } 01050 sys_sem_signal(selectsem); 01051 01052 /* Now decide if anyone is waiting for this socket */ 01053 /* NOTE: This code is written this way to protect the select link list 01054 but to avoid a deadlock situation by releasing socksem before 01055 signalling for the select. This means we need to go through the list 01056 multiple times ONLY IF a select was actually waiting. We go through 01057 the list the number of waiting select calls + 1. This list is 01058 expected to be small. */ 01059 while (1) { 01060 sys_sem_wait(selectsem); 01061 for (scb = select_cb_list; scb; scb = scb->next) { 01062 if (scb->sem_signalled == 0) { 01063 /* Test this select call for our socket */ 01064 if (scb->readset && FD_ISSET(s, scb->readset)) 01065 if (sock->rcvevent) 01066 break; 01067 if (scb->writeset && FD_ISSET(s, scb->writeset)) 01068 if (sock->sendevent) 01069 break; 01070 } 01071 } 01072 if (scb) { 01073 scb->sem_signalled = 1; 01074 sys_sem_signal(selectsem); 01075 sys_sem_signal(scb->sem); 01076 } else { 01077 sys_sem_signal(selectsem); 01078 break; 01079 } 01080 } 01081 } 01082 01083 /** 01084 * Unimplemented: Close one end of a full-duplex connection. 01085 * Currently, the full connection is closed. 01086 */ 01087 int 01088 lwip_shutdown(int s, int how) 01089 { 01090 LWIP_UNUSED_ARG(how); 01091 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_shutdown(%d, how=%d)\n", s, how)); 01092 return lwip_close(s); /* XXX temporary hack until proper implementation */ 01093 } 01094 01095 static int 01096 lwip_getaddrname(int s, struct sockaddr *name, socklen_t *namelen, u8_t local) 01097 { 01098 struct lwip_socket *sock; 01099 struct sockaddr_in sin; 01100 struct ip_addr naddr; 01101 01102 sock = get_socket(s); 01103 if (!sock) 01104 return -1; 01105 01106 memset(&sin, 0, sizeof(sin)); 01107 sin.sin_len = sizeof(sin); 01108 sin.sin_family = AF_INET; 01109 01110 /* get the IP address and port */ 01111 netconn_getaddr(sock->conn, &naddr, &sin.sin_port, local); 01112 01113 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getaddrname(%d, addr=", s)); 01114 ip_addr_debug_print(SOCKETS_DEBUG, &naddr); 01115 LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%d)\n", sin.sin_port)); 01116 01117 sin.sin_port = htons(sin.sin_port); 01118 sin.sin_addr.s_addr = naddr.addr; 01119 01120 if (*namelen > sizeof(sin)) 01121 *namelen = sizeof(sin); 01122 01123 SMEMCPY(name, &sin, *namelen); 01124 sock_set_errno(sock, 0); 01125 return 0; 01126 } 01127 01128 int 01129 lwip_getpeername(int s, struct sockaddr *name, socklen_t *namelen) 01130 { 01131 return lwip_getaddrname(s, name, namelen, 0); 01132 } 01133 01134 int 01135 lwip_getsockname(int s, struct sockaddr *name, socklen_t *namelen) 01136 { 01137 return lwip_getaddrname(s, name, namelen, 1); 01138 } 01139 01140 int 01141 lwip_getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen) 01142 { 01143 err_t err = ERR_OK; 01144 struct lwip_socket *sock = get_socket(s); 01145 struct lwip_setgetsockopt_data data; 01146 01147 if (!sock) 01148 return -1; 01149 01150 if ((NULL == optval) || (NULL == optlen)) { 01151 sock_set_errno(sock, EFAULT); 01152 return -1; 01153 } 01154 01155 /* Do length and type checks for the various options first, to keep it readable. */ 01156 switch (level) { 01157 01158 /* Level: SOL_SOCKET */ 01159 case SOL_SOCKET: 01160 switch (optname) { 01161 01162 case SO_ACCEPTCONN: 01163 case SO_BROADCAST: 01164 /* UNIMPL case SO_DEBUG: */ 01165 /* UNIMPL case SO_DONTROUTE: */ 01166 case SO_ERROR: 01167 case SO_KEEPALIVE: 01168 /* UNIMPL case SO_CONTIMEO: */ 01169 /* UNIMPL case SO_SNDTIMEO: */ 01170 #if LWIP_SO_RCVTIMEO 01171 case SO_RCVTIMEO: 01172 #endif /* LWIP_SO_RCVTIMEO */ 01173 #if LWIP_SO_RCVBUF 01174 case SO_RCVBUF: 01175 #endif /* LWIP_SO_RCVBUF */ 01176 /* UNIMPL case SO_OOBINLINE: */ 01177 /* UNIMPL case SO_SNDBUF: */ 01178 /* UNIMPL case SO_RCVLOWAT: */ 01179 /* UNIMPL case SO_SNDLOWAT: */ 01180 #if SO_REUSE 01181 case SO_REUSEADDR: 01182 case SO_REUSEPORT: 01183 #endif /* SO_REUSE */ 01184 case SO_TYPE: 01185 /* UNIMPL case SO_USELOOPBACK: */ 01186 if (*optlen < sizeof(int)) { 01187 err = EINVAL; 01188 } 01189 break; 01190 01191 case SO_NO_CHECK: 01192 if (*optlen < sizeof(int)) { 01193 err = EINVAL; 01194 } 01195 #if LWIP_UDP 01196 if ((sock->conn->type != NETCONN_UDP) || 01197 ((udp_flags(sock->conn->pcb.udp) & UDP_FLAGS_UDPLITE) != 0)) { 01198 /* this flag is only available for UDP, not for UDP lite */ 01199 err = EAFNOSUPPORT; 01200 } 01201 #endif /* LWIP_UDP */ 01202 break; 01203 01204 default: 01205 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, UNIMPL: optname=0x%x, ..)\n", 01206 s, optname)); 01207 err = ENOPROTOOPT; 01208 } /* switch (optname) */ 01209 break; 01210 01211 /* Level: IPPROTO_IP */ 01212 case IPPROTO_IP: 01213 switch (optname) { 01214 /* UNIMPL case IP_HDRINCL: */ 01215 /* UNIMPL case IP_RCVDSTADDR: */ 01216 /* UNIMPL case IP_RCVIF: */ 01217 case IP_TTL: 01218 case IP_TOS: 01219 if (*optlen < sizeof(int)) { 01220 err = EINVAL; 01221 } 01222 break; 01223 #if LWIP_IGMP 01224 case IP_MULTICAST_TTL: 01225 if (*optlen < sizeof(u8_t)) { 01226 err = EINVAL; 01227 } 01228 break; 01229 case IP_MULTICAST_IF: 01230 if (*optlen < sizeof(struct in_addr)) { 01231 err = EINVAL; 01232 } 01233 break; 01234 #endif /* LWIP_IGMP */ 01235 01236 default: 01237 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, UNIMPL: optname=0x%x, ..)\n", 01238 s, optname)); 01239 err = ENOPROTOOPT; 01240 } /* switch (optname) */ 01241 break; 01242 01243 #if LWIP_TCP 01244 /* Level: IPPROTO_TCP */ 01245 case IPPROTO_TCP: 01246 if (*optlen < sizeof(int)) { 01247 err = EINVAL; 01248 break; 01249 } 01250 01251 /* If this is no TCP socket, ignore any options. */ 01252 if (sock->conn->type != NETCONN_TCP) 01253 return 0; 01254 01255 switch (optname) { 01256 case TCP_NODELAY: 01257 case TCP_KEEPALIVE: 01258 #if LWIP_TCP_KEEPALIVE 01259 case TCP_KEEPIDLE: 01260 case TCP_KEEPINTVL: 01261 case TCP_KEEPCNT: 01262 #endif /* LWIP_TCP_KEEPALIVE */ 01263 break; 01264 01265 default: 01266 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_TCP, UNIMPL: optname=0x%x, ..)\n", 01267 s, optname)); 01268 err = ENOPROTOOPT; 01269 } /* switch (optname) */ 01270 break; 01271 #endif /* LWIP_TCP */ 01272 #if LWIP_UDP && LWIP_UDPLITE 01273 /* Level: IPPROTO_UDPLITE */ 01274 case IPPROTO_UDPLITE: 01275 if (*optlen < sizeof(int)) { 01276 err = EINVAL; 01277 break; 01278 } 01279 01280 /* If this is no UDP lite socket, ignore any options. */ 01281 if (sock->conn->type != NETCONN_UDPLITE) 01282 return 0; 01283 01284 switch (optname) { 01285 case UDPLITE_SEND_CSCOV: 01286 case UDPLITE_RECV_CSCOV: 01287 break; 01288 01289 default: 01290 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_UDPLITE, UNIMPL: optname=0x%x, ..)\n", 01291 s, optname)); 01292 err = ENOPROTOOPT; 01293 } /* switch (optname) */ 01294 break; 01295 #endif /* LWIP_UDP && LWIP_UDPLITE*/ 01296 /* UNDEFINED LEVEL */ 01297 default: 01298 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, level=0x%x, UNIMPL: optname=0x%x, ..)\n", 01299 s, level, optname)); 01300 err = ENOPROTOOPT; 01301 } /* switch */ 01302 01303 01304 if (err != ERR_OK) { 01305 sock_set_errno(sock, err); 01306 return -1; 01307 } 01308 01309 /* Now do the actual option processing */ 01310 data.sock = sock; 01311 data.level = level; 01312 data.optname = optname; 01313 data.optval = optval; 01314 data.optlen = optlen; 01315 data.err = err; 01316 tcpip_callback(lwip_getsockopt_internal, &data); 01317 sys_arch_sem_wait(sock->conn->op_completed, 0); 01318 /* maybe lwip_getsockopt_internal has changed err */ 01319 err = data.err; 01320 01321 sock_set_errno(sock, err); 01322 return err ? -1 : 0; 01323 } 01324 01325 static void 01326 lwip_getsockopt_internal(void *arg) 01327 { 01328 struct lwip_socket *sock; 01329 #ifdef LWIP_DEBUG 01330 int s; 01331 #endif /* LWIP_DEBUG */ 01332 int level, optname; 01333 void *optval; 01334 struct lwip_setgetsockopt_data *data; 01335 01336 LWIP_ASSERT("arg != NULL", arg != NULL); 01337 01338 data = (struct lwip_setgetsockopt_data*)arg; 01339 sock = data->sock; 01340 #ifdef LWIP_DEBUG 01341 s = data->s; 01342 #endif /* LWIP_DEBUG */ 01343 level = data->level; 01344 optname = data->optname; 01345 optval = data->optval; 01346 01347 switch (level) { 01348 01349 /* Level: SOL_SOCKET */ 01350 case SOL_SOCKET: 01351 switch (optname) { 01352 01353 /* The option flags */ 01354 case SO_ACCEPTCONN: 01355 case SO_BROADCAST: 01356 /* UNIMPL case SO_DEBUG: */ 01357 /* UNIMPL case SO_DONTROUTE: */ 01358 case SO_KEEPALIVE: 01359 /* UNIMPL case SO_OOBINCLUDE: */ 01360 #if SO_REUSE 01361 case SO_REUSEADDR: 01362 case SO_REUSEPORT: 01363 #endif /* SO_REUSE */ 01364 /*case SO_USELOOPBACK: UNIMPL */ 01365 *(int*)optval = sock->conn->pcb.ip->so_options & optname; 01366 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, optname=0x%x, ..) = %s\n", 01367 s, optname, (*(int*)optval?"on":"off"))); 01368 break; 01369 01370 case SO_TYPE: 01371 switch (NETCONNTYPE_GROUP(sock->conn->type)) { 01372 case NETCONN_RAW: 01373 *(int*)optval = SOCK_RAW; 01374 break; 01375 case NETCONN_TCP: 01376 *(int*)optval = SOCK_STREAM; 01377 break; 01378 case NETCONN_UDP: 01379 *(int*)optval = SOCK_DGRAM; 01380 break; 01381 default: /* unrecognized socket type */ 01382 *(int*)optval = sock->conn->type; 01383 LWIP_DEBUGF(SOCKETS_DEBUG, 01384 ("lwip_getsockopt(%d, SOL_SOCKET, SO_TYPE): unrecognized socket type %d\n", 01385 s, *(int *)optval)); 01386 } /* switch (sock->conn->type) */ 01387 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, SO_TYPE) = %d\n", 01388 s, *(int *)optval)); 01389 break; 01390 01391 case SO_ERROR: 01392 if (sock->err == 0) { 01393 sock_set_errno(sock, err_to_errno(sock->conn->err)); 01394 } 01395 *(int *)optval = sock->err; 01396 sock->err = 0; 01397 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, SO_ERROR) = %d\n", 01398 s, *(int *)optval)); 01399 break; 01400 01401 #if LWIP_SO_RCVTIMEO 01402 case SO_RCVTIMEO: 01403 *(int *)optval = sock->conn->recv_timeout; 01404 break; 01405 #endif /* LWIP_SO_RCVTIMEO */ 01406 #if LWIP_SO_RCVBUF 01407 case SO_RCVBUF: 01408 *(int *)optval = sock->conn->recv_bufsize; 01409 break; 01410 #endif /* LWIP_SO_RCVBUF */ 01411 #if LWIP_UDP 01412 case SO_NO_CHECK: 01413 *(int*)optval = (udp_flags(sock->conn->pcb.udp) & UDP_FLAGS_NOCHKSUM) ? 1 : 0; 01414 break; 01415 #endif /* LWIP_UDP*/ 01416 } /* switch (optname) */ 01417 break; 01418 01419 /* Level: IPPROTO_IP */ 01420 case IPPROTO_IP: 01421 switch (optname) { 01422 case IP_TTL: 01423 *(int*)optval = sock->conn->pcb.ip->ttl; 01424 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_TTL) = %d\n", 01425 s, *(int *)optval)); 01426 break; 01427 case IP_TOS: 01428 *(int*)optval = sock->conn->pcb.ip->tos; 01429 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_TOS) = %d\n", 01430 s, *(int *)optval)); 01431 break; 01432 #if LWIP_IGMP 01433 case IP_MULTICAST_TTL: 01434 *(u8_t*)optval = sock->conn->pcb.ip->ttl; 01435 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_MULTICAST_TTL) = %d\n", 01436 s, *(int *)optval)); 01437 break; 01438 case IP_MULTICAST_IF: 01439 ((struct in_addr*) optval)->s_addr = sock->conn->pcb.udp->multicast_ip.addr; 01440 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_MULTICAST_IF) = 0x%x\n", 01441 s, *(u32_t *)optval)); 01442 break; 01443 #endif /* LWIP_IGMP */ 01444 } /* switch (optname) */ 01445 break; 01446 01447 #if LWIP_TCP 01448 /* Level: IPPROTO_TCP */ 01449 case IPPROTO_TCP: 01450 switch (optname) { 01451 case TCP_NODELAY: 01452 *(int*)optval = (sock->conn->pcb.tcp->flags & TF_NODELAY); 01453 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_TCP, TCP_NODELAY) = %s\n", 01454 s, (*(int*)optval)?"on":"off") ); 01455 break; 01456 case TCP_KEEPALIVE: 01457 *(int*)optval = (int)sock->conn->pcb.tcp->keep_idle; 01458 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, TCP_KEEPALIVE) = %d\n", 01459 s, *(int *)optval)); 01460 break; 01461 01462 #if LWIP_TCP_KEEPALIVE 01463 case TCP_KEEPIDLE: 01464 *(int*)optval = (int)(sock->conn->pcb.tcp->keep_idle/1000); 01465 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, TCP_KEEPIDLE) = %d\n", 01466 s, *(int *)optval)); 01467 break; 01468 case TCP_KEEPINTVL: 01469 *(int*)optval = (int)(sock->conn->pcb.tcp->keep_intvl/1000); 01470 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, TCP_KEEPINTVL) = %d\n", 01471 s, *(int *)optval)); 01472 break; 01473 case TCP_KEEPCNT: 01474 *(int*)optval = (int)sock->conn->pcb.tcp->keep_cnt; 01475 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, TCP_KEEPCNT) = %d\n", 01476 s, *(int *)optval)); 01477 break; 01478 #endif /* LWIP_TCP_KEEPALIVE */ 01479 01480 } /* switch (optname) */ 01481 break; 01482 #endif /* LWIP_TCP */ 01483 #if LWIP_UDP && LWIP_UDPLITE 01484 /* Level: IPPROTO_UDPLITE */ 01485 case IPPROTO_UDPLITE: 01486 switch (optname) { 01487 case UDPLITE_SEND_CSCOV: 01488 *(int*)optval = sock->conn->pcb.udp->chksum_len_tx; 01489 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_UDPLITE, UDPLITE_SEND_CSCOV) = %d\n", 01490 s, (*(int*)optval)) ); 01491 break; 01492 case UDPLITE_RECV_CSCOV: 01493 *(int*)optval = sock->conn->pcb.udp->chksum_len_rx; 01494 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_UDPLITE, UDPLITE_RECV_CSCOV) = %d\n", 01495 s, (*(int*)optval)) ); 01496 break; 01497 } /* switch (optname) */ 01498 break; 01499 #endif /* LWIP_UDP */ 01500 } /* switch (level) */ 01501 sys_sem_signal(sock->conn->op_completed); 01502 } 01503 01504 int 01505 lwip_setsockopt(int s, int level, int optname, const void *optval, socklen_t optlen) 01506 { 01507 struct lwip_socket *sock = get_socket(s); 01508 int err = ERR_OK; 01509 struct lwip_setgetsockopt_data data; 01510 01511 if (!sock) 01512 return -1; 01513 01514 if (NULL == optval) { 01515 sock_set_errno(sock, EFAULT); 01516 return -1; 01517 } 01518 01519 /* Do length and type checks for the various options first, to keep it readable. */ 01520 switch (level) { 01521 01522 /* Level: SOL_SOCKET */ 01523 case SOL_SOCKET: 01524 switch (optname) { 01525 01526 case SO_BROADCAST: 01527 /* UNIMPL case SO_DEBUG: */ 01528 /* UNIMPL case SO_DONTROUTE: */ 01529 case SO_KEEPALIVE: 01530 /* UNIMPL case case SO_CONTIMEO: */ 01531 /* UNIMPL case case SO_SNDTIMEO: */ 01532 #if LWIP_SO_RCVTIMEO 01533 case SO_RCVTIMEO: 01534 #endif /* LWIP_SO_RCVTIMEO */ 01535 #if LWIP_SO_RCVBUF 01536 case SO_RCVBUF: 01537 #endif /* LWIP_SO_RCVBUF */ 01538 /* UNIMPL case SO_OOBINLINE: */ 01539 /* UNIMPL case SO_SNDBUF: */ 01540 /* UNIMPL case SO_RCVLOWAT: */ 01541 /* UNIMPL case SO_SNDLOWAT: */ 01542 #if SO_REUSE 01543 case SO_REUSEADDR: 01544 case SO_REUSEPORT: 01545 #endif /* SO_REUSE */ 01546 /* UNIMPL case SO_USELOOPBACK: */ 01547 if (optlen < sizeof(int)) { 01548 err = EINVAL; 01549 } 01550 break; 01551 case SO_NO_CHECK: 01552 if (optlen < sizeof(int)) { 01553 err = EINVAL; 01554 } 01555 #if LWIP_UDP 01556 if ((sock->conn->type != NETCONN_UDP) || 01557 ((udp_flags(sock->conn->pcb.udp) & UDP_FLAGS_UDPLITE) != 0)) { 01558 /* this flag is only available for UDP, not for UDP lite */ 01559 err = EAFNOSUPPORT; 01560 } 01561 #endif /* LWIP_UDP */ 01562 break; 01563 default: 01564 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, SOL_SOCKET, UNIMPL: optname=0x%x, ..)\n", 01565 s, optname)); 01566 err = ENOPROTOOPT; 01567 } /* switch (optname) */ 01568 break; 01569 01570 /* Level: IPPROTO_IP */ 01571 case IPPROTO_IP: 01572 switch (optname) { 01573 /* UNIMPL case IP_HDRINCL: */ 01574 /* UNIMPL case IP_RCVDSTADDR: */ 01575 /* UNIMPL case IP_RCVIF: */ 01576 case IP_TTL: 01577 case IP_TOS: 01578 if (optlen < sizeof(int)) { 01579 err = EINVAL; 01580 } 01581 break; 01582 #if LWIP_IGMP 01583 case IP_MULTICAST_TTL: 01584 if (optlen < sizeof(u8_t)) { 01585 err = EINVAL; 01586 } 01587 if (NETCONNTYPE_GROUP(sock->conn->type) != NETCONN_UDP) { 01588 err = EAFNOSUPPORT; 01589 } 01590 break; 01591 case IP_MULTICAST_IF: 01592 if (optlen < sizeof(struct in_addr)) { 01593 err = EINVAL; 01594 } 01595 if (NETCONNTYPE_GROUP(sock->conn->type) != NETCONN_UDP) { 01596 err = EAFNOSUPPORT; 01597 } 01598 break; 01599 case IP_ADD_MEMBERSHIP: 01600 case IP_DROP_MEMBERSHIP: 01601 if (optlen < sizeof(struct ip_mreq)) { 01602 err = EINVAL; 01603 } 01604 if (NETCONNTYPE_GROUP(sock->conn->type) != NETCONN_UDP) { 01605 err = EAFNOSUPPORT; 01606 } 01607 break; 01608 #endif /* LWIP_IGMP */ 01609 default: 01610 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_IP, UNIMPL: optname=0x%x, ..)\n", 01611 s, optname)); 01612 err = ENOPROTOOPT; 01613 } /* switch (optname) */ 01614 break; 01615 01616 #if LWIP_TCP 01617 /* Level: IPPROTO_TCP */ 01618 case IPPROTO_TCP: 01619 if (optlen < sizeof(int)) { 01620 err = EINVAL; 01621 break; 01622 } 01623 01624 /* If this is no TCP socket, ignore any options. */ 01625 if (sock->conn->type != NETCONN_TCP) 01626 return 0; 01627 01628 switch (optname) { 01629 case TCP_NODELAY: 01630 case TCP_KEEPALIVE: 01631 #if LWIP_TCP_KEEPALIVE 01632 case TCP_KEEPIDLE: 01633 case TCP_KEEPINTVL: 01634 case TCP_KEEPCNT: 01635 #endif /* LWIP_TCP_KEEPALIVE */ 01636 break; 01637 01638 default: 01639 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, UNIMPL: optname=0x%x, ..)\n", 01640 s, optname)); 01641 err = ENOPROTOOPT; 01642 } /* switch (optname) */ 01643 break; 01644 #endif /* LWIP_TCP */ 01645 #if LWIP_UDP && LWIP_UDPLITE 01646 /* Level: IPPROTO_UDPLITE */ 01647 case IPPROTO_UDPLITE: 01648 if (optlen < sizeof(int)) { 01649 err = EINVAL; 01650 break; 01651 } 01652 01653 /* If this is no UDP lite socket, ignore any options. */ 01654 if (sock->conn->type != NETCONN_UDPLITE) 01655 return 0; 01656 01657 switch (optname) { 01658 case UDPLITE_SEND_CSCOV: 01659 case UDPLITE_RECV_CSCOV: 01660 break; 01661 01662 default: 01663 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_UDPLITE, UNIMPL: optname=0x%x, ..)\n", 01664 s, optname)); 01665 err = ENOPROTOOPT; 01666 } /* switch (optname) */ 01667 break; 01668 #endif /* LWIP_UDP && LWIP_UDPLITE */ 01669 /* UNDEFINED LEVEL */ 01670 default: 01671 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, level=0x%x, UNIMPL: optname=0x%x, ..)\n", 01672 s, level, optname)); 01673 err = ENOPROTOOPT; 01674 } /* switch (level) */ 01675 01676 01677 if (err != ERR_OK) { 01678 sock_set_errno(sock, err); 01679 return -1; 01680 } 01681 01682 01683 /* Now do the actual option processing */ 01684 data.sock = sock; 01685 data.level = level; 01686 data.optname = optname; 01687 data.optval = (void*)optval; 01688 data.optlen = &optlen; 01689 data.err = err; 01690 tcpip_callback(lwip_setsockopt_internal, &data); 01691 sys_arch_sem_wait(sock->conn->op_completed, 0); 01692 /* maybe lwip_setsockopt_internal has changed err */ 01693 err = data.err; 01694 01695 sock_set_errno(sock, err); 01696 return err ? -1 : 0; 01697 } 01698 01699 static void 01700 lwip_setsockopt_internal(void *arg) 01701 { 01702 struct lwip_socket *sock; 01703 #ifdef LWIP_DEBUG 01704 int s; 01705 #endif /* LWIP_DEBUG */ 01706 int level, optname; 01707 const void *optval; 01708 struct lwip_setgetsockopt_data *data; 01709 01710 LWIP_ASSERT("arg != NULL", arg != NULL); 01711 01712 data = (struct lwip_setgetsockopt_data*)arg; 01713 sock = data->sock; 01714 #ifdef LWIP_DEBUG 01715 s = data->s; 01716 #endif /* LWIP_DEBUG */ 01717 level = data->level; 01718 optname = data->optname; 01719 optval = data->optval; 01720 01721 switch (level) { 01722 01723 /* Level: SOL_SOCKET */ 01724 case SOL_SOCKET: 01725 switch (optname) { 01726 01727 /* The option flags */ 01728 case SO_BROADCAST: 01729 /* UNIMPL case SO_DEBUG: */ 01730 /* UNIMPL case SO_DONTROUTE: */ 01731 case SO_KEEPALIVE: 01732 /* UNIMPL case SO_OOBINCLUDE: */ 01733 #if SO_REUSE 01734 case SO_REUSEADDR: 01735 case SO_REUSEPORT: 01736 #endif /* SO_REUSE */ 01737 /* UNIMPL case SO_USELOOPBACK: */ 01738 if (*(int*)optval) { 01739 sock->conn->pcb.ip->so_options |= optname; 01740 } else { 01741 sock->conn->pcb.ip->so_options &= ~optname; 01742 } 01743 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, SOL_SOCKET, optname=0x%x, ..) -> %s\n", 01744 s, optname, (*(int*)optval?"on":"off"))); 01745 break; 01746 #if LWIP_SO_RCVTIMEO 01747 case SO_RCVTIMEO: 01748 sock->conn->recv_timeout = ( *(int*)optval ); 01749 break; 01750 #endif /* LWIP_SO_RCVTIMEO */ 01751 #if LWIP_SO_RCVBUF 01752 case SO_RCVBUF: 01753 sock->conn->recv_bufsize = ( *(int*)optval ); 01754 break; 01755 #endif /* LWIP_SO_RCVBUF */ 01756 #if LWIP_UDP 01757 case SO_NO_CHECK: 01758 if (*(int*)optval) { 01759 udp_setflags(sock->conn->pcb.udp, udp_flags(sock->conn->pcb.udp) | UDP_FLAGS_NOCHKSUM); 01760 } else { 01761 udp_setflags(sock->conn->pcb.udp, udp_flags(sock->conn->pcb.udp) & ~UDP_FLAGS_NOCHKSUM); 01762 } 01763 break; 01764 #endif /* LWIP_UDP */ 01765 } /* switch (optname) */ 01766 break; 01767 01768 /* Level: IPPROTO_IP */ 01769 case IPPROTO_IP: 01770 switch (optname) { 01771 case IP_TTL: 01772 sock->conn->pcb.ip->ttl = (u8_t)(*(int*)optval); 01773 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_IP, IP_TTL, ..) -> %u\n", 01774 s, sock->conn->pcb.ip->ttl)); 01775 break; 01776 case IP_TOS: 01777 sock->conn->pcb.ip->tos = (u8_t)(*(int*)optval); 01778 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_IP, IP_TOS, ..)-> %u\n", 01779 s, sock->conn->pcb.ip->tos)); 01780 break; 01781 #if LWIP_IGMP 01782 case IP_MULTICAST_TTL: 01783 sock->conn->pcb.udp->ttl = (u8_t)(*(u8_t*)optval); 01784 break; 01785 case IP_MULTICAST_IF: 01786 sock->conn->pcb.udp->multicast_ip.addr = ((struct in_addr*) optval)->s_addr; 01787 break; 01788 case IP_ADD_MEMBERSHIP: 01789 case IP_DROP_MEMBERSHIP: 01790 { 01791 /* If this is a TCP or a RAW socket, ignore these options. */ 01792 struct ip_mreq *imr = (struct ip_mreq *)optval; 01793 if(optname == IP_ADD_MEMBERSHIP){ 01794 data->err = igmp_joingroup((struct ip_addr*)&(imr->imr_interface.s_addr), (struct ip_addr*)&(imr->imr_multiaddr.s_addr)); 01795 } else { 01796 data->err = igmp_leavegroup((struct ip_addr*)&(imr->imr_interface.s_addr), (struct ip_addr*)&(imr->imr_multiaddr.s_addr)); 01797 } 01798 if(data->err != ERR_OK) { 01799 data->err = EADDRNOTAVAIL; 01800 } 01801 } 01802 break; 01803 #endif /* LWIP_IGMP */ 01804 } /* switch (optname) */ 01805 break; 01806 01807 #if LWIP_TCP 01808 /* Level: IPPROTO_TCP */ 01809 case IPPROTO_TCP: 01810 switch (optname) { 01811 case TCP_NODELAY: 01812 if (*(int*)optval) { 01813 sock->conn->pcb.tcp->flags |= TF_NODELAY; 01814 } else { 01815 sock->conn->pcb.tcp->flags &= ~TF_NODELAY; 01816 } 01817 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_NODELAY) -> %s\n", 01818 s, (*(int *)optval)?"on":"off") ); 01819 break; 01820 case TCP_KEEPALIVE: 01821 sock->conn->pcb.tcp->keep_idle = (u32_t)(*(int*)optval); 01822 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_KEEPALIVE) -> %lu\n", 01823 s, sock->conn->pcb.tcp->keep_idle)); 01824 break; 01825 01826 #if LWIP_TCP_KEEPALIVE 01827 case TCP_KEEPIDLE: 01828 sock->conn->pcb.tcp->keep_idle = 1000*(u32_t)(*(int*)optval); 01829 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_KEEPIDLE) -> %lu\n", 01830 s, sock->conn->pcb.tcp->keep_idle)); 01831 break; 01832 case TCP_KEEPINTVL: 01833 sock->conn->pcb.tcp->keep_intvl = 1000*(u32_t)(*(int*)optval); 01834 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_KEEPINTVL) -> %lu\n", 01835 s, sock->conn->pcb.tcp->keep_intvl)); 01836 break; 01837 case TCP_KEEPCNT: 01838 sock->conn->pcb.tcp->keep_cnt = (u32_t)(*(int*)optval); 01839 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_KEEPCNT) -> %lu\n", 01840 s, sock->conn->pcb.tcp->keep_cnt)); 01841 break; 01842 #endif /* LWIP_TCP_KEEPALIVE */ 01843 01844 } /* switch (optname) */ 01845 break; 01846 #endif /* LWIP_TCP*/ 01847 #if LWIP_UDP && LWIP_UDPLITE 01848 /* Level: IPPROTO_UDPLITE */ 01849 case IPPROTO_UDPLITE: 01850 switch (optname) { 01851 case UDPLITE_SEND_CSCOV: 01852 if ((*(int*)optval != 0) && (*(int*)optval < 8)) { 01853 /* don't allow illegal values! */ 01854 sock->conn->pcb.udp->chksum_len_tx = 8; 01855 } else { 01856 sock->conn->pcb.udp->chksum_len_tx = *(int*)optval; 01857 } 01858 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_UDPLITE, UDPLITE_SEND_CSCOV) -> %d\n", 01859 s, (*(int*)optval)) ); 01860 break; 01861 case UDPLITE_RECV_CSCOV: 01862 if ((*(int*)optval != 0) && (*(int*)optval < 8)) { 01863 /* don't allow illegal values! */ 01864 sock->conn->pcb.udp->chksum_len_rx = 8; 01865 } else { 01866 sock->conn->pcb.udp->chksum_len_rx = *(int*)optval; 01867 } 01868 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_UDPLITE, UDPLITE_RECV_CSCOV) -> %d\n", 01869 s, (*(int*)optval)) ); 01870 break; 01871 } /* switch (optname) */ 01872 break; 01873 #endif /* LWIP_UDP */ 01874 } /* switch (level) */ 01875 sys_sem_signal(sock->conn->op_completed); 01876 } 01877 01878 int 01879 lwip_ioctl(int s, long cmd, void *argp) 01880 { 01881 struct lwip_socket *sock = get_socket(s); 01882 u16_t buflen = 0; 01883 01884 if (!sock) 01885 return -1; 01886 01887 switch (cmd) { 01888 case FIONREAD: 01889 if (!argp) { 01890 sock_set_errno(sock, EINVAL); 01891 return -1; 01892 } 01893 01894 SYS_ARCH_GET(sock->conn->recv_avail, *((u16_t*)argp)); 01895 01896 /* Check if there is data left from the last recv operation. /maq 041215 */ 01897 if (sock->lastdata) { 01898 buflen = netbuf_len(sock->lastdata); 01899 buflen -= sock->lastoffset; 01900 01901 *((u16_t*)argp) += buflen; 01902 } 01903 01904 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(%d, FIONREAD, %p) = %u\n", s, argp, *((u16_t*)argp))); 01905 sock_set_errno(sock, 0); 01906 return 0; 01907 01908 case FIONBIO: 01909 if (argp && *(u32_t*)argp) 01910 sock->flags |= O_NONBLOCK; 01911 else 01912 sock->flags &= ~O_NONBLOCK; 01913 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(%d, FIONBIO, %d)\n", s, !!(sock->flags & O_NONBLOCK))); 01914 sock_set_errno(sock, 0); 01915 return 0; 01916 01917 default: 01918 LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(%d, UNIMPL: 0x%lx, %p)\n", s, cmd, argp)); 01919 sock_set_errno(sock, ENOSYS); /* not yet implemented */ 01920 return -1; 01921 } /* switch (cmd) */ 01922 } 01923 01924 #endif /* LWIP_SOCKET */
Generated on Tue Jul 12 2022 16:06:24 by
1.7.2