Implement a more involved example

Use minimal server echo example instead.

CMakeLists.txt

@@ -70,7 +70,7 @@ add_executable(
     src/packages/game/input/IZ_midi.h
     src/packages/game/data/IZ_list.c
     src/packages/game/data/IZ_list.h
-        src/packages/game/network/IZ_wsclient.c src/packages/game/network/IZ_wsclient.h)
+        src/packages/game/network/IZ_wsclient.c src/packages/game/network/IZ_wsclient.h src/packages/game/log/IZ_log.c src/packages/game/log/IZ_log.h)
 
 target_link_libraries(
   game
@@ -170,11 +170,15 @@ add_executable(
     dependencies/minIni/dev/minIni.h
     dependencies/minIni/dev/minIni.c
     src/packages/server/IZ_common.h
+    src/packages/server/log/IZ_log.h
+    src/packages/server/log/IZ_log.c
     src/packages/server/main.c
-        src/packages/server/protocol_lws_minimal.c)
+    src/packages/server/protocol_lws_minimal_server_echo.c src/packages/server/IZ_app.c src/packages/server/IZ_app.h)
 
 target_link_libraries(
   server
+    SDL2main
+    SDL2
     libcrypto
     libssl
     websockets

src/packages/game/log/IZ_log.c

@@ -0,0 +1,24 @@
+#include "IZ_log.h"
+
+void IZ_LogHandleFromWS(i32 level, const char* line) {
+	switch (level) {
+		case LLL_ERR:
+			SDL_LogError(SDL_LOG_CATEGORY_ERROR, "%s", line);
+			return;
+		case LLL_WARN:
+			SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "%s", line);
+			return;
+		case LLL_NOTICE:
+			SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "%s", line);
+			return;
+		case LLL_USER:
+		default:
+			break;
+	}
+
+	SDL_Log("%s", line);
+}
+
+void IZ_LogInterceptWSMessages(i32 level) {
+	lws_set_log_level(level, IZ_LogHandleFromWS);
+}

src/packages/game/log/IZ_log.h

@@ -0,0 +1,10 @@
+#ifndef IZ_LOG_H
+#define IZ_LOG_H
+
+#include <SDL_log.h>
+#include <libwebsockets.h>
+#include "../IZ_common.h"
+
+void IZ_LogInterceptWSMessages(i32);
+
+#endif

src/packages/server/IZ_app.c

@@ -0,0 +1,57 @@
+#include "IZ_app.h"
+
+void IZ_AppHandleSignal(i32 _signal) {
+	interrupted = true;
+}
+
+void IZ_AppCreateContext(IZ_App* app) {
+	struct lws_context_creation_info info;
+	memset(&info, 0, sizeof info);
+	info.port = app->config.port;
+	// TODO initialize protocols
+	info.options = (
+		LWS_SERVER_OPTION_VALIDATE_UTF8
+		| LWS_SERVER_OPTION_HTTP_HEADERS_SECURITY_BEST_PRACTICES_ENFORCE
+	);
+}
+
+void IZ_AppLoadConfig(IZ_AppConfig* config, u8 argc, const char** argv) {
+	memcpy_s(config, sizeof(IZ_AppConfig), &IZ_APP_DEFAULT_CONFIG, sizeof(IZ_AppConfig));
+
+	const char* cmdline_buffer;
+	if ((cmdline_buffer = lws_cmdline_option(argc, argv, "-d"))) {
+		config->log_level = atoi(cmdline_buffer);
+	}
+
+	if ((cmdline_buffer = lws_cmdline_option(argc, argv, "-p"))) {
+		config->port = atoi(cmdline_buffer);
+	}
+
+	if (lws_cmdline_option(argc, argv, "-o")) {
+		// connect once
+		config->vhost_options |= 1;
+	}
+
+	if (!lws_cmdline_option(argc, argv, "-n")) {
+		config->extensions_enabled = true;
+	}
+}
+
+IZ_ProcedureResult IZ_AppInitialize(IZ_App* app, u8 argc, const char** argv) {
+	interrupted = false;
+	signal(SIGINT, IZ_AppHandleSignal);
+
+	IZ_AppLoadConfig(&app->config, argc, argv);
+	IZ_LogInterceptWSMessages(app->config.log_level);
+	IZ_AppCreateContext(app);
+
+	return 0;
+}
+
+IZ_ProcedureResult IZ_AppRun(IZ_App* app, u8 argc, const char** argv) {
+	if (IZ_AppInitialize(app, argc, argv)) {
+		return 1;
+	}
+
+	return 0;
+}

