LNXCORE/v8/include/libwebsockets/lws-secure-streams-serialization.h

/*
 * libwebsockets - small server side websockets and web server implementation
 *
 * Copyright (C) 2019 - 2021 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.
 *
 * included from libwebsockets.h
 *
 * This defines the Serialized Secure Streams framing, and the optional
 * lws_transport_mux framing.
 *
 * APIs are declared for lws_transport and binding those to the SSPC and proxy
 * sides in lws.
 */

#if defined(STANDALONE)
struct lws_context_standalone;
#define lws_context lws_context_standalone
#endif

#define LWSSSS_VERSION 1

typedef enum {
	/*
	 * This is the Serialized Serure Streams framing.  It's sufficient to
	 * carry all SS API actions over a point-to-point bytestream between
	 * an SSPC client and an SS oroxy, in both directions.
	 *
	 * These serialized streams may be multiplexed by the transport (eg,
	 * for unix domain sockets transport, each SS opens its own UDS socket
	 * to the proxy) or via lws_transport_mux framing encapsulation.
	 *
	 *
	 * Framing for Proxy -> Client direction
	 */

	LWSSS_SER_RXPRE_RX_PAYLOAD				= 0x55,
	/*
	 * Proxied rx
	 *
	 *   -  0: LWSSS_SER_RXPRE_RX_PAYLOAD
	 *   -  1: 2 byte MSB-first rest-of-frame length
	 *   -  3: 4-byte MSB-first flags
	 *   -  7: 4-byte MSB-first us between inbound read and wrote to client
	 *   - 11: 8-byte MSB-first us resolution unix time proxy wrote to client
	 *   - 17: (rideshare name len + rideshare name if flags &
	 *   		LWSSS_FLAG_RIDESHARE) payload
	 */
	LWSSS_SER_RXPRE_CREATE_RESULT,
	/*
	 * Proxied connection setup result
	 *
	 *   -  0: LWSSS_SER_RXPRE_CREATE_RESULT
	 *   -  1: 2 byte MSB-first rest-of-frame length (usually 00, 03)
	 *   -  3: 1 byte result, 0 = success.  On failure, proxy will close
	 *   		connection.
	 *   -  4: 4 byte client dsh allocation recommended for stream type,
	 *   		from policy (introduced in SSSv1)
	 *   -  8: 2 byte MSB-first initial tx credit
	 *   - 10: if present, comma-sep list of rideshare types from policy
	 */
	LWSSS_SER_RXPRE_CONNSTATE,
	/*
	 * Proxied state (8 or 11 byte packet)
	 *
	 *   -  0: LWSSS_SER_RXPRE_CONNSTATE
	 *   -  1: 00, 05 if state < 256, else 00, 08
	 *   -  3: 1 byte state index if state < 256, else 4-byte MSB-first
	 *   		state index
	 *   -  4 or 7: 4-byte MSB-first ordinal
	 */
	LWSSS_SER_RXPRE_TXCR_UPDATE,
	/*
	 * Proxied tx credit
	 *
	 *   -  0: LWSSS_SER_RXPRE_TXCR_UPDATE
	 *   -  1: 00, 04
	 *   -  3: 4-byte MSB-first addition tx credit bytes
	 */
	LWSSS_SER_RXPRE_METADATA,
	/*
	 * Proxied rx metadata
	 *
	 *   -  0: LWSSS_SER_RXPRE_METADATA
	 *   -  1: 2-byte MSB-first rest-of-frame length
	 *   -  3: 1-byte metadata name length
	 *   -  4: metadata name
	 *   -  ...: metadata value (for rest of packet)
	 */
	LWSSS_SER_RXPRE_TLSNEG_ENCLAVE_SIGN,
	/* reserved */
	LWSSS_SER_RXPRE_PERF,
	/*
	 * Proxied performance information
	 *
	 *   -  0: LWSSS_SER_RXPRE_PERF
	 *   -  1: 2-byte MSB-first rest-of-frame length
	 *   -  3: ... performance JSON (for rest of packet)
	 */

	/*
	 * Framing for Client -> Proxy direction
	 */

	LWSSS_SER_TXPRE_STREAMTYPE				= 0xaa,
	/*
	 * Proxied connection setup
	 *
	 *   -  0: LWSSS_SER_TXPRE_STREAMTYPE
	 *   -  1: 2-byte MSB-first rest-of-frame length
	 *   -  3: 1-byte Client SSS protocol version (introduced in SSSv1)
	 *   -  4: 4-byte Client PID (introduced in SSSv1)
	 *   -  8: 4-byte MSB-first initial tx credit
	 *   - 12: the streamtype name with no NUL
	 */
	LWSSS_SER_TXPRE_ONWARD_CONNECT,
	/*
	 * Proxied request for onward connection
	 *
	 *   -  0: LWSSS_SER_TXPRE_ONWARD_CONNECT
	 *   -  1: 00, 00
	 */
	LWSSS_SER_TXPRE_DESTROYING,
	/*
	 * Proxied secure stream destroy
	 *
	 *   -  0: LWSSS_SER_TXPRE_DESTROYING
	 *   -  1: 00, 00
	 */
	LWSSS_SER_TXPRE_TX_PAYLOAD,
	/*
	 * Proxied tx
	 *
	 *   -  0: LWSSS_SER_TXPRE_TX_PAYLOAD
	 *   -  1: 2 byte MSB-first rest-of-frame length
	 *   -  3: 4-byte MSB-first flags
	 *   -  7: 4-byte MSB-first us between client requested write and wrote
	 *   			    to proxy
	 *   - 11: 8-byte MSB-first us resolution unix time client wrote to proxy
	 *   - 19: ...payload  (for rest of packet)
	 */
	LWSSS_SER_TXPRE_METADATA,
	/*
	 * Proxied metadata - sent when one metadata item set clientside
	 *
	 *   -  0: LWSSS_SER_TXPRE_METADATA
	 *   -  1: 2-byte MSB-first rest-of-frame length
	 *   -  3: 1-byte metadata name length
	 *   -  4: metadata name
	 *   -  ...: metadata value (for rest of packet)
	 */
	LWSSS_SER_TXPRE_TXCR_UPDATE,
	/*
	 * TX credit management - sent when using tx credit apis, cf METADATA
	 *
	 *   - 0: LWSSS_SER_TXPRE_TXCR_UPDATE
	 *   - 1: 2-byte MSB-first rest-of-frame length 00, 04
	 *   - 3: 4-byte additional tx credit adjust value
	 */
	LWSSS_SER_TXPRE_TIMEOUT_UPDATE,
	/*
	 * Stream timeout management - forwarded when user applying or
	 *  	cancelling t.o.
	 *
	 *   -  0: LWSSS_SER_TXPRE_TIMEOUT_UPDATE
	 *   -  1: 2-byte MSB-first rest-of-frame length 00, 04
	 *   -  3: 4-byte MSB-first unsigned 32-bit timeout,
	 *   			0 = use policy, -1 = cancel
	 */
	LWSSS_SER_TXPRE_PAYLOAD_LENGTH_HINT,
	/*
	 * Passing up payload length hint
	 *
	 *   -  0: LWSSS_SER_TXPRE_PAYLOAD_LENGTH_HINT
	 *   -  1: 2-byte MSB-first rest-of-frame length 00, 04
	 *   -  3: 4-byte MSB-first unsigned 32-bit payload length hint
	 */
	LWSSS_SER_TXPRE_TLSNEG_ENCLAVE_SIGNED,
	/* reserved */
	LWSSS_SER_TXPRE_LINK_VALIDITY_PROBE,
} lws_sss_cmds_t;

