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

package/3rdparty/output/android/libwebsockets/x86_64/include/libwebsockets/lws-misc.h

@@ -136,7 +136,7 @@ lws_buflist_linear_use(struct lws_buflist **head, uint8_t *buf, size_t len);
  * lws_buflist_fragment_use(): copy and consume <= 1 frag from buflist head
  *
  * \param head: list head
- * \param buf: buffer to copy linearly into
+ * \param buf: NULL, buffer to copy linearly into
  * \param len: length of buffer available
  * \param frag_first: pointer to char written on exit to if this is start of frag
  * \param frag_fin: pointer to char written on exit to if this is end of frag
@@ -148,6 +148,10 @@ lws_buflist_linear_use(struct lws_buflist **head, uint8_t *buf, size_t len);
  * Since it was consumed, calling again will resume copying out and consuming
  * from as far as it got the first time.
  *
+ * It's legal for buf to be NULL and / or len = 0.  In this case nothing is
+ * "used" and the effect is to set `frag_first` according to if we are at the
+ * start of the fragment and 0 is returned.
+ *
  * Returns the number of bytes written into \p buf.
  */
 LWS_VISIBLE LWS_EXTERN int
@@ -178,6 +182,140 @@ lws_buflist_destroy_all_segments(struct lws_buflist **head);
 LWS_VISIBLE LWS_EXTERN void
 lws_buflist_describe(struct lws_buflist **head, void *id, const char *reason);
 
