Documentation

Documentation

Includes

lwip/opt.h

#include "lwip/opt.h"
#include "lwip/opt.h"

lwip/ip_addr.h

#include "lwip/ip_addr.h"
#include "lwip/ip_addr.h"

lwip/netif.h

#include "lwip/netif.h"
#include "lwip/netif.h"

lwip/err.h

#include "lwip/err.h"
#include "lwip/err.h"

lwip/inet.h

#include "lwip/inet.h"
#include "lwip/inet.h"

lwip/errno.h

#include "lwip/errno.h"
#include "lwip/errno.h"

string.h

#include <string.h>
#include 

Macros

Marco LWIP_HDR_SOCKETS_H

#define LWIP_HDR_SOCKETS_H


      

Marco IOV_MAX

#define IOV_MAX 65535


      

Marco MSG_TRUNC

#define MSG_TRUNC  4
/* struct msghdr->msg_flags bit field values */

Marco MSG_CTRUNC

#define MSG_CTRUNC 8


      

Marco ALIGN_H(size)

#define ALIGN_H(size) (((size) + sizeof(long) - 1U) & ~(sizeof(long)-1U))
/* cmsg header/data alignment. NOTE: we align to native word size (double word
size on 16-bit arch) so structures are not placed at an unaligned address.
16-bit arch needs double word to ensure 32-bit alignment because socklen_t
could be 32 bits. If we ever have cmsg data with a 64-bit variable, alignment
will need to increase long long */

Marco ALIGN_D(size)

#define ALIGN_D(size) ALIGN_H(size)


      

Marco CMSG_FIRSTHDR(mhdr)

#define CMSG_FIRSTHDR(mhdr) \
         ((mhdr)->msg_controllen >= sizeof(struct cmsghdr) ? \
          (struct cmsghdr *)(mhdr)->msg_control : \
          (struct cmsghdr *)NULL)


      

Marco CMSG_NXTHDR(mhdr, cmsg)

#define CMSG_NXTHDR(mhdr, cmsg) \
       (((cmsg) == NULL) ? CMSG_FIRSTHDR(mhdr) : \
        (((u8_t *)(cmsg) + ALIGN_H((cmsg)->cmsg_len) \
                           + ALIGN_D(sizeof(struct cmsghdr)) > \
          (u8_t *)((mhdr)->msg_control) + (mhdr)->msg_controllen) ? \
         (struct cmsghdr *)NULL : \
         (struct cmsghdr *)((void*)((u8_t *)(cmsg) + \
                                     ALIGN_H((cmsg)->cmsg_len)))))


      

Marco CMSG_DATA(cmsg)

#define CMSG_DATA(cmsg) ((void*)((u8_t *)(cmsg) + \
                        ALIGN_D(sizeof(struct cmsghdr))))


      

Marco CMSG_SPACE(length)

#define CMSG_SPACE(length) (ALIGN_D(sizeof(struct cmsghdr)) + \
                           ALIGN_H(length))


      

Marco CMSG_LEN(length)

#define CMSG_LEN(length) (ALIGN_D(sizeof(struct cmsghdr)) + \
                          length)


      

Marco IFNAMSIZ

#define IFNAMSIZ NETIF_NAMESIZE
/* Set socket options argument */

Marco SOCK_STREAM

#define SOCK_STREAM    1
/* Socket protocol types (TCP/UDP/RAW) */

Marco SOCK_DGRAM

#define SOCK_DGRAM     2


      

Marco SOCK_RAW

#define SOCK_RAW       3


      

Marco SO_REUSEADDR

#define SO_REUSEADDR  4 /* Allow local address reuse */
/*
 * Option flags per-socket. These must match the SOF_ flags in ip.h (checked in init.c)
 */

Marco SO_KEEPALIVE

#define SO_KEEPALIVE  8 /* keep connections alive */


      

Marco SO_BROADCAST

#define SO_BROADCAST  32 /* permit to send and to receive broadcast messages (see IP_SOF_BROADCAST option) */


      

Marco SO_DEBUG

#define SO_DEBUG       1 /* Unimplemented: turn on debugging info recording */
/*
 * Additional options, not kept in so_options.
 */

Marco SO_ACCEPTCONN

#define SO_ACCEPTCONN  2 /* socket has had listen() */


      

Marco SO_DONTROUTE

#define SO_DONTROUTE   16 /* Unimplemented: just use interface addresses */


      