/* SSPC serialization states */

 typedef enum {
 	LPCSPROX_WAIT_INITIAL_TX = 1, /* after connect, must send streamtype */
 	LPCSPROX_REPORTING_FAIL, /* stream creation failed, wait to to tell */
 	LPCSPROX_REPORTING_OK, /* stream creation succeeded, wait to to tell */
 	LPCSPROX_OPERATIONAL, /* ready for payloads */
 	LPCSPROX_DESTROYED,

 	LPCSCLI_SENDING_INITIAL_TX,  /* after connect, must send streamtype */
 	LPCSCLI_WAITING_CREATE_RESULT,   /* wait to hear if proxy ss create OK */
 	LPCSCLI_LOCAL_CONNECTED,	      /* we are in touch with the proxy */
 	LPCSCLI_ONWARD_CONNECT,	      /* request onward ss connection */
 	LPCSCLI_OPERATIONAL, /* ready for payloads */

 } lws_ss_conn_states_t;

 /*
  * Optional multiplexing layer
  *
  * Either side can:
  *
  *  - open and close channels asynchronously
  *  - send and receive transport-level (not mux channel) timed PINGs / PONGs
  *  - send and receive data bound to an open mux channel
  *
  *  PONGs are produced and sent automatically on recipt of a PING from the peer
  *  The peer sends a PONGACK so the single transaction can validate connection
  *  viability in both directions.
  */

 enum {
	 LWSSSS_LLM_CHANNEL_REQ					= 0xf0,
	 /**<
	  * Either side proposes to open a new mux channel
	  *
	  *  - 0: LWSSSS_LLM_CHANNEL_REQ
	  *  - 1: 1-byte mux channel index, client initiated: first free from
	  *         zero up, server initiated: first free from 0xff down
	  */
	 LWSSSS_LLM_CHANNEL_ACK,
	 /**<
	  * Positive response to earlier LWSSSS_LLM_CHANNEL_REQ
	  *
	  *  - 0: LWSSSS_LLM_CHANNEL_ACK
	  *  - 1: 1-byte mux channel index, from the reqyuest
	  */
	 LWSSSS_LLM_CHANNEL_NACK,
	 /**<
	  * Negative response to earlier LWSSSS_LLM_CHANNEL_REQ.  This also acts
	  * as a FIN if one arrives on a channel unsolicited.
	  *
	  *  - 0: LWSSSS_LLM_CHANNEL_NACK
	  *  - 1: 1-byte mux channel index, from the reqyuest
	  */
	 LWSSSS_LLM_CHANNEL_CLOSE,
	 /**<
	  * Either side informs peer it is closing a mux channel
	  *
	  *  - 0: LWSSSS_LLM_CHANNEL_CLOSE
	  *  - 1: 1-byte mux channel index
	  */
	 LWSSSS_LLM_CHANNEL_CLOSE_ACK,
	 /**<
	  * Peer acknowledges closing a mux channel, so it can be reused
	  *
	  *  - 0: LWSSSS_LLM_CHANNEL_CLOSE_ACK
	  *  - 1: 1-byte mux channel index
	  */
	 LWSSSS_LLM_MUX,
	 /**<
	  * Encapsulate data on an open mux channel
	  *
	  *  - 0: LWSSSS_LLM_MUX
	  *  - 1: 1-byte mux channel index
	  *  - 2: 2-byte MSB-first rest-of-frame length
	  *  - 4... mux payload
	  */
	 LWSSSS_LLM_PING,
	 /**<
	  * Either side wants to validate communication on mux transport
	  *
	  *  - 0: LWSSSS_LLM_PING
	  *  - 1:  8-byte MSB-first us resolution unix time this was issued
	  */
	 LWSSSS_LLM_PONG,
	 /**<
	  * Either side responds to peer's PING.
	  *
	  *  - 0: LWSSSS_LLM_PONG
	  *  - 1: 8-byte MSB-first us resolution unix time from PING
	  *  - 9: 8-byte MSB-first us resolution unix time this PONG sent
	  */
	 LWSSSS_LLM_PONGACK,
	 /**<
	  * When the original PING sender receives a PONG, it immediately sends
	  * a PINGACK, which is not replied to.  This allows the other side to
	  * also know the connection is valid in both directions, with only one
	  * side needing to issue PINGs.
	  *
	  * It also synchronizes both sides' understanding of the transport
	  * validity in one transaction.
	  *
	  *  - 0: LWSSSS_LLM_PONGACK
	  *  - 1: 8-byte MSB-first us resolution unix time from PING
	  */
	 LWSSSS_LLM_RESET_TRANSPORT,
	 /**<
	  * Either side can issue this to indicate they no longer trust the
	  * transport link.  They should close all their channels and enter a
	  * state trying to resync using 3-way PINGs
	  */
};

