lws-misc.h

/*
 * libwebsockets - small server side websockets and web server implementation
 *
 * Copyright (C) 2010-2018 Andy Green <andy@warmcat.com>
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation:
 *  version 2.1 of the License.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 *  MA  02110-1301  USA
 *
 * included from libwebsockets.h
 */
 
 
#define lws_start_foreach_ll(type, it, start)\
{ \
        type it = start; \
        while (it) {
 
#define lws_end_foreach_ll(it, nxt) \
                it = it->nxt; \
        } \
}
 
#define lws_start_foreach_ll_safe(type, it, start, nxt)\
{ \
        type it = start; \
        while (it) { \
                type next_##it = it->nxt;
 
#define lws_end_foreach_ll_safe(it) \
                it = next_##it; \
        } \
}
 
#define lws_start_foreach_llp(type, it, start)\
{ \
        type it = &(start); \
        while (*(it)) {
 
#define lws_start_foreach_llp_safe(type, it, start, nxt)\
{ \
        type it = &(start); \
        type next; \
        while (*(it)) { \
                next = &((*(it))->nxt); \
 
#define lws_end_foreach_llp(it, nxt) \
                it = &(*(it))->nxt; \
        } \
}
 
#define lws_end_foreach_llp_safe(it) \
                it = next; \
        } \
}
 
#define lws_ll_fwd_insert(\
        ___new_object,  /* pointer to new object */ \
        ___m_list,      /* member for next list object ptr */ \
        ___list_head    /* list head */ \
                ) {\
                ___new_object->___m_list = ___list_head; \
                ___list_head = ___new_object; \
        }
 
#define lws_ll_fwd_remove(\
        ___type,        /* type of listed object */ \
        ___m_list,      /* member for next list object ptr */ \
        ___target,      /* object to remove from list */ \
        ___list_head    /* list head */ \
        ) { \
                lws_start_foreach_llp(___type **, ___ppss, ___list_head) { \
                        if (*___ppss == ___target) { \
                                *___ppss = ___target->___m_list; \
                                break; \
                        } \
                } lws_end_foreach_llp(___ppss, ___m_list); \
        }
 
/*
 * doubly linked-list
 */
 
#if defined (LWS_WITH_DEPRECATED_LWS_DLL)
 
/*
 * This is going away in v4.1.  You can set the cmake option above to keep it
 * around temporarily.  Migrate your stuff to the more capable and robust
 * lws_dll2 below
 */
 
struct lws_dll {
        struct lws_dll *prev;
        struct lws_dll *next;
};
 
/*
 * these all point to the composed list objects... you have to use the
 * lws_container_of() helper to recover the start of the containing struct
 */
 
#define lws_dll_add_front lws_dll_add_head
 
LWS_VISIBLE LWS_EXTERN void
lws_dll_add_head(struct lws_dll *d, struct lws_dll *phead);
 
LWS_VISIBLE LWS_EXTERN void
lws_dll_add_tail(struct lws_dll *d, struct lws_dll *phead);
 
LWS_VISIBLE LWS_EXTERN void
lws_dll_insert(struct lws_dll *d, struct lws_dll *target,
               struct lws_dll *phead, int before);
 
static LWS_INLINE struct lws_dll *
lws_dll_get_head(struct lws_dll *phead) { return phead->next; }
 
static LWS_INLINE struct lws_dll *
lws_dll_get_tail(struct lws_dll *phead) { return phead->prev; }
 
/*
 * caution, this doesn't track the tail in the head struct.  Use
 * lws_dll_remove_track_tail() instead of this if you want tail tracking.  Using
 * this means you can't use lws_dll_add_tail() amd
 */
LWS_VISIBLE LWS_EXTERN void
lws_dll_remove(struct lws_dll *d) LWS_WARN_DEPRECATED;
 
LWS_VISIBLE LWS_EXTERN void
lws_dll_remove_track_tail(struct lws_dll *d, struct lws_dll *phead);
 
/* another way to do lws_start_foreach_dll_safe() on a list via a cb */
 
LWS_VISIBLE LWS_EXTERN int
lws_dll_foreach_safe(struct lws_dll *phead, void *user,
                     int (*cb)(struct lws_dll *d, void *user));
 
#define lws_dll_is_detached(___dll, __head) \
        (!(___dll)->prev && !(___dll)->next && (__head)->prev != (___dll))
 
