lws-adopt.h

Go to the documentation of this file.

/*
 * libwebsockets - small server side websockets and web server implementation
 *
 * Copyright (C) 2010 - 2019 Andy Green <andy@warmcat.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */


LWS_VISIBLE LWS_EXTERN struct lws *
lws_adopt_socket(struct lws_context *context, lws_sockfd_type accept_fd);

LWS_VISIBLE LWS_EXTERN struct lws *
lws_adopt_socket_vhost(struct lws_vhost *vh, lws_sockfd_type accept_fd);
 
typedef enum {
        LWS_ADOPT_RAW_FILE_DESC         =  0,   /* convenience constant */
        LWS_ADOPT_HTTP                  =  1,   /* flag: absent implies RAW */
        LWS_ADOPT_SOCKET                =  2,   /* flag: absent implies file */
        LWS_ADOPT_ALLOW_SSL             =  4,   /* flag: use tls */
        LWS_ADOPT_FLAG_UDP              = 16,   /* flag: socket is UDP */
        LWS_ADOPT_FLAG_RAW_PROXY        = 32,   /* flag: raw proxy */
        LWS_ADOPT_FLAG_NO_NONBLOCK      = 64,   /* flag: file fd can't be made
                                                 * nonblocking, and is never
                                                 * read in a way that can block,
                                                 * eg, a Darwin kqueue fd */
 
        LWS_ADOPT_RAW_SOCKET_UDP = LWS_ADOPT_SOCKET | LWS_ADOPT_FLAG_UDP,
} lws_adoption_type;
 
typedef union {
        lws_sockfd_type sockfd;
        lws_filefd_type filefd;
} lws_sock_file_fd_type;
 
#if defined(LWS_ESP_PLATFORM)
#include <lwip/sockets.h>
#endif
 
typedef union lws_sockaddr46 {
#if defined(LWS_WITH_IPV6)
        struct sockaddr_in6 sa6;
#else
#if defined(LWS_ESP_PLATFORM)
        uint8_t _pad_sa6[28];
#endif
#endif
        struct sockaddr_in sa4;
} lws_sockaddr46;
 
#define sa46_sockaddr(_sa46) ((struct sockaddr *)(_sa46))
 
#if defined(LWS_WITH_IPV6)
#define sa46_socklen(_sa46) (socklen_t)((_sa46)->sa4.sin_family == AF_INET ? \
                                sizeof(struct sockaddr_in) : \
                                sizeof(struct sockaddr_in6))
#define sa46_sockport(_sa46, _sp)  { if ((_sa46)->sa4.sin_family == AF_INET) \
                                        (_sa46)->sa4.sin_port = (_sp); else \
                                        (_sa46)->sa6.sin6_port = (_sp); }
#define sa46_address(_sa46) ((uint8_t *)((_sa46)->sa4.sin_family == AF_INET ? \
                     &_sa46->sa4.sin_addr : &_sa46->sa6.sin6_addr ))
#else
#define sa46_socklen(_sa46) (socklen_t)sizeof(struct sockaddr_in)
#define sa46_sockport(_sa46, _sp)  (_sa46)->sa4.sin_port = (_sp)
#define sa46_address(_sa46) (uint8_t *)&_sa46->sa4.sin_addr
#endif
 
#define sa46_address_len(_sa46) ((_sa46)->sa4.sin_family == AF_INET ? 4 : 16)
 
#if defined(LWS_WITH_UDP)
struct lws_udp {
        lws_sockaddr46          sa46;
        lws_sockaddr46          sa46_pending;
        uint8_t                 connected:1;
};
#endif

LWS_VISIBLE LWS_EXTERN struct lws *
lws_adopt_descriptor_vhost(struct lws_vhost *vh, lws_adoption_type type,
                           lws_sock_file_fd_type fd, const char *vh_prot_name,
                           struct lws *parent);

LWS_VISIBLE LWS_EXTERN lws_sockfd_type
lws_get_socket_fd(struct lws *wsi);

LWS_VISIBLE LWS_EXTERN const struct lws_udp * LWS_WARN_UNUSED_RESULT
lws_get_udp(const struct lws *wsi);
 
#if defined(LWS_WITH_TLS) && !defined(LWS_WITH_MBEDTLS) && !defined(LWS_WITH_BEARSSL)
LWS_VISIBLE LWS_EXTERN SSL*
lws_get_ssl(struct lws *wsi);
#endif
 
/*
 * A transport under IO, in place of the socket.  IO still owns the wsi's
 * place in the poll set (the fd is what the loop watches), but the bytes
 * of a connection with a transport set go through these instead of recv,
 * send, recvmsg and sendto, below the tls record layer: a connection in
 * the clear exchanges its protocol bytes with the transport, one with tls
 * its ciphertext.  This is how a test drives the sansIO half with no
 * network under it (api-test-sansio), and how an embedder carries lws over
 * something that is not a socket.
 *
 * read and write follow lws_ssl_capable_read() / write(): bytes moved, or
 * LWS_SSL_CAPABLE_MORE_SERVICE_READ / _WRITE when nothing can move now, or
 * LWS_SSL_CAPABLE_ERROR; a read of 0 is the peer closing.  recv_dgram
 * returns the datagram's length with its peer and ECN bits, or 0 when
 * there is none; send_dgram as lws_io_send_dgram().  Either datagram op
 * may be NULL when the transport carries streams only.
 */
typedef struct lws_transport_ops {
        int (*read)(struct lws *wsi, void *opaque, uint8_t *buf, size_t len);
        int (*write)(struct lws *wsi, void *opaque, const uint8_t *buf,
                     size_t len);
        int (*recv_dgram)(struct lws *wsi, void *opaque, uint8_t *buf,
                          size_t len, lws_sockaddr46 *peer, uint8_t *ecn);
        int (*send_dgram)(struct lws *wsi, void *opaque, const uint8_t *buf,
                          size_t len, const lws_sockaddr46 *dest);
} lws_transport_ops_t;

LWS_VISIBLE LWS_EXTERN void
lws_set_transport(struct lws *wsi, const lws_transport_ops_t *ops,
                  void *opaque);
 
typedef struct lws_adopt_desc {
        struct lws_vhost        *vh;            
        lws_adoption_type       type;           
        lws_sock_file_fd_type   fd;             
        const char              *vh_prot_name;  
        struct lws              *parent;        
        void                    *opaque;        
        const char              *fi_wsi_name;   
} lws_adopt_desc_t;

LWS_VISIBLE LWS_EXTERN struct lws *
lws_adopt_descriptor_vhost_via_info(const lws_adopt_desc_t *info);

LWS_VISIBLE LWS_EXTERN struct lws *
lws_adopt_socket_readbuf(struct lws_context *context, lws_sockfd_type accept_fd,
                         const char *readbuf, size_t len);
LWS_VISIBLE LWS_EXTERN struct lws *
lws_adopt_socket_vhost_readbuf(struct lws_vhost *vhost,
                               lws_sockfd_type accept_fd, const char *readbuf,
                               size_t len);
 
#define LWS_CAUDP_BIND (1 << 0)
#define LWS_CAUDP_BROADCAST (1 << 1)
#define LWS_CAUDP_PF_PACKET (1 << 2)
 
#if defined(LWS_WITH_UDP)
LWS_VISIBLE LWS_EXTERN struct lws *
lws_create_adopt_udp(struct lws_vhost *vhost, const char *ads, int port,
                     int flags, const char *protocol_name, const char *ifname,
                     struct lws *parent_wsi, void *opaque,
                     const lws_retry_bo_t *retry_policy, const char *fi_wsi_name);
#endif