Skip to content
Snippets Groups Projects
minimal-http-server-form-post.c 5.43 KiB
Newer Older
  • Learn to ignore specific revisions
  • /*
     * lws-minimal-http-server-form-post-lwsac
     *
     * Copyright (C) 2018 Andy Green <andy@warmcat.com>
     *
     * This file is made available under the Creative Commons CC0 1.0
     * Universal Public Domain Dedication.
     *
     * This demonstrates a minimal http server that performs POST with a couple
     * of parameters.  It dumps the parameters to the console log and redirects
     * to another page.
     */
    
    #include <libwebsockets.h>
    #include <string.h>
    #include <signal.h>
    
    /*
     * Unlike ws, http is a stateless protocol.  This pss only exists for the
     * duration of a single http transaction.  With http/1.1 keep-alive and http/2,
     * that is unrelated to (shorter than) the lifetime of the network connection.
     */
    struct pss {
    	struct lws_spa *spa;
    	struct lwsac *ac;
    };
    
    static int interrupted;
    
    static const char * const param_names[] = {
    	"text1",
    	"send",
    };
    
    enum enum_param_names {
    	EPN_TEXT1,
    	EPN_SEND,
    };
    
    static int
    callback_http(struct lws *wsi, enum lws_callback_reasons reason, void *user,
    	      void *in, size_t len)
    {
    	struct pss *pss = (struct pss *)user;
    	uint8_t buf[LWS_PRE + LWS_RECOMMENDED_MIN_HEADER_SPACE], *start = &buf[LWS_PRE],
    		*p = start, *end = &buf[sizeof(buf) - 1];
    	int n;
    
    	switch (reason) {
    	case LWS_CALLBACK_HTTP:
    
    		/*
    		 * Manually report that our form target URL exists
    		 *
    		 * you can also do this by adding a mount for the form URL
    		 * to the protocol with type LWSMPRO_CALLBACK, then no need
    		 * to trap LWS_CALLBACK_HTTP.
    		 */
    
    		if (!strcmp((const char *)in, "/form1"))
    			/* assertively allow it to exist in the URL space */
    			return 0;
    
    		/* default to 404-ing the URL if not mounted */
    		break;
    
    	case LWS_CALLBACK_HTTP_BODY:
    
    		/* create the POST argument parser if not already existing */
    
    		if (!pss->spa) {
    			lws_spa_create_info_t i;
    
    			memset(&i, 0, sizeof(i));
    			i.param_names = param_names;
    			i.count_params = LWS_ARRAY_SIZE(param_names);
    			i.ac = &pss->ac;
    			i.ac_chunk_size = 512;
    
    			pss->spa = lws_spa_create_via_info(wsi, &i); /* no file upload */
    			if (!pss->spa)
    				return -1;
    		}
    
    		/* let it parse the POST data */
    
    		if (lws_spa_process(pss->spa, in, (int)len))
    			return -1;
    		break;
    
    	case LWS_CALLBACK_HTTP_BODY_COMPLETION:
    
    		/* inform the spa no more payload data coming */
    
    		lwsl_user("LWS_CALLBACK_HTTP_BODY_COMPLETION\n");
    		lws_spa_finalize(pss->spa);
    
    		/* we just dump the decoded things to the log */
    
    		for (n = 0; n < (int)LWS_ARRAY_SIZE(param_names); n++) {
    			if (!lws_spa_get_string(pss->spa, n))
    				lwsl_user("%s: undefined\n", param_names[n]);
    			else
    				lwsl_user("%s: (len %d) '%s'\n",
    				    param_names[n],
    				    lws_spa_get_length(pss->spa, n),
    				    lws_spa_get_string(pss->spa, n));
    		}
    
    		lwsac_free(&pss->ac);
    
    		/*
    		 * Our response is to redirect to a static page.  We could
    		 * have generated a dynamic html page here instead.
    		 */
    
    		if (lws_http_redirect(wsi, HTTP_STATUS_MOVED_PERMANENTLY,
    				      (unsigned char *)"after-form1.html",
    				      16, &p, end) < 0)
    			return -1;
    		break;
    
    	case LWS_CALLBACK_HTTP_DROP_PROTOCOL:
    		/* called when our wsi user_space is going to be destroyed */
    		if (pss->spa) {
    			lws_spa_destroy(pss->spa);
    			pss->spa = NULL;
    		}
    		lwsac_free(&pss->ac);
    		break;
    
    	default:
    		break;
    	}
    
    	return lws_callback_http_dummy(wsi, reason, user, in, len);
    }
    
    static struct lws_protocols protocols[] = {
    	{ "http", callback_http, sizeof(struct pss), 0 },
    	{ NULL, NULL, 0, 0 } /* terminator */
    };
    
    /* default mount serves the URL space from ./mount-origin */
    
    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,
    };
    
    void sigint_handler(int sig)
    {
    	interrupted = 1;
    }
    
    int main(int argc, const char **argv)
    {
    	struct lws_context_creation_info info;
    	struct lws_context *context;
    	const char *p;
    	int n = 0, 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 ((p = lws_cmdline_option(argc, argv, "-d")))
    		logs = atoi(p);
    
    	lws_set_log_level(logs, NULL);
    	lwsl_user("LWS minimal http server POST | visit http://localhost:7681\n");
    
    	memset(&info, 0, sizeof info); /* otherwise uninitialized garbage */
    	info.port = 7681;
    	info.protocols = protocols;
    	info.mounts = &mount;
    	info.options =
    		LWS_SERVER_OPTION_HTTP_HEADERS_SECURITY_BEST_PRACTICES_ENFORCE;
    
    	if (lws_cmdline_option(argc, argv, "-s")) {
    		info.options |= LWS_SERVER_OPTION_DO_SSL_GLOBAL_INIT;
    		info.ssl_cert_filepath = "localhost-100y.cert";
    		info.ssl_private_key_filepath = "localhost-100y.key";
    	}
    
    	context = lws_create_context(&info);
    	if (!context) {
    		lwsl_err("lws init failed\n");
    		return 1;
    	}
    
    	while (n >= 0 && !interrupted)
    		n = lws_service(context, 1000);
    
    	lws_context_destroy(context);
    
    	return 0;
    }