plugins/protocol_lws_raw_test.c - platform/external/libwebsockets - Gitiles

 /*
  * ws protocol handler plugin for testing raw file and raw socket
  *
  * Written in 2010-2019 by Andy Green <andy@warmcat.com>
  *
  * This file is made available under the Creative Commons CC0 1.0
  * Universal Public Domain Dedication.
  *
  * The person who associated a work with this deed has dedicated
  * the work to the public domain by waiving all of his or her rights
  * to the work worldwide under copyright law, including all related
  * and neighboring rights, to the extent allowed by law. You can copy,
  * modify, distribute and perform the work, even for commercial purposes,
  * all without asking permission.
  *
  * These test plugins are intended to be adapted for use in your code, which
  * may be proprietary.  So unlike the library itself, they are licensed
  * Public Domain.
  *
  * This plugin test both raw file descriptors and raw socket descriptors.  It
  * can test both or just one depending on how you configure it.  libwebsockets-
  * test-server-v2.0 is set up to test both.
  *
  * RAW File Descriptor Testing
  * ===========================
  *
  * Enable on a vhost like this
  *
  *        "protocol-lws-raw-test": {
  *                 "status": "ok",
  *                 "fifo-path": "/tmp/lws-test-raw"
  *        },
  *
  * Then you can feed it data through the FIFO like this
  *
  *  $ sudo sh -c "echo hello > /tmp/lws-test-raw"
  *
  * This plugin simply prints the data.  But it does it through the lws event
  * loop / service poll.
  *
  *
  * RAW Socket Descriptor Testing
  * =============================
  *
  * 1) You must give the vhost the option flag
  * 	LWS_SERVER_OPTION_FALLBACK_TO_APPLY_LISTEN_ACCEPT_CONFIG
  *
  * 2) Enable on a vhost like this
  *
  *        "protocol-lws-raw-test": {
  *                 "status": "ok",
  *                 "raw": "1"
  *        },
  *
  *    The "raw" pvo marks this protocol as being used for RAW connections.
  *
  * 3) Run libwebsockets-test-server-v2.0 and connect to it by telnet, eg
  *
  *    telnet 127.0.0.1 7681
  *
  *    type something that isn't a valid HTTP method and enter, before the
  *    connection times out.  The connection will switch to RAW mode using this
  *    protocol, and pass the unused rx as a raw RX callback.
  *
  *    The test protocol echos back what was typed on telnet to telnet.
  */

 #if !defined (LWS_PLUGIN_STATIC)
 #if !defined(LWS_DLL)
 #define LWS_DLL
 #endif
 #if !defined(LWS_INTERNAL)
 #define LWS_INTERNAL
 #endif
 #include <libwebsockets.h>
 #endif

 #include <string.h>
 #include <fcntl.h>

 #include <sys/stat.h>

 struct per_vhost_data__raw_test {
 	struct lws_context *context;
 	struct lws_vhost *vhost;
 	const struct lws_protocols *protocol;
 	char fifo_path[100];
 	int fifo;
 	char zero_length_read;
 };

 struct per_session_data__raw_test {
 	int number;
 	unsigned char buf[128];
 	int len;
 };

 static int
 callback_raw_test(struct lws *wsi, enum lws_callback_reasons reason, void *user,
 		  void *in, size_t len)
 {
 	struct per_session_data__raw_test *pss =
 			(struct per_session_data__raw_test *)user;
 	struct per_vhost_data__raw_test *vhd =
 			(struct per_vhost_data__raw_test *)
 			lws_protocol_vh_priv_get(lws_get_vhost(wsi),
 					lws_get_protocol(wsi));
 	lws_sock_file_fd_type u;

 	(void)pss;

 	switch (reason) {
 	case LWS_CALLBACK_PROTOCOL_INIT:
 		vhd = lws_protocol_vh_priv_zalloc(lws_get_vhost(wsi),
 				lws_get_protocol(wsi),
 				sizeof(struct per_vhost_data__raw_test));
 		if (!vhd)
 			return 0;
 		vhd->context = lws_get_context(wsi);
 		vhd->protocol = lws_get_protocol(wsi);
 		vhd->vhost = lws_get_vhost(wsi);
 		{
 			const struct lws_protocol_vhost_options *pvo =
 				(const struct lws_protocol_vhost_options *)in;
 			while (pvo) {
 				if (!strcmp(pvo->name, "fifo-path"))
 					lws_strncpy(vhd->fifo_path, pvo->value,
 							sizeof(vhd->fifo_path));
 				pvo = pvo->next;
 			}
 			if (vhd->fifo_path[0] == '\0') {
 				lwsl_warn("%s: Missing pvo \"fifo-path\", "
 					 "raw file fd testing disabled\n",
 					 __func__);
 				break;
 			}
 		}
 		unlink(vhd->fifo_path);
 		if (mkfifo(vhd->fifo_path, 0666)) {
 			lwsl_err("mkfifo failed\n");
 			return 1;
 		}
 		vhd->fifo = lws_open(vhd->fifo_path, O_NONBLOCK | O_RDONLY);
 		if (vhd->fifo == -1) {
 			lwsl_err("opening fifo failed\n");
 			unlink(vhd->fifo_path);
 			return 1;
 		}
 		lwsl_notice("FIFO %s created\n", vhd->fifo_path);
 		u.filefd = vhd->fifo;
 		if (!lws_adopt_descriptor_vhost(vhd->vhost,
 						LWS_ADOPT_RAW_FILE_DESC, u,
 						"protocol-lws-raw-test",
 						NULL)) {
 			lwsl_err("Failed to adopt fifo descriptor\n");
 			close(vhd->fifo);
 			unlink(vhd->fifo_path);
 			return 1;
 		}
 		break;

 	case LWS_CALLBACK_PROTOCOL_DESTROY:
 		if (!vhd)
 			break;
 		if (vhd->fifo >= 0) {
 			close(vhd->fifo);
 			unlink(vhd->fifo_path);
 		}
 		break;


 	/*
 	 * Callbacks related to Raw file descriptor testing
 	 */

 	case LWS_CALLBACK_RAW_ADOPT_FILE:
 		lwsl_notice("LWS_CALLBACK_RAW_ADOPT_FILE\n");
 		break;


 	case LWS_CALLBACK_RAW_RX_FILE:
 		lwsl_notice("LWS_CALLBACK_RAW_RX_FILE\n");
 		{
 			char buf[256];
 			int n;

 			n = (int)read(vhd->fifo, buf, sizeof(buf) - 1);
 			if (n < 0) {
 				lwsl_err("FIFO read failed\n");
 				return 1;
 			}
 			/*
 			 * When nobody opened the other side of the FIFO, the
 			 * FIFO fd acts well and only signals POLLIN when
 			 * somebody opened and wrote to it.
 			 *
 			 * But if the other side of the FIFO closed it, we will
 			 * see an endless POLLIN and 0 available to read.
 			 *
 			 * The only way to handle it is to reopen the FIFO our
 			 * side and wait for a new peer.  This is a quirk of
 			 * FIFOs not of LWS.
 			 */
 			if (n == 0) { /* peer closed - reopen in close processing */
 				vhd->zero_length_read = 1;
 				return 1;
 			}
 			buf[n] = '\0';
 			lwsl_info("read %d\n", n);
 			puts(buf);
 		}
 		break;

 	case LWS_CALLBACK_RAW_CLOSE_FILE:
 		lwsl_notice("LWS_CALLBACK_RAW_CLOSE_FILE\n");
 		if (vhd->zero_length_read) {
 			vhd->zero_length_read = 0;
 			close(vhd->fifo);
 			/* the wsi that adopted the fifo file is closing...
 			 * reopen the fifo and readopt
 			 */
 			vhd->fifo = lws_open(vhd->fifo_path,
 					     O_NONBLOCK | O_RDONLY);
 			if (vhd->fifo == -1) {
 				lwsl_err("opening fifo failed\n");
 				return 1;
 			}
 			lwsl_notice("FIFO %s reopened\n", vhd->fifo_path);
 			u.filefd = vhd->fifo;
 			if (!lws_adopt_descriptor_vhost(vhd->vhost, 0, u,
 					"protocol-lws-raw-test", NULL)) {
 				lwsl_err("Failed to adopt fifo descriptor\n");
 				close(vhd->fifo);
 				return 1;
 			}
 		}
 		break;

 	case LWS_CALLBACK_RAW_WRITEABLE_FILE:
 		lwsl_notice("LWS_CALLBACK_RAW_WRITEABLE_FILE\n");
 		break;

 	/*
 	 * Callbacks related to Raw socket descriptor testing
 	 */

 	case LWS_CALLBACK_RAW_ADOPT:
 		lwsl_notice("LWS_CALLBACK_RAW_ADOPT\n");
 		break;

 	case LWS_CALLBACK_RAW_RX:
 		lwsl_notice("LWS_CALLBACK_RAW_RX %ld\n", (long)len);
 		if (len > sizeof(pss->buf))
 			len = sizeof(pss->buf);
 		memcpy(pss->buf, in, len);
 		pss->len = (int)len;
 		lws_callback_on_writable(wsi);
 		break;

 	case LWS_CALLBACK_RAW_CLOSE:
 		lwsl_notice("LWS_CALLBACK_RAW_CLOSE\n");
 		break;

 	case LWS_CALLBACK_RAW_WRITEABLE:
 		lwsl_notice("LWS_CALLBACK_RAW_WRITEABLE\n");
 		lws_write(wsi, pss->buf, (size_t)pss->len, LWS_WRITE_HTTP);
 		break;

 	default:
 		break;
 	}

 	return 0;
 }

 #define LWS_PLUGIN_PROTOCOL_RAW_TEST \
 	{ \
 		"protocol-lws-raw-test", \
 		callback_raw_test, \
 		sizeof(struct per_session_data__raw_test), \
 		1024, /* rx buf size must be >= permessage-deflate rx size */ 0, NULL, 0\
 	}

 #if !defined (LWS_PLUGIN_STATIC)

 LWS_VISIBLE const struct lws_protocols lws_raw_test_protocols[] = {
 	LWS_PLUGIN_PROTOCOL_RAW_TEST
 };

 LWS_VISIBLE const lws_plugin_protocol_t lws_raw_test = {
 	.hdr = {
 		"lws raw test",
 		"lws_protocol_plugin",
 		LWS_BUILD_HASH,
 		LWS_PLUGIN_API_MAGIC
 	},

 	.protocols = lws_raw_test_protocols,
 	.count_protocols = LWS_ARRAY_SIZE(lws_raw_test_protocols),
 	.extensions = NULL,
 	.count_extensions = 0,
 };

 #endif
	/*
	* ws protocol handler plugin for testing raw file and raw socket
	*
	* Written in 2010-2019 by Andy Green <andy@warmcat.com>
	*
	* This file is made available under the Creative Commons CC0 1.0
	* Universal Public Domain Dedication.
	*
	* The person who associated a work with this deed has dedicated
	* the work to the public domain by waiving all of his or her rights
	* to the work worldwide under copyright law, including all related
	* and neighboring rights, to the extent allowed by law. You can copy,
	* modify, distribute and perform the work, even for commercial purposes,
	* all without asking permission.
	*
	* These test plugins are intended to be adapted for use in your code, which
	* may be proprietary. So unlike the library itself, they are licensed
	* Public Domain.
	*
	* This plugin test both raw file descriptors and raw socket descriptors. It
	* can test both or just one depending on how you configure it. libwebsockets-
	* test-server-v2.0 is set up to test both.
	*
	* RAW File Descriptor Testing
	* ===========================
	*
	* Enable on a vhost like this
	*
	* "protocol-lws-raw-test": {
	* "status": "ok",
	* "fifo-path": "/tmp/lws-test-raw"
	* },
	*
	* Then you can feed it data through the FIFO like this
	*
	* $ sudo sh -c "echo hello > /tmp/lws-test-raw"
	*
	* This plugin simply prints the data. But it does it through the lws event
	* loop / service poll.
	*
	*
	* RAW Socket Descriptor Testing
	* =============================
	*
	* 1) You must give the vhost the option flag
	* LWS_SERVER_OPTION_FALLBACK_TO_APPLY_LISTEN_ACCEPT_CONFIG
	*
	* 2) Enable on a vhost like this
	*
	* "protocol-lws-raw-test": {
	* "status": "ok",
	* "raw": "1"
	* },
	*
	* The "raw" pvo marks this protocol as being used for RAW connections.
	*
	* 3) Run libwebsockets-test-server-v2.0 and connect to it by telnet, eg
	*
	* telnet 127.0.0.1 7681
	*
	* type something that isn't a valid HTTP method and enter, before the
	* connection times out. The connection will switch to RAW mode using this
	* protocol, and pass the unused rx as a raw RX callback.
	*
	* The test protocol echos back what was typed on telnet to telnet.
	*/

	#if !defined (LWS_PLUGIN_STATIC)
	#if !defined(LWS_DLL)
	#define LWS_DLL
	#endif
	#if !defined(LWS_INTERNAL)
	#define LWS_INTERNAL
	#endif
	#include <libwebsockets.h>
	#endif

	#include <string.h>
	#include <fcntl.h>

	#include <sys/stat.h>

	struct per_vhost_data__raw_test {
	struct lws_context *context;
	struct lws_vhost *vhost;
	const struct lws_protocols *protocol;
	char fifo_path[100];
	int fifo;
	char zero_length_read;
	};

	struct per_session_data__raw_test {
	int number;
	unsigned char buf[128];
	int len;
	};

	static int
	callback_raw_test(struct lws wsi, enum lws_callback_reasons reason, void user,
	void *in, size_t len)
	{
	struct per_session_data__raw_test *pss =
	(struct per_session_data__raw_test *)user;
	struct per_vhost_data__raw_test *vhd =
	(struct per_vhost_data__raw_test *)
	lws_protocol_vh_priv_get(lws_get_vhost(wsi),
	lws_get_protocol(wsi));
	lws_sock_file_fd_type u;

	(void)pss;

	switch (reason) {
	case LWS_CALLBACK_PROTOCOL_INIT:
	vhd = lws_protocol_vh_priv_zalloc(lws_get_vhost(wsi),
	lws_get_protocol(wsi),
	sizeof(struct per_vhost_data__raw_test));
	if (!vhd)
	return 0;
	vhd->context = lws_get_context(wsi);
	vhd->protocol = lws_get_protocol(wsi);
	vhd->vhost = lws_get_vhost(wsi);
	{
	const struct lws_protocol_vhost_options *pvo =
	(const struct lws_protocol_vhost_options *)in;
	while (pvo) {
	if (!strcmp(pvo->name, "fifo-path"))
	lws_strncpy(vhd->fifo_path, pvo->value,
	sizeof(vhd->fifo_path));
	pvo = pvo->next;
	}
	if (vhd->fifo_path[0] == '\0') {
	lwsl_warn("%s: Missing pvo \"fifo-path\", "
	"raw file fd testing disabled\n",
	__func__);
	break;
	}
	}
	unlink(vhd->fifo_path);
	if (mkfifo(vhd->fifo_path, 0666)) {
	lwsl_err("mkfifo failed\n");
	return 1;
	}
	vhd->fifo = lws_open(vhd->fifo_path, O_NONBLOCK \| O_RDONLY);
	if (vhd->fifo == -1) {
	lwsl_err("opening fifo failed\n");
	unlink(vhd->fifo_path);
	return 1;
	}
	lwsl_notice("FIFO %s created\n", vhd->fifo_path);
	u.filefd = vhd->fifo;
	if (!lws_adopt_descriptor_vhost(vhd->vhost,
	LWS_ADOPT_RAW_FILE_DESC, u,
	"protocol-lws-raw-test",
	NULL)) {
	lwsl_err("Failed to adopt fifo descriptor\n");
	close(vhd->fifo);
	unlink(vhd->fifo_path);
	return 1;
	}
	break;

	case LWS_CALLBACK_PROTOCOL_DESTROY:
	if (!vhd)
	break;
	if (vhd->fifo >= 0) {
	close(vhd->fifo);
	unlink(vhd->fifo_path);
	}
	break;


	/*
	* Callbacks related to Raw file descriptor testing
	*/

	case LWS_CALLBACK_RAW_ADOPT_FILE:
	lwsl_notice("LWS_CALLBACK_RAW_ADOPT_FILE\n");
	break;


	case LWS_CALLBACK_RAW_RX_FILE:
	lwsl_notice("LWS_CALLBACK_RAW_RX_FILE\n");
	{
	char buf[256];
	int n;

	n = (int)read(vhd->fifo, buf, sizeof(buf) - 1);
	if (n < 0) {
	lwsl_err("FIFO read failed\n");
	return 1;
	}
	/*
	* When nobody opened the other side of the FIFO, the
	* FIFO fd acts well and only signals POLLIN when
	* somebody opened and wrote to it.
	*
	* But if the other side of the FIFO closed it, we will
	* see an endless POLLIN and 0 available to read.
	*
	* The only way to handle it is to reopen the FIFO our
	* side and wait for a new peer. This is a quirk of
	* FIFOs not of LWS.
	*/
	if (n == 0) { /* peer closed - reopen in close processing */
	vhd->zero_length_read = 1;
	return 1;
	}
	buf[n] = '\0';
	lwsl_info("read %d\n", n);
	puts(buf);
	}
	break;

	case LWS_CALLBACK_RAW_CLOSE_FILE:
	lwsl_notice("LWS_CALLBACK_RAW_CLOSE_FILE\n");
	if (vhd->zero_length_read) {
	vhd->zero_length_read = 0;
	close(vhd->fifo);
	/* the wsi that adopted the fifo file is closing...
	* reopen the fifo and readopt
	*/
	vhd->fifo = lws_open(vhd->fifo_path,
	O_NONBLOCK \| O_RDONLY);
	if (vhd->fifo == -1) {
	lwsl_err("opening fifo failed\n");
	return 1;
	}
	lwsl_notice("FIFO %s reopened\n", vhd->fifo_path);
	u.filefd = vhd->fifo;
	if (!lws_adopt_descriptor_vhost(vhd->vhost, 0, u,
	"protocol-lws-raw-test", NULL)) {
	lwsl_err("Failed to adopt fifo descriptor\n");
	close(vhd->fifo);
	return 1;
	}
	}
	break;

	case LWS_CALLBACK_RAW_WRITEABLE_FILE:
	lwsl_notice("LWS_CALLBACK_RAW_WRITEABLE_FILE\n");
	break;

	/*
	* Callbacks related to Raw socket descriptor testing
	*/

	case LWS_CALLBACK_RAW_ADOPT:
	lwsl_notice("LWS_CALLBACK_RAW_ADOPT\n");
	break;

	case LWS_CALLBACK_RAW_RX:
	lwsl_notice("LWS_CALLBACK_RAW_RX %ld\n", (long)len);
	if (len > sizeof(pss->buf))
	len = sizeof(pss->buf);
	memcpy(pss->buf, in, len);
	pss->len = (int)len;
	lws_callback_on_writable(wsi);
	break;

	case LWS_CALLBACK_RAW_CLOSE:
	lwsl_notice("LWS_CALLBACK_RAW_CLOSE\n");
	break;

	case LWS_CALLBACK_RAW_WRITEABLE:
	lwsl_notice("LWS_CALLBACK_RAW_WRITEABLE\n");
	lws_write(wsi, pss->buf, (size_t)pss->len, LWS_WRITE_HTTP);
	break;

	default:
	break;
	}

	return 0;
	}

	#define LWS_PLUGIN_PROTOCOL_RAW_TEST \
	{ \
	"protocol-lws-raw-test", \
	callback_raw_test, \
	sizeof(struct per_session_data__raw_test), \
	1024, /* rx buf size must be >= permessage-deflate rx size */ 0, NULL, 0\
	}

	#if !defined (LWS_PLUGIN_STATIC)

	LWS_VISIBLE const struct lws_protocols lws_raw_test_protocols[] = {
	LWS_PLUGIN_PROTOCOL_RAW_TEST
	};

	LWS_VISIBLE const lws_plugin_protocol_t lws_raw_test = {
	.hdr = {
	"lws raw test",
	"lws_protocol_plugin",
	LWS_BUILD_HASH,
	LWS_PLUGIN_API_MAGIC
	},

	.protocols = lws_raw_test_protocols,
	.count_protocols = LWS_ARRAY_SIZE(lws_raw_test_protocols),
	.extensions = NULL,
	.count_extensions = 0,
	};

	#endif