typedef void * lws_transport_priv_t; /* care - this is a pointer type already */
struct lws_transport_mux;
struct lws_sss_proxy_conn;
struct lws_transport_client_ops;
struct lws_transport_proxy_ops;
struct lws_sspc_handle;

/*
 * These describe the path through different transport layers.  Each has an
 * 'in' and 'onw' (onward) side that can be bound to different parts in lws.
 * SSPC and the SS Proxy code in lws each exposes one of these as terminals
 * for the "path" to handle the SS Serialization on each side.
 *
 * sspc-transport-wsi and proxy-transport-wsi expose possible endpoints for the
 * paths, so you can simply "wire SSPC and proxy up to a wsi transport".
 *
 * You can also create a lws_transport_mux_t and interpose it in the transport
 * path on each side, and produce your own custom lws_transport ops implementing
 * arbitrary transport support.
 */

typedef struct lws_txp_path_client {
	const struct lws_transport_client_ops	*ops_in;
	lws_transport_priv_t			priv_in;
	const struct lws_transport_client_ops	*ops_onw;
	lws_transport_priv_t			priv_onw;
	struct lws_transport_mux		*mux;
} lws_txp_path_client_t;

typedef struct lws_txp_path_proxy {
	const struct lws_transport_proxy_ops	*ops_in;
	lws_transport_priv_t			priv_in;
	const struct lws_transport_proxy_ops	*ops_onw;
	lws_transport_priv_t			priv_onw;
	struct lws_transport_mux		*mux;
} lws_txp_path_proxy_t;