Marco SO_USELOOPBACK

#define SO_USELOOPBACK 64 /* Unimplemented: bypass hardware when possible */


      

Marco SO_LINGER

#define SO_LINGER      128 /* linger on close if data present */


      

Marco SO_DONTLINGER

#define SO_DONTLINGER  ((int)(~SO_LINGER))


      

Marco SO_OOBINLINE

#define SO_OOBINLINE   256 /* Unimplemented: leave received OOB data in line */


      

Marco SO_REUSEPORT

#define SO_REUSEPORT   512 /* Unimplemented: allow local address & port reuse */


      

Marco SO_SNDBUF

#define SO_SNDBUF      4097 /* Unimplemented: send buffer size */


      

Marco SO_RCVBUF

#define SO_RCVBUF      4098 /* receive buffer size */


      

Marco SO_SNDLOWAT

#define SO_SNDLOWAT    4099 /* Unimplemented: send low-water mark */


      

Marco SO_RCVLOWAT

#define SO_RCVLOWAT    4100 /* Unimplemented: receive low-water mark */


      

Marco SO_SNDTIMEO

#define SO_SNDTIMEO    4101 /* send timeout */


      

Marco SO_RCVTIMEO

#define SO_RCVTIMEO    4102 /* receive timeout */


      

Marco SO_ERROR

#define SO_ERROR       4103 /* get error status and clear */


      

Marco SO_TYPE

#define SO_TYPE        4104 /* get socket type */


      

Marco SO_CONTIMEO

#define SO_CONTIMEO    4105 /* Unimplemented: connect timeout */


      

Marco SO_NO_CHECK

#define SO_NO_CHECK    256a /* don't create UDP checksum */


      

Marco SO_BINDTODEVICE

#define SO_BINDTODEVICE 256b /* bind to device */


      

Marco SOL_SOCKET

#define SOL_SOCKET 4095   /* options for socket level */
/*
 * Level number for (get/set)sockopt() to apply to socket itself.
 */

Marco AF_UNSPEC

#define AF_UNSPEC      0


      

Marco AF_INET

#define AF_INET        2


      

Marco AF_INET6

#define AF_INET6       10


      

Marco AF_INET6

#define AF_INET6       AF_UNSPEC


      

Marco PF_INET

#define PF_INET        AF_INET


      

Marco PF_INET6

#define PF_INET6       AF_INET6


      

Marco PF_UNSPEC

#define PF_UNSPEC      AF_UNSPEC


      

Marco IPPROTO_IP

#define IPPROTO_IP     0


      

Marco IPPROTO_ICMP

#define IPPROTO_ICMP   1


      

Marco IPPROTO_TCP

#define IPPROTO_TCP    6


      

Marco IPPROTO_UDP

#define IPPROTO_UDP    17


      

Marco IPPROTO_IPV6

#define IPPROTO_IPV6   41


      

Marco IPPROTO_ICMPV6

#define IPPROTO_ICMPV6 58


      

Marco IPPROTO_UDPLITE

#define IPPROTO_UDPLITE 136


      

Marco IPPROTO_RAW

#define IPPROTO_RAW    255


      

Marco MSG_PEEK

#define MSG_PEEK      1   /* Peeks at an incoming message */
/* Flags we can use with send and recv. */

Marco MSG_WAITALL

#define MSG_WAITALL   2   /* Unimplemented: Requests that the function block until the full amount of data requested can be returned */


      

Marco MSG_OOB

#define MSG_OOB       4   /* Unimplemented: Requests out-of-band data. The significance and semantics of out-of-band data are protocol-specific */


      

Marco MSG_DONTWAIT

#define MSG_DONTWAIT  8   /* Nonblocking i/o for this operation only */


      

Marco MSG_MORE

#define MSG_MORE      16   /* Sender will send more */


      

Marco MSG_NOSIGNAL

#define MSG_NOSIGNAL  32   /* Uninmplemented: Requests not to send the SIGPIPE signal if an attempt to send is made on a stream-oriented socket that is no longer connected. */


      

Marco IP_TOS

#define IP_TOS            1
/*
 * Options for level IPPROTO_IP
 */

Marco IP_TTL

#define IP_TTL            2


      

Marco IP_PKTINFO

#define IP_PKTINFO        8


      

Marco TCP_NODELAY

#define TCP_NODELAY   1   /* don't delay send to coalesce packets */
/*
 * Options for level IPPROTO_TCP
 */

