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

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

@@ -0,0 +1,122 @@
+/*
+ * lws OTA updates
+ *
+ * Copyright (C) 2019 - 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.
+ *
+ * This is the platform interface that lws_ota uses to flash new firmware.
+ * The platform implementation for these ops is set via lws_system and consists
+ * of user code.
+ *
+ * All the update-related calls have async interfaces with a callback and opaque
+ * callback context that is called on completion.  This allows us to, eg,
+ * download the next buffer while flashing the previous one.
+ *
+ * If the platform implementation is actually synchronous, then just call the
+ * callback before returning.
+ *
+ * If it is async, because eg, erase is slow, in the platform ota op
+ * implementation spawn a thread to do the platform operation, return
+ * immediately with LWSOTARET_ONGOING, and call the callback from the spawned
+ * thread context with the real return before terminating the thread.
+ */
+
+typedef void * lws_ota_process_t;
+
+typedef enum {
+	LWSOTARET_OK,
+	LWSOTARET_ONGOING, /* result not ready to read yet */
+	LWSOTARET_REJECTED,
+	LWSOTARET_NOSLOT,
+
+	LWSOTARET_UPDATE_AVAILABLE,
+	LWSOTARET_PROGRESS,
+	LWSOTARET_FAILED,
+	LWSOTARET_COMPLETED
+} lws_ota_ret_t;
+
+typedef enum {
+	LWS_OTA_ASYNC_START = 1,
+	LWS_OTA_ASYNC_WRITE,
+	LWS_OTA_ASYNC_ABORT,
+	LWS_OTA_ASYNC_FINALIZE
+} lws_ota_async_t;
+
+struct lws_ota;
+
+typedef void (*lws_ota_cb_t)(void *ctx, lws_ota_ret_t r);
+
+typedef struct {
+
+	/* asynchronous (completions via lws_cancel_service) */
+
+	int (*ota_start)(struct lws_ota *g);
+	/**< Creates the ota task and queues LWS_OTA_ASYNC_START on it. */
+
+	void (*ota_queue)(struct lws_ota *g, lws_ota_async_t a);
+	/**< Queue next command to OTA task (args are in g) */
+
+	/* synchronous */
+
+	int (*ota_report_current)(struct lws_ota *g, int bad);
+	/**< Report information to the platform code about how we feel about the
+	 * current boot... if we can check the OTA then we report it seems in
+	 * good shape (bad = 0), if we can identify it's brain-damaged then
+	 * (bad = 1).  What action the platform takes about these reports is up
+	 * to the platform code */
+
+	int (*ota_progress)(lws_ota_ret_t state, int percent);
+	/**< Gets called so the platform can represent OTA progress, give
+	 * platform a chance to choose what to do about an available update */
+
+	int (*ota_get_last_fw_unixtime)(uint64_t *fw_unixtime);
+	/**< tries to recover the newest firmware unixtime that had been
+	 * OTA'd into fw_unixtime, updates from same or earlier unixtime are
+	 * ignored for update purposes. */
+
+	int ota_periodic_check_secs;
+	/**< Check after this many seconds for a new update */
+} lws_ota_ops_t;
+
+/**
+ * lws_ota_variant_name() - returns the build variant name
+ *
+ * Returns a string that uniquely identifies the kind of firmware build this
+ * device is running.
+ */
+
+LWS_VISIBLE LWS_EXTERN const char *
+lws_ota_variant_name(void);
+
+LWS_VISIBLE LWS_EXTERN int
+lws_plat_ota_start(struct lws_ota *g);
+
+
+#define LWSOTAFIN_OK	0
+#define LWSOTAFIN_BAD	1
+
+LWS_VISIBLE LWS_EXTERN void
+lws_plat_ota_queue(struct lws_ota *g, lws_ota_async_t a);
+
+LWS_VISIBLE LWS_EXTERN int
+lws_plat_ota_report_current(struct lws_ota *g, int bad);
+
+LWS_VISIBLE LWS_EXTERN int
+lws_plat_ota_get_last_fw_unixtime(uint64_t *fw_unixtime);

package/3rdparty/output/android/libwebsockets/x86_64/include/libwebsockets/lws-secure-streams-client.h

@@ -29,6 +29,9 @@
  * lws_sspc_        when client is in a different process to the event loop
  *
  * The client api is almost the same except the slightly diffent names.
+ *
+ * This header is included as part of libwebsockets.h, for link against the
+ * libwebsockets library.
  */
 
 /*
@@ -40,6 +43,7 @@
  * lws_sspc_ in one step by #define LWS_SS_USE_SSPC before including
  */
 
+
 struct lws_sspc_handle;
 
 #if defined(LWS_SS_USE_SSPC)