/*
 * Operations for client-side transport
 */

typedef struct lws_transport_client_ops {
	const char *name;

 	int (*event_retry_connect)(lws_txp_path_client_t *path,
 				   struct lws_sspc_handle *h);
 	/**< Attempt to create a new connection / channel to the proxy */
 	lws_ss_state_return_t (*event_connect_disposition)(
 			       struct lws_sspc_handle *h, int disposition);
 	/**< Connection attempt result, disposition 9 = success, else failed */
 	void (*req_write)(lws_transport_priv_t priv);
 	/**< Request a write to the proxy on this channel */
 	int (*_write)(lws_transport_priv_t priv, uint8_t *buf, size_t len);
 	/**< Write the requested data on the channel to the proxy *** MUST have
 	 * LWS_PRE usable behind buf */
 	lws_ss_state_return_t (*event_read)(lws_transport_priv_t priv,
 					    const uint8_t *buf, size_t len);
 	/**< len bytes at buf have been received */
 	void (*lost_coherence)(lws_transport_priv_t priv);
 	/**< report that the framing inside the mux channel is broken */
 	void (*_close)(lws_transport_priv_t priv);
 	/**< Close the channel to the proxy */
 	void (*event_stream_up)(lws_transport_priv_t priv);
 	/**< Called when a new channel to the proxy is acknowledged as up */
	void (*event_client_up)(lws_transport_priv_t priv);
	/**< Called when a client channel is acknowledged as up */
	lws_ss_state_return_t (*event_can_write)(struct lws_sspc_handle *h,
						 size_t metadata_limit);
	/**< Called when possible to write on the transport, after req_write */
	lws_ss_state_return_t (*event_closed)(lws_transport_priv_t priv /*struct lws_sspc_handle *h */);
	/**< we notice an onward proxy connection had closed */
	uint32_t			flags;
	/**< Used for DSH creation flags */
	uint32_t			dsh_splitat;
} lws_transport_client_ops_t;

/*
 * Operations for proxy-side transport
 */

