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

package/3rdparty/output/android/libwebsockets/x86/include/psa/crypto_values.h

@@ -279,6 +279,11 @@
  * to read from a resource. */
 #define PSA_ERROR_INSUFFICIENT_DATA     ((psa_status_t)-143)
 
+/** This can be returned if a function can no longer operate correctly.
+ * For example, if an essential initialization operation failed or
+ * a mutex operation failed. */
+#define PSA_ERROR_SERVICE_FAILURE       ((psa_status_t)-144)
+
 /** The key identifier is not valid. See also :ref:\`key-handles\`.
  */
 #define PSA_ERROR_INVALID_HANDLE        ((psa_status_t)-136)
@@ -408,7 +413,7 @@
     ((type) | PSA_KEY_TYPE_CATEGORY_FLAG_PAIR)
 /** The public key type corresponding to a key pair type.
  *
- * You may also pass a key pair type as \p type, it will be left unchanged.
+ * You may also pass a public key type as \p type, it will be left unchanged.
  *
  * \param type      A public key type or key pair type.
  *
@@ -594,19 +599,23 @@
  * They are defined in _Standards for Efficient Cryptography_,
  * _SEC 2: Recommended Elliptic Curve Domain Parameters_.
  * https://www.secg.org/sec2-v2.pdf
+ *
+ * \note For secp224k1, the bit-size is 225 (size of a private value).
+ *
+ * \note Mbed TLS only supports secp192k1 and secp256k1.
  */
 #define PSA_ECC_FAMILY_SECP_K1           ((psa_ecc_family_t) 0x17)
 
 /** SEC random curves over prime fields.
  *
  * This family comprises the following curves:
- * secp192k1, secp224r1, secp256r1, secp384r1, secp521r1.
+ * secp192r1, secp224r1, secp256r1, secp384r1, secp521r1.
  * They are defined in _Standards for Efficient Cryptography_,
  * _SEC 2: Recommended Elliptic Curve Domain Parameters_.
  * https://www.secg.org/sec2-v2.pdf
  */
 #define PSA_ECC_FAMILY_SECP_R1           ((psa_ecc_family_t) 0x12)
-/* SECP160R2 (SEC2 v1, obsolete) */
+/* SECP160R2 (SEC2 v1, obsolete, not supported in Mbed TLS) */
 #define PSA_ECC_FAMILY_SECP_R2           ((psa_ecc_family_t) 0x1b)
 
 /** SEC Koblitz curves over binary fields.
@@ -616,6 +625,8 @@
  * They are defined in _Standards for Efficient Cryptography_,
  * _SEC 2: Recommended Elliptic Curve Domain Parameters_.
  * https://www.secg.org/sec2-v2.pdf
+ *
+ * \note Mbed TLS does not support any curve in this family.
  */
 #define PSA_ECC_FAMILY_SECT_K1           ((psa_ecc_family_t) 0x27)
 
@@ -626,6 +637,8 @@
  * They are defined in _Standards for Efficient Cryptography_,
  * _SEC 2: Recommended Elliptic Curve Domain Parameters_.
  * https://www.secg.org/sec2-v2.pdf
+ *
+ * \note Mbed TLS does not support any curve in this family.
  */
 #define PSA_ECC_FAMILY_SECT_R1           ((psa_ecc_family_t) 0x22)
 
@@ -636,6 +649,8 @@
  * It is defined in _Standards for Efficient Cryptography_,
  * _SEC 2: Recommended Elliptic Curve Domain Parameters_.
  * https://www.secg.org/sec2-v2.pdf
+ *
+ * \note Mbed TLS does not support any curve in this family.
  */
 #define PSA_ECC_FAMILY_SECT_R2           ((psa_ecc_family_t) 0x2b)
 
@@ -645,6 +660,9 @@
  * brainpoolP160r1, brainpoolP192r1, brainpoolP224r1, brainpoolP256r1,
  * brainpoolP320r1, brainpoolP384r1, brainpoolP512r1.
  * It is defined in RFC 5639.