Marco TCP_KEEPALIVE

#define TCP_KEEPALIVE 2   /* send KEEPALIVE probes when idle for pcb->keep_idle milliseconds */


      

Marco TCP_KEEPIDLE

#define TCP_KEEPIDLE  3   /* set pcb->keep_idle  - Same as TCP_KEEPALIVE, but use seconds for get/setsockopt */


      

Marco TCP_KEEPINTVL

#define TCP_KEEPINTVL 4   /* set pcb->keep_intvl - Use seconds for get/setsockopt */


      

Marco TCP_KEEPCNT

#define TCP_KEEPCNT   5   /* set pcb->keep_cnt   - Use number of probes sent for get/setsockopt */


      

Marco IPV6_CHECKSUM

#define IPV6_CHECKSUM      7 /* RFC3542: calculate and insert the ICMPv6 checksum for raw sockets. */
/*
 * Options for level IPPROTO_IPV6
 */

Marco IPV6_V6ONLY

#define IPV6_V6ONLY        27 /* RFC3493: boolean control to restrict AF_INET6 sockets to IPv6 communications only. */


      

Marco UDPLITE_SEND_CSCOV

#define UDPLITE_SEND_CSCOV 1 /* sender checksum coverage */
/*
 * Options for level IPPROTO_UDPLITE
 */

Marco UDPLITE_RECV_CSCOV

#define UDPLITE_RECV_CSCOV 2 /* minimal receiver checksum coverage */


      

Marco IP_MULTICAST_TTL

#define IP_MULTICAST_TTL  5
/*
 * Options and types for UDP multicast traffic handling
 */

Marco IP_MULTICAST_IF

#define IP_MULTICAST_IF   6


      

Marco IP_MULTICAST_LOOP

#define IP_MULTICAST_LOOP 7


      

Marco IP_ADD_MEMBERSHIP

#define IP_ADD_MEMBERSHIP 3
/*
 * Options and types related to multicast membership
 */

Marco IP_DROP_MEMBERSHIP

#define IP_DROP_MEMBERSHIP 4


      

Marco IPV6_JOIN_GROUP

#define IPV6_JOIN_GROUP     12
/*
 * Options and types related to IPv6 multicast membership
 */

Marco IPV6_ADD_MEMBERSHIP

#define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP


      

Marco IPV6_LEAVE_GROUP

#define IPV6_LEAVE_GROUP    13


      

Marco IPV6_DROP_MEMBERSHIP

#define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP


      

Marco IPTOS_TOS_MASK

#define IPTOS_TOS_MASK         1E
/*
 * The Type of Service provides an indication of the abstract
 * parameters of the quality of service desired.  These parameters are
 * to be used to guide the selection of the actual service parameters
 * when transmitting a datagram through a particular network.  Several
 * networks offer service precedence, which somehow treats high
 * precedence traffic as more important than other traffic (generally
 * by accepting only traffic above a certain precedence at time of high
 * load).  The major choice is a three way tradeoff between low-delay,
 * high-reliability, and high-throughput.
 * The use of the Delay, Throughput, and Reliability indications may
 * increase the cost (in some sense) of the service.  In many networks
 * better performance for one of these parameters is coupled with worse
 * performance on another.  Except for very unusual cases at most two
 * of these three indications should be set.
 */

Marco IPTOS_TOS(tos)

#define IPTOS_TOS(tos)         ((tos) & IPTOS_TOS_MASK)


      

Marco IPTOS_LOWDELAY

#define IPTOS_LOWDELAY         16


      

Marco IPTOS_THROUGHPUT

#define IPTOS_THROUGHPUT       8


      

Marco IPTOS_RELIABILITY

#define IPTOS_RELIABILITY      4


      

Marco IPTOS_LOWCOST

#define IPTOS_LOWCOST          2


      

Marco IPTOS_MINCOST

#define IPTOS_MINCOST          IPTOS_LOWCOST


      

Marco IPTOS_PREC_MASK

#define IPTOS_PREC_MASK                0xe0
/*
 * The Network Control precedence designation is intended to be used
 * within a network only.  The actual use and control of that
 * designation is up to each network. The Internetwork Control
 * designation is intended for use by gateway control originators only.
 * If the actual use of these precedence designations is of concern to
 * a particular network, it is the responsibility of that network to
 * control the access to, and use of, those precedence designations.
 */

Marco IPTOS_PREC(tos)