+/**
+ * lws_buflist_get_frag_start_or_NULL(): get pointer to start of fragment
+ *
+ * \param head: list head
+ *
+ * This gets you a pointer to the start of the fragment payload, no matter
+ * how much of it you may have 'used' already.  This is useful for schemes
+ * where you prepend something to the payload and need to reference it no
+ * matter how much of it you have consumed or the fragmentation details.
+ *
+ * If the buflist is empty, it will return NULL.
+ */
+LWS_VISIBLE LWS_EXTERN void *
+lws_buflist_get_frag_start_or_NULL(struct lws_buflist **head);
+
+
+struct lws_wsmsg_info;
+
+typedef void (*lws_wsmsg_transfer_cb)(struct lws_wsmsg_info *info);
+
+typedef struct lws_wsmsg_info {
+	struct lws_buflist	**head_upstream;	/* the upstream buflist */
+       	struct lws_buflist	**private_heads;	/* the private reassembly heads */
+	int			private_source_idx;	/* which index to use in private_heads */
+	lws_wsmsg_transfer_cb	optional_cb;		/* optional transfer callback */
+	void			*opaque;		/* optional opaque pointer */
+       	const uint8_t		*buf;			/* array to add */
+       	size_t			len;			/* length of bytes in array */
+       	unsigned int		ss_flags;		/* SS flags for SOM / EOM */
+} lws_wsmsg_info_t;
+
+/**
+ * lws_wsmsg_append() - append to buflist via private buflists
+ *
+ * \param info: the info struct, filled in before calling
+ *
+ * This api allows you to pass incoming fragments through a private buflist
+ * until the message it contains is reassembled and complete.  At that point, if
+ * the upstream buflist is not blocked by being in the middle of a message itself,
+ * the fragments are added to the end of an upstream buflist and the private
+ * buflist left empty.
+ *
+ * As an optimization, if the upstream buflist is not blocked waiting for an EOM,
+ * the private buflist is empty, and the incoming data represents a complete
+ * message, then the incoming message is added directly to the upstream buflist.
+ *
+ * This method allows potentially many async connections with fragmented messages
+ * to contribute to a single buflist containing only complete messages.  It's
+ * not possible to add a partial message (without the EOM flag) to the upstream
+ * buflist; when all parts of it have arrived it will be added.
+ *
+ * An array of private buflists is supported so that messages from many different
+ * connections can be reassembled before moving to the upstream buflist.
+ *
+ * Optionally, instead of transfer to another buflist when the message is complete,
+ * if the optional_cb is provided, this is called instead with the info struct, so
+ * arbitrary operations can be performed by the user.
+ *
+ * The info->opaque pointer is not used by lws, it's there to facilitate passing
+ * related user parameters in the callback case.
+ */
+LWS_VISIBLE LWS_EXTERN int
+lws_wsmsg_append(lws_wsmsg_info_t *info);
+
+/*
+ * lws_wsmsg_destroy() - free all allocations in private buflists
+ *
+ * \param private_heads: the private buflists
+ * \param count_private_heads: the number of private buflists
+ */
+LWS_VISIBLE LWS_EXTERN void
+lws_wsmsg_destroy(struct lws_buflist *private_heads[], size_t count_private_heads);
+
+
+
+/*
+ * Optional helpers for closely-managed stream flow control.  These are useful
+ * when there is no memory for large rx buffers and instead tx credit is being
+ * used to regulate the server sending data.
+ *
+ * When combined with stateful consumption-on-demand, this can be very effective
+ * at managing data flows through restricted circumstances.  These helpers
+ * implement a golden implementation that can be bound to a stream in its priv
+ * data.
+ *
+ * The helper is sophisticated enough to contain a buflist to manage overflows
+ * on heap and preferentially drain it.  RX goes through heap to guarantee the
+ * consumer can exit cleanly at any time.
+ */
+
+enum {
+	LWSDLOFLOW_STATE_READ, /* default, we want input */
+	LWSDLOFLOW_STATE_READ_COMPLETED, /* we do not need further rx, every-
+					  * thing is locally buffered or used */
+	LWSDLOFLOW_STATE_READ_FAILED, /* operation has fatal error */
+};
+
+struct lws_ss_handle;
+
+typedef struct lws_flow {
+	lws_dll2_t			list;
+
+	struct lws_ss_handle		*h;
+	struct lws_buflist		*bl;
+
+	const uint8_t			*data;
+	size_t				len;		/* bytes left in data */
+	uint32_t			blseglen;	/* bytes issued */
+	int32_t				window;
+
+	uint8_t				state;
+} lws_flow_t;
+
+/**
+ * lws_flow_feed() - consume waiting data if ready for it
+ *
+ * \param flow: pointer to the flow struct managing waiting data
+ *
+ * This will bring out waiting data from the flow buflist when it is needed.
+ */
+LWS_VISIBLE LWS_EXTERN lws_stateful_ret_t
+lws_flow_feed(lws_flow_t *flow);
+
+/**
+ * lws_flow_req() - request remote data if we have run low
+ *
+ * \param flow: pointer to the flow struct managing waiting data
+ *
+ * When the estimated remote tx credit is below flow->window, accounting for
+ * what is in the buflist, add to the peer tx credit so it can send us more.
+ */
+LWS_VISIBLE LWS_EXTERN lws_stateful_ret_t
+lws_flow_req(lws_flow_t *flow);
+
 /**
  * lws_ptr_diff(): helper to report distance between pointers as an int
  *
@@ -289,6 +427,25 @@ lws_json_simple_find(const char *buf, size_t len, const char *name, size_t *alen
 LWS_VISIBLE LWS_EXTERN int
 lws_json_simple_strcmp(const char *buf, size_t len, const char *name, const char *comp);
 
+/**
+ * lws_hex_len_to_byte_array(): convert hex string like 0123456789ab into byte data
+ *
+ * \param h: incoming hex string
+ * \param hlen: number of chars to process at \p h
+ * \param dest: array to fill with binary decodes of hex pairs from h
+ * \param max: maximum number of bytes dest can hold, must be at least half
+ *		the size of strlen(h)
+ *
+ * This converts hex strings into an array of 8-bit representations, ie the
+ * input "abcd" produces two bytes of value 0xab and 0xcd.
+ *
+ * Returns number of bytes produced into \p dest, or -1 on error.
+ *
+ * Errors include non-hex chars and an odd count of hex chars in the input
+ * string.
+ */
+LWS_VISIBLE LWS_EXTERN int
+lws_hex_len_to_byte_array(const char *h, size_t hlen, uint8_t *dest, int max);
 
 /**
  * lws_hex_to_byte_array(): convert hex string like 0123456789ab into byte data
@@ -449,6 +606,8 @@ lws_parse_uri(char *p, const char **prot, const char **ads, int *port,
  *
  * Returns NULL if the string \p val is not found in the arguments.
  *
+ * This only returns the first hit for \p val.
+ *
  * If it is found, then it returns a pointer to the next character after \p val.
  * So if \p val is "-d", then for the commandlines "myapp -d15" and
  * "myapp -d 15", in both cases the return will point to the "15".
@@ -456,10 +615,101 @@ lws_parse_uri(char *p, const char **prot, const char **ads, int *port,
  * In the case there is no argument, like "myapp -d", the return will
  * either point to the '\\0' at the end of -d, or to the start of the
  * next argument, ie, will be non-NULL.
+ *
+ * This original api variant does not handle stdin-passed commandline content,
+ * only that present in the passed argc / argv.
  */
 LWS_VISIBLE LWS_EXTERN const char *
 lws_cmdline_option(int argc, const char **argv, const char *val);
 
