lws-network-helper.h

Go to the documentation of this file.

/*
 * libwebsockets - small server side websockets and web server implementation
 *
 * Copyright (C) 2010 - 2023 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_dll2_owner *
lws_routing_table_get(struct lws_context *cx);

 
#if defined(LWS_ESP_PLATFORM)
#include <lwip/sockets.h>
#endif
 
/* cope with large amounts of route information */
typedef uint16_t lws_route_uidx_t;
 
typedef struct lws_dns_score {
        uint8_t precedence;
        uint8_t label;
} lws_dns_score_t;
 
/*
 * This represents an entry in the system routing table
 */
 
typedef struct lws_route {
        lws_dll2_t              list;
 
        lws_sockaddr46          src; /* lws_dns_sort_t: the source route's src */
        lws_sockaddr46          dest;
        lws_sockaddr46          gateway;
 
        lws_dns_score_t         score; /* when used as lws_dns_sort_t */
 
        int                     if_idx;
        int                     priority;
        int                     ifa_flags; /* if source_ads */
 
        lws_route_uidx_t        uidx; /* unique index for this route */
 
        uint8_t                 proto;
        uint8_t                 dest_len;
        uint8_t                 src_len;
        uint8_t                 scope; /* if source_ads */
        uint8_t                 af; /* if source_ads */
 
        uint8_t                 source_ads:1;
        uint8_t                 has_source:1; /* lws_dns_sort_t: src is set */
} lws_route_t;
 
/*
 * We reuse the route object as the dns sort granule, so there's only one
 * struct needs to know all the gnarly ipv6 details
 */
 
typedef lws_route_t lws_dns_sort_t;

LWS_VISIBLE LWS_EXTERN const char * LWS_WARN_UNUSED_RESULT
lws_canonical_hostname(struct lws_context *context);

LWS_VISIBLE LWS_EXTERN int LWS_WARN_UNUSED_RESULT
lws_get_peer_addresses(struct lws *wsi, lws_sockfd_type fd, char *name,
                       int name_len, char *rip, int rip_len);

LWS_VISIBLE LWS_EXTERN const char *
lws_get_peer_simple(struct lws *wsi, char *name, size_t namelen);
 
LWS_VISIBLE LWS_EXTERN const char *
lws_get_peer_simple_fd(lws_sockfd_type fd, char *name, size_t namelen);
 
#define LWS_ITOSA_USABLE        0
#define LWS_ITOSA_NOT_EXIST     -1
#define LWS_ITOSA_NOT_USABLE    -2
#define LWS_ITOSA_BUSY          -3 /* only returned by lws_socket_bind() on
                                        EADDRINUSE */

LWS_VISIBLE LWS_EXTERN int
lws_interface_to_sa(int ipv6, const char *ifname, struct sockaddr_in *addr,
                    size_t addrlen);

LWS_VISIBLE LWS_EXTERN int
lws_sa46_compare_ads(const lws_sockaddr46 *sa46a, const lws_sockaddr46 *sa46b);

#if defined(LWS_WITH_IPV6)
#define lws_sa46_compare_sin6_addr(a, b) memcmp((a)->s6_addr, (b)->s6_addr, 16)
#endif

LWS_VISIBLE LWS_EXTERN int
lws_sa46_on_net(const lws_sockaddr46 *sa46a, const lws_sockaddr46 *sa46_net,
                        int net_len);
 
/*
 * lws_parse_numeric_address() - converts numeric ipv4 or ipv6 to byte address
 *
 * \param ads: the numeric ipv4 or ipv6 address string
 * \param result: result array
 * \param max_len: max length of result array
 *
 * Converts a 1.2.3.4 or 2001:abcd:123:: or ::ffff:1.2.3.4 formatted numeric
 * address into an array of network ordered byte address elements.
 *
 * The parse is as strict as inet_pton(): the string must contain nothing but
 * the address, and an ipv4 octet may not have a leading zero, since libc's
 * resolver reads one as octal (to it "012.0.0.1" is 10.0.0.1).
 *
 * Returns < 0 on error, else length of result set, either 4 or 16 for ipv4 /
 * ipv6.
 */
LWS_VISIBLE LWS_EXTERN int
lws_parse_numeric_address(const char *ads, uint8_t *result, size_t max_len);

LWS_VISIBLE LWS_EXTERN int
lws_host_is_ambiguous_numeric(const char *host);

LWS_VISIBLE LWS_EXTERN int
lws_host_is_localhost(const char *host);
 
/*
 * lws_sa46_parse_numeric_address() - converts numeric ipv4 or ipv6 to sa46
 *
 * \param ads: the numeric ipv4 or ipv6 address string
 * \param sa46: pointer to sa46 to set
 *
 * Converts a 1.2.3.4 or 2001:abcd:123:: or ::ffff:1.2.3.4 formatted numeric
 * address into an sa46, a union of sockaddr_in or sockaddr_in6 depending on
 * what kind of address was found.  sa46->sa4.sin_fmaily will be AF_INET if
 * ipv4, or AF_INET6 if ipv6.
 *
 * Returns 0 if the sa46 was set, else < 0 on error.
 */
LWS_VISIBLE LWS_EXTERN int
lws_sa46_parse_numeric_address(const char *ads, lws_sockaddr46 *sa46);

