react-native-real-time-nitro 1.7.0 → 1.8.0

package/3rdparty/output/android/libwebsockets/arm64-v8a/include/everest/kremlin/c_endianness.h

@@ -7,6 +7,8 @@
 #include <string.h>
 #include <inttypes.h>
 
+#include "kremlin/internal/callconv.h"
+
 /******************************************************************************/
 /* Implementing C.fst (part 2: endian-ness macros)                            */
 /******************************************************************************/

package/3rdparty/output/android/libwebsockets/arm64-v8a/include/everest/kremlin/internal/callconv.h

@@ -27,8 +27,10 @@
 /* Since KreMLin emits the inline keyword unconditionally, we follow the
  * guidelines at https://gcc.gnu.org/onlinedocs/gcc/Inline.html and make this
  * __inline__ to ensure the code compiles with -std=c90 and earlier. */
-#ifdef __GNUC__
+#if defined(__GNUC__)
 #  define inline __inline__
+#elif defined(_MSC_VER)
+#  define inline __inline
 #endif
 
 /* GCC-specific attribute syntax; everyone else gets the standard C inline

package/3rdparty/output/android/libwebsockets/arm64-v8a/include/libwebsockets/lws-adopt.h

@@ -47,6 +47,7 @@
  */
 LWS_VISIBLE LWS_EXTERN struct lws *
 lws_adopt_socket(struct lws_context *context, lws_sockfd_type accept_fd);
+
 /**
  * lws_adopt_socket_vhost() - adopt foreign socket as if listen socket accepted
  * it for vhost
@@ -146,13 +147,20 @@ lws_adopt_descriptor_vhost(struct lws_vhost *vh, lws_adoption_type type,
 			   struct lws *parent);
 
 typedef struct lws_adopt_desc {
-	struct lws_vhost *vh;		/**< vhost the wsi should belong to */
-	lws_adoption_type type;		/**< OR-ed combinations of lws_adoption_type flags */
-	lws_sock_file_fd_type fd;	/**< union with either .sockfd or .filefd set */
-	const char *vh_prot_name;	/**< NULL or vh protocol name to bind raw connection to */
-	struct lws *parent;		/**< NULL or struct lws to attach new_wsi to as a child */
-	void *opaque;			/**< opaque pointer to set on created wsi */
-	const char *fi_wsi_name;	/**< NULL, or Fault Injection inheritence filter for wsi=string/ context faults */
+	struct lws_vhost	*vh;		/**< vhost the wsi should belong to */
+	lws_adoption_type	type;		/**< OR-ed combinations of
+						 * lws_adoption_type flags */
+	lws_sock_file_fd_type	fd;		/**< union with either .sockfd
+						 * or .filefd set */
+	const char		*vh_prot_name;	/**< NULL or vh protocol name to
+						 * bind raw connection to */
+	struct lws		*parent; 	/**< NULL or struct lws to
+						 * attach new_wsi to as a child */
+	void			*opaque;	/**< opaque pointer to set on
+						 *created wsi */
+	const char		*fi_wsi_name;	/**< NULL, or Fault Injection
+						 * inheritence filter for
+						 * wsi=string/ context faults */
 } lws_adopt_desc_t;
 
 /**

package/3rdparty/output/android/libwebsockets/arm64-v8a/include/libwebsockets/lws-async-dns.h

@@ -22,7 +22,7 @@
  * IN THE SOFTWARE.
  */
 