+/**
+ * lws_cmdline_options():	simple commandline parser
+ *
+ * \param argc:		count of argument strings
+ * \param argv:		argument strings
+ * \param val:		string to find
+ * \param last:		last successful return from previous call
+ *
+ * Returns NULL if the string \p val is not found in the arguments.
+ *
+ * Before checking, the api aligns itself to the place of the \p last
+ * hit (or the beginning of the commandline if NULL), and starts checking
+ * from just beyond that.  In this way you can get the first, or
+ * incrementally get multiple results, for every hit.
+ *
+ * If a match is found, then it returns a pointer to the next character after \p val.
+ * So if \p val is "-d", then for the commandlines "myapp -d15" and
+ * "myapp -d 15", in both cases the return will point to the "15".
+ *
+ * In the case there is no argument, like "myapp -d", the return will
+ * either point to the '\\0' at the end of -d, or to the start of the
+ * next argument, ie, will be non-NULL indicating success.
+ *
+ * This original api variant does not handle stdin-passed commandline content,
+ * only that present in the passed argc / argv.
+ */
+LWS_VISIBLE LWS_EXTERN const char *
+lws_cmdline_options(int argc, const char * const *argv, const char *val, const char *last);
+
+/**
+ * lws_cmdline_options_cx():	simple commandline parser
+ *
+ * \param cx:		the lws_context
+ * \param val:		string to find
+ * \param last:		last successful return from previous call
+ *
+ * Returns NULL if the string \p val is not found in the arguments.
+ *
+ * Before checking, the api aligns itself to the place of the \p last
+ * hit (or the beginning of the commandline if NULL), and starts checking
+ * from just beyond that.  In this way you can get the first, or
+ * incrementally get multiple results, for every hit.
+ * 
+ * If a match is found, then it returns a pointer to the next character after \p val.
+ * So if \p val is "-d", then for the commandlines "myapp -d15" and
+ * "myapp -d 15", in both cases the return will point to the "15".
+ *
+ * In the case there is no argument, like "myapp -d", the return will
+ * either point to the '\\0' at the end of -d, or to the start of the
+ * next argument, ie, will be non-NULL indicating success.
+ *
+ * This api variant handles stdin-passed commandline content, placing it
+ * after the argc / argv content.  You must ensure the context creation
+ * info .argc and .argv were set to the application's main argc and argv,
+ * either manually or it is handled for you as a side-effect of calling
+ * lws_cmdline_option_handle_builtin().
+ */
+
+LWS_VISIBLE LWS_EXTERN const char *
+lws_cmdline_options_cx(const struct lws_context *cx, const char *val, const char *last);
+
+/**
+ * lws_cmdline_option_cx():	simple commandline parser
+ *
+ * \param cx:		the lws_context
+ * \param val:		string to find
+ *
+ * Returns NULL if the string \p val is not found in the arguments.
+ *
+ * This only returns the first hit for \p val.
+ *
+ * If a match is found, then it returns a pointer to the next character after \p val.
+ * So if \p val is "-d", then for the commandlines "myapp -d15" and
+ * "myapp -d 15", in both cases the return will point to the "15".
+ *
+ * In the case there is no argument, like "myapp -d", the return will
+ * either point to the '\\0' at the end of -d, or to the start of the
+ * next argument, ie, will be non-NULL indicating success.
+ *
+ * This api variant handles stdin-passed commandline content, placing it
+ * after the argc / argv content.  You must ensure the context creation
+ * info .argc and .argv were set to the application's main argc and argv,
+ * either manually or it is handled for you as a side-effect of calling
+ * lws_cmdline_option_handle_builtin().
+ */
+LWS_VISIBLE LWS_EXTERN const char *
+lws_cmdline_option_cx(const struct lws_context *cx, const char *val);
+
 /**
  * lws_cmdline_option_handle_builtin(): apply standard cmdline options
  *
@@ -684,8 +934,10 @@ lws_rx_flow_allow_all_protocol(const struct lws_context *context,
  * ws, it is legal to not know the length of the message before it completes.
  *
  * Additionally if the message is sent via the negotiated permessage-deflate
- * extension, this number only tells the amount of **compressed** data left to
- * be read, since that is the only information available at the ws layer.
+ * extension, zero is always reported.  You should use lws_is_final_fragment()
+ * to find out if you have completed the message... in compressed case, it holds
+ * back reporting the final fragment until it's also the final decompressed
+ * block issued.
  */
 LWS_VISIBLE LWS_EXTERN size_t
 lws_remaining_packet_payload(struct lws *wsi);
