libwebsockets/minimal-examples/http-client/minimal-http-client-multi/minimal-http-client-multi.c

/*
 * lws-minimal-http-client-multi
 *
 * Written in 2010-2020 by Andy Green <andy@warmcat.com>
 *
 * This file is made available under the Creative Commons CC0 1.0
 * Universal Public Domain Dedication.
 *
 * This demonstrates the a minimal http client using lws, which makes
 * 8 downloads simultaneously from warmcat.com.
 *
 * Currently that takes the form of 8 individual simultaneous tcp and
 * tls connections, which happen concurrently.  Notice that the ordering
 * of the returned payload may be intermingled for the various connections.
 *
 * By default the connections happen all together at the beginning and operate
 * concurrently, which is fast.  However this is resource-intenstive, there are
 * 8 tcp connections, 8 tls tunnels on both the client and server.  You can
 * instead opt to have the connections happen one after the other inside a
 * single tcp connection and tls tunnel, using HTTP/1.1 pipelining.  To be
 * eligible to be pipelined on another existing connection to the same server,
 * the client connection must have the LCCSCF_PIPELINE flag on its
 * info.ssl_connection member (this is independent of whether the connection
 * is in ssl mode or not).
 *
 * HTTP/1.0: Pipelining only possible if Keep-Alive: yes sent by server
 * HTTP/1.1: always possible... serializes requests
 * HTTP/2:   always possible... all requests sent as individual streams in parallel
 */

#include <libwebsockets.h>
#include <string.h>
#include <signal.h>
#include <assert.h>
#include <time.h>

#define COUNT 8

struct cliuser {
	int index;
};

static int completed, failed, numbered, stagger_idx, posting, count = COUNT;
static lws_sorted_usec_list_t sul_stagger;
static struct lws_client_connect_info i;
static struct lws *client_wsi[COUNT];
static char urlpath[64];
static struct lws_context *context;

/* we only need this for tracking POST emit state */

struct pss {
	char body_part;
};

static int
callback_http(struct lws *wsi, enum lws_callback_reasons reason,
	      void *user, void *in, size_t len)
{
	char buf[LWS_PRE + 1024], *start = &buf[LWS_PRE], *p = start,
	     *end = &buf[sizeof(buf) - LWS_PRE - 1];
	int n, idx = (int)(long)lws_get_opaque_user_data(wsi);
	struct pss *pss = (struct pss *)user;

	switch (reason) {

	case LWS_CALLBACK_ESTABLISHED_CLIENT_HTTP:
		lwsl_user("LWS_CALLBACK_ESTABLISHED_CLIENT_HTTP: idx: %d, resp %u\n",
				idx, lws_http_client_http_response(wsi));
		break;

	/* because we are protocols[0] ... */
	case LWS_CALLBACK_CLIENT_CONNECTION_ERROR:
		lwsl_err("CLIENT_CONNECTION_ERROR: %s\n",
			 in ? (char *)in : "(null)");
		client_wsi[idx] = NULL;
		failed++;
		goto finished;

	/* chunks of chunked content, with header removed */
	case LWS_CALLBACK_RECEIVE_CLIENT_HTTP_READ:
		lwsl_user("RECEIVE_CLIENT_HTTP_READ: conn %d: read %d\n", idx, (int)len);
		lwsl_hexdump_info(in, len);
		return 0; /* don't passthru */

	case LWS_CALLBACK_CLIENT_APPEND_HANDSHAKE_HEADER:
		/*
		 * Tell lws we are going to send the body next...
		 */
		if (posting && !lws_http_is_redirected_to_get(wsi)) {
			lwsl_user("%s: doing POST flow\n", __func__);
			lws_client_http_body_pending(wsi, 1);
			lws_callback_on_writable(wsi);
		} else
			lwsl_user("%s: doing GET flow\n", __func__);
		break;

	/* uninterpreted http content */
	case LWS_CALLBACK_RECEIVE_CLIENT_HTTP:
		{
			char buffer[1024 + LWS_PRE];
			char *px = buffer + LWS_PRE;
			int lenx = sizeof(buffer) - LWS_PRE;

			if (lws_http_client_read(wsi, &px, &lenx) < 0)
				return -1;
		}
		return 0; /* don't passthru */

	case LWS_CALLBACK_COMPLETED_CLIENT_HTTP:
		lwsl_user("LWS_CALLBACK_COMPLETED_CLIENT_HTTP %p: idx %d\n",
			  wsi, idx);
		client_wsi[idx] = NULL;
		goto finished;

	case LWS_CALLBACK_CLOSED_CLIENT_HTTP:
		lwsl_info("%s: closed: %p\n", __func__, client_wsi[idx]);
		if (client_wsi[idx]) {
			/*
			 * If it completed normally, it will have been set to
			 * NULL then already.  So we are dealing with an
			 * abnormal, failing, close
			 */
			client_wsi[idx] = NULL;
			failed++;
			goto finished;
		}
		break;

	case LWS_CALLBACK_CLIENT_HTTP_WRITEABLE:
		if (!posting)
			break;
		if (lws_http_is_redirected_to_get(wsi))
			break;
		lwsl_user("LWS_CALLBACK_CLIENT_HTTP_WRITEABLE: %p, part %d\n", wsi, pss->body_part);
		n = LWS_WRITE_HTTP;

		/*
		 * For a small body like this, we could prepare it in memory and
		 * send it all at once.  But to show how to handle, eg,
		 * arbitrary-sized file payloads, or huge form-data fields, the
		 * sending is done in multiple passes through the event loop.
		 */

		switch (pss->body_part++) {
		case 0:
			if (lws_client_http_multipart(wsi, "text", NULL, NULL,
						      &p, end))
				return -1;
			/* notice every usage of the boundary starts with -- */
			p += lws_snprintf(p, end - p, "my text field\xd\xa");
			break;
		case 1:
			if (lws_client_http_multipart(wsi, "file", "myfile.txt",
						      "text/plain", &p, end))
				return -1;
			p += lws_snprintf(p, end - p,
					"This is the contents of the "
					"uploaded file.\xd\xa"
					"\xd\xa");
			break;
		case 2:
			if (lws_client_http_multipart(wsi, NULL, NULL, NULL,
						      &p, end))
				return -1;
			lws_client_http_body_pending(wsi, 0);
			 /* necessary to support H2, it means we will write no
			  * more on this stream */
			n = LWS_WRITE_HTTP_FINAL;
			break;

		default:
			/*
			 * We can get extra callbacks here, if nothing to do,
			 * then do nothing.
			 */
			return 0;
		}

		if (lws_write(wsi, (uint8_t *)start, lws_ptr_diff(p, start), n)
				!= lws_ptr_diff(p, start))
			return 1;

		if (n != LWS_WRITE_HTTP_FINAL)
			lws_callback_on_writable(wsi);

		break;

	default:
		break;
	}

	return lws_callback_http_dummy(wsi, reason, user, in, len);

finished:
	if (++completed == count) {
		if (!failed)
			lwsl_user("Done: all OK\n");
		else
			lwsl_err("Done: failed: %d\n", failed);
		//interrupted = 1;
		/*
		 * This is how we can exit the event loop even when it's an
		 * event library backing it... it will start and stage the
		 * destroy to happen after we exited this service for each pt
		 */
		lws_context_destroy(lws_get_context(wsi));
	}

	return 0;
}