#endif
 
/*
 * lws_dll2_owner / lws_dll2 : more capable version of lws_dll.  Differences:
 *
 *  - there's an explicit lws_dll2_owner struct which holds head, tail and
 *    count of members.
 *
 *  - list members all hold a pointer to their owner.  So user code does not
 *    have to track anything about exactly what lws_dll2_owner list the object
 *    is a member of.
 *
 *  - you can use lws_dll unless you want the member count or the ability to
 *    not track exactly which list it's on.
 *
 *  - layout is compatible with lws_dll (but lws_dll apis will not update the
 *    new stuff)
 */
 
 
struct lws_dll2;
struct lws_dll2_owner;
 
typedef struct lws_dll2 {
        struct lws_dll2         *prev;
        struct lws_dll2         *next;
        struct lws_dll2_owner   *owner;
} lws_dll2_t;
 
typedef struct lws_dll2_owner {
        struct lws_dll2         *tail;
        struct lws_dll2         *head;
 
        uint32_t                count;
} lws_dll2_owner_t;
 
static LWS_INLINE int
lws_dll2_is_detached(const struct lws_dll2 *d) { return !d->owner; }
 
static LWS_INLINE const struct lws_dll2_owner *
lws_dll2_owner(const struct lws_dll2 *d) { return d->owner; }
 
static LWS_INLINE struct lws_dll2 *
lws_dll2_get_head(struct lws_dll2_owner *owner) { return owner->head; }
 
static LWS_INLINE struct lws_dll2 *
lws_dll2_get_tail(struct lws_dll2_owner *owner) { return owner->tail; }
 
LWS_VISIBLE LWS_EXTERN void
lws_dll2_add_head(struct lws_dll2 *d, struct lws_dll2_owner *owner);
 
LWS_VISIBLE LWS_EXTERN void
lws_dll2_add_tail(struct lws_dll2 *d, struct lws_dll2_owner *owner);
 
LWS_VISIBLE LWS_EXTERN void
lws_dll2_remove(struct lws_dll2 *d);
 
LWS_VISIBLE LWS_EXTERN int
lws_dll2_foreach_safe(struct lws_dll2_owner *owner, void *user,
                      int (*cb)(struct lws_dll2 *d, void *user));
 
LWS_VISIBLE LWS_EXTERN void
lws_dll2_clear(struct lws_dll2 *d);
 
LWS_VISIBLE LWS_EXTERN void
lws_dll2_owner_clear(struct lws_dll2_owner *d);
 
LWS_VISIBLE LWS_EXTERN void
lws_dll2_add_before(struct lws_dll2 *d, struct lws_dll2 *after);
 
LWS_VISIBLE LWS_EXTERN void
lws_dll2_add_sorted(lws_dll2_t *d, lws_dll2_owner_t *own,
                    int (*compare)(const lws_dll2_t *d, const lws_dll2_t *i));
 
#if defined(_DEBUG)
void
lws_dll2_describe(struct lws_dll2_owner *owner, const char *desc);
#else
#define lws_dll2_describe(x, y)
#endif
 
/*
 * these are safe against the current container object getting deleted,
 * since the hold his next in a temp and go to that next.  ___tmp is
 * the temp.
 */
 
#define lws_start_foreach_dll_safe(___type, ___it, ___tmp, ___start) \
{ \
        ___type ___it = ___start; \
        while (___it) { \
                ___type ___tmp = (___it)->next;
 
#define lws_end_foreach_dll_safe(___it, ___tmp) \
                ___it = ___tmp; \
        } \
}
 
#define lws_start_foreach_dll(___type, ___it, ___start) \
{ \
        ___type ___it = ___start; \
        while (___it) {
 
#define lws_end_foreach_dll(___it) \
                ___it = (___it)->next; \
        } \
}
 
struct lws_buflist;
 
LWS_VISIBLE LWS_EXTERN int LWS_WARN_UNUSED_RESULT
lws_buflist_append_segment(struct lws_buflist **head, const uint8_t *buf,
                           size_t len);
LWS_VISIBLE LWS_EXTERN size_t
lws_buflist_next_segment_len(struct lws_buflist **head, uint8_t **buf);
 
LWS_VISIBLE LWS_EXTERN int
lws_buflist_use_segment(struct lws_buflist **head, size_t len);
 