@@ -712,6 +964,13 @@ typedef int
 lws_dir_callback_function(const char *dirpath, void *user,
 			  struct lws_dir_entry *lde);
 
+struct lws_dir_info {
+	const char 			*dirpath;
+	void 				*user;
+	lws_dir_callback_function	*cb;
+	unsigned char			do_toplevel_cb:1;
+};
+
 /**
  * lws_dir() - get a callback for everything in a directory
  *
@@ -721,12 +980,42 @@ lws_dir_callback_function(const char *dirpath, void *user,
  *
  * Calls \p cb (with \p user) for every object in dirpath.
  *
+ * This form does not call the callback for the toplevel, dirpath dir
+ * itself.  If you want to do that, use lws_dir_via_info(), with
+ * .do_toplevel_cb nonzero.
+ *
  * This wraps whether it's using POSIX apis, or libuv (as needed for windows,
  * since it refuses to support POSIX apis for this).
+ *
+ * Returns 1 if completed normally or 0 if the recursion ended early.
+ *
+ * This is here for historical reasons, use the below lws_dir_via_info() for
+ * new code, it's the same function but using an info struct type args.
  */
 LWS_VISIBLE LWS_EXTERN int
 lws_dir(const char *dirpath, void *user, lws_dir_callback_function cb);
 
+/**
+ * lws_dir_via_info() - get a callback for everything in a directory
+ *
+ * \param info: details of what to scan and how
+ *
+ * All of the members of \p info should be set on entry.
+ *
+ * Calls \p info.cb (with \p info.user) for every object in info.dirpath.
+ *
+ * Set \p info.do_toplevel_cb to nonzero if you also want the callback to
+ * be called for the toplevel dir, ie, dirpath itself.
+ *
+ * This wraps whether it's using POSIX apis, or libuv (as needed for windows,
+ * since it refuses to support POSIX apis for this).
+ *
+ * Returns 1 if completed normally or 0 if the recursion ended early.
+ */
+LWS_VISIBLE LWS_EXTERN int
+lws_dir_via_info(struct lws_dir_info *info);
+
+
 /**
  * lws_dir_rm_rf_cb() - callback for lws_dir that performs recursive rm -rf
  *
@@ -741,6 +1030,34 @@ lws_dir(const char *dirpath, void *user, lws_dir_callback_function cb);
 LWS_VISIBLE LWS_EXTERN int
 lws_dir_rm_rf_cb(const char *dirpath, void *user, struct lws_dir_entry *lde);
 
+
+/**
+ * lws_dir_du_t: context for lws_dir_du_cb()
+ *
+ * It's zeroed before starting the lws_dir() walk.
+ */
+
+typedef struct lws_dir_du {
+	uint64_t			size_in_bytes;
+	uint32_t			count_files;
+} lws_dir_du_t;
+
+/**
+ * lws_dir_du_cb() - callback for lws_dir that performs recursive du
+ *
+ * \param dirpath: directory we are at in lws_dir
+ * \param user: pointer to a lws_dir_du_t to collate the results in
+ * \param lde: lws_dir info on the file or directory we are at
+ *
+ * This is a readymade du -b callback for use with lws_dir.  It recursively
+ * sums the sizes of all files it finds and the count of files.  The user
+ an
+ * lws_dir_du_t struct should be zeroed before starting the walk.
+ */
+LWS_VISIBLE LWS_EXTERN int
+lws_dir_du_cb(const char *dirpath, void *user, struct lws_dir_entry *lde);
+
+
 /*
  * We pass every file in the base dir through a filter, and call back on the
  * ones that match.  Directories are ignored.
@@ -882,6 +1199,13 @@ LWS_VISIBLE extern const lws_humanize_unit_t humanize_schema_si[7];
 LWS_VISIBLE extern const lws_humanize_unit_t humanize_schema_si_bytes[7];
 LWS_VISIBLE extern const lws_humanize_unit_t humanize_schema_us[8];
 
+#if defined(_DEBUG)
+void
+lws_assert_fourcc(uint32_t fourcc, uint32_t expected);
+#else
+#define lws_assert_fourcc(_a, _b) do { } while (0);
+#endif
+
 /**
  * lws_humanize() - Convert possibly large number to human-readable uints
  *
@@ -900,13 +1224,20 @@ LWS_VISIBLE extern const lws_humanize_unit_t humanize_schema_us[8];
  * which represents a count of us as a human-readable time like "  14.350min",
  * or "  1.500d".
  *
- * You can produce your own schema.
+ * You can produce your own schema tables.
+ *
+ * lws_humanize_pad() is the same but pads the lhs so that it
+ * always produces the same length.
  */
 
 LWS_VISIBLE LWS_EXTERN int
 lws_humanize(char *buf, size_t len, uint64_t value,
 	     const lws_humanize_unit_t *schema);
 
