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

package/3rdparty/output/android/libwebsockets/x86_64/include/libwebsockets/lws-struct.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 - 2025 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
@@ -26,6 +26,14 @@
 #include <sqlite3.h>
 #endif
 
+/*
+ * lws_struct provides apis for these transforms
+ *
+ *    sqlite3 <-> C struct <-> JSON
+ *
+ * in a "structured" way.
+ */
+
 typedef enum {
 	LSMT_SIGNED,
 	LSMT_UNSIGNED,
@@ -40,48 +48,53 @@ typedef enum {
 } lws_struct_map_type_eum;
 
 typedef struct lejp_collation {
-	struct lws_dll2 chunks;
-	int len;
-	char buf[LEJP_STRING_CHUNK + 1];
+	struct lws_dll2			chunks;
+	int				len;
+	char				buf[LEJP_STRING_CHUNK + 1];
 } lejp_collation_t;
 
 typedef struct lws_struct_map {
-	const char *colname;
-	const struct lws_struct_map *child_map;
-	lejp_callback lejp_cb;
-	size_t ofs;			/* child dll2; points to dll2_owner */
-	size_t aux;
-	size_t ofs_clist;
-	size_t child_map_size;
-	lws_struct_map_type_eum type;
+	const char			*colname;
+	const struct lws_struct_map	*child_map;
+	lejp_callback			lejp_cb;
+	size_t				ofs;	/* child dll2; points to dll2_owner */
+	size_t				aux;
+	size_t				ofs_clist;
+	size_t				child_map_size;
+	lws_struct_map_type_eum 	type;
+	char				json_only;
 } lws_struct_map_t;
 
 typedef int (*lws_struct_args_cb)(void *obj, void *cb_arg);
 
 typedef struct lws_struct_args {
-	const lws_struct_map_t *map_st[LEJP_MAX_PARSING_STACK_DEPTH];
-	lws_struct_args_cb cb;
-	struct lwsac *ac;
-	void *cb_arg;
-	void *dest;
+	const lws_struct_map_t		*map_st[LEJP_MAX_PARSING_STACK_DEPTH];
+	lws_struct_args_cb		cb;
+	struct lwsac			*ac;
+	void				*cb_arg;
+	void				*dest;
 
-	size_t dest_len;
-	size_t toplevel_dll2_ofs;
-	size_t map_entries_st[LEJP_MAX_PARSING_STACK_DEPTH];
-	size_t ac_block_size;
-	int subtype;
+	size_t				dest_len;
+	size_t				toplevel_dll2_ofs;
+	size_t				map_entries_st[LEJP_MAX_PARSING_STACK_DEPTH];
+	size_t				ac_block_size;
+	int				subtype;
 
-	int top_schema_index;
+	int				top_schema_index;
 
 	/*
 	 * temp ac used to collate unknown possibly huge strings before final
 	 * allocation and copy
 	 */
-	struct lwsac *ac_chunks;
-	struct lws_dll2_owner chunks_owner;
-	size_t chunks_length;
+	struct lwsac			*ac_chunks;
+	struct lws_dll2_owner		chunks_owner;
+	size_t				chunks_length;
 } lws_struct_args_t;
 
+/*
+ * These types apply to both Sqlite3 and JSON representations
+ */
+
 #define LSM_SIGNED(type, name, qname) \
 	{ \
 	  qname, \
@@ -91,7 +104,8 @@ typedef struct lws_struct_args {
 	  sizeof ((type *)0)->name, \
 	  0, \
 	  0, \
-	  LSMT_SIGNED \
+	  LSMT_SIGNED, \
+	  0 \
 	}
 
 #define LSM_UNSIGNED(type, name, qname) \
@@ -103,7 +117,8 @@ typedef struct lws_struct_args {
 	  sizeof ((type *)0)->name, \
 	  0, \
 	  0, \
-	  LSMT_UNSIGNED \
+	  LSMT_UNSIGNED, \
+	  0, \
 	}
 
 #define LSM_BOOLEAN(type, name, qname) \
@@ -115,7 +130,8 @@ typedef struct lws_struct_args {
 	  sizeof ((type *)0)->name, \
 	  0, \
 	  0, \
-	  LSMT_BOOLEAN \
+	  LSMT_BOOLEAN, \
+	  0, \
 	}
 
 #define LSM_CARRAY(type, name, qname) \
@@ -127,7 +143,8 @@ typedef struct lws_struct_args {
 	  sizeof (((type *)0)->name), \
 	  0, \
 	  0, \
-	  LSMT_STRING_CHAR_ARRAY \
+	  LSMT_STRING_CHAR_ARRAY, \
+	  0, \
 	}
 
 #define LSM_STRING_PTR(type, name, qname) \
@@ -139,7 +156,8 @@ typedef struct lws_struct_args {
 	  sizeof (((type *)0)->name), \
 	  0, \
 	  0, \
-	  LSMT_STRING_PTR \
+	  LSMT_STRING_PTR, \
+	  0 \
 	}
 
 #define LSM_LIST(ptype, pname, ctype, cname, lejp_cb, cmap, qname) \
@@ -151,7 +169,8 @@ typedef struct lws_struct_args {
 	  sizeof (ctype), \
 	  offsetof(ctype, cname), \
 	  LWS_ARRAY_SIZE(cmap), \
-	  LSMT_LIST \
+	  LSMT_LIST, \
+	  0, \
 	}
 
 #define LSM_CHILD_PTR(ptype, pname, ctype, lejp_cb, cmap, qname) \
@@ -163,7 +182,8 @@ typedef struct lws_struct_args {
 	  sizeof (ctype), \
 	  0, \
 	  LWS_ARRAY_SIZE(cmap), \
-	  LSMT_CHILD_PTR \
+	  LSMT_CHILD_PTR, \
+	  0, \
 	}
 
 #define LSM_SCHEMA(ctype, lejp_cb, map, schema_name) \
@@ -175,7 +195,8 @@ typedef struct lws_struct_args {
 	  sizeof (ctype), \
 	  0, \
 	  LWS_ARRAY_SIZE(map), \
-	  LSMT_SCHEMA \
+	  LSMT_SCHEMA, \
+	  0, \
 	}
 
 #define LSM_SCHEMA_DLL2(ctype, cdll2mem, lejp_cb, map, schema_name) \
@@ -187,9 +208,137 @@ typedef struct lws_struct_args {
 	  sizeof (ctype), \
 	  0, \
 	  LWS_ARRAY_SIZE(map), \
-	  LSMT_SCHEMA \
+	  LSMT_SCHEMA, \
+	  0, \
+	}
+
+/*
+ * These types are the same as above, but they are JSON-ONLY; they
+ * do not apply to sqlite3, do not appear as columns in the table etc.
+ * This is useful when these values are dynamically added to the
+ * struct before creating the JSON representation and do not directly
+ * use information stored in the table associated with the sqlite3
+ * representation
+ */
+
+#define LSM_JO_SIGNED(type, name, qname) \
+	{ \
+	  qname, \
+	  NULL, \
+	  NULL, \
+	  offsetof(type, name), \
+	  sizeof ((type *)0)->name, \
+	  0, \
+	  0, \
+	  LSMT_SIGNED, \
+	  1 \
+	}
+
+#define LSM_JO_UNSIGNED(type, name, qname) \
+	{ \
+	  qname, \
+	  NULL, \
+	  NULL, \
+	  offsetof(type, name), \
+	  sizeof ((type *)0)->name, \
+	  0, \
+	  0, \
+	  LSMT_UNSIGNED, \
+	  1, \
+	}
+
+#define LSM_JO_BOOLEAN(type, name, qname) \
+	{ \
+	  qname, \
+	  NULL, \
+	  NULL, \
+	  offsetof(type, name), \
+	  sizeof ((type *)0)->name, \
+	  0, \
+	  0, \
+	  LSMT_BOOLEAN, \
+	  1, \
+	}
+
+#define LSM_JO_CARRAY(type, name, qname) \
+	{ \
+	  qname, \
+	  NULL, \
+	  NULL, \
+	  offsetof(type, name), \
+	  sizeof (((type *)0)->name), \
+	  0, \
+	  0, \
+	  LSMT_STRING_CHAR_ARRAY, \
+	  1, \
+	}
+
+#define LSM_JO_STRING_PTR(type, name, qname) \
+	{ \
+	  qname, \
+	  NULL, \
+	  NULL, \
+	  offsetof(type, name), \
+	  sizeof (((type *)0)->name), \
+	  0, \
+	  0, \
+	  LSMT_STRING_PTR, \
+	  1, \
+	}
+
+#define LSM_JO_LIST(ptype, pname, ctype, cname, lejp_cb, cmap, qname) \
+	{ \
+	  qname, \
+	  cmap, \
+	  lejp_cb, \
+	  offsetof(ptype, pname), \
+	  sizeof (ctype), \
+	  offsetof(ctype, cname), \
+	  LWS_ARRAY_SIZE(cmap), \
+	  LSMT_LIST, \
+	  1, \
+	}
+
+#define LSM_JO_CHILD_PTR(ptype, pname, ctype, lejp_cb, cmap, qname) \
+	{ \
+	  qname, \
+	  cmap, \
+	  lejp_cb, \
+	  offsetof(ptype, pname), \
+	  sizeof (ctype), \
+	  0, \
+	  LWS_ARRAY_SIZE(cmap), \
+	  LSMT_CHILD_PTR, \
+	  1, \
+	}
+
+#define LSM_JO_SCHEMA(ctype, lejp_cb, map, schema_name) \
+	{ \
+	  schema_name, \
+	  map, \
+	  lejp_cb, \
+	  0, \
+	  sizeof (ctype), \
+	  0, \
+	  LWS_ARRAY_SIZE(map), \
+	  LSMT_SCHEMA, \
+	  1, \
+	}
+
+#define LSM_JO_SCHEMA_DLL2(ctype, cdll2mem, lejp_cb, map, schema_name) \
+	{ \
+	  schema_name, \
+	  map, \
+	  lejp_cb, \
+	  offsetof(ctype, cdll2mem), \
+	  sizeof (ctype), \
+	  0, \
+	  LWS_ARRAY_SIZE(map), \
+	  LSMT_SCHEMA, \
+	  1, \
 	}
 
+
 /*
  * This is just used to create the table schema, it is not part of serialization
  * and deserialization.  Blobs should be accessed separately.
@@ -204,7 +353,8 @@ typedef struct lws_struct_args {
 	  sizeof (((type *)0)->blobptr_name),       /* size of blob pointer */ \
 	  0,		 /* member holding blob len */ \
 	  0, /* size of blob length member */ \
-	  LSMT_BLOB_PTR \
+	  LSMT_BLOB_PTR, \
+	  0, \
 	}
 
 typedef struct lws_struct_serialize_st {
@@ -239,6 +389,19 @@ typedef enum {
 	LSJS_RESULT_ERROR
 } lws_struct_json_serialize_result_t;
 
+/*
+ * JSON -> C struct
+ */
+
+/**
+ * lws_struct_json_init_parse(): prepare to translate JSON to C struct
+ *
+ * \p ctx: JSON parse context
+ * \p cb: the parsing callback
+ * \p user: an opaque user pointer
+ *
+ * Returns 0 if OK else nonzero for error.
+ */
 LWS_VISIBLE LWS_EXTERN int
 lws_struct_json_init_parse(struct lejp_ctx *ctx, lejp_callback cb,
 			   void *user);
@@ -249,36 +412,142 @@ lws_struct_schema_only_lejp_cb(struct lejp_ctx *ctx, char reason);
 LWS_VISIBLE LWS_EXTERN signed char
 lws_struct_default_lejp_cb(struct lejp_ctx *ctx, char reason);
 
+/*
+ * C struct -> JSON
+ */
+
+/**
+ * lws_struct_json_serialize_create(): create a C struct -> JSON renderer
+ *
+ * \p map: the map of members and types
+ * \p map_entries: the count of entries in the map
+ * \p flags: JSON parsing options
+ * \p ptoplevel: the start of the C struct to render
+ *
+ * Returns an object that manages the stateful translation of a C struct
+ * to a JSON representation.
+ *
+ * Returns a pointer to the object, or NULL on failure.
+ */
 LWS_VISIBLE LWS_EXTERN lws_struct_serialize_t *
 lws_struct_json_serialize_create(const lws_struct_map_t *map,
 				 size_t map_entries, int flags,
 				 const void *ptoplevel);
 
-LWS_VISIBLE LWS_EXTERN void
-lws_struct_json_serialize_destroy(lws_struct_serialize_t **pjs);
-
+/**
+ * lws_struct_json_serialize(): output the next buffer of JSON
+ *
+ * \p js: the management object
+ * \p buf: the output fragment buffer
+ * \p len: the max size of \p buf
+ * \p written: pointer to a size_t to be set to the valid about in buf on exit
+ *
+ * This emits the next section of JSON for the object being represented
+ * by \p js.  You must refer to the return from the function to understand
+ * what is in the buffer on exit, LSJS_RESULT_ERROR indicates the function
+ * failed and the buffer is invalid, LSJS_RESULT_CONTINUE indicates the
+ * buffer is valid, but is a fragment of the full representation and you
+ * should call this function again later to get another fragment, and
+ * LSJS_RESULT_FINISH indicates the buffer is valid and is the last part
+ * of the representation.
+ *
+ * After seeing LSJS_RESULT_FINISH or LSJS_RESULT_ERROR you should clean
+ * up \js by calling lws_struct_json_serialize_destroy() on it
+ */
 LWS_VISIBLE LWS_EXTERN lws_struct_json_serialize_result_t
 lws_struct_json_serialize(lws_struct_serialize_t *js, uint8_t *buf,
 			  size_t len, size_t *written);
 
+/**
+ * lws_struct_json_serialize_destroy(): destruct a C struct -> JSON renderer
+ *
+ * \p pjs: pointer to the object to be destroyed
+ *
+ * The object to be destroyed should have been returned originally from
+ * lws_struct_json_serialize_create()
+ */
+LWS_VISIBLE LWS_EXTERN void
+lws_struct_json_serialize_destroy(lws_struct_serialize_t **pjs);
+
+/*
+ * Sqlite3
+ */
+
 typedef struct sqlite3 sqlite3;
 
+/**
+ * lws_struct_sq3_open(): open an sqlite3 database
+ *
+ * \p context: the lws_context
+ * \p sqlite3_path: the filepath to the database file
+ * \p create_if_missing: flag to control if the database is created or not if absent
+ * \p pdb: pointer to an sqlite3 * to be set to the database handle if successful
+ *
+ * Returns 0 for success, *pdb is valid, else nonzero for failure
+ */
 LWS_VISIBLE LWS_EXTERN int
-lws_struct_sq3_serialize(sqlite3 *pdb, const lws_struct_map_t *schema,
-			 lws_dll2_owner_t *owner, uint32_t manual_idx);
+lws_struct_sq3_open(struct lws_context *context, const char *sqlite3_path,
+		    char create_if_missing, sqlite3 **pdb);
 
+/*
+ * lws_struct_sq3_close(): close db handle
+ *
+ * \p pdb: pointer to sqlite3 * that will be set to NULL
+ *
+ * *pdb will be closed and set to NULL.
+ */
 LWS_VISIBLE LWS_EXTERN int
-lws_struct_sq3_deserialize(sqlite3 *pdb, const char *filter, const char *order,
-			   const lws_struct_map_t *schema, lws_dll2_owner_t *o,
-			   struct lwsac **ac, int start, int limit);
+lws_struct_sq3_close(sqlite3 **pdb);
+
+/*
+ * lws_struct_sq3_create_table(): ensure table exists with correct schema
+ *
+ * \p pdb: sqlite3 database handle
+ * \p schema: map describing table name and schema details
+ */
 
 LWS_VISIBLE LWS_EXTERN int
 lws_struct_sq3_create_table(sqlite3 *pdb, const lws_struct_map_t *schema);
 
+/*
+ * struct -> sqlite3 (list)
+ */
+
+/**
+ * lws_struct_sq3_serialize(): store objects pointed to by owner in the db
+ *
+ * \p pdb: the open sqlite3 db
+ * \p schema: the schema (and db table) to use
+ * \p owner: the list of objects to store to the db table
+ * \p manual_idx: the starting index for the objects
+ *
+ */
 LWS_VISIBLE LWS_EXTERN int
-lws_struct_sq3_open(struct lws_context *context, const char *sqlite3_path,
-		    char create_if_missing, sqlite3 **pdb);
+lws_struct_sq3_serialize(sqlite3 *pdb, const lws_struct_map_t *schema,
+			 lws_dll2_owner_t *owner, uint32_t manual_idx);
+
+/*
+ * struct -> sqlite3 (single)
+ */
+
 
 LWS_VISIBLE LWS_EXTERN int
-lws_struct_sq3_close(sqlite3 **pdb);
+lws_struct_sq3_update(sqlite3 *pdb, const char *table,
+		      const lws_struct_map_t *map, size_t map_entries, const void *data,
+		      const char *where_col);
+
+LWS_VISIBLE LWS_EXTERN int
+lws_struct_sq3_upsert(sqlite3 *pdb, const char *table,
+		      const lws_struct_map_t *map, size_t map_entries, const void *data,
+		      const char *where_col);
+
+/*
+ * sqlite3 -> struct(s) in lwsac
+ */
+
+LWS_VISIBLE LWS_EXTERN int
+lws_struct_sq3_deserialize(sqlite3 *pdb, const char *filter, const char *order,
+			   const lws_struct_map_t *schema, lws_dll2_owner_t *o,
+			   struct lwsac **ac, int start, int limit);
+
 

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

@@ -108,6 +108,9 @@ typedef enum { /* keep system_state_names[] in sync in context.c */
 	LWS_SYSTATE_CONTEXT_CREATED,	 /* context was just created */
 	LWS_SYSTATE_INITIALIZED,	 /* protocols initialized.  Lws itself
 					  * can operate normally */
+	LWS_SYSTATE_COLLECTING_STDIN,	 /* we are waiting for stdin RX and / or
+					  * closure.  This is skipped if
+					  * system_ops.stdin_rx is NULL */
 	LWS_SYSTATE_IFACE_COLDPLUG,	 /* existing net ifaces iterated */
 	LWS_SYSTATE_DHCP,		 /* at least one net iface configured */
 	LWS_SYSTATE_CPD_PRE_TIME,	 /* Captive portal detect without valid
@@ -133,6 +136,11 @@ typedef enum { /* keep system_state_names[] in sync in context.c */
 	LWS_SYSTATE_AUTH1,		 /* identity used for main auth token */
 	LWS_SYSTATE_AUTH2,		 /* identity used for optional auth */
 
+	LWS_SYSTATE_ONE_TIME_UPDATES,	 /* pre-OPERATIONAL one-time updates,
+					  * when a firmware needs to perform
+					  * one-time upgrades to state before
+					  * OPERATIONAL */
+
 	LWS_SYSTATE_OPERATIONAL,	 /* user code can operate normally */
 
 	LWS_SYSTATE_POLICY_INVALID,	 /* user code is changing its policies
@@ -140,6 +148,9 @@ typedef enum { /* keep system_state_names[] in sync in context.c */
 					  * policy, switch to new then enter
 					  * LWS_SYSTATE_POLICY_VALID */
 	LWS_SYSTATE_CONTEXT_DESTROYING,	 /* Context is being destroyed */
+	LWS_SYSTATE_AWAITING_MODAL_UPDATING,	 /* We're negotiating with the
+						  * user code for update mode */
+	LWS_SYSTATE_MODAL_UPDATING,	 /* We're updating the firmware */
 } lws_system_states_t;
 
 /* Captive Portal Detect -related */
@@ -187,11 +198,12 @@ typedef struct lws_system_ops {
 	 * by calling lws_captive_portal_detect_result() api
 	 */
 
+#if defined(LWS_WITH_NETWORK)
 	int (*metric_report)(lws_metric_pub_t *mdata);
 	/**< metric \p item is reporting an event of kind \p rpt,
 	 * held in \p mdata... return 0 to leave the metric object as it is,
 	 * or nonzero to reset it. */
-
+#endif
 	int (*jit_trust_query)(struct lws_context *cx, const uint8_t *skid,
 			       size_t skid_len, void *got_opaque);
 	/**< user defined trust store search, if we do trust a cert with SKID
@@ -201,7 +213,22 @@ typedef struct lws_system_ops {
 	 * returning.  The DER should be destroyed if in heap before returning.
 	 */
 
-	uint32_t	wake_latency_us;
+	int (*stdin_rx)(struct lws_context *cx, const char *buf, size_t len);
+	/**< anything from stdin turns up here, eg, echo -n 123 | ./myapp will
+	 * cause this to be called with buf = "123" and len=3.  If stdin closes
+	 * before the event loop terminates, we will be called with buf = NULL
+	 * and len = 0 and nothing further, since stdin will be closed.  This is
+	 * very handy for passing secrets into your app that will not be visible
+	 * to others via the commandline and with solid behaviours whenever the
+	 * stdin source closes.
+	 */
+
+#if defined(LWS_WITH_OTA)
+	lws_ota_ops_t		ota_ops;
+	/**< Platform OTA interface to lws_ota, see lws-ota.h */
+#endif
+
+	uint32_t		wake_latency_us;
 	/**< time taken for this device to wake from suspend, in us
 	 */
 } lws_system_ops_t;
@@ -309,6 +336,7 @@ enum {
 	_LWSDH_SA46_COUNT,
 };
 
+#if defined(LWS_WITH_NETWORK)
 typedef struct lws_dhcpc_ifstate {
 	char				ifname[16];
 	char				domain[64];
@@ -397,3 +425,41 @@ lws_system_cpd_set(struct lws_context *context, lws_cpd_result_t result);
  */
 LWS_EXTERN LWS_VISIBLE lws_cpd_result_t
 lws_system_cpd_state_get(struct lws_context *context);
+
+enum {
+	LWS_SAS_FLAG__APPEND_COMMANDLINE	= (1 << 0)
+};
+
+/**
+ * lws_system_adopt_stdin(): add stdin to be a wsi handled by the event loop
+ *
+ * \param context: the lws_context
+ *
+ * The user code should call this after context creation.  It will add stdin
+ * to the context event loop and handle it one of two ways
+ *
+ * 1) flags has LWS_SAS_FLAG__APPEND_COMMANDLINE set: internally manage the
+ *    stdin input as additional commandline content that can be accessed
+ *    alongside the official commandline context using the
+ *    lws_cmdline_option_cx() api.  Note this a) requires you to pass your
+ *    app argc and argv to the same-named context creation info struct members,
+ *    and b) is only effective after context creation.  This is very useful if
+ *    passing secrets to your app that can't appear on the commandline.  Or,
+ *
+ *  2) flags = 0: ignore the received stdin input internally, and call back
+ *  rx data (and close) to lws_system to the .stdin_rx callback.
+ *
+ * The callback is called with a buffer and length for received RX from stdin,
+ * which may be arbitrarily fragmented.  If it's called with a NULL buffer and
+ * 0 length, it means stdin was closed.
+ *
+ * Your callback should process the provided RX passed to it, and choose to
+ * return 0 to continue to wait for stdin RX, or nonzero to close stdin and
+ * continue the lws_system state startup.
+ */
+LWS_EXTERN LWS_VISIBLE int
+lws_system_adopt_stdin(struct lws_context *cx, unsigned int flags);
+
+
+#endif
+

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

@@ -28,6 +28,11 @@
 */
 //@{
 
+#if defined(STANDALONE)
+struct lws_context_standalone;
+#define lws_context lws_context_standalone
+#endif
+
 /*
  * NOTE: These public enums are part of the abi.  If you want to add one,
  * add it at where specified so existing users are unaffected.
@@ -301,4 +306,8 @@ __lws_sul_insert(lws_dll2_owner_t *own, lws_sorted_usec_list_t *sul);
 LWS_VISIBLE LWS_EXTERN lws_usec_t
 __lws_sul_service_ripe(lws_dll2_owner_t *own, int own_len, lws_usec_t usnow);
 
+#if defined(STANDALONE)
+#undef lws_context
+#endif
+
 ///@}

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

@@ -47,11 +47,18 @@
 #define LWS_TOKENIZE_F_ASTERISK_NONTERM	(1 << 9)
 /* Do not treat = as a terminal character, so "x=y" is one token */
 #define LWS_TOKENIZE_F_EQUALS_NONTERM	(1 << 10)
+/* Do not treat : as a terminal character, so ::1 is one token */
+#define LWS_TOKENIZE_F_COLON_NONTERM	(1 << 11)
+
+/* We're just tokenizing a chunk, don't treat running out of input as final */
+#define LWS_TOKENIZE_F_EXPECT_MORE	(1 << 12)
 
 typedef enum {
 
-	LWS_TOKZE_ERRS			=  5, /* the number of errors defined */
+	LWS_TOKZE_ERRS			=  7, /* the number of errors defined */
 
+	LWS_TOKZE_TOO_LONG		= -7,	/* token too long */
+	LWS_TOKZE_WANT_READ		= -6,	/* need more input */
 	LWS_TOKZE_ERR_BROKEN_UTF8	= -5,	/* malformed or partial utf8 */
 	LWS_TOKZE_ERR_UNTERM_STRING	= -4,	/* ended while we were in "" */
 	LWS_TOKZE_ERR_MALFORMED_FLOAT	= -3,	/* like 0..1 or 0.1.1 */
@@ -84,16 +91,32 @@ enum lws_tokenize_delimiter_tracking {
 	LWSTZ_DT_NEED_NEXT_CONTENT,
 };
 
+typedef enum {
+	LWS_TOKZS_LEADING_WHITESPACE,
+	LWS_TOKZS_QUOTED_STRING,
+	LWS_TOKZS_TOKEN,
+	LWS_TOKZS_TOKEN_POST_TERMINAL
+} lws_tokenize_state;
+
 typedef struct lws_tokenize {
+	char collect[256]; /* token length limit */
 	const char *start; /**< set to the start of the string to tokenize */
 	const char *token; /**< the start of an identified token or delimiter */
 	size_t len;	/**< set to the length of the string to tokenize */
 	size_t token_len;	/**< the length of the identied token or delimiter */
 
+	lws_tokenize_state state;
+
+	int line;
+	int effline;
+
 	uint16_t flags;	/**< optional LWS_TOKENIZE_F_ flags, or 0 */
 	uint8_t delim;
 
 	int8_t e; /**< convenient for storing lws_tokenize return */
+	uint8_t reset_token:1;
+	uint8_t crlf:1;
+	uint8_t dry:1;
 } lws_tokenize_t;
 
 /**