typedef struct lws_transport_proxy_ops {
	const char *name;
	int (*init_proxy_server)(struct lws_context *context,
			   const struct lws_transport_proxy_ops *txp_ops_inward,
			   lws_transport_priv_t txp_priv_inward,
			   lws_txp_path_proxy_t *txp_ppath, const void *aux,
			   const char *bind, int port);
	/**< Instantiate a proxy transport... bind/port are as shown for wsi
	 * transport, but may be overloaded to provide transport-specific init */
	int (*destroy_proxy_server)(struct lws_context *context);
	lws_ss_state_return_t (*event_new_conn)(struct lws_context *cx,
				const struct lws_transport_proxy_ops *txp_ops_inward,
				lws_transport_priv_t txp_priv_inward,
	#if defined(LWS_WITH_SYS_FAULT_INJECTION)
				         const lws_fi_ctx_t *fic,
	#endif
				struct lws_sss_proxy_conn **conn,
				lws_transport_priv_t txp_priv);
	/**< proxy has received a new connection from client */
	void (*event_onward_bind)(lws_transport_priv_t priv,
				  struct lws_ss_handle *h);
	/**< Called when the proxy creates an onward SS for a client channel */
 	void (*proxy_req_write)(lws_transport_priv_t priv);
 	/**< Request a write to the proxy on this channel */
	lws_ss_state_return_t (*event_proxy_can_write)(
			lws_transport_priv_t priv
#if defined(LWS_WITH_SYS_FAULT_INJECTION)
					, const lws_fi_ctx_t *fic
#endif
			);
	/**< Transport can now be written on, after earlier proxy_req_write */
 	int (*proxy_write)(lws_transport_priv_t priv, uint8_t *buf, size_t *len);
 	/**< Write the requested data on the channel to the proxy *** MUST have
 	 * LWS_PRE usable behind buf.  May do partial writes, len is set on return
 	 * to actual length written*/
	lws_ss_state_return_t (*event_close_conn)(
				struct lws_sss_proxy_conn *conn);
	/**< proxy sees an existing conn closes */
#if defined(LWS_WITH_SYS_FAULT_INJECTION)
	const lws_fi_ctx_t * (*fault_context)(lws_transport_priv_t priv);
	/**< Get the fault context relating to the proxy connection, if any */
#endif
 	lws_ss_state_return_t (*close_conn)(struct lws_sss_proxy_conn *conn);
 	/**< called to handle closure of underlying transport */
 	lws_ss_state_return_t (*proxy_read)(lws_transport_priv_t priv,
 					    const uint8_t *buf, size_t len);
	void (*event_client_up)(lws_transport_priv_t priv);
	/**< Called when the proxy has accepted a new client conn */
	int (*proxy_check_write_more)(lws_transport_priv_t priv);
	/**< optional, allows checking if we can write again */
	uint32_t			flags; /* dsh flags */
} lws_transport_proxy_ops_t;

/* lws_transport_mux parser states */

enum lwstmc_parser {
	LWSTMCPAR_CMD,
	LWSTMCPAR_CHIDX_DONE,
	LWSTMCPAR_CHIDX,
	LWSTMCPAR_PLENH,
	LWSTMCPAR_PLENL,
	LWSTMCPAR_PAY,
	LWSTMCPAR_T64_1,
	LWSTMCPAR_T64_2
};

/* lws_transport_mux channel definitions */

typedef uint8_t lws_mux_ch_idx_t;
#define LWS_MUCH_RANGE 256

/* lws_transport mux states */

enum {
	/* lws_transport_mux_ch_t created */
	LWSTMC_PENDING_CREATE_CHANNEL,	    /* waiting to send create channel */
	LWSTMC_AWAITING_CREATE_CHANNEL_ACK, /* sent create ch, awaiting ack */
	LWSTMC_PENDING_CREATE_CHANNEL_NACK, /* waiting to send create ch ack */
	LWSTMC_PENDING_CREATE_CHANNEL_ACK,  /* waiting to send create ch ack */
	LWSTMC_OPERATIONAL,		    /* had ack, we are operational */
	LWSTMC_PENDING_CLOSE_CHANNEL,	    /* waiting to send close channel */
	LWSTMC_AWAITING_CLOSE_CHANNEL_ACK,  /* sent close ch, awaiting ack */
	LWSTMC_PENDING_CLOSE_CHANNEL_ACK,   /* waiting to send close ch ack */
	/* lws_transport_mux_ch_t destroyed */
};

#define LWS_TRANSPORT_MUXCH_MAGIC LWS_FOURCC('T', 'm', 'C', 'h')
#define assert_is_tmch(_tm) lws_assert_fourcc(_tm->magic, LWS_TRANSPORT_MUXCH_MAGIC)

typedef struct lws_transport_mux_ch {
#if defined(_DEBUG)
	uint32_t				magic;
#endif
	lws_dll2_t				list;
	lws_dll2_t				list_pending_tx;
	lws_transport_priv_t			priv;
	lws_sorted_usec_list_t			sul;
	void					*opaque;
	lws_mux_ch_idx_t			ch_idx;
	uint8_t					state;
	uint8_t					server:1;
} lws_transport_mux_ch_t;