LWS_VISIBLE LWS_EXTERN int
lws_sa46_is_ipv4_mapped(const lws_sockaddr46 *sa46);
 
/*
 * Room for any key lws_sa46_host_key() / lws_get_peer_host_key() writes,
 * including the terminating NUL
 */
#define LWS_HOST_KEY_LEN        32
/* the one key every peer whose address is not IPv4 or IPv6 shares */
#define LWS_HOST_KEY_UNKNOWN    "unknown"
/*
 * the one key every peer whose address nothing proved shares, see
 * lws_get_peer_host_key()
 */
#define LWS_HOST_KEY_UNPROVEN   "unproven"

LWS_VISIBLE LWS_EXTERN int
lws_sa46_host_key(const lws_sockaddr46 *sa46, char *key, size_t len);

LWS_VISIBLE LWS_EXTERN const char *
lws_get_peer_host_key(struct lws *wsi, char *key, size_t len);
 
/*
 * The peer address stack
 *
 * Who a connection's peer is may be known at several layers, each believed
 * to a different degree: the transport's own peer (the address a TCP
 * handshake completed with, or a datagram's source), and above it a claim
 * about the real client (eg, the PROXY v2 header of a trusted front).  lws
 * keeps these as a stack per connection, top (the most specific claim)
 * first, each entry tagged with how far it can be believed.
 */

 */
typedef enum lws_peer_cred {
        LWS_PEER_CRED_NONE,     
        LWS_PEER_CRED_HEARSAY,  
        LWS_PEER_CRED_VOUCHED,  
        LWS_PEER_CRED_ROUTABLE, 
        LWS_PEER_CRED_CRYPTO,   
} lws_peer_cred_t;

 */
typedef enum lws_peer_kind {
        LWS_PEER_KIND_SOCKET,   
        LWS_PEER_KIND_LOCAL,    
        LWS_PEER_KIND_PROXY_V2, 
        LWS_PEER_KIND_RELAY,    
        LWS_PEER_KIND_XFF,      
        LWS_PEER_KIND_DATAGRAM, 
} lws_peer_kind_t;

 */
typedef struct lws_peer_entry {
        lws_sockaddr46          sa46;   
        uint8_t                 cred;   
        uint8_t                 kind;   
} lws_peer_entry_t;
 
/*
 * The most entries lws_peer_walk() can give: a stream's own claim, a claim
 * about the client on the connection, and the transport's peer
 */
#define LWS_PEER_WALK_MAX       3

LWS_VISIBLE LWS_EXTERN int
lws_peer_walk(struct lws *wsi, lws_peer_entry_t *dest, int max);

LWS_VISIBLE LWS_EXTERN int
lws_peer_effective(struct lws *wsi, lws_peer_entry_t *dest);

LWS_VISIBLE LWS_EXTERN int
lws_peer_entries_effective(const lws_peer_entry_t *e, int count);
 
/* lws_peer_describe() flags */
#define LWS_PEER_DESC_TOKEN     (1 << 0) /* one token, no spaces, see below */
#define LWS_PEER_DESC_BARE_SINGLE (1 << 1) /* one proven entry: its address */
 
/*
 * Room for any description of what lws_peer_walk() can give, including the
 * terminating NUL
 */
#define LWS_PEER_DESC_LEN       224

LWS_VISIBLE LWS_EXTERN const char *
lws_peer_entries_describe(const lws_peer_entry_t *e, int count, char *buf,
                          size_t len, int flags);

LWS_VISIBLE LWS_EXTERN const char *
lws_peer_describe(struct lws *wsi, char *buf, size_t len, int flags);

LWS_VISIBLE LWS_EXTERN int
lws_peer_raise(struct lws *wsi, const lws_sockaddr46 *seen,
               lws_peer_cred_t cred);

LWS_VISIBLE LWS_EXTERN const char *
lws_peer_cred_name(lws_peer_cred_t cred);

LWS_VISIBLE LWS_EXTERN const char *
lws_peer_kind_name(lws_peer_kind_t kind);

LWS_VISIBLE LWS_EXTERN int
lws_write_numeric_address(const uint8_t *ads, int size, char *buf, size_t len);

LWS_VISIBLE LWS_EXTERN int
lws_sa46_write_numeric_address(lws_sockaddr46 *sa46, char *buf, size_t len);

LWS_VISIBLE LWS_EXTERN int
lws_parse_mac(const char *ads, uint8_t *result_6_bytes);
 
LWS_VISIBLE LWS_EXTERN int
lws_parse_cidr(const char *cidr, lws_sockaddr46 *sa46, int *len);

LWS_VISIBLE LWS_EXTERN int
lws_is_lan_address(const char *ads);
 
/*
 * lws_is_local_address() - checks if the given string represents a local address
 *
 * \param ads: the address string to check
 *
 * Returns 1 if the address is a recognized local address like "localhost" or "127.0.0.1",
 * or a name under "localhost" (see lws_host_is_localhost()), else 0.
 */
LWS_VISIBLE LWS_EXTERN int
lws_is_local_address(const char *ads);

LWS_VISIBLE LWS_EXTERN int
lws_is_lan_address(const char *ads);