+LWS_VISIBLE LWS_EXTERN int
+lws_humanize_pad(char *p, size_t len, uint64_t v,
+		 const lws_humanize_unit_t *schema);
+
 LWS_VISIBLE LWS_EXTERN void
 lws_ser_wu16be(uint8_t *b, uint16_t u);
 
@@ -945,8 +1276,22 @@ struct _lws_siginfo_t {
 typedef struct _lws_siginfo_t siginfo_t;
 #endif
 
-typedef void (*lsp_cb_t)(void *opaque, lws_usec_t *accounting, siginfo_t *si,
-			 int we_killed_him);
+/**
+ * lws_spawn_resource_us_t - resource usage results from spawned process
+ *
+ * All time values are in uS.
+ * All size values are in bytes.
+ */
+typedef struct lws_spawn_resource_us {
+	uint64_t			us_cpu_user;  /**< user space cpu time */
+	uint64_t			us_cpu_sys;   /**< kernel space cpu time */
+
+	uint64_t			peak_mem_rss; /**< peak resident memory */
+	uint64_t			peak_mem_virt; /**< peak virtual memory */
+} lws_spawn_resource_us_t;
+
+typedef void (*lsp_cb_t)(void *opaque, const lws_spawn_resource_us_t *res,
+			 siginfo_t *si, int we_killed_him);
 
 
 /**
@@ -962,9 +1307,11 @@ typedef void (*lsp_cb_t)(void *opaque, lws_usec_t *accounting, siginfo_t *si,
  * \p wd: working directory to cd to after fork, NULL defaults to /tmp
  * \p plsp: NULL, or pointer to the outer lsp pointer so it can be set NULL when destroyed
  * \p opaque: pointer passed to the reap callback, if any
- * \p timeout: optional us-resolution timeout, or zero
  * \p reap_cb: callback when child process has been reaped and the lsp destroyed
  * \p tsi: tsi to bind stdwsi to... from opt_parent if given
+ * \p cgroup_name_suffix: for Linux, encapsulate spawn into this new cgroup
+ * \p p_cgroup_ret: NULL, or pointer to int to show if cgroups applied OK (0 = OK)
+ * \p pres: NULL, or pointer to a lws_spawn_resource_us_t to take the results
  */
 struct lws_spawn_piped_info {
 	struct lws_dll2_owner		*owner;
@@ -983,6 +1330,8 @@ struct lws_spawn_piped_info {
 
 	lsp_cb_t			reap_cb;
 
+	lws_spawn_resource_us_t		*res;
+
 	lws_usec_t			timeout_us;
 	int				max_log_lines;
 	int				tsi;
@@ -990,6 +1339,9 @@ struct lws_spawn_piped_info {
 	const struct lws_role_ops	*ops; /* NULL is raw file */
 
 	uint8_t				disable_ctrlc;
+
+	const char			*cgroup_name_suffix;
+	int				*p_cgroup_ret;
 };
 
 /**
@@ -1026,6 +1378,16 @@ lws_spawn_piped(const struct lws_spawn_piped_info *lspi);
 LWS_VISIBLE LWS_EXTERN int
 lws_spawn_piped_kill_child_process(struct lws_spawn_piped *lsp);
 
+/**
+ * lws_spawn_get_stdwsi_open_count() - return stdwsi unclosed count
+ *
+ * \p lsp: the spawn object
+ *
+ * Returns number of stdwsi left unclosed on the lsp.
+ */
+LWS_VISIBLE LWS_EXTERN int
+lws_spawn_get_stdwsi_open_count(struct lws_spawn_piped *lsp);
+
 /**
  * lws_spawn_stdwsi_closed() - inform the spawn one of its stdxxx pipes closed
  *
@@ -1038,10 +1400,22 @@ lws_spawn_piped_kill_child_process(struct lws_spawn_piped *lsp);
  *
  * This is the mechanism whereby the spawn object can understand its child
  * has closed.
+ *
+ * Returns non-zero if there are no more stdwsi to wait for.
  */
-LWS_VISIBLE LWS_EXTERN void
+LWS_VISIBLE LWS_EXTERN int
 lws_spawn_stdwsi_closed(struct lws_spawn_piped *lsp, struct lws *wsi);
 
+/*
+ * lws_spawn_closedown_stdwsis() - forcibly close the spawner side of stdwsi pipes
+ *
+ * \p lsp: the spawn object
+ *
+ * Closes the spawner side of all the stdwsi for an lsp that are still open.
+ */
+LWS_VISIBLE LWS_EXTERN void
+lws_spawn_closedown_stdwsis(struct lws_spawn_piped *lsp);
+
 /**
  * lws_spawn_get_stdfd() - return std channel index for stdwsi
  *
@@ -1055,6 +1429,52 @@ lws_spawn_stdwsi_closed(struct lws_spawn_piped *lsp, struct lws *wsi);
 LWS_VISIBLE LWS_EXTERN int
 lws_spawn_get_stdfd(struct lws *wsi);
 
+/**
+ * lws_spawn_get_fd_stdxxx() - return fd belonging to lws side of spawn stdxxx
+ *
+ * \p lsp: the opaque pointer returned from lws_spawn()
+ * \p std_idx: 0 (stdin write side), 1 (stdout read side), 2 (stderr read side)
+ *
+ * Lets you get the fd for writing to the spawned process stdin, or reading from
+ * the spawned process stdout and stderr.
+ */
+LWS_VISIBLE LWS_EXTERN int
+lws_spawn_get_fd_stdxxx(struct lws_spawn_piped *lsp, int std_idx);
+
+/**
+ * lws_spawn_prepare_self_cgroup() - Create lws parent cgroup
+ *
+ * \p user: NULL, or the user name that will use the toplevel cgroup
+ * \p group: NULL, or the group name that will use the toplevel cgroup
+ *
+ * This helper should be called once at startup by a process that has root
+ * privileges. It will configure the current process cgroup to be able to
+ * bring children into it when running under different uid / gid.
+ *
+ * After this has been called successfully, the process can drop privileges
+ * to a non-root user, and subsequent calls to lws_spawn_piped() with a
+ * cgroup_name_suffix will succeed as long as that user has write permission
+ * in the master cgroup directory (which can be arranged via chown).
+ *
+ * Returns 0 on success. On non-Linux platforms, it's a no-op that returns 1.
+ */
+LWS_VISIBLE LWS_EXTERN int
+lws_spawn_prepare_self_cgroup(const char *user, const char *group);
+
+/**
+ * lws_spawn_get_self_cgroup() - Return current process cgroup name
+ *
+ * \p cgroup: buffer to take cgroup name
+ * \p max: max size of cgroup buffer
+ *
+ * Helper stores cgroup name of current process into the buffer.
+ * Returns 0 on success or 1 if failed.
+ *
+ * Returned name is a fragment like "system.slice/sai-builder.service"
+ */
+LWS_VISIBLE LWS_EXTERN int
+lws_spawn_get_self_cgroup(char *cgroup, size_t max);
+
 #endif
 
 struct lws_fsmount {
@@ -1120,3 +1540,57 @@ lws_fsmount_mount(struct lws_fsmount *fsm);
  */
 LWS_VISIBLE LWS_EXTERN int
 lws_fsmount_unmount(struct lws_fsmount *fsm);
+
+#define LWS_MINILEX_FAIL -1
+#define LWS_MINILEX_CONTINUE 0
+#define LWS_MINILEX_MATCH 1
+
+/**
+ * lws_minilex_parse() - stateful matching vs lws minilex tables
+ *
+ * \p lex: the start of the precomputed minilex table
+ * \p ps: pointer to the int16_t that holds the parsing state (init to 0)
+ * \p c: the next incoming character to parse
+ * \p match: pointer to take the match
+ *
+ * Returns either
+ *
+ *  - LWS_MINILEX_FAIL if there is no way to match the characters seen,
+ * this is sticky for additional characters until the *ps is reset to 0.
+ *
+ *  - LWS_MINILEX_CONTINUE if the character could be part of a match but more
+ *    are required to see if it can match
+ *
+ *  - LWS_MINILEX_MATCH and *match is set to the match index if there is a
+ *    valid match.
+ *
+ * In cases where the match is ambiguous, eg, we saw "right" and the possible
+ * matches are "right" or "right-on", LWS_MINILEX_CONTINUE is returned.  To
+ * allow it to match on the complete-but-ambiguous token, if the caller sees
+ * a delimiter it can call lws_minilex_parse() again with c == 0.  This will
+ * either return LWS_MINILEX_MATCH and set *match to the smaller ambiguous
+ * match, or return LWS_MINILEX_FAIL.
+ */
+LWS_VISIBLE LWS_EXTERN int
+lws_minilex_parse(const uint8_t *lex, int16_t *ps, const uint8_t c,
+			int *match);
+
+/*
+ * Reports the number of significant bits (from the left) that is needed to
+ * represent u.  So if u is 0x80, result is 8.
+ */
+
+LWS_VISIBLE LWS_EXTERN unsigned int
+lws_sigbits(uintptr_t u);
+
+/**
+ * lws_wol() - broadcast a magic WOL packet to MAC, optionally binding to if IP
+ *
+ * \p ctx: The lws context
+ * \p ip_or_NULL: The IP address to bind to at the client side, to send the
+ *                magic packet on.  If NULL, the system chooses, probably the
+ *                interface with the default route.
+ * \p mac_6_bytes: Points to a 6-byte MAC address to direct the magic packet to
+ */
+LWS_VISIBLE LWS_EXTERN int
+lws_wol(struct lws_context *ctx, const char *ip_or_NULL, uint8_t *mac_6_bytes);

package/3rdparty/output/android/libwebsockets/x86_64/include/libwebsockets/lws-mqtt.h

@@ -33,6 +33,11 @@ struct lws_mqtt_str_st;
 typedef struct lws_mqtt_str_st lws_mqtt_str_t;
 
 #define MQTT_VER_3_1_1 4
+#if MQTT_VER_3_1_1 == 4
+	#define MQTT_VER_STRING "3.1.1"
+#else
+	#define MQTT_VER_STRING "unknown"
+#endif
 
 #define LWS_MQTT_FINAL_PART 1
 

package/3rdparty/output/android/libwebsockets/x86_64/include/libwebsockets/lws-network-helper.h

@@ -1,7 +1,7 @@
 /*
  * libwebsockets - small server side websockets and web server implementation
  *
- * Copyright (C) 2010 - 2020 Andy Green <andy@warmcat.com>
+ * 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
@@ -246,4 +246,16 @@ 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_parse_mac() - convert XX:XX:XX:XX:XX:XX to 6-byte MAC address
+ *
+ * \param ads: mac address as XX:XX:XX:XX:XX:XX string
+ * \param result_6_bytes: result buffer to take 6 bytes
+ *
+ * Converts a string representation of a 6-byte hex mac address to a 6-byte
+ * array.
+ */
+LWS_VISIBLE LWS_EXTERN int
+lws_parse_mac(const char *ads, uint8_t *result_6_bytes);
+
 ///@}