LWS_VISIBLE LWS_EXTERN void
lws_buflist_destroy_all_segments(struct lws_buflist **head);
 
void
lws_buflist_describe(struct lws_buflist **head, void *id);
 
#define lws_ptr_diff(head, tail) \
                        ((int)((char *)(head) - (char *)(tail)))
 
LWS_VISIBLE LWS_EXTERN int
lws_snprintf(char *str, size_t size, const char *format, ...) LWS_FORMAT(3);
 
LWS_VISIBLE LWS_EXTERN char *
lws_strncpy(char *dest, const char *src, size_t size);
 
LWS_VISIBLE LWS_EXTERN int
lws_hex_to_byte_array(const char *h, uint8_t *dest, int max);
 
/*
 * lws_timingsafe_bcmp(): constant time memcmp
 *
 * \param a: first buffer
 * \param b: second buffer
 * \param len: count of bytes to compare
 *
 * Return 0 if the two buffers are the same, else nonzero.
 *
 * Always compares all of the buffer before returning, so it can't be used as
 * a timing oracle.
 */
 
LWS_VISIBLE LWS_EXTERN int
lws_timingsafe_bcmp(const void *a, const void *b, uint32_t len);
 
LWS_VISIBLE LWS_EXTERN int
lws_get_random(struct lws_context *context, void *buf, int len);
LWS_VISIBLE LWS_EXTERN int LWS_WARN_UNUSED_RESULT
lws_daemonize(const char *_lock_path);
LWS_VISIBLE LWS_EXTERN const char * LWS_WARN_UNUSED_RESULT
lws_get_library_version(void);
 
LWS_VISIBLE LWS_EXTERN void *
lws_wsi_user(struct lws *wsi);
 
LWS_VISIBLE LWS_EXTERN void
lws_set_wsi_user(struct lws *wsi, void *user);
 
LWS_VISIBLE LWS_EXTERN int LWS_WARN_UNUSED_RESULT
lws_parse_uri(char *p, const char **prot, const char **ads, int *port,
              const char **path);
LWS_VISIBLE LWS_EXTERN const char *
lws_cmdline_option(int argc, const char **argv, const char *val);
 
LWS_VISIBLE LWS_EXTERN unsigned long
lws_now_secs(void);
 
LWS_VISIBLE LWS_EXTERN lws_usec_t
lws_now_usecs(void);
 
LWS_VISIBLE LWS_EXTERN struct lws_context * LWS_WARN_UNUSED_RESULT
lws_get_context(const struct lws *wsi);
 
LWS_VISIBLE LWS_EXTERN int LWS_WARN_UNUSED_RESULT
lws_get_vhost_listen_port(struct lws_vhost *vhost);
 
LWS_VISIBLE LWS_EXTERN int LWS_WARN_UNUSED_RESULT
lws_get_count_threads(struct lws_context *context);
 
LWS_VISIBLE LWS_EXTERN struct lws * LWS_WARN_UNUSED_RESULT
lws_get_parent(const struct lws *wsi);
 
LWS_VISIBLE LWS_EXTERN struct lws * LWS_WARN_UNUSED_RESULT
lws_get_child(const struct lws *wsi);
 
LWS_VISIBLE LWS_EXTERN void
lws_get_effective_uid_gid(struct lws_context *context, int *uid, int *gid);
 
LWS_VISIBLE LWS_EXTERN const struct lws_udp * LWS_WARN_UNUSED_RESULT
lws_get_udp(const struct lws *wsi);
 
LWS_VISIBLE LWS_EXTERN void *
lws_get_opaque_parent_data(const struct lws *wsi);
 
LWS_VISIBLE LWS_EXTERN void
lws_set_opaque_parent_data(struct lws *wsi, void *data);
 
LWS_VISIBLE LWS_EXTERN void *
lws_get_opaque_user_data(const struct lws *wsi);
 
LWS_VISIBLE LWS_EXTERN void
lws_set_opaque_user_data(struct lws *wsi, void *data);
 
LWS_VISIBLE LWS_EXTERN int
lws_get_child_pending_on_writable(const struct lws *wsi);
 
LWS_VISIBLE LWS_EXTERN void
lws_clear_child_pending_on_writable(struct lws *wsi);
 