src/packages/server/IZ_app.h

@@ -0,0 +1,33 @@
+#ifndef IZ_APP_H
+#define IZ_APP_H
+
+#include <signal.h>
+#include <stdbool.h>
+#include <libwebsockets.h>
+#include "IZ_common.h"
+#include "log/IZ_log.h"
+
+static bool interrupted;
+
+typedef struct {
+	i32 log_level;
+	u16 port;
+	i32 vhost_options;
+	bool extensions_enabled;
+} IZ_AppConfig;
+
+typedef struct {
+	IZ_AppConfig config;
+	struct lws_context* context;
+} IZ_App;
+
+static const IZ_AppConfig IZ_APP_DEFAULT_CONFIG = {
+	.log_level = LLL_USER | LLL_ERR | LLL_WARN | LLL_NOTICE,
+	.port = 42069,
+	.vhost_options = 0,
+	.extensions_enabled = false,
+};
+
+IZ_ProcedureResult IZ_AppRun(IZ_App*, u8, const char**);
+
+#endif

src/packages/server/log

@@ -0,0 +1 @@
+E:/Projects/Games/izanagi/src/packages/game/log

src/packages/server/main.c

@@ -1,104 +1,117 @@
 #include <libwebsockets.h>
+#include <string.h>
 #include <signal.h>
+
 #include "IZ_common.h"
+#include "log/IZ_log.h"
 
 #define LWS_PLUGIN_STATIC
-#include "protocol_lws_minimal.c"
+#include "protocol_lws_minimal_server_echo.c"
 
 static struct lws_protocols protocols[] = {
-	{ "http", lws_callback_http_dummy, 0, 0, 0, NULL, 0},
-	LWS_PLUGIN_PROTOCOL_MINIMAL,
+	LWS_PLUGIN_PROTOCOL_MINIMAL_SERVER_ECHO,
 	LWS_PROTOCOL_LIST_TERM
 };
 