static const struct lws_protocols protocols[] = {
	{ "http", callback_http, sizeof(struct pss), 0, },
	{ NULL, NULL, 0, 0 }
};

static void
signal_cb(void *handle, int signum)
{
	switch (signum) {
	case SIGTERM:
	case SIGINT:
		break;
	default:
		lwsl_err("%s: signal %d\n", __func__, signum);
		break;
	}
	lws_context_destroy(context);
}

static void
sigint_handler(int sig)
{
	signal_cb(NULL, sig);
}

#if defined(WIN32)
int gettimeofday(struct timeval * tp, struct timezone * tzp)
{
    // Note: some broken versions only have 8 trailing zero's, the correct epoch has 9 trailing zero's
    // This magic number is the number of 100 nanosecond intervals since January 1, 1601 (UTC)
    // until 00:00:00 January 1, 1970 
    static const uint64_t EPOCH = ((uint64_t) 116444736000000000ULL);

    SYSTEMTIME  system_time;
    FILETIME    file_time;
    uint64_t    time;

    GetSystemTime( &system_time );
    SystemTimeToFileTime( &system_time, &file_time );
    time =  ((uint64_t)file_time.dwLowDateTime )      ;
    time += ((uint64_t)file_time.dwHighDateTime) << 32;

    tp->tv_sec  = (long) ((time - EPOCH) / 10000000L);
    tp->tv_usec = (long) (system_time.wMilliseconds * 1000);
    return 0;
}
#endif

unsigned long long us(void)
{
	struct timeval t;

	gettimeofday(&t, NULL);

	return (t.tv_sec * 1000000ull) + t.tv_usec;
}

static void
lws_try_client_connection(struct lws_client_connect_info *i, int m)
{
	char path[128];

	if (numbered) {
		lws_snprintf(path, sizeof(path), "/%d.png", m + 1);
		i->path = path;
	} else
		i->path = urlpath;

	i->pwsi = &client_wsi[m];
	i->opaque_user_data = (void *)(long)m;

	if (!lws_client_connect_via_info(i)) {
		failed++;
		if (++completed == count) {
			lwsl_user("Done: failed: %d\n", failed);
			lws_context_destroy(context);
		}
	} else
		lwsl_user("started connection %p: idx %d (%s)\n",
			  client_wsi[m], m, i->path);
}

static void
stagger_cb(lws_sorted_usec_list_t *sul)
{
	lws_usec_t next;

	/*
	 * open the connections at 100ms intervals, with the
	 * last one being after 1s, testing both queuing, and
	 * direct H2 stream addition stability
	 */
	lws_try_client_connection(&i, stagger_idx++);

	if (stagger_idx == count)
		return;

	next = 300 * LWS_US_PER_MS;
	if (stagger_idx == count - 1)
		next += 700 * LWS_US_PER_MS;

	lws_sul_schedule(context, 0, &sul_stagger, stagger_cb, next);
}

