You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
472 lines
13 KiB
472 lines
13 KiB
/*
|
|
* 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)(intptr_t)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 *)(intptr_t)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
|
|
if (lws_cmdline_option(argc, argv, "--glib"))
|
|
info.options |= LWS_SERVER_OPTION_GLIB;
|
|
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 ((p = lws_cmdline_option(argc, argv, "--limit")))
|
|
info.simultaneous_ssl_restriction = atoi(p);
|
|
|
|
#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;
|
|
}
|