enum { /* states of the transport */
	LWSTM_TRANSPORT_DOWN,
	LWSTM_OPERATIONAL,
};

#define LWSTMINFO_SERVER			(1 << 0)

typedef struct lws_transport_info {
	uint32_t				ping_interval_us;
	/**< us inbetween transport mux sending pings on transport */
	uint32_t				pong_grace_us;
	/**< us we should wait for pong before assuming transport down */
	lws_txp_path_client_t			txp_cpath;
	lws_txp_path_proxy_t			txp_ppath;
	struct lws_transport_info		*onward_txp_info;
	uint32_t				flags; /* LWSTMINFO_.... */
} lws_transport_info_t;

#define LWS_TRANSPORT_MUX_MAGIC LWS_FOURCC('I', 's', 'T', 'M')
#define assert_is_tm(_tm) lws_assert_fourcc(_tm->magic, LWS_TRANSPORT_MUX_MAGIC)

typedef struct lws_transport_mux {
#if defined(_DEBUG)
	uint32_t				magic;
#endif
	struct lws_context			*cx;
	lws_transport_info_t			info;
	lws_sorted_usec_list_t			sul_ping;
	void					*txp_handle;
	void					*txp_aux;
	uint64_t				us_ping_in;
	uint64_t				us_ping_out;
	uint64_t				us_unixtime_peer;
	uint64_t				us_unixtime_peer_loc;
	uint64_t				mp_time;
	uint64_t				mp_time1;
	enum lwstmc_parser			mp_state;
	uint32_t				mp_pay; /* remaining payload */
	uint8_t					mp_cmd;
	lws_mux_ch_idx_t			mp_idx;
	uint8_t					mp_ctr;
	uint32_t				_open[LWS_MUCH_RANGE / 32];
	uint32_t				fin[LWS_MUCH_RANGE / 32];
	lws_dll2_owner_t			pending_tx;
	lws_dll2_owner_t			owner; /* lws_mux_ch_t */
	uint8_t					link_state;
	uint8_t					issue_ping:1;
	uint8_t					issue_pong:1;
	uint8_t					issue_pongack:1;
	uint8_t					awaiting_pong:1;
} lws_transport_mux_t;

lws_transport_mux_t *
lws_transport_mux_create(struct lws_context *cx, lws_transport_info_t *info,
			 void *txp_handle);

void
lws_transport_mux_destroy(lws_transport_mux_t **tm);

void
lws_transport_mux_request_tx(lws_transport_mux_t *tm);

#if defined(_DEBUG)
void
lws_transport_path_client_dump(lws_txp_path_client_t *path, const char *ctx);
void
lws_transport_path_proxy_dump(lws_txp_path_proxy_t *path, const char *ctx);
#else
#define lws_transport_path_client_dump(_a, _b)
#define lws_transport_path_proxy_dump(_a, _b)
#endif

/*
 * Callback set used to customize parser and _pending apis
 */

typedef struct lws_txp_mux_parse_cbs {
	int (*payload)(lws_transport_mux_ch_t *tmc, const uint8_t *buf,
			size_t len);
	int (*ch_opens)(lws_transport_mux_ch_t *tmc, int determination);
	int (*ch_closes)(lws_transport_mux_ch_t *tmc);
	void (*txp_req_write)(lws_transport_mux_t *tm);
	int (*txp_can_write)(lws_transport_mux_ch_t *tmc);
} lws_txp_mux_parse_cbs_t;

int
lws_transport_mux_rx_parse(lws_transport_mux_t *tm, const uint8_t *buf,
			   size_t len, const lws_txp_mux_parse_cbs_t *cbs);

int /* nonzero if the transport mux has filled buf and wants to write it */
lws_transport_mux_pending(lws_transport_mux_t *tm, uint8_t *buf, size_t *len,
			  const lws_txp_mux_parse_cbs_t *cbs);

extern const lws_transport_client_ops_t lws_transport_mux_client_ops;
extern const lws_transport_proxy_ops_t lws_transport_mux_proxy_ops;

extern const lws_transport_client_ops_t lws_txp_inside_sspc;
extern const lws_transport_proxy_ops_t lws_txp_inside_proxy;

#if defined(STANDALONE)
#undef lws_context
#endif