#define IPTOS_PREC(tos)               ((tos) & IPTOS_PREC_MASK)


      

Marco IPTOS_PREC_NETCONTROL

#define IPTOS_PREC_NETCONTROL          0xe0


      

Marco IPTOS_PREC_INTERNETCONTROL

#define IPTOS_PREC_INTERNETCONTROL     0xc0


      

Marco IPTOS_PREC_CRITIC_ECP

#define IPTOS_PREC_CRITIC_ECP          0xa0


      

Marco IPTOS_PREC_FLASHOVERRIDE

#define IPTOS_PREC_FLASHOVERRIDE       128


      

Marco IPTOS_PREC_FLASH

#define IPTOS_PREC_FLASH               96


      

Marco IPTOS_PREC_IMMEDIATE

#define IPTOS_PREC_IMMEDIATE           64


      

Marco IPTOS_PREC_PRIORITY

#define IPTOS_PREC_PRIORITY            32


      

Marco IPTOS_PREC_ROUTINE

#define IPTOS_PREC_ROUTINE             0


      

Marco IOCPARM_MASK

#define IOCPARM_MASK   0x7fU          /* parameters must be < 128 bytes */


      

Marco IOC_VOID

#define IOC_VOID       0x20000000UL   /* no parameters */


      

Marco IOC_OUT

#define IOC_OUT        0x40000000UL   /* copy out parameters */


      

Marco IOC_IN

#define IOC_IN         0x80000000UL   /* copy in parameters */


      

Marco IOC_INOUT

#define IOC_INOUT      (IOC_IN|IOC_OUT)


      

Marco _IO(x,y)

#define _IO(x,y)       ((long)(IOC_VOID|((x)<<8)|(y)))


      

Marco _IOR(x,y,t)

#define _IOR(x,y,t)    ((long)(IOC_OUT|((sizeof(t)&IOCPARM_MASK)<<16)|((x)<<8)|(y)))


      

Marco _IOW(x,y,t)

#define _IOW(x,y,t)    ((long)(IOC_IN|((sizeof(t)&IOCPARM_MASK)<<16)|((x)<<8)|(y)))


      

Marco FIONREAD

#define FIONREAD   _IOR('f', 127, unsigned long) /* get # bytes to read */


      

Marco FIONBIO

#define FIONBIO    _IOW('f', 126, unsigned long) /* set/clear non-blocking i/o */


      

Marco SIOCSHIWAT

#define SIOCSHIWAT _IOW('s', 0, unsigned long) /* set high watermark */


      

Marco SIOCGHIWAT

#define SIOCGHIWAT _IOR('s', 1, unsigned long) /* get high watermark */


      

Marco SIOCSLOWAT

#define SIOCSLOWAT _IOW('s', 2, unsigned long) /* set low watermark */


      

Marco SIOCGLOWAT

#define SIOCGLOWAT _IOR('s', 3, unsigned long) /* get low watermark */


      

Marco SIOCATMARK

#define SIOCATMARK _IOR('s', 7, unsigned long) /* at oob mark? */


      

Marco F_GETFL

#define F_GETFL 3


      

Marco F_SETFL

#define F_SETFL 4


      

Marco O_NONBLOCK

#define O_NONBLOCK 1 /* nonblocking I/O */


      

Marco O_NDELAY

#define O_NDELAY   O_NONBLOCK /* same as O_NONBLOCK, for compatibility */


      

Marco O_RDONLY

#define O_RDONLY   2


      

Marco O_WRONLY

#define O_WRONLY   4


      

Marco O_RDWR

#define O_RDWR     (O_RDONLY|O_WRONLY)


      

Marco SHUT_RD

#define SHUT_RD  0


      

Marco SHUT_WR

#define SHUT_WR  1


      

Marco SHUT_RDWR

#define SHUT_RDWR 2


      

Marco FD_SETSIZE

#define FD_SETSIZE   MEMP_NUM_NETCONN
/* Make FD_SETSIZE match NUM_SOCKETS in socket.c */

Marco LWIP_SELECT_MAXNFDS

#define LWIP_SELECT_MAXNFDS (FD_SETSIZE + LWIP_SOCKET_OFFSET)


      

Marco FDSETSAFESET(n, code)

#define FDSETSAFESET(n, code) do { \
 if (((n) - LWIP_SOCKET_OFFSET < MEMP_NUM_NETCONN) && (((int)(n) - LWIP_SOCKET_OFFSET) >= 0)) { \
 code; }} while(0)


      