-#if defined(LWS_WITH_UDP)
+#if defined(LWS_WITH_UDP) && defined(LWS_WITH_NETWORK)
 
 typedef enum dns_query_type {
 	LWS_ADNS_RECORD_A					= 0x01,
@@ -40,11 +40,17 @@ typedef enum {
 	LADNS_RET_CONTINUING
 } lws_async_dns_retcode_t;
 
+#define LWS_ADNS_SYNTHETIC	0x10000	/* don't send, synthetic response will
+					 * be injected for testing */
+
 struct addrinfo;
 
 typedef struct lws * (*lws_async_dns_cb_t)(struct lws *wsi, const char *ads,
 		const struct addrinfo *result, int n, void *opaque);
 
+struct lws_adns_q;
+struct lws_async_dns;
+
 /**
  * lws_async_dns_query() - perform a dns lookup using async dns
  *
@@ -54,6 +60,7 @@ typedef struct lws * (*lws_async_dns_cb_t)(struct lws *wsi, const char *ads,
  * \param qtype: type of query (A, AAAA etc)
  * \param cb: query completion callback
  * \param wsi: wsi if the query is related to one
+ * \param pq: NULL, or pointer to lws_adns_q query (used for testing)
  *
  * Starts an asynchronous DNS lookup, on completion the \p cb callback will
  * be called.
@@ -68,7 +75,7 @@ typedef struct lws * (*lws_async_dns_cb_t)(struct lws *wsi, const char *ads,
 LWS_VISIBLE LWS_EXTERN lws_async_dns_retcode_t
 lws_async_dns_query(struct lws_context *context, int tsi, const char *name,
 		    adns_query_type_t qtype, lws_async_dns_cb_t cb,
-		    struct lws *wsi, void *opaque);
+		    struct lws *wsi, void *opaque, struct lws_adns_q **pq);
 
 /**
  * lws_async_dns_freeaddrinfo() - decrement refcount on cached addrinfo results
@@ -83,4 +90,41 @@ lws_async_dns_query(struct lws_context *context, int tsi, const char *name,
 LWS_VISIBLE LWS_EXTERN void
 lws_async_dns_freeaddrinfo(const struct addrinfo **ai);
 
+/**
+ * lws_async_dns_server_add() - add a DNS server to the lws async DNS list
+ *
+ * \param cx: the lws_context
+ * \param sa46: the ipv4 or ipv6 DNS server address to add
+ *
+ * Adds the given DNS server to the lws list of async DNS servers to query.
+ * If the address is already listed, its refcount is increased, otherwise a new
+ * entry is made.
+ */
+LWS_VISIBLE LWS_EXTERN int
+lws_async_dns_server_add(struct lws_context *cx, const lws_sockaddr46 *sa46);
+
+/**
+ * lws_async_dns_server_remove() - remove a DNS server from the lws async DNS list
+ *
+ * \param cx: the lws_context
+ * \param sa46: the ipv4 or ipv6 DNS server address to add
+ *
+ * Removes the given DNS server from the lws list of async DNS servers to query.
+ * If the address does not correspond to an existing entry, no action is taken.
+ * If it does, the refcount on it is decremented, and if it reaches zero, the
+ * entry is detached from the list and destroyed.
+ */
+LWS_VISIBLE LWS_EXTERN void
+lws_async_dns_server_remove(struct lws_context *cx, const lws_sockaddr46 *sa46);
+
+/* only needed for testing */
+
+LWS_VISIBLE LWS_EXTERN uint16_t
+lws_adns_get_tid(struct lws_adns_q *q);
+LWS_VISIBLE LWS_EXTERN struct lws_async_dns *
+lws_adns_get_async_dns(struct lws_adns_q *q);
+
+LWS_VISIBLE LWS_EXTERN void
+lws_adns_parse_udp(struct lws_async_dns *dns, const uint8_t *pkt, size_t len);
+
 #endif

package/3rdparty/output/android/libwebsockets/arm64-v8a/include/libwebsockets/lws-backtrace.h

@@ -0,0 +1,280 @@
+/*
+ * libwebsockets - small server side websockets and web server implementation
+ *
+ * Copyright (C) 2010 - 2022 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.
+ */
+
+/** \defgroup lws_backtrace generic and compressed backtrace acquisition
+ * ##Backtrace apis
+ * \ingroup lwsbacktrace
+ *
+ * lws_backtrace
+ *
+ * These apis abstract acquisition and optionally compressed on binary back-
+ * traces, effectively build-specific signatures for where in the code you are
+ * and how you got there.
+ */
+//@{
+
+typedef struct {
+	uintptr_t	st[32];
+	uintptr_t	asize;
+
+	uint8_t		sp;
+	uint8_t		pre;
+	uint8_t		post;
+} lws_backtrace_info_t;
+
+typedef struct {
+	uint8_t		*comp;
+	size_t		pos;
+	size_t		len;
+} lws_backtrace_comp_t;
+
+/*
+ * lws_backtrace() - init and fiull a backtrace struct
+ *
+ * \param si: the backtrace struct to populate
+ * \param pre: the number of call levels to snip from the top
+ * \param post: the number of call levels to snip from the bottom
+ *
+ * This describes the call stack into \p si.  \p si doesn't need preparing
+ * before the call.  \p pre levels of the call stack at the top will be snipped,
+ * this will usually want to be 1 or 2 to conceal the helpers that are making
+ * the call stack, such as lws_backtrace itself.
+ *
+ * \p post levels of the call stack at the bottom will be snipped, this is to
+ * conceal loaders or other machinery that was used to start your application,
+ * otherwise those entries will bloat all call stacks results on that platform.
+ *
+ * Returns 0 for success.
+ */
+LWS_VISIBLE LWS_EXTERN int
+lws_backtrace(lws_backtrace_info_t *si, uint8_t pre, uint8_t post);
+
+/*
+ * lws_backtrace_compression_stream_init() - init and fiull a backtrace struct
+ *
+ * \param c: the backtrace compression struct
+ * \param comp: the buffer to take the compressed bytes
+ * \param comp_len: the number of bytes available at \p comp
+ *
+ * This initializes the caller's lws_backtrace_comp_t.  Because it's expected
+ * the caller will want to put his own compressed data after the compressed
+ * backtrace, he is responsible for the compression context.
+ */
+LWS_VISIBLE LWS_EXTERN void
+lws_backtrace_compression_stream_init(lws_backtrace_comp_t *c,
+				      uint8_t *comp, size_t comp_len);
+
+/*
+ * lws_backtrace_compression_stream() - add bitfields to compression stream
+ *
+ * \param c: the backtrace compression context struct
+ * \param v: the bitfield to add to the stream
+ * \param bits: the number of bits of v to add
+ *
+ * This inserts bits from the LSB end of v to the compression stream.
+ *
+ * This is used by the backtrace compression, user code can use this to add
+ * its own bitfields into the compression stream after the compressed backtrace.
+ *
+ * User data should be added after, so that the backtrace can be processed even
+ * if the additional data is not understood by the processing script.
+ *
+ * Returns 0 for success or nonzero if ran out of compression output buffer.
+ */
+LWS_VISIBLE LWS_EXTERN int
+lws_backtrace_compression_stream(lws_backtrace_comp_t *c, uintptr_t v,
+				 unsigned int bits);
+
+/*
+ * lws_backtrace_compression_destream() - add bitfields to compression stream
+ *
+ * \param c: the backtrace compression context struct
+ * \param _v: pointer to take the bitfield result
+ * \param bits: the number of bits to bring out into _v
+ *
+ * This reads the compression stream and creates a bitfield from it in \p _v.
+ *
+ * Returns 0 for success (with \p _v set to the value), or nonzero if ran out
+ * of compression output buffer.
+ */
+LWS_VISIBLE LWS_EXTERN int
+lws_backtrace_compression_destream(lws_backtrace_comp_t *c, uintptr_t *_v,
+				   unsigned int bits);
+
+/*
+ * lws_backtrace_compress_backtrace() - compress backtrace si into c
+ *
+ * \param si: the backtrace struct to compress
+ * \param c: the backtrace compression context struct
+ *
+ * This compresses backtrace information acquired in \p si into the compression
+ * context \p c.  It compresses first the call stack length and then each IP
+ * address in turn.
+ *
+ * Returns 0 for success.
+ */
+LWS_VISIBLE LWS_EXTERN int
+lws_backtrace_compress_backtrace(lws_backtrace_info_t *si,
+				 lws_backtrace_comp_t *c);
+
+//@}
+
+/** \defgroup lws_alloc_metadata helpers for allocator instrumentation
+ * ##Alloc Metadata APIs
+ * \ingroup lwsallocmetadata
+ *
+ * lws_alloc_metadata
+ *
+ * These helpers let you rapidly instrument your libc or platform memory
+ * allocator so that you can later dump details, including a backtrace of where
+ * the allocation was made, for every live heap allocation.
+ *
+ * You would use it at peak memory usage, to audit who is using what at that
+ * time.
+ *
+ * Effective compression is used to keep the metadata overhead to ~48 bytes
+ * per active allocation on 32-bit systems.
+ */
+//@{
+
+/**
+ * lws_alloc_metadata_gen() - generate metadata blob (with compressed backtrace)
+ *
+ * \param size: the allocation size
+ * \param comp: buffer for compressed backtrace
+ * \param comp_len: number of bytes available in the compressed backtrace
+ * \param adj: takes the count of additional bytes needed for metadata behind
+ *             the allocation we tell the user about
+ * \param cl: takes the count of bytes used in comp
+ *
+ * This helper creates the compressed part of the alloc metadata blob and
+ * calculates the total overallocation that is needed in \p adj.
+ *
+ * This doesn't need any locking.
+ *
+ * If \p comp_len is too small for the whole result, or it was not possible to
+ * get the backtrace information, the compressed part is set to empty (total
+ * length 2 to carry the 00 00 length).
+ *
+ * 6 or 10 (64-bit) bytes per backtrace IP allowed (currently 16) should always
+ * be enough, typically the compression reduces this very significantly.
+ */
+LWS_VISIBLE LWS_EXTERN void
+lws_alloc_metadata_gen(size_t size, uint8_t *comp, size_t comp_len, size_t *adj,
+								size_t *cl);
+
+/**
+ * _lws_alloc_metadata_adjust() - helper to inject metadata and list as active
+ *
+ * \param active: the allocation owner
+ * \param v: Original, true allocation pointer, adjusted on exit
+ * \param adj: Total size of metadata overallocation
+ * \param comp: The compressed metadata
+ * \param cl: takes the count of bytes used in comp
+ *
+ * THIS MUST BE LOCKED BY THE CALLER IF YOUR ALLOCATOR MAY BE CALLED BY OTHER
+ * THREADS.  You can call it from an existing mutex or similar -protected
+ * critical section in your allocator if there is one already, or you will have
+ * to protect the caller of it with your own mutex so it cannot reenter.
+ *
+ * This is a helper that adjusts the allocation past the metadata part so the
+ * caller of the allocator using this sees what he asked for.  The deallocator
+ * must call _lws_alloc_metadata_trim() to balance this before actual
+ * deallocation.
+ */
+LWS_VISIBLE LWS_EXTERN void
+_lws_alloc_metadata_adjust(lws_dll2_owner_t *active, void **v, size_t adj, uint8_t *comp, unsigned int cl);
+
+/**
+ * _lws_alloc_metadata_trim() - helper to trim metadata and remove from active
+ *
+ * \param ptr: Adjusted allocation pointer on entry, true allocation ptr on exit
+ * \param comp: NULL, or set on exit to point to start of compressed area
+ * \param complen: NULL, or set on exit to length of compressed area in bytes
+ *
+ * THIS MUST BE LOCKED BY THE CALLER IF YOUR DEALLOCATOR MAY BE CALLED BY OTHER
+ * THREADS.  You can call it from an existing mutex or similar -protected
+ * critical section in your deallocator if there is one already, or you will
+ * have to protect that caller of it with your own mutex so it cannot reenter.
+ */
+LWS_VISIBLE LWS_EXTERN void
+_lws_alloc_metadata_trim(void **ptr, uint8_t **comp, uint16_t *complen);
+
+/**
+ * lws_alloc_metadata_parse() - parse compressed metadata into struct
+ *
+ * \param si: Struct to take the backtrace results from decompression
+ * \param adjusted_alloc: pointer to adjusted, user allocation start
+ *
+ * This api parses and decompresses the blob behind the \p adjusted_alloc
+ * address into \p si.
+ *
+ * Returns 0 for success.
+ */
+LWS_VISIBLE LWS_EXTERN int
+lws_alloc_metadata_parse(lws_backtrace_info_t *si, const uint8_t *adjusted_alloc);
+
+/**
+ * lws_alloc_metadata_dump_stdout() - helper to print base64 blob on stdout
+ *
+ * \param d: the current list item
+ * \param user: the optional arg given to the dump api (ignored)
+ *
+ * Generic helper that can be given to _lws_alloc_metadata_dump() as the
+ * callback that will emit a standardized base64 blob for the alloc metadata
+ */
+LWS_VISIBLE LWS_EXTERN int
+lws_alloc_metadata_dump_stdout(struct lws_dll2 *d, void *user);
+
+/**
+ * lws_alloc_metadata_dump_stdout() - dump all live allocs in instrumented heap
+ *
+ * \param active: the owner of the active allocation list for this heap
+ * \param cb: the callback to receive information
+ * \param arg: optional arg devivered to the callback
+ *
+ * THIS MUST BE LOCKED BY THE CALLER IF YOUR ALLOCATOR MAY BE CALLED BY OTHER
+ * THREADS.  You can call it from an existing mutex or similar -protected
+ * critical section in your allocator if there is one already, or you will have
+ * to protect the caller of it with your own mutex so it cannot reenter.
+ *
+ * Iterates through the list of instrumented allocations calling the given
+ * callback for each one.
+ */
+LWS_VISIBLE LWS_EXTERN void
+_lws_alloc_metadata_dump(lws_dll2_owner_t *active, lws_dll2_foreach_cb_t cb,
+			 void *arg);
+
+#if defined(LWS_WITH_ALLOC_METADATA_LWS)
+/*
+ * Wrapper for _lws_alloc_metadata_dump() that uses the list owner that tracks
+ *
+ */
+LWS_VISIBLE LWS_EXTERN void
+_lws_alloc_metadata_dump_lws(lws_dll2_foreach_cb_t cb, void *arg);
+#else
+#define _lws_alloc_metadata_dump_lws(_a, _b)
+#endif
+
+//@}

package/3rdparty/output/android/libwebsockets/arm64-v8a/include/libwebsockets/lws-bb-spi.h

@@ -48,6 +48,8 @@ typedef struct lws_bb_spi {
 	_lws_plat_gpio_t	mosi;
 	_lws_plat_gpio_t	miso;
 
+	uint8_t			unit;
+
 	uint8_t			flags;
 } lws_bb_spi_t;
 

package/3rdparty/output/android/libwebsockets/arm64-v8a/include/libwebsockets/lws-cgi.h

@@ -58,7 +58,33 @@ struct lws_cgi_args {
 	int len; /**< length */
 };
 
+/** struct lws_cgi_info - parameters to spawn network-connected cgi
+ *                        process when using lws_cgi_via_info() */
+struct lws_cgi_info {
+	struct lws *wsi;
+	/**< connection to own the process */
+	const char * const *exec_array;
+	/**< array of "exec-name" "arg1" ... "argn" NULL */
+	int script_uri_path_len;
+	/**< how many chars on the left of the uri are the path to the
+	 * cgi, or -1 to spawn without URL-related env vars */
+	int timeout_secs;
+	/**< seconds script should be allowed to run */
+	const struct lws_protocol_vhost_options *mp_cgienv;
+	/**< pvo list with per-vhost cgi options to put in env */
+	const char *chroot_path;
+	/**< NULL, or chroot patch for child process */
+	const char *wd;
+	/**< working directory to cd to after fork, NULL defaults to /tmp */
+};
+
 #ifdef LWS_WITH_CGI
+/**
+ * lws_cgi_via_info() - Spawn network-connected cgi process
+ * \param cgiinfo: pointer to lws_cgi_info struct
+ */
+LWS_VISIBLE LWS_EXTERN int lws_cgi_via_info(struct lws_cgi_info * cgiinfo);
+
 /**
  * lws_cgi: spawn network-connected cgi process
  *

package/3rdparty/output/android/libwebsockets/arm64-v8a/include/libwebsockets/lws-client.h

@@ -48,6 +48,18 @@ enum lws_client_connect_ssl_connection_flags {
 	LCCSCF_HTTP_MULTIPART_MIME		= (1 << 10),
 	LCCSCF_HTTP_X_WWW_FORM_URLENCODED	= (1 << 11),
 	LCCSCF_HTTP_NO_FOLLOW_REDIRECT		= (1 << 12),
+	LCCSCF_HTTP_NO_CACHE_CONTROL		= (1 << 13),
+
+	LCCSCF_ALLOW_REUSE_ADDR				= (1 << 14),
+	/**< allow reuse local addresses in a bind call
+	 * When the listening socket is bound to INADDR_ANY with a specific port 
+	 * then it is not possible to bind to this port for any local address
+	 */
+
+	LCCSCF_IPV6_PREFER_PUBLIC_ADDR				= (1 << 15),
+	/**< RFC5014 - For IPv6 systems with SLAAC config, allow for preference
+	 * to bind a socket to public address vs temporary private address
+	 */
 
 	LCCSCF_PIPELINE				= (1 << 16),
 		/**< Serialize / pipeline multiple client connections
@@ -158,6 +170,9 @@ struct lws_client_connect_info {
 	const char *iface;
 	/**< NULL to allow routing on any interface, or interface name or IP
 	 * to bind the socket to */
+	int local_port;
+	/**< 0 to pick an ephemeral port, or a specific local port
+	 * to bind the socket to */
 	const char *local_protocol_name;
 	/**< NULL: .protocol is used both to select the local protocol handler
 	 *         to bind to and as the list of remote ws protocols we could
@@ -172,11 +187,6 @@ struct lws_client_connect_info {
 	 *           tokens
 	 */
 
-	struct lws_sequencer *seq;
-	/**< NULL, or an lws_seq_t that wants to be given messages about
-	 * this wsi's lifecycle as it connects, errors or closes.
-	 */
-
 	void *opaque_user_data;
 	/**< This data has no meaning to lws but is applied to the client wsi
 	 *   and can be retrieved by user code with lws_get_opaque_user_data().
@@ -234,6 +244,20 @@ struct lws_client_connect_info {
 	 * context template to take a copy of for this wsi.  Used to isolate
 	 * wsi-specific logs into their own stream or file.
 	 */
+	const char *auth_username;
+	const char *auth_password;
+
+#if defined(LWS_ROLE_WS)
+	uint8_t		allow_reserved_bits;
+	/**< non-zero to allow reserved bits. You can get it by lws_get_reserved_bits().
+	 * Note: default zero means close the websocket connection for non-zero rsv.
+	 */
+
+	uint8_t		allow_unknown_opcode;
+	/**< non-zero to allow unknown opcode. You can get it by `lws_get_opcode`.
+	 * None: default zero means close the websocket connection for unknown opcode.
+	 */
+#endif
 
 	/* Add new things just above here ---^
 	 * This is part of the ABI, don't needlessly break compatibility
@@ -372,12 +396,58 @@ lws_client_http_body_pending(struct lws *wsi, int something_left_to_send);
  * This issues a multipart mime boundary, or terminator if name = NULL.
  *
  * Returns 0 if OK or nonzero if couldn't fit in buffer
+ *
+ * This is deprecated in favour of the below lws_http_mp apis
  */
 LWS_VISIBLE LWS_EXTERN int
 lws_client_http_multipart(struct lws *wsi, const char *name,
 			  const char *filename, const char *content_type,
 			  char **p, char *end);
 
+struct lws_http_mp_sm;
+typedef int (*lws_http_mp_sm_cb_t)(struct lws_context *cx, char *ft, size_t ft_len, const char **last);
+
+/**
+ * lws_http_mp_sm_init() - allocate and init an http post multipart state machine
+ *
+ * \p wsi: the wsi this will be used on
+ * \p cb: the http_mp callback for getting next form item
+ * \p p: pointer to pointer to next header byte
+ * \p end: pointer to last possible header byte
+ *
+ * Returns a new and initialized multipart post state machine object,
+ * or NULL if OOM or other problems.
+ */
+LWS_VISIBLE LWS_EXTERN struct lws_http_mp_sm *
+lws_http_mp_sm_init(struct lws *wsi, lws_http_mp_sm_cb_t cb, uint8_t **p, uint8_t *end);
+
+/**
+ * lws_http_mp_sm_destroy() - deallocates an http post multipart state machine
+ *
+ * \p pphms: pointer to http_mp_sm pointer
+ *
+ * Frees and sets the pointed-to pointer to NULL.
+ */
+LWS_VISIBLE LWS_EXTERN void
+lws_http_mp_sm_destroy(struct lws_http_mp_sm **pphms);
+
+/**
+ * lws_http_mp_sm_fill() - fills a buffer with the next fragment of form data
+ *
+ * \p phms: pointer to http_mp_sm
+ * \p p: cursor into buffer - moved on by call
+ * \p end: last byte of buffer
+ *
+ * Fills \p *p potentially to \p end with form data, and moves
+ * *p on by the amount used.
+ *
+ * Returns 0 if successful (and *p has been moved on to show the extent
+ * of the written amount) or nonzero for failure
+ */
+LWS_VISIBLE LWS_EXTERN int
+lws_http_mp_sm_fill(struct lws_http_mp_sm *phms, uint8_t **p, uint8_t *end);
+
+
 /**
  * lws_http_basic_auth_gen() - helper to encode client basic auth string
  *
@@ -393,6 +463,26 @@ lws_client_http_multipart(struct lws *wsi, const char *name,
 LWS_VISIBLE LWS_EXTERN int
 lws_http_basic_auth_gen(const char *user, const char *pw, char *buf, size_t len);
 
+/**
+ * lws_http_basic_auth_gen2() - helper to encode client basic auth string
+ *
+ * \param user: user name
+ * \param pw: password
+ * \param pwd_len: count of bytes in password
+ * \param buf: where to store base64 result
+ * \param len: max usable size of buf
+ *
+ * Encodes a username and password in Basic Auth format for use with the
+ * Authorization header.  On return, buf is filled with something like
+ * "Basic QWxhZGRpbjpPcGVuU2VzYW1l".
+ *
+ * This differs from lws_http_baic_auth_gen() in that NUL bytes can
+ * appear in the password due to an explicit password length argument.
+ */
+LWS_VISIBLE LWS_EXTERN int
+lws_http_basic_auth_gen2(const char *user, const void *pw, size_t pwd_len,
+                         char *buf, size_t len);
+
 /**
  * lws_tls_session_is_reused() - returns nonzero if tls session was cached
  *