@@ -62,16 +66,11 @@ struct lws_sspc_handle;
 #define lws_ss_to_user_object		lws_sspc_to_user_object
 #define lws_ss_change_handlers		lws_sspc_change_handlers
 #define lws_smd_ss_rx_forward		lws_smd_sspc_rx_forward
+#define lws_ss_server_ack		lws_sspc_server_ack
 #define lws_ss_tag			lws_sspc_tag
 #define _lws_fi_user_ss_fi		_lws_fi_user_sspc_fi
 #define lwsl_ss_get_cx			lwsl_sspc_get_cx
 
-LWS_VISIBLE LWS_EXTERN void
-lws_log_prepend_sspc(struct lws_log_cx *cx, void *obj, char **p, char *e);
-
-LWS_VISIBLE LWS_EXTERN struct lws_log_cx *
-lwsl_sspc_get_cx(struct lws_sspc_handle *ss);
-
 #undef lwsl_ss
 #define lwsl_ss lwsl_sspc
 
@@ -79,6 +78,12 @@ lwsl_sspc_get_cx(struct lws_sspc_handle *ss);
 #define lwsl_hexdump_ss lwsl_hexdump_sspc
 #endif
 
+LWS_VISIBLE LWS_EXTERN void
+lws_log_prepend_sspc(struct lws_log_cx *cx, void *obj, char **p, char *e);
+
+LWS_VISIBLE LWS_EXTERN struct lws_log_cx *
+lwsl_sspc_get_cx(struct lws_sspc_handle *ss);
+
 #define lwsl_sspc(_h, _fil, ...) \
 		 _lws_log_cx(lwsl_sspc_get_cx(_h), lws_log_prepend_sspc, _h, \
 					_fil, __func__, __VA_ARGS__)
@@ -170,11 +175,33 @@ lwsl_sspc_get_cx(struct lws_sspc_handle *ss);
 #define lwsl_hexdump_sspc_info(_v, ...)   lwsl_hexdump_sspc(_v, LLL_INFO, __VA_ARGS__)
 #define lwsl_hexdump_sspc_debug(_v, ...)  lwsl_hexdump_sspc(_v, LLL_DEBUG, __VA_ARGS__)
 
+/*
+ * How lws refers to your per-proxy-link private data... not allocated or freed
+ * by lws, nor used except to pass a pointer to it through to ops callbacks
+ * below.  Should be set to your transport private instance object, it's set to
+ * the wsi for the wsi transport.  Notice it is provided as a ** (ptr-to-ptr) in
+ * most apis.
+ */
+
+/*
+ * Stub context when using LWS_ONLY_SSPC
+ */
+
+struct lws_context_standalone {
+	lws_txp_path_client_t			txp_cpath;
+	lws_dll2_owner_t			ss_client_owner;
+	uint32_t				ssidx;
+};
+
+#if defined(STANDALONE)
+#define lws_context lws_context_standalone
+struct lws_context_standalone;
+#endif
 
 LWS_VISIBLE LWS_EXTERN int
 lws_sspc_create(struct lws_context *context, int tsi, const lws_ss_info_t *ssi,
 		void *opaque_user_data, struct lws_sspc_handle **ppss,
-		struct lws_sequencer *seq_owner, const char **ppayload_fmt);
+		void *reserved, const char **ppayload_fmt);
 
 /**
  * lws_sspc_destroy() - Destroy secure stream
@@ -228,19 +255,6 @@ lws_sspc_request_tx_len(struct lws_sspc_handle *h, unsigned long len);
 LWS_VISIBLE LWS_EXTERN lws_ss_state_return_t
 lws_sspc_client_connect(struct lws_sspc_handle *h);
 
-/**
- * lws_sspc_get_sequencer() - Return parent sequencer pointer if any
- *
- * \param h: secure streams handle
- *
- * Returns NULL if the secure stream is not associated with a sequencer.
- * Otherwise returns a pointer to the owning sequencer.  You can use this to
- * identify which sequencer to direct messages to, from the secure stream
- * callback.
- */
-LWS_VISIBLE LWS_EXTERN struct lws_sequencer *
-lws_sspc_get_sequencer(struct lws_sspc_handle *h);
-
 /**
  * lws_sspc_proxy_create() - Start a unix domain socket proxy for Secure Streams
  *
@@ -264,7 +278,9 @@ lws_sspc_proxy_create(struct lws_context *context);
 LWS_VISIBLE LWS_EXTERN struct lws_context *
 lws_sspc_get_context(struct lws_sspc_handle *h);
 
-LWS_VISIBLE extern const struct lws_protocols lws_sspc_protocols[2];
+#if defined(LWS_WITH_NETWORK)
+extern const struct lws_protocols lws_sspc_protocols[2];
+#endif
 
 LWS_VISIBLE LWS_EXTERN const char *
 lws_sspc_rideshare(struct lws_sspc_handle *h);
@@ -318,14 +334,29 @@ lws_sspc_to_user_object(struct lws_sspc_handle *h);
 
 LWS_VISIBLE LWS_EXTERN void
 lws_sspc_change_handlers(struct lws_sspc_handle *h,
-	lws_ss_state_return_t (*rx)(void *userobj, const uint8_t *buf,
-				    size_t len, int flags),
-	lws_ss_state_return_t (*tx)(void *userobj, lws_ss_tx_ordinal_t ord,
-				    uint8_t *buf, size_t *len, int *flags),
-	lws_ss_state_return_t (*state)(void *userobj, void *h_src
-					/* ss handle type */,
-				       lws_ss_constate_t state,
-				       lws_ss_tx_ordinal_t ack));
-
-const char *
+			 lws_sscb_rx rx,lws_sscb_tx tx, lws_sscb_state state);
+
+LWS_VISIBLE LWS_EXTERN void
+lws_sspc_server_ack(struct lws_sspc_handle *h, int nack);
+
+
+/*
+ * Helpers offered by lws to handle transport SSPC-side proxy link events
+ */
+
+/**
+ * lws_sspc_tag() - get the sspc log tag
+ *
+ * \param h: the sspc handle
+ *
+ * Returns the sspc log tag, to assist in logging traceability
+ */
+LWS_VISIBLE LWS_EXTERN const char *
 lws_sspc_tag(struct lws_sspc_handle *h);