Marco FDSETSAFEGET(n, code)

#define FDSETSAFEGET(n, code) (((n) - LWIP_SOCKET_OFFSET < MEMP_NUM_NETCONN) && (((int)(n) - LWIP_SOCKET_OFFSET) >= 0) ?\
 (code) : 0)


      

Marco FD_SET(n, p)

#define FD_SET(n, p) FDSETSAFESET(n, (p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] = (u8_t)((p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] | (1 << (((n)-LWIP_SOCKET_OFFSET) & 7))))


      

Marco FD_CLR(n, p)

#define FD_CLR(n, p) FDSETSAFESET(n, (p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] = (u8_t)((p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] & ~(1 << (((n)-LWIP_SOCKET_OFFSET) & 7))))


      

Marco FD_ISSET(n,p)

#define FD_ISSET(n,p) FDSETSAFEGET(n, (p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] &  (1 << (((n)-LWIP_SOCKET_OFFSET) & 7)))


      

Marco FD_ZERO(p)

#define FD_ZERO(p)   memset((void*)(p), 0, sizeof(*(p)))


      

Marco LWIP_SELECT_MAXNFDS

#define LWIP_SELECT_MAXNFDS FD_SETSIZE


      

Marco POLLIN

#define POLLIN    1


      

Marco POLLOUT

#define POLLOUT   2


      

Marco POLLERR

#define POLLERR   4


      

Marco POLLNVAL

#define POLLNVAL  8


      

Marco POLLRDNORM

#define POLLRDNORM 16
/* Below values are unimplemented */

Marco POLLRDBAND

#define POLLRDBAND 32


      

Marco POLLPRI

#define POLLPRI   64


      

Marco POLLWRNORM

#define POLLWRNORM 128


      

Marco POLLWRBAND

#define POLLWRBAND 256


      

Marco POLLHUP

#define POLLHUP   512


      

Marco LWIP_TIMEVAL_PRIVATE

#define LWIP_TIMEVAL_PRIVATE 1


      

Marco lwip_socket_init()

#define lwip_socket_init() /* Compatibility define, no init needed. */


      

Marco lwip_accept

#define lwip_accept      accept
/* This helps code parsers/code completion by not having the COMPAT functions as defines */

Marco lwip_bind

#define lwip_bind        bind


      

Marco lwip_shutdown

#define lwip_shutdown    shutdown


      

Marco lwip_getpeername

#define lwip_getpeername getpeername


      

Marco lwip_getsockname

#define lwip_getsockname getsockname


      

Marco lwip_setsockopt

#define lwip_setsockopt  setsockopt


      

Marco lwip_getsockopt

#define lwip_getsockopt  getsockopt


      

Marco lwip_close

#define lwip_close       closesocket


      

Marco lwip_connect

#define lwip_connect     connect


      

Marco lwip_listen

#define lwip_listen      listen


      

Marco lwip_recv

#define lwip_recv        recv


      

Marco lwip_recvmsg

#define lwip_recvmsg     recvmsg


      

Marco lwip_recvfrom

#define lwip_recvfrom    recvfrom


      

Marco lwip_send

#define lwip_send        send


      

Marco lwip_sendmsg

#define lwip_sendmsg     sendmsg


      

Marco lwip_sendto

#define lwip_sendto      sendto


      

Marco lwip_socket

#define lwip_socket      socket


      

Marco lwip_select

#define lwip_select      select


      

Marco lwip_poll

#define lwip_poll        poll


      

Marco lwip_ioctl

#define lwip_ioctl       ioctlsocket


      

Marco lwip_inet_ntop

#define lwip_inet_ntop   inet_ntop


      

Marco lwip_inet_pton

#define lwip_inet_pton   inet_pton


      

Marco lwip_read

#define lwip_read        read


      

Marco lwip_readv

#define lwip_readv       readv


      

Marco lwip_write

#define lwip_write       write


      

Marco lwip_writev

#define lwip_writev      writev


      

Marco lwip_close

#define lwip_close       close


      

Marco closesocket(s)

#define closesocket(s)   close(s)


      

Marco lwip_ioctl

#define lwip_ioctl       ioctl


      

Marco ioctlsocket

#define ioctlsocket      ioctl


      

Marco accept(s,addr,addrlen)

#define accept(s,addr,addrlen)                   lwip_accept(s,addr,addrlen)
/** @ingroup socket */