-static const lws_retry_bo_t retry = {
-	.secs_since_valid_ping = 3,
-	.secs_since_valid_hangup = 10,
+static int interrupted, port = 7681, options;
+
+/* pass pointers to shared vars to the protocol */
+
+static const struct lws_protocol_vhost_options pvo_options = {
+	NULL,
+	NULL,
+	"options",		/* pvo name */
+	(void *)&options	/* pvo value */
 };
 
-static i32 interrupted;
-
-static const struct lws_http_mount mount = {
-	.mount_next = NULL,		/* linked-list "next" */
-	.mountpoint = "/",		/* mountpoint URL */
-	.origin = "./mount-origin",  /* serve from dir */
-	.def = "index.html",	/* default filename */
-	.protocol = NULL,
-	.cgienv = NULL,
-	.extra_mimetypes = NULL,
-	.interpret = NULL,
-	.cgi_timeout = 0,
-	.cache_max_age = 0,
-	.auth_mask = 0,
-	.cache_reusable = 0,
-	.cache_revalidate = 0,
-	.cache_intermediaries = 0,
-	.origin_protocol = LWSMPRO_FILE,	/* files in a dir */
-	.mountpoint_len = 1,		/* char count */
-	.basic_auth_login_file = NULL,
+static const struct lws_protocol_vhost_options pvo_interrupted = {
+	&pvo_options,
+	NULL,
+	"interrupted",		/* pvo name */
+	(void *)&interrupted	/* pvo value */
 };
 
-#if defined(LWS_WITH_PLUGINS)
-/* if plugins enabled, only protocols explicitly named in pvo bind to vhost */
-static struct lws_protocol_vhost_options pvo = { NULL, NULL, "lws-minimal", "" };
-#endif
+static const struct lws_protocol_vhost_options pvo = {
+	NULL,				/* "next" pvo linked-list */
+	&pvo_interrupted,		/* "child" pvo linked-list */
+	"lws-minimal-server-echo",	/* protocol name we belong to on this vhost */
+	""				/* ignored */
+};
+static const struct lws_extension extensions[] = {
+	{
+		"permessage-deflate",
+		lws_extension_callback_pm_deflate,
+		"permessage-deflate"
+		"; client_no_context_takeover"
+		"; client_max_window_bits"
+	},
+	{ NULL, NULL, NULL /* terminator */ }
+};
 
-void sigint_handler(i32 sig) {
+void sigint_handler(int sig)
+{
 	interrupted = 1;
 }
 
-IZ_ProcedureResult main(i32 arg_count, char* arg_values[]) {
-	struct lws_context_creation_info info;
-	struct lws_context* context;
-	const char* p;
-	i32 n = 0;
-	i32 logs = LLL_USER | LLL_ERR | LLL_WARN | LLL_NOTICE;
+IZ_ProcedureResult main(i32 argc, const char **argv)
+{
+	const char *cmdline_buffer;
+	i32 logs = LLL_USER | LLL_ERR | LLL_WARN | LLL_NOTICE
+	/* for LLL_ verbosity above NOTICE to be built into lws,
+	 * lws must have been configured and built with
+	 * -DCMAKE_BUILD_TYPE=DEBUG instead of =RELEASE */
+	/* | LLL_INFO */ /* | LLL_PARSER */ /* | LLL_HEADER */
+	/* | LLL_EXT */ /* | LLL_CLIENT */ /* | LLL_LATENCY */
+	/* | LLL_DEBUG */;
 
 	signal(SIGINT, sigint_handler);
+	if ((cmdline_buffer = lws_cmdline_option(argc, argv, "-d"))) {
+		logs = atoi(cmdline_buffer);
+	}
 
-	if ((p = lws_cmdline_option(arg_count, arg_values, "-d")))
-		logs = atoi(p);
+	IZ_LogInterceptWSMessages(logs);
+	lwsl_user("LWS minimal ws client echo + permessage-deflate + multifragment bulk message\n");
+	lwsl_user("   lws-minimal-ws-client-echo [-n (no exts)] [-p port] [-o (once)]\n");
 
-	lws_set_log_level(logs, NULL);
-	lwsl_user("LWS minimal ws server | visit http://localhost:7681 (-s = use TLS / https)\n");
+	if ((cmdline_buffer = lws_cmdline_option(argc, argv, "-p"))) {
+		port = atoi(cmdline_buffer);
+	}
 
+	if (lws_cmdline_option(argc, argv, "-o")) {
+		// connect once
+		options |= 1;
+	}
+
+	struct lws_context_creation_info info;
 	memset(&info, 0, sizeof info); /* otherwise uninitialized garbage */
-	info.port = 6969;
-	info.mounts = &mount;
+	info.port = port;
 	info.protocols = protocols;
-	info.vhost_name = "localhost";
-#if defined(LWS_WITH_PLUGINS)
 	info.pvo = &pvo;
-#endif
-	info.options =
-		LWS_SERVER_OPTION_HTTP_HEADERS_SECURITY_BEST_PRACTICES_ENFORCE;
-
-#if defined(LWS_WITH_TLS)
-	if (lws_cmdline_option(arg_count, arg_values, "-s")) {
-		lwsl_user("Server using TLS\n");
-		info.options |= LWS_SERVER_OPTION_DO_SSL_GLOBAL_INIT;
-		info.ssl_cert_filepath = "localhost-100y.cert";
-		info.ssl_private_key_filepath = "localhost-100y.key";
-	}
-#endif
-
-	if (lws_cmdline_option(arg_count, arg_values, "-h"))
-		info.options |= LWS_SERVER_OPTION_VHOST_UPG_STRICT_HOST_CHECK;
-
-	if (lws_cmdline_option(arg_count, arg_values, "-v"))
-		info.retry_and_idle_policy = &retry;
+	if (!lws_cmdline_option(argc, argv, "-n"))
+		info.extensions = extensions;
+	info.pt_serv_buf_size = 32 * 1024;
+	info.options = LWS_SERVER_OPTION_VALIDATE_UTF8 |
+								 LWS_SERVER_OPTION_HTTP_HEADERS_SECURITY_BEST_PRACTICES_ENFORCE;
 
+	struct lws_context *context;
 	context = lws_create_context(&info);
 	if (!context) {
 		lwsl_err("lws init failed\n");
 		return 1;
 	}
 
-	while (n >= 0 && !interrupted)
+	i32 n;
+	while (!interrupted) {
 		n = lws_service(context, 0);
+		printf("%d\n", n);
+		if (n < 0) {
+			break;
+		}
+	}
 
 	lws_context_destroy(context);
 
+	lwsl_user("Completed %s\n", interrupted == 2 ? "OK" : "failed");
 
-	return 0;
+	return interrupted != 2;
 }

src/packages/server/protocol_lws_minimal.c

@@ -1,143 +0,0 @@
-
-#if !defined (LWS_PLUGIN_STATIC)
-#define LWS_DLL
-#define LWS_INTERNAL
-#include <libwebsockets.h>
-#endif
-
-#include <string.h>
-
-/* one of these created for each message */
-
-struct msg {
-	void *payload; /* is malloc'd */
-	size_t len;
-};
-
-/* one of these is created for each client connecting to us */
-
-struct per_session_data__minimal {
-	struct per_session_data__minimal *pss_list;
-	struct lws *wsi;
-	int last; /* the last message number we sent */
-};
-
-/* one of these is created for each vhost our protocol is used with */
-
-struct per_vhost_data__minimal {
-	struct lws_context *context;
-	struct lws_vhost *vhost;
-	const struct lws_protocols *protocol;
-
-	struct per_session_data__minimal *pss_list; /* linked-list of live pss*/
-
-	struct msg amsg; /* the one pending message... */
-	int current; /* the current message number we are caching */
-};
-
-/* destroys the message when everyone has had a copy of it */
-
-static void
-__minimal_destroy_message(void *_msg)
-{
-	struct msg *msg = _msg;
-
-	free(msg->payload);
-	msg->payload = NULL;
-	msg->len = 0;
-}
-
-static int
-callback_minimal(struct lws *wsi, enum lws_callback_reasons reason,
-								 void *user, void *in, size_t len)
-{
-	struct per_session_data__minimal *pss =
-		(struct per_session_data__minimal *)user;
-	struct per_vhost_data__minimal *vhd =
-		(struct per_vhost_data__minimal *)
-			lws_protocol_vh_priv_get(lws_get_vhost(wsi),
-															 lws_get_protocol(wsi));
-	int m;
-
-	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__minimal));
-			vhd->context = lws_get_context(wsi);
-			vhd->protocol = lws_get_protocol(wsi);
-			vhd->vhost = lws_get_vhost(wsi);
-			break;
-
-		case LWS_CALLBACK_ESTABLISHED:
-			/* add ourselves to the list of live pss held in the vhd */
-		lws_ll_fwd_insert(pss, pss_list, vhd->pss_list);
-			pss->wsi = wsi;
-			pss->last = vhd->current;
-			break;
-
-		case LWS_CALLBACK_CLOSED:
-			/* remove our closing pss from the list of live pss */
-		lws_ll_fwd_remove(struct per_session_data__minimal, pss_list,
-											pss, vhd->pss_list);
-			break;
-
-		case LWS_CALLBACK_SERVER_WRITEABLE:
-			if (!vhd->amsg.payload)
-				break;
-
-			if (pss->last == vhd->current)
-				break;
-
-			/* notice we allowed for LWS_PRE in the payload already */
-			m = lws_write(wsi, ((unsigned char *)vhd->amsg.payload) +
-												 LWS_PRE, vhd->amsg.len, LWS_WRITE_TEXT);
-			if (m < (int)vhd->amsg.len) {
-				lwsl_err("ERROR %d writing to ws\n", m);
-				return -1;
-			}
-
-			pss->last = vhd->current;
-			break;
-
-		case LWS_CALLBACK_RECEIVE:
-			if (vhd->amsg.payload)
-				__minimal_destroy_message(&vhd->amsg);
-
-			vhd->amsg.len = len;
-			/* notice we over-allocate by LWS_PRE */
-			vhd->amsg.payload = malloc(LWS_PRE + len);
-			if (!vhd->amsg.payload) {
-				lwsl_user("OOM: dropping\n");
-				break;
-			}
-
-			memcpy((char *)vhd->amsg.payload + LWS_PRE, in, len);
-			vhd->current++;
-
-			/*
-			 * let everybody know we want to write something on them
-			 * as soon as they are ready
-			 */
-			lws_start_foreach_llp(struct per_session_data__minimal **,
-														ppss, vhd->pss_list) {
-						lws_callback_on_writable((*ppss)->wsi);
-					} lws_end_foreach_llp(ppss, pss_list);
-			break;
-
-		default:
-			break;
-	}
-
-	return 0;
-}
-
-#define LWS_PLUGIN_PROTOCOL_MINIMAL \
-        { \
-                "lws-minimal", \
-                callback_minimal, \
-                sizeof(struct per_session_data__minimal), \
-                128, \
-                0, NULL, 0 \
-        }
-

src/packages/server/protocol_lws_minimal_server_echo.c

@@ -0,0 +1,219 @@
+#ifndef LWS_PLUGIN_STATIC
+#define LWS_DLL
+#define LWS_INTERNAL
+
+#include <libwebsockets.h>
+#endif
+
+#include <string.h>
+
+#define RING_DEPTH 4096
+
+/* one of these created for each message */
+
+struct msg {
+	void *payload; /* is malloc'd */
+	size_t len;
+	char binary;
+	char first;
+	char final;
+};
+
+struct per_session_data__minimal_server_echo {
+	struct lws_ring *ring;
+	uint32_t msglen;
+	uint32_t tail;
+	uint8_t completed: 1;
+	uint8_t flow_controlled: 1;
+	uint8_t write_consume_pending: 1;
+};
+
+struct vhd_minimal_server_echo {
+	struct lws_context *context;
+	struct lws_vhost *vhost;
+
+	int *interrupted;
+	int *options;
+};
+
+static void
+__minimal_destroy_message(void *_msg) {
+	struct msg *msg = _msg;
+
+	free(msg->payload);
+	msg->payload = NULL;
+	msg->len = 0;
+}
+
+static int
+callback_minimal_server_echo(struct lws *wsi, enum lws_callback_reasons reason,
+														 void *user, void *in, size_t len) {
+	struct per_session_data__minimal_server_echo *pss =
+		(struct per_session_data__minimal_server_echo *) user;
+	struct vhd_minimal_server_echo *vhd = (struct vhd_minimal_server_echo *)
+		lws_protocol_vh_priv_get(lws_get_vhost(wsi),
+														 lws_get_protocol(wsi));
+	const struct msg *pmsg;
+	struct msg amsg;
+	int m, n, flags;
+
+	switch (reason) {
+
+		case LWS_CALLBACK_PROTOCOL_INIT:
+			vhd = lws_protocol_vh_priv_zalloc(lws_get_vhost(wsi),
+																				lws_get_protocol(wsi),
+																				sizeof(struct vhd_minimal_server_echo));
+			if (!vhd)
+				return -1;
+
+			vhd->context = lws_get_context(wsi);
+			vhd->vhost = lws_get_vhost(wsi);
+
+			/* get the pointers we were passed in pvo */
+
+			vhd->interrupted = (int *) lws_pvo_search(
+				(const struct lws_protocol_vhost_options *) in,
+				"interrupted")->value;
+			vhd->options = (int *) lws_pvo_search(
+				(const struct lws_protocol_vhost_options *) in,
+				"options")->value;
+			break;
+
+		case LWS_CALLBACK_ESTABLISHED:
+			/* generate a block of output before travis times us out */
+			lwsl_warn("LWS_CALLBACK_ESTABLISHED\n");
+			pss->ring = lws_ring_create(sizeof(struct msg), RING_DEPTH,
+																	__minimal_destroy_message);
+			if (!pss->ring)
+				return 1;
+			pss->tail = 0;
+			break;
+
+		case LWS_CALLBACK_SERVER_WRITEABLE:
+
+			lwsl_user("LWS_CALLBACK_SERVER_WRITEABLE\n");
+
+			if (pss->write_consume_pending) {
+				/* perform the deferred fifo consume */
+				lws_ring_consume_single_tail(pss->ring, &pss->tail, 1);
+				pss->write_consume_pending = 0;
+			}
+
+			pmsg = lws_ring_get_element(pss->ring, &pss->tail);
+			if (!pmsg) {
+				lwsl_user(" (nothing in ring)\n");
+				break;
+			}
+
+			flags = lws_write_ws_flags(
+				pmsg->binary ? LWS_WRITE_BINARY : LWS_WRITE_TEXT,
+				pmsg->first, pmsg->final);
+
+			/* notice we allowed for LWS_PRE in the payload already */
+			m = lws_write(wsi, ((unsigned char *) pmsg->payload) +
+												 LWS_PRE, pmsg->len, (enum lws_write_protocol) flags);
+			if (m < (int) pmsg->len) {
+				lwsl_err("ERROR %d writing to ws socket\n", m);
+				return -1;
+			}
+
+			lwsl_user(" wrote %d: flags: 0x%x first: %d final %d\n",
+								m, flags, pmsg->first, pmsg->final);
+			/*
+			 * Workaround deferred deflate in pmd extension by only
+			 * consuming the fifo entry when we are certain it has been
+			 * fully deflated at the next WRITABLE callback.  You only need
+			 * this if you're using pmd.
+			 */
+			pss->write_consume_pending = 1;
+			lws_callback_on_writable(wsi);
+
+			if (pss->flow_controlled &&
+					(int) lws_ring_get_count_free_elements(pss->ring) > RING_DEPTH - 5) {
+				lws_rx_flow_control(wsi, 1);
+				pss->flow_controlled = 0;
+			}
+
+			if ((*vhd->options & 1) && pmsg && pmsg->final)
+				pss->completed = 1;
+
+			break;
+
+		case LWS_CALLBACK_RECEIVE:
+
+			lwsl_user("LWS_CALLBACK_RECEIVE: %4d (rpp %5d, first %d, "
+								"last %d, bin %d, msglen %d (+ %d = %d))\n",
+								(int) len, (int) lws_remaining_packet_payload(wsi),
+								lws_is_first_fragment(wsi),
+								lws_is_final_fragment(wsi),
+								lws_frame_is_binary(wsi), pss->msglen, (int) len,
+								(int) pss->msglen + (int) len);
+
+			if (len) { ;
+				//puts((const char *)in);
+				//lwsl_hexdump_notice(in, len);
+			}
+
+			amsg.first = (char) lws_is_first_fragment(wsi);
+			amsg.final = (char) lws_is_final_fragment(wsi);
+			amsg.binary = (char) lws_frame_is_binary(wsi);
+			n = (int) lws_ring_get_count_free_elements(pss->ring);
+			if (!n) {
+				lwsl_user("dropping!\n");
+				break;
+			}
+
+			if (amsg.final)
+				pss->msglen = 0;
+			else
+				pss->msglen += (uint32_t) len;
+
+			amsg.len = len;
+			/* notice we over-allocate by LWS_PRE */
+			amsg.payload = malloc(LWS_PRE + len);
+			if (!amsg.payload) {
+				lwsl_user("OOM: dropping\n");
+				break;
+			}
+
+			memcpy((char *) amsg.payload + LWS_PRE, in, len);
+			if (!lws_ring_insert(pss->ring, &amsg, 1)) {
+				__minimal_destroy_message(&amsg);
+				lwsl_user("dropping!\n");
+				break;
+			}
+			lws_callback_on_writable(wsi);
+
+			if (n < 3 && !pss->flow_controlled) {
+				pss->flow_controlled = 1;
+				lws_rx_flow_control(wsi, 0);
+			}
+			break;
+
+		case LWS_CALLBACK_CLOSED:
+			lwsl_user("LWS_CALLBACK_CLOSED\n");
+			lws_ring_destroy(pss->ring);
+
+			if (*vhd->options & 1) {
+				if (!*vhd->interrupted)
+					*vhd->interrupted = 1 + pss->completed;
+				lws_cancel_service(lws_get_context(wsi));
+			}
+			break;
+
+		default:
+			break;
+	}
+
+	return 0;
+}
+
+#define LWS_PLUGIN_PROTOCOL_MINIMAL_SERVER_ECHO \
+	{ \
+		"lws-minimal-server-echo", \
+		callback_minimal_server_echo, \
+		sizeof(struct per_session_data__minimal_server_echo), \
+		1024, \
+		0, NULL, 0 \
+	}
+