+ *
+ * \note Mbed TLS only supports the 256-bit, 384-bit and 512-bit curves
+ *       in this family.
  */
 #define PSA_ECC_FAMILY_BRAINPOOL_P_R1    ((psa_ecc_family_t) 0x30)
 
@@ -673,6 +691,8 @@
  * - 448-bit: Edwards448, the twisted Edwards curve birationally equivalent
  *   to Curve448.
  *   Hamburg, _Ed448-Goldilocks, a new elliptic curve_, NIST ECC Workshop, 2015.
+ *
+ * \note Mbed TLS does not support Edwards curves yet.
  */
 #define PSA_ECC_FAMILY_TWISTED_EDWARDS   ((psa_ecc_family_t) 0x42)
 

package/3rdparty/output/android/libwebsockets/x86/lib/cmake/libwebsockets/LwsCheckRequirements.cmake

@@ -29,10 +29,12 @@ MACRO(require_lws_config reqconfig _val result)
 
 	# we go in the first clause if in-tree
 	if (LWS_WITH_MINIMAL_EXAMPLES AND NOT ${SAME})
-		if (${_val})
-			message("${SAMP}: skipping as lws being built without ${reqconfig}")
-		else()
-			message("${SAMP}: skipping as lws built with ${reqconfig}")
+               if (${result} EQUAL "requirements")
+                       if (${_val})
+                               message("${SAMP}: skipping as lws being built without ${reqconfig} (${_val} / ${rq})")
+                       else()
+                               message("${SAMP}: skipping as lws built with ${reqconfig} (${_val} / ${rq})")
+                       endif()
 		endif()
 		set(${result} 0)
 	else()

package/3rdparty/output/android/libwebsockets/x86/lib/cmake/libwebsockets/libwebsockets-config-version.cmake

@@ -1,4 +1,4 @@
-set(PACKAGE_VERSION "4.3.3-v4.3.3")
+set(PACKAGE_VERSION "4.5.2-v4.5.2")
 
 # Check whether the requested PACKAGE_FIND_VERSION is compatible
 if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}")

package/3rdparty/output/android/libwebsockets/x86/lib/cmake/libwebsockets/libwebsockets-config.cmake

@@ -11,7 +11,10 @@ list(APPEND CMAKE_MODULE_PATH ${libwebsockets_DIR})
 set(LIBWEBSOCKETS_INCLUDE_DIRS "${LWS_CMAKE_DIR}/../../../include" "/Volumes/my-disk/Work/my-project/react-native-real-time-nitro/3rdparty/build/android/x86/mbedtls-install/include;/Volumes/my-disk/Work/my-project/react-native-real-time-nitro/3rdparty/build/android/x86/mbedtls-install/include/mbedtls")
 
 # Include the project Targets file, this contains definitions for IMPORTED targets.
+if (LIB_LIST_AT_END)
+else()
 include(${LWS_CMAKE_DIR}/LibwebsocketsTargets.cmake)
+endif()
 include(${LWS_CMAKE_DIR}/LwsCheckRequirements.cmake)
 
 # IMPORTED targets from LibwebsocketsTargets.cmake

package/3rdparty/output/android/libwebsockets/x86/lib/pkgconfig/libwebsockets.pc

@@ -5,7 +5,7 @@ includedir=${prefix}/include
 
 Name: libwebsockets
 Description: Websockets server and client library
-Version: 4.3.3-v4.3.3
+Version: 4.5.2-v4.5.2
 
 Libs: -L${libdir} -lwebsockets
 Cflags: -I${includedir}

package/3rdparty/output/android/libwebsockets/x86/lib/pkgconfig/libwebsockets_static.pc

@@ -5,7 +5,7 @@ includedir=${prefix}/include
 
 Name: libwebsockets_static
 Description: Websockets server and client static library
-Version: 4.3.3-v4.3.3
+Version: 4.5.2-v4.5.2
 
 Libs: -L${libdir} -l:libwebsockets.a
 Libs.private:

package/3rdparty/output/android/libwebsockets/x86_64/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/x86_64/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/x86_64/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/x86_64/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/x86_64/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/x86_64/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/x86_64/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
  *