Marco bind(s,name,namelen)

#define bind(s,name,namelen)                     lwip_bind(s,name,namelen)
/** @ingroup socket */

Marco shutdown(s,how)

#define shutdown(s,how)                          lwip_shutdown(s,how)
/** @ingroup socket */

Marco getpeername(s,name,namelen)

#define getpeername(s,name,namelen)              lwip_getpeername(s,name,namelen)
/** @ingroup socket */

Marco getsockname(s,name,namelen)

#define getsockname(s,name,namelen)              lwip_getsockname(s,name,namelen)
/** @ingroup socket */

Marco setsockopt(s,level,optname,opval,optlen)

#define setsockopt(s,level,optname,opval,optlen) lwip_setsockopt(s,level,optname,opval,optlen)
/** @ingroup socket */

Marco getsockopt(s,level,optname,opval,optlen)

#define getsockopt(s,level,optname,opval,optlen) lwip_getsockopt(s,level,optname,opval,optlen)
/** @ingroup socket */

Marco closesocket(s)

#define closesocket(s)                           lwip_close(s)
/** @ingroup socket */

Marco connect(s,name,namelen)

#define connect(s,name,namelen)                  lwip_connect(s,name,namelen)
/** @ingroup socket */

Marco listen(s,backlog)

#define listen(s,backlog)                        lwip_listen(s,backlog)
/** @ingroup socket */

Marco recv(s,mem,len,flags)

#define recv(s,mem,len,flags)                    lwip_recv(s,mem,len,flags)
/** @ingroup socket */

Marco recvmsg(s,message,flags)

#define recvmsg(s,message,flags)                 lwip_recvmsg(s,message,flags)
/** @ingroup socket */

Marco recvfrom(s,mem,len,flags,from,fromlen)

#define recvfrom(s,mem,len,flags,from,fromlen)   lwip_recvfrom(s,mem,len,flags,from,fromlen)
/** @ingroup socket */

Marco send(s,dataptr,size,flags)

#define send(s,dataptr,size,flags)               lwip_send(s,dataptr,size,flags)
/** @ingroup socket */

Marco sendmsg(s,message,flags)

#define sendmsg(s,message,flags)                 lwip_sendmsg(s,message,flags)
/** @ingroup socket */

Marco sendto(s,dataptr,size,flags,to,tolen)

#define sendto(s,dataptr,size,flags,to,tolen)    lwip_sendto(s,dataptr,size,flags,to,tolen)
/** @ingroup socket */

Marco socket(domain,type,protocol)

#define socket(domain,type,protocol)             lwip_socket(domain,type,protocol)
/** @ingroup socket */

Marco select(maxfdp1,readset,writeset,exceptset,timeout)

#define select(maxfdp1,readset,writeset,exceptset,timeout)    lwip_select(maxfdp1,readset,writeset,exceptset,timeout)
/** @ingroup socket */

Marco poll(fds,nfds,timeout)

#define poll(fds,nfds,timeout)                   lwip_poll(fds,nfds,timeout)
/** @ingroup socket */

Marco ioctlsocket(s,cmd,argp)

#define ioctlsocket(s,cmd,argp)                  lwip_ioctl(s,cmd,argp)
/** @ingroup socket */

Marco inet_ntop(af,src,dst,size)

#define inet_ntop(af,src,dst,size)               lwip_inet_ntop(af,src,dst,size)
/** @ingroup socket */

Marco inet_pton(af,src,dst)

#define inet_pton(af,src,dst)                    lwip_inet_pton(af,src,dst)
/** @ingroup socket */

Marco read(s,mem,len)

#define read(s,mem,len)                          lwip_read(s,mem,len)
/** @ingroup socket */

Marco readv(s,iov,iovcnt)

#define readv(s,iov,iovcnt)                      lwip_readv(s,iov,iovcnt)
/** @ingroup socket */

Marco write(s,dataptr,len)

#define write(s,dataptr,len)                     lwip_write(s,dataptr,len)
/** @ingroup socket */

Marco writev(s,iov,iovcnt)

#define writev(s,iov,iovcnt)                     lwip_writev(s,iov,iovcnt)
/** @ingroup socket */

Marco close(s)

#define close(s)                                 lwip_close(s)
/** @ingroup socket */

Marco fcntl(s,cmd,val)

#define fcntl(s,cmd,val)                         lwip_fcntl(s,cmd,val)
/** @ingroup socket */