LWS_VISIBLE LWS_EXTERN int
lws_get_close_length(struct lws *wsi);
 
LWS_VISIBLE LWS_EXTERN unsigned char *
lws_get_close_payload(struct lws *wsi);
 
LWS_VISIBLE LWS_EXTERN
struct lws *lws_get_network_wsi(struct lws *wsi);
 
LWS_VISIBLE LWS_EXTERN void
lws_set_allocator(void *(*realloc)(void *ptr, size_t size, const char *reason));
 
enum {
        /*
         * Flags for enable and disable rxflow with reason bitmap and with
         * backwards-compatible single bool
         */
        LWS_RXFLOW_REASON_USER_BOOL             = (1 << 0),
        LWS_RXFLOW_REASON_HTTP_RXBUFFER         = (1 << 6),
        LWS_RXFLOW_REASON_H2_PPS_PENDING        = (1 << 7),
 
        LWS_RXFLOW_REASON_APPLIES               = (1 << 14),
        LWS_RXFLOW_REASON_APPLIES_ENABLE_BIT    = (1 << 13),
        LWS_RXFLOW_REASON_APPLIES_ENABLE        = LWS_RXFLOW_REASON_APPLIES |
                                                  LWS_RXFLOW_REASON_APPLIES_ENABLE_BIT,
        LWS_RXFLOW_REASON_APPLIES_DISABLE       = LWS_RXFLOW_REASON_APPLIES,
        LWS_RXFLOW_REASON_FLAG_PROCESS_NOW      = (1 << 12),
 
};
 
LWS_VISIBLE LWS_EXTERN int
lws_rx_flow_control(struct lws *wsi, int enable);
 
LWS_VISIBLE LWS_EXTERN void
lws_rx_flow_allow_all_protocol(const struct lws_context *context,
                               const struct lws_protocols *protocol);
 
LWS_VISIBLE LWS_EXTERN size_t
lws_remaining_packet_payload(struct lws *wsi);
 
#if defined(LWS_WITH_DIR)
 
typedef enum {
        LDOT_UNKNOWN,
        LDOT_FILE,
        LDOT_DIR,
        LDOT_LINK,
        LDOT_FIFO,
        LDOTT_SOCKET,
        LDOT_CHAR,
        LDOT_BLOCK
} lws_dir_obj_type_t;
 
struct lws_dir_entry {
        const char *name;
        lws_dir_obj_type_t type;
};
 
typedef int
lws_dir_callback_function(const char *dirpath, void *user,
                          struct lws_dir_entry *lde);
 
LWS_VISIBLE LWS_EXTERN int
lws_dir(const char *dirpath, void *user, lws_dir_callback_function cb);
#endif
 
size_t lws_get_allocated_heap(void);
 
LWS_VISIBLE LWS_EXTERN int
lws_is_ssl(struct lws *wsi);
LWS_VISIBLE LWS_EXTERN int
lws_is_cgi(struct lws *wsi);
 
LWS_VISIBLE LWS_EXTERN int
lws_open(const char *__file, int __oflag, ...);
 
struct lws_wifi_scan { /* generic wlan scan item */
        struct lws_wifi_scan *next;
        char ssid[32];
        int32_t rssi; /* divide by .count to get db */
        uint8_t bssid[6];
        uint8_t count;
        uint8_t channel;
        uint8_t authmode;
};
 
#if defined(LWS_WITH_TLS) && !defined(LWS_WITH_MBEDTLS)
LWS_VISIBLE LWS_EXTERN SSL*
lws_get_ssl(struct lws *wsi);
#endif
 
LWS_VISIBLE LWS_EXTERN void
lws_explicit_bzero(void *p, size_t len);
 
typedef struct lws_humanize_unit {
        const char *name; /* array ends with NULL name */
        uint64_t factor;
} lws_humanize_unit_t;
 
LWS_VISIBLE LWS_EXTERN const lws_humanize_unit_t humanize_schema_si[7];
LWS_VISIBLE LWS_EXTERN const lws_humanize_unit_t humanize_schema_si_bytes[7];
LWS_VISIBLE LWS_EXTERN const lws_humanize_unit_t humanize_schema_us[8];
 
LWS_VISIBLE LWS_EXTERN int
lws_humanize(char *buf, int len, uint64_t value,
             const lws_humanize_unit_t *schema);