+
+
+#if defined(STANDALONE)
+#undef lws_context
+#endif
+
+

package/3rdparty/output/android/libwebsockets/x86_64/include/libwebsockets/lws-secure-streams-policy.h

@@ -51,32 +51,6 @@ typedef int (*plugin_auth_status_cb)(struct lws_ss_handle *ss, int status);
  * has the LWSSSPOLF_NAILED_UP flag.
  */
 
-#if defined(LWS_WITH_SSPLUGINS)
-typedef struct lws_ss_plugin {
-	struct lws_ss_plugin	*next;
-	const char		*name;	/**< auth plugin name */
-	size_t			alloc;	/**< size of private allocation */
-
-	int			(*create)(struct lws_ss_handle *ss, void *info,
-					  plugin_auth_status_cb status);
-				/**< called when the auth plugin is instantiated
-				     and bound to the secure stream.  status is
-				     called back with advisory information about
-				     the authenticated stream state as it
-				     proceeds */
-	int			(*destroy)(struct lws_ss_handle *ss);
-				/**< called when the related secure stream is
-				     being destroyed, and anything the auth
-				     plugin is doing should also be destroyed */
-	int			(*munge)(struct lws_ss_handle *ss, char *path,
-					 size_t path_len);
-				/**< if the plugin needs to munge transactions
-				     that have metadata outside the payload (eg,
-				     add http headers) this callback will give
-				     it the opportunity to do so */
-} lws_ss_plugin_t;
-#endif
-
 /* the public, const metrics policy definition */
 
 typedef struct lws_metric_policy {
@@ -260,6 +234,10 @@ typedef struct lws_ss_policy {
 	const lws_metric_policy_t *metrics; /* linked-list of metric policies */
 	const lws_ss_auth_t	*auth; /* NULL or auth object we bind to */
 
+#if defined(LWS_WITH_SERVER)
+	const struct lws_protocol_vhost_options *pvo;
+#endif
+
 	/* protocol-specific connection policy details */
 
 	union {
@@ -332,12 +310,6 @@ typedef struct lws_ss_policy {
 		/* details for non-http related protocols... */
 	} u;
 
-#if defined(LWS_WITH_SSPLUGINS)
-	const
-	struct lws_ss_plugin	*plugins[2]; /**< NULL or auth plugin */
-	const void		*plugins_info[2];   /**< plugin-specific data */
-#endif
-
 #if defined(LWS_WITH_SECURE_STREAMS_AUTH_SIGV4)
 	/* directly point to the metadata name, no need to expand */
 	const char *aws_region;
@@ -363,6 +335,9 @@ typedef struct lws_ss_policy {
 
 	const lws_retry_bo_t	*retry_bo;   /**< retry policy to use */
 
+	int32_t			txc;
+	int32_t			txc_peer;
+
 	uint32_t		proxy_buflen; /**< max dsh alloc for proxy */
 	uint32_t		proxy_buflen_rxflow_on_above;
 	uint32_t		proxy_buflen_rxflow_off_below;
@@ -371,7 +346,6 @@ typedef struct lws_ss_policy {
 	uint32_t		client_buflen_rxflow_on_above;
 	uint32_t		client_buflen_rxflow_off_below;
 
-
 	uint32_t		timeout_ms;  /**< default message response
 					      * timeout in ms */
 	uint32_t		flags;	     /**< stream attribute flags */