Marco ioctl(s,cmd,argp)

#define ioctl(s,cmd,argp)                        lwip_ioctl(s,cmd,argp)
/** @ingroup socket */

Functions

Func lwip_socket_thread_init

err_t lwip_socket_thread_init(void *task);


      

Func lwip_socket_thread_cleanup

err_t lwip_socket_thread_cleanup(void *task);
/* LWIP_NETCONN_SEM_PER_THREAD==1: initialize thread-local semaphore */

Func fcntl

int fcntl(int s, int cmd, ...);


      

Func lwip_accept

int lwip_accept(int s, struct sockaddr *addr, socklen_t *addrlen);


      

Func lwip_bind

int lwip_bind(int s, const struct sockaddr *name, socklen_t namelen);


      

Func lwip_shutdown

int lwip_shutdown(int s, int how);


      

Func lwip_getpeername

int lwip_getpeername (int s, struct sockaddr *name, socklen_t *namelen);


      

Func lwip_getsockname

int lwip_getsockname (int s, struct sockaddr *name, socklen_t *namelen);


      

Func lwip_getsockopt

int lwip_getsockopt (int s, int level, int optname, void *optval, socklen_t *optlen);


      

Func lwip_setsockopt

int lwip_setsockopt (int s, int level, int optname, const void *optval, socklen_t optlen);


      

Func lwip_close

int lwip_close(int s);


      

Func lwip_connect

int lwip_connect(int s, const struct sockaddr *name, socklen_t namelen);


      

Func lwip_listen

int lwip_listen(int s, int backlog);


      

Func lwip_recv

ssize_t lwip_recv(int s, void *mem, size_t len, int flags);


      

Func lwip_read

ssize_t lwip_read(int s, void *mem, size_t len);


      

Func lwip_readv

ssize_t lwip_readv(int s, const struct iovec *iov, int iovcnt);


      

Func lwip_recvfrom

ssize_t lwip_recvfrom(int s, void *mem, size_t len, int flags,
     struct sockaddr *from, socklen_t *fromlen);


      

Func lwip_recvmsg

ssize_t lwip_recvmsg(int s, struct msghdr *message, int flags);


      

Func lwip_send

ssize_t lwip_send(int s, const void *dataptr, size_t size, int flags);


      

Func lwip_sendmsg

ssize_t lwip_sendmsg(int s, const struct msghdr *message, int flags);


      

Func lwip_sendto

ssize_t lwip_sendto(int s, const void *dataptr, size_t size, int flags,
   const struct sockaddr *to, socklen_t tolen);


      

Func lwip_socket

int lwip_socket(int domain, int type, int protocol);


      

Func lwip_write

ssize_t lwip_write(int s, const void *dataptr, size_t size);


      

Func lwip_writev

ssize_t lwip_writev(int s, const struct iovec *iov, int iovcnt);


      

Func lwip_select

int lwip_select(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset,
               struct timeval *timeout);


      

Func lwip_poll

int lwip_poll(struct pollfd *fds, nfds_t nfds, int timeout);


      

Func lwip_ioctl

int lwip_ioctl(int s, long cmd, void *argp);


      

Func lwip_fcntl

int lwip_fcntl(int s, int cmd, int val);


      

Func lwip_inet_pton

int lwip_inet_pton(int af, const char *src, void *dst);

      

Vars

Consts

Const

const char *lwip_inet_ntop(int af, const void *src, char *dst, socklen_t size);

      

Types

Typedefs

Typedef sa_family_t

typedef u8_t sa_family_t;


      

Typedef in_port_t

typedef u16_t in_port_t;


      

Typedef socklen_t

typedef u32_t socklen_t;


      

Typedef ip_mreq;

typedef struct ip_mreq {
   struct in_addr imr_multiaddr; /* IP multicast address of group */
   struct in_addr imr_interface; /* local IP address of interface */
} ip_mreq;


      

Typedef ipv6_mreq;

typedef struct ipv6_mreq {
 struct in6_addr ipv6mr_multiaddr; /*  IPv6 multicast addr */
 unsigned int   ipv6mr_interface; /*  interface index, or 0 */
} ipv6_mreq;


      

Typedef fd_set;

typedef struct fd_set
{
 unsigned char fd_bits [(FD_SETSIZE+7)/8];
} fd_set;


      

Typedef nfds_t

typedef unsigned int nfds_t;