int main(int argc, const char **argv)
{
	struct lws_context_creation_info info;
	unsigned long long start;
	const char *p;
	int m, staggered = 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 */;

	memset(&info, 0, sizeof info); /* otherwise uninitialized garbage */
	memset(&i, 0, sizeof i); /* otherwise uninitialized garbage */

	info.signal_cb = signal_cb;
	info.options = LWS_SERVER_OPTION_DO_SSL_GLOBAL_INIT;

	if (lws_cmdline_option(argc, argv, "--uv"))
		info.options |= LWS_SERVER_OPTION_LIBUV;
	else
		if (lws_cmdline_option(argc, argv, "--event"))
			info.options |= LWS_SERVER_OPTION_LIBEVENT;
		else
			if (lws_cmdline_option(argc, argv, "--ev"))
				info.options |= LWS_SERVER_OPTION_LIBEV;
			else
				signal(SIGINT, sigint_handler);

	staggered = !!lws_cmdline_option(argc, argv, "-s");
	if ((p = lws_cmdline_option(argc, argv, "-d")))
		logs = atoi(p);

	lws_set_log_level(logs, NULL);
	lwsl_user("LWS minimal http client [-s (staggered)] [-p (pipeline)]\n");
	lwsl_user("   [--h1 (http/1 only)] [-l (localhost)] [-d <logs>]\n");
	lwsl_user("   [-n (numbered)] [--post]\n");

	info.port = CONTEXT_PORT_NO_LISTEN; /* we do not run any server */
	info.protocols = protocols;
	/*
	 * since we know this lws context is only ever going to be used with
	 * COUNT client wsis / fds / sockets at a time, let lws know it doesn't
	 * have to use the default allocations for fd tables up to ulimit -n.
	 * It will just allocate for 1 internal and COUNT + 1 (allowing for h2
	 * network wsi) that we will use.
	 */
	info.fd_limit_per_thread = 1 + COUNT + 1;

#if defined(LWS_WITH_MBEDTLS)
	/*
	 * OpenSSL uses the system trust store.  mbedTLS has to be told which
	 * CA to trust explicitly.
	 */
	info.client_ssl_ca_filepath = "./warmcat.com.cer";
#endif

#if defined(LWS_WITH_DETAILED_LATENCY)
	info.detailed_latency_cb = lws_det_lat_plot_cb;
	info.detailed_latency_filepath = "/tmp/lws-latency-results";
#endif

	context = lws_create_context(&info);
	if (!context) {
		lwsl_err("lws init failed\n");
		return 1;
	}

	i.context = context;
	i.ssl_connection = LCCSCF_USE_SSL |
			   LCCSCF_H2_QUIRK_OVERFLOWS_TXCR |
			   LCCSCF_H2_QUIRK_NGHTTP2_END_STREAM;

	if (lws_cmdline_option(argc, argv, "--post")) {
		posting = 1;
		i.method = "POST";
		i.ssl_connection |= LCCSCF_HTTP_MULTIPART_MIME;
	} else
		i.method = "GET";

	/* enables h1 or h2 connection sharing */
	if (lws_cmdline_option(argc, argv, "-p"))
		i.ssl_connection |= LCCSCF_PIPELINE;

	/* force h1 even if h2 available */
	if (lws_cmdline_option(argc, argv, "--h1"))
		i.alpn = "http/1.1";

	strcpy(urlpath, "/");

	if (lws_cmdline_option(argc, argv, "-l")) {
		i.port = 7681;
		i.address = "localhost";
		i.ssl_connection |= LCCSCF_ALLOW_SELFSIGNED;
		if (posting)
			strcpy(urlpath, "/formtest");
	} else {
		i.port = 443;
		i.address = "libwebsockets.org";
		if (posting)
			strcpy(urlpath, "/testserver/formtest");
	}

	if (lws_cmdline_option(argc, argv, "-n"))
		numbered = 1;

	if ((p = lws_cmdline_option(argc, argv, "--server")))
		i.address = p;

	if ((p = lws_cmdline_option(argc, argv, "--port")))
		i.port = atoi(p);

	if ((p = lws_cmdline_option(argc, argv, "--path")))
		lws_strncpy(urlpath, p, sizeof(urlpath));

	if ((p = lws_cmdline_option(argc, argv, "-c")))
		if (atoi(p) <= COUNT && atoi(p))
			count = atoi(p);

	i.host = i.address;
	i.origin = i.address;
	i.protocol = protocols[0].name;

	if (!staggered)
		/*
		 * just pile on all the connections at once, testing the
		 * pipeline queuing before the first is connected
		 */
		for (m = 0; m < count; m++)
			lws_try_client_connection(&i, m);
	else
		/*
		 * delay the connections slightly
		 */
		lws_sul_schedule(context, 0, &sul_stagger, stagger_cb,
				 100 * LWS_US_PER_MS);

	start = us();
	while (!lws_service(context, 0))
		;

	lwsl_user("Duration: %lldms\n", (us() - start) / 1000);
	lws_context_destroy(context);

	lwsl_user("Exiting with %d\n", failed || completed != count);

	return failed || completed != count;
}