summaryrefslogtreecommitdiffstats
path: root/src/civetweb/test/public_server.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/civetweb/test/public_server.c')
-rw-r--r--src/civetweb/test/public_server.c4953
1 files changed, 4953 insertions, 0 deletions
diff --git a/src/civetweb/test/public_server.c b/src/civetweb/test/public_server.c
new file mode 100644
index 00000000..b080ac26
--- /dev/null
+++ b/src/civetweb/test/public_server.c
@@ -0,0 +1,4953 @@
+/* Copyright (c) 2015-2017 the Civetweb developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifdef _MSC_VER
+#ifndef _CRT_SECURE_NO_WARNINGS
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdint.h>
+#include <time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "public_server.h"
+#include <civetweb.h>
+
+#if defined(_WIN32)
+#include <windows.h>
+#define test_sleep(x) (Sleep((x)*1000))
+#else
+#include <unistd.h>
+#define test_sleep(x) (sleep(x))
+#endif
+
+#define SLEEP_BEFORE_MG_START (1)
+#define SLEEP_AFTER_MG_START (3)
+#define SLEEP_BEFORE_MG_STOP (1)
+#define SLEEP_AFTER_MG_STOP (5)
+
+/* This unit test file uses the excellent Check unit testing library.
+ * The API documentation is available here:
+ * http://check.sourceforge.net/doc/check_html/index.html
+ */
+
+#if defined(__MINGW32__) || defined(__GNUC__)
+/* Return codes of the tested functions are evaluated. Checking all other
+ * functions, used only to prepare the test environment seems redundant.
+ * If they fail, the test fails anyway. */
+#pragma GCC diagnostic ignored "-Wunused-result"
+#endif
+
+static const char *
+locate_path(const char *a_path)
+{
+ static char r_path[256];
+
+#ifdef _WIN32
+#ifdef LOCAL_TEST
+ sprintf(r_path, "%s\\", a_path);
+#else
+ /* Appveyor */
+ sprintf(r_path, "..\\..\\..\\%s\\", a_path);
+/* TODO: the different paths
+ * used in the different test
+ * system is an unsolved
+ * problem. */
+#endif
+#else
+#ifdef LOCAL_TEST
+ sprintf(r_path, "%s/", a_path);
+#else
+ /* Travis */
+ sprintf(r_path,
+ "../../%s/",
+ a_path); // TODO: fix path in CI test environment
+#endif
+#endif
+
+ return r_path;
+}
+
+
+#define locate_resources() locate_path("resources")
+#define locate_test_exes() locate_path("output")
+
+
+static const char *
+locate_ssl_cert(void)
+{
+ static char cert_path[256];
+ const char *res = locate_resources();
+ size_t l;
+
+ ck_assert(res != NULL);
+ l = strlen(res);
+ ck_assert_uint_gt(l, 0);
+ ck_assert_uint_lt(l, 100); /* assume there is enough space left in our
+ typical 255 character string buffers */
+
+ strcpy(cert_path, res);
+ strcat(cert_path, "ssl_cert.pem");
+ return cert_path;
+}
+
+
+static int
+wait_not_null(void *volatile *data)
+{
+ int i;
+ for (i = 0; i < 100; i++) {
+ mark_point();
+ test_sleep(1);
+
+ if (*data != NULL) {
+ mark_point();
+ return 1;
+ }
+ }
+
+#if defined(__MINGW32__) || defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunreachable-code"
+#pragma GCC diagnostic ignored "-Wunreachable-code-return"
+#endif
+
+ ck_abort_msg("wait_not_null failed (%i sec)", i);
+
+ return 0;
+
+#if defined(__MINGW32__) || defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+}
+
+
+START_TEST(test_the_test_environment)
+{
+ char wd[300];
+ char buf[500];
+ FILE *f;
+ struct stat st;
+ int ret;
+ const char *ssl_cert = locate_ssl_cert();
+
+ memset(wd, 0, sizeof(wd));
+ memset(buf, 0, sizeof(buf));
+
+/* Get the current working directory */
+#ifdef _WIN32
+ (void)GetCurrentDirectoryA(sizeof(wd), wd);
+ wd[sizeof(wd) - 1] = 0;
+#else
+ (void)getcwd(wd, sizeof(wd));
+ wd[sizeof(wd) - 1] = 0;
+#endif
+
+/* Check the pem file */
+#ifdef _WIN32
+ strcpy(buf, wd);
+ strcat(buf, "\\");
+ strcat(buf, ssl_cert);
+ f = fopen(buf, "rb");
+#else
+ strcpy(buf, wd);
+ strcat(buf, "/");
+ strcat(buf, ssl_cert);
+ f = fopen(buf, "r");
+#endif
+
+ if (f) {
+ fclose(f);
+ } else {
+ fprintf(stderr, "%s not found", buf);
+ }
+
+/* Check the test dir */
+#ifdef _WIN32
+ strcpy(buf, wd);
+ strcat(buf, "\\test");
+#else
+ strcpy(buf, wd);
+ strcat(buf, "/test");
+#endif
+
+ memset(&st, 0, sizeof(st));
+ ret = stat(buf, &st);
+
+ if (ret) {
+ fprintf(stderr, "%s not found", buf);
+ }
+
+
+#ifdef _WIN32
+/* Try to copy the files required for AppVeyor */
+#if defined(_WIN64) || defined(__MINGW64__)
+ (void)system("cmd /c copy C:\\OpenSSL-Win64\\libeay32.dll libeay32.dll");
+ (void)system("cmd /c copy C:\\OpenSSL-Win64\\libssl32.dll libssl32.dll");
+ (void)system("cmd /c copy C:\\OpenSSL-Win64\\ssleay32.dll ssleay32.dll");
+ (void)system("cmd /c copy C:\\OpenSSL-Win64\\libeay32.dll libeay64.dll");
+ (void)system("cmd /c copy C:\\OpenSSL-Win64\\libssl32.dll libssl64.dll");
+ (void)system("cmd /c copy C:\\OpenSSL-Win64\\ssleay32.dll ssleay64.dll");
+#else
+ (void)system("cmd /c copy C:\\OpenSSL-Win32\\libeay32.dll libeay32.dll");
+ (void)system("cmd /c copy C:\\OpenSSL-Win32\\libssl32.dll libssl32.dll");
+ (void)system("cmd /c copy C:\\OpenSSL-Win32\\ssleay32.dll ssleay32.dll");
+#endif
+#endif
+}
+END_TEST
+
+
+static void *threading_data = 0;
+
+static void *
+test_thread_func_t(void *param)
+{
+ ck_assert_ptr_eq(param, &threading_data);
+ ck_assert_ptr_eq(threading_data, NULL);
+ threading_data = &threading_data;
+ return NULL;
+}
+
+
+START_TEST(test_threading)
+{
+ int ok;
+
+ threading_data = NULL;
+ mark_point();
+
+ ok = mg_start_thread(test_thread_func_t, &threading_data);
+ ck_assert_int_eq(ok, 0);
+
+ wait_not_null(&threading_data);
+ ck_assert_ptr_eq(threading_data, &threading_data);
+}
+END_TEST
+
+
+static int
+log_msg_func(const struct mg_connection *conn, const char *message)
+{
+ struct mg_context *ctx;
+ char *ud;
+
+ ck_assert(conn != NULL);
+ ctx = mg_get_context(conn);
+ ck_assert(ctx != NULL);
+ ud = (char *)mg_get_user_data(ctx);
+
+ strncpy(ud, message, 255);
+ ud[255] = 0;
+ mark_point();
+
+ printf("LOG_MSG_FUNC: %s\n", message);
+ mark_point();
+
+ return 1; /* Return 1 means "already handled" */
+}
+
+
+static int
+test_log_message(const struct mg_connection *conn, const char *message)
+{
+ (void)conn;
+
+ printf("LOG_MESSAGE: %s\n", message);
+ mark_point();
+
+ return 0; /* Return 0 means "not yet handled" */
+}
+
+
+static struct mg_context *
+test_mg_start(const struct mg_callbacks *callbacks,
+ void *user_data,
+ const char **configuration_options)
+{
+ struct mg_context *ctx;
+ struct mg_callbacks cb;
+
+ if (callbacks) {
+ memcpy(&cb, callbacks, sizeof(cb));
+ } else {
+ memset(&cb, 0, sizeof(cb));
+ }
+
+ if (cb.log_message == NULL) {
+ cb.log_message = test_log_message;
+ }
+
+ mark_point();
+ test_sleep(SLEEP_BEFORE_MG_START);
+ mark_point();
+ ctx = mg_start(&cb, user_data, configuration_options);
+ mark_point();
+ if (ctx) {
+ /* Give the server some time to start in the test VM */
+ /* Don't need to do this if mg_start failed */
+ test_sleep(SLEEP_AFTER_MG_START);
+ }
+ mark_point();
+
+ return ctx;
+}
+
+
+static void
+test_mg_stop(struct mg_context *ctx)
+{
+#ifdef __MACH__
+ /* For unknown reasons, there are sporadic hands
+ * for OSX if mark_point is called here */
+ test_sleep(SLEEP_BEFORE_MG_STOP);
+ mg_stop(ctx);
+ test_sleep(SLEEP_AFTER_MG_STOP);
+#else
+ mark_point();
+ test_sleep(SLEEP_BEFORE_MG_STOP);
+ mark_point();
+ mg_stop(ctx);
+ mark_point();
+ test_sleep(SLEEP_AFTER_MG_STOP);
+ mark_point();
+#endif
+}
+
+
+static void
+test_mg_start_stop_http_server_impl(int ipv6)
+{
+ struct mg_context *ctx;
+ const char *OPTIONS[16];
+ int optcnt = 0;
+ const char *localhost_name = ((ipv6) ? "[::1]" : "127.0.0.1");
+
+#if defined(MG_LEGACY_INTERFACE)
+ size_t ports_cnt;
+ int ports[16];
+ int ssl[16];
+#endif
+ struct mg_callbacks callbacks;
+ char errmsg[256];
+
+ struct mg_connection *client_conn;
+ char client_err[256];
+ const struct mg_request_info *client_ri;
+ int client_res, ret;
+ struct mg_server_ports portinfo[8];
+
+ mark_point();
+
+#if !defined(NO_FILES)
+ OPTIONS[optcnt++] = "document_root";
+ OPTIONS[optcnt++] = ".";
+#endif
+ OPTIONS[optcnt++] = "listening_ports";
+ OPTIONS[optcnt++] = ((ipv6) ? "+8080" : "8080");
+ OPTIONS[optcnt] = 0;
+
+#if defined(MG_LEGACY_INTERFACE)
+ memset(ports, 0, sizeof(ports));
+ memset(ssl, 0, sizeof(ssl));
+#endif
+ memset(portinfo, 0, sizeof(portinfo));
+ memset(&callbacks, 0, sizeof(callbacks));
+ memset(errmsg, 0, sizeof(errmsg));
+
+ callbacks.log_message = log_msg_func;
+
+ ctx = test_mg_start(&callbacks, (void *)errmsg, OPTIONS);
+
+ ck_assert_str_eq(errmsg, "");
+ ck_assert(ctx != NULL);
+
+#if defined(MG_LEGACY_INTERFACE)
+ ports_cnt = mg_get_ports(ctx, 16, ports, ssl);
+ ck_assert_uint_eq(ports_cnt, 1);
+ ck_assert_int_eq(ports[0], 8080);
+ ck_assert_int_eq(ssl[0], 0);
+ ck_assert_int_eq(ports[1], 0);
+ ck_assert_int_eq(ssl[1], 0);
+#endif
+
+ ret = mg_get_server_ports(ctx, 0, portinfo);
+ ck_assert_int_lt(ret, 0);
+ ck_assert_int_eq(portinfo[0].protocol, 0);
+ ck_assert_int_eq(portinfo[0].port, 0);
+ ck_assert_int_eq(portinfo[0].is_ssl, 0);
+ ck_assert_int_eq(portinfo[0].is_redirect, 0);
+ ck_assert_int_eq(portinfo[1].protocol, 0);
+ ck_assert_int_eq(portinfo[1].port, 0);
+ ck_assert_int_eq(portinfo[1].is_ssl, 0);
+ ck_assert_int_eq(portinfo[1].is_redirect, 0);
+
+ ret = mg_get_server_ports(ctx, 4, portinfo);
+ ck_assert_int_eq(ret, 1);
+ if (ipv6) {
+ ck_assert_int_eq(portinfo[0].protocol, 3);
+ } else {
+ ck_assert_int_eq(portinfo[0].protocol, 1);
+ }
+ ck_assert_int_eq(portinfo[0].port, 8080);
+ ck_assert_int_eq(portinfo[0].is_ssl, 0);
+ ck_assert_int_eq(portinfo[0].is_redirect, 0);
+ ck_assert_int_eq(portinfo[1].protocol, 0);
+ ck_assert_int_eq(portinfo[1].port, 0);
+ ck_assert_int_eq(portinfo[1].is_ssl, 0);
+ ck_assert_int_eq(portinfo[1].is_redirect, 0);
+
+ test_sleep(1);
+
+ /* HTTP 1.0 GET request */
+ memset(client_err, 0, sizeof(client_err));
+ client_conn = mg_connect_client(
+ localhost_name, 8080, 0, client_err, sizeof(client_err));
+
+ ck_assert_str_eq(client_err, "");
+ ck_assert(client_conn != NULL);
+
+ mg_printf(client_conn, "GET / HTTP/1.0\r\n\r\n");
+ client_res =
+ mg_get_response(client_conn, client_err, sizeof(client_err), 10000);
+ ck_assert_int_ge(client_res, 0);
+ ck_assert_str_eq(client_err, "");
+ client_ri = mg_get_request_info(client_conn);
+ ck_assert(client_ri != NULL);
+
+#if defined(NO_FILES)
+ ck_assert_str_eq(client_ri->local_uri, "404");
+#else
+ ck_assert_str_eq(client_ri->local_uri, "200");
+ /* TODO: ck_assert_str_eq(client_ri->request_method, "HTTP/1.0"); */
+ client_res = (int)mg_read(client_conn, client_err, sizeof(client_err));
+ ck_assert_int_gt(client_res, 0);
+ ck_assert_int_le(client_res, sizeof(client_err));
+#endif
+ mg_close_connection(client_conn);
+
+ test_sleep(1);
+
+ /* HTTP 1.1 GET request */
+ memset(client_err, 0, sizeof(client_err));
+ client_conn = mg_connect_client(
+ localhost_name, 8080, 0, client_err, sizeof(client_err));
+
+ ck_assert_str_eq(client_err, "");
+ ck_assert(client_conn != NULL);
+
+ mg_printf(client_conn, "GET / HTTP/1.1\r\n");
+ mg_printf(client_conn, "Host: localhost:8080\r\n");
+ mg_printf(client_conn, "Connection: close\r\n\r\n");
+ client_res =
+ mg_get_response(client_conn, client_err, sizeof(client_err), 10000);
+ ck_assert_int_ge(client_res, 0);
+ ck_assert_str_eq(client_err, "");
+ client_ri = mg_get_request_info(client_conn);
+ ck_assert(client_ri != NULL);
+
+#if defined(NO_FILES)
+ ck_assert_str_eq(client_ri->local_uri, "404");
+#else
+ ck_assert_str_eq(client_ri->local_uri, "200");
+ /* TODO: ck_assert_str_eq(client_ri->request_method, "HTTP/1.0"); */
+ client_res = (int)mg_read(client_conn, client_err, sizeof(client_err));
+ ck_assert_int_gt(client_res, 0);
+ ck_assert_int_le(client_res, sizeof(client_err));
+#endif
+ mg_close_connection(client_conn);
+
+ test_sleep(1);
+
+
+ /* HTTP 1.7 GET request - this HTTP version does not exist */
+ memset(client_err, 0, sizeof(client_err));
+ client_conn = mg_connect_client(
+ localhost_name, 8080, 0, client_err, sizeof(client_err));
+
+ ck_assert_str_eq(client_err, "");
+ ck_assert(client_conn != NULL);
+
+ mg_printf(client_conn, "GET / HTTP/1.7\r\n");
+ mg_printf(client_conn, "Host: localhost:8080\r\n");
+ mg_printf(client_conn, "Connection: close\r\n\r\n");
+ client_res =
+ mg_get_response(client_conn, client_err, sizeof(client_err), 10000);
+ ck_assert_int_ge(client_res, 0);
+ ck_assert_str_eq(client_err, "");
+ client_ri = mg_get_request_info(client_conn);
+ ck_assert(client_ri != NULL);
+
+ /* Response must be 505 HTTP Version not supported */
+ ck_assert_str_eq(client_ri->local_uri, "505");
+ mg_close_connection(client_conn);
+
+ test_sleep(1);
+
+
+ /* HTTP request with multiline header.
+ * Multiline header are obsolete with RFC 7230 section-3.2.4
+ * and must return "400 Bad Request" */
+ memset(client_err, 0, sizeof(client_err));
+ client_conn = mg_connect_client(
+ localhost_name, 8080, 0, client_err, sizeof(client_err));
+
+ ck_assert_str_eq(client_err, "");
+ ck_assert(client_conn != NULL);
+
+ mg_printf(client_conn, "GET / HTTP/1.1\r\n");
+ mg_printf(client_conn, "Host: localhost:8080\r\n");
+ mg_printf(client_conn, "X-Obsolete-Header: something\r\nfor nothing\r\n");
+ mg_printf(client_conn, "Connection: close\r\n\r\n");
+ client_res =
+ mg_get_response(client_conn, client_err, sizeof(client_err), 10000);
+ ck_assert_int_ge(client_res, 0);
+ ck_assert_str_eq(client_err, "");
+ client_ri = mg_get_request_info(client_conn);
+ ck_assert(client_ri != NULL);
+
+ /* Response must be 400 Bad Request */
+ ck_assert_str_eq(client_ri->local_uri, "400");
+ mg_close_connection(client_conn);
+
+ test_sleep(1);
+
+ /* End test */
+ test_mg_stop(ctx);
+ mark_point();
+}
+
+
+START_TEST(test_mg_start_stop_http_server)
+{
+ mark_point();
+ test_mg_start_stop_http_server_impl(0);
+ mark_point();
+}
+END_TEST
+
+
+START_TEST(test_mg_start_stop_http_server_ipv6)
+{
+ mark_point();
+#if defined(USE_IPV6)
+ test_mg_start_stop_http_server_impl(1);
+#endif
+ mark_point();
+}
+END_TEST
+
+
+START_TEST(test_mg_start_stop_https_server)
+{
+#ifndef NO_SSL
+
+ struct mg_context *ctx;
+
+#if defined(MG_LEGACY_INTERFACE)
+ size_t ports_cnt;
+ int ports[16];
+ int ssl[16];
+#endif
+ struct mg_callbacks callbacks;
+ char errmsg[256];
+
+ const char *OPTIONS[8]; /* initializer list here is rejected by CI test */
+ int opt_idx = 0;
+ const char *ssl_cert = locate_ssl_cert();
+
+ struct mg_connection *client_conn;
+ char client_err[256];
+ const struct mg_request_info *client_ri;
+ int client_res, ret;
+ struct mg_server_ports portinfo[8];
+
+ ck_assert(ssl_cert != NULL);
+
+ memset((void *)OPTIONS, 0, sizeof(OPTIONS));
+#if !defined(NO_FILES)
+ OPTIONS[opt_idx++] = "document_root";
+ OPTIONS[opt_idx++] = ".";
+#endif
+ OPTIONS[opt_idx++] = "listening_ports";
+ OPTIONS[opt_idx++] = "8080r,8443s";
+ OPTIONS[opt_idx++] = "ssl_certificate";
+ OPTIONS[opt_idx++] = ssl_cert;
+
+ ck_assert_int_le(opt_idx, (int)(sizeof(OPTIONS) / sizeof(OPTIONS[0])));
+ ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 1] == NULL);
+ ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 2] == NULL);
+
+#if defined(MG_LEGACY_INTERFACE)
+ memset(ports, 0, sizeof(ports));
+ memset(ssl, 0, sizeof(ssl));
+#endif
+ memset(portinfo, 0, sizeof(portinfo));
+ memset(&callbacks, 0, sizeof(callbacks));
+ memset(errmsg, 0, sizeof(errmsg));
+
+ callbacks.log_message = log_msg_func;
+
+ ctx = test_mg_start(&callbacks, (void *)errmsg, OPTIONS);
+
+ ck_assert_str_eq(errmsg, "");
+ ck_assert(ctx != NULL);
+
+#if defined(MG_LEGACY_INTERFACE)
+ ports_cnt = mg_get_ports(ctx, 16, ports, ssl);
+ ck_assert_uint_eq(ports_cnt, 2);
+ ck_assert_int_eq(ports[0], 8080);
+ ck_assert_int_eq(ssl[0], 0);
+ ck_assert_int_eq(ports[1], 8443);
+ ck_assert_int_eq(ssl[1], 1);
+ ck_assert_int_eq(ports[2], 0);
+ ck_assert_int_eq(ssl[2], 0);
+#endif
+
+ ret = mg_get_server_ports(ctx, 0, portinfo);
+ ck_assert_int_lt(ret, 0);
+ ck_assert_int_eq(portinfo[0].protocol, 0);
+ ck_assert_int_eq(portinfo[0].port, 0);
+ ck_assert_int_eq(portinfo[0].is_ssl, 0);
+ ck_assert_int_eq(portinfo[0].is_redirect, 0);
+ ck_assert_int_eq(portinfo[1].protocol, 0);
+ ck_assert_int_eq(portinfo[1].port, 0);
+ ck_assert_int_eq(portinfo[1].is_ssl, 0);
+ ck_assert_int_eq(portinfo[1].is_redirect, 0);
+
+ ret = mg_get_server_ports(ctx, 4, portinfo);
+ ck_assert_int_eq(ret, 2);
+ ck_assert_int_eq(portinfo[0].protocol, 1);
+ ck_assert_int_eq(portinfo[0].port, 8080);
+ ck_assert_int_eq(portinfo[0].is_ssl, 0);
+ ck_assert_int_eq(portinfo[0].is_redirect, 1);
+ ck_assert_int_eq(portinfo[1].protocol, 1);
+ ck_assert_int_eq(portinfo[1].port, 8443);
+ ck_assert_int_eq(portinfo[1].is_ssl, 1);
+ ck_assert_int_eq(portinfo[1].is_redirect, 0);
+ ck_assert_int_eq(portinfo[2].protocol, 0);
+ ck_assert_int_eq(portinfo[2].port, 0);
+ ck_assert_int_eq(portinfo[2].is_ssl, 0);
+ ck_assert_int_eq(portinfo[2].is_redirect, 0);
+
+ test_sleep(1);
+
+ memset(client_err, 0, sizeof(client_err));
+ client_conn =
+ mg_connect_client("127.0.0.1", 8443, 1, client_err, sizeof(client_err));
+
+ ck_assert_str_eq(client_err, "");
+ ck_assert(client_conn != NULL);
+
+ mg_printf(client_conn, "GET / HTTP/1.0\r\n\r\n");
+ client_res =
+ mg_get_response(client_conn, client_err, sizeof(client_err), 10000);
+ ck_assert_int_ge(client_res, 0);
+ ck_assert_str_eq(client_err, "");
+ client_ri = mg_get_request_info(client_conn);
+ ck_assert(client_ri != NULL);
+
+#if defined(NO_FILES)
+ ck_assert_str_eq(client_ri->local_uri, "404");
+#else
+ ck_assert_str_eq(client_ri->local_uri, "200");
+ /* TODO: ck_assert_str_eq(client_ri->request_method, "HTTP/1.0"); */
+ client_res = (int)mg_read(client_conn, client_err, sizeof(client_err));
+ ck_assert_int_gt(client_res, 0);
+ ck_assert_int_le(client_res, sizeof(client_err));
+#endif
+ mg_close_connection(client_conn);
+
+ test_sleep(1);
+
+ test_mg_stop(ctx);
+ mark_point();
+#endif
+}
+END_TEST
+
+
+START_TEST(test_mg_server_and_client_tls)
+{
+#ifndef NO_SSL
+
+ struct mg_context *ctx;
+
+ int ports_cnt;
+ struct mg_server_ports ports[16];
+ struct mg_callbacks callbacks;
+ char errmsg[256];
+
+ struct mg_connection *client_conn;
+ char client_err[256];
+ const struct mg_request_info *client_ri;
+ int client_res;
+ struct mg_client_options client_options;
+
+ const char *OPTIONS[32]; /* initializer list here is rejected by CI test */
+ int opt_idx = 0;
+ char server_cert[256];
+ char client_cert[256];
+ const char *res_dir = locate_resources();
+
+ ck_assert(res_dir != NULL);
+ strcpy(server_cert, res_dir);
+ strcpy(client_cert, res_dir);
+#ifdef _WIN32
+ strcat(server_cert, "cert\\server.pem");
+ strcat(client_cert, "cert\\client.pem");
+#else
+ strcat(server_cert, "cert/server.pem");
+ strcat(client_cert, "cert/client.pem");
+#endif
+
+ memset((void *)OPTIONS, 0, sizeof(OPTIONS));
+#if !defined(NO_FILES)
+ OPTIONS[opt_idx++] = "document_root";
+ OPTIONS[opt_idx++] = ".";
+#endif
+ OPTIONS[opt_idx++] = "listening_ports";
+ OPTIONS[opt_idx++] = "8080r,8443s";
+ OPTIONS[opt_idx++] = "ssl_certificate";
+ OPTIONS[opt_idx++] = server_cert;
+ OPTIONS[opt_idx++] = "ssl_verify_peer";
+ OPTIONS[opt_idx++] = "yes";
+ OPTIONS[opt_idx++] = "ssl_ca_file";
+ OPTIONS[opt_idx++] = client_cert;
+
+ ck_assert_int_le(opt_idx, (int)(sizeof(OPTIONS) / sizeof(OPTIONS[0])));
+ ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 1] == NULL);
+ ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 2] == NULL);
+
+ memset(ports, 0, sizeof(ports));
+ memset(&callbacks, 0, sizeof(callbacks));
+ memset(errmsg, 0, sizeof(errmsg));
+
+ callbacks.log_message = log_msg_func;
+
+ ctx = test_mg_start(&callbacks, (void *)errmsg, OPTIONS);
+
+ ck_assert_str_eq(errmsg, "");
+ ck_assert(ctx != NULL);
+
+ ports_cnt = mg_get_server_ports(ctx, 16, ports);
+ ck_assert_int_eq(ports_cnt, 2);
+ ck_assert_int_eq(ports[0].protocol, 1);
+ ck_assert_int_eq(ports[0].port, 8080);
+ ck_assert_int_eq(ports[0].is_ssl, 0);
+ ck_assert_int_eq(ports[0].is_redirect, 1);
+ ck_assert_int_eq(ports[1].protocol, 1);
+ ck_assert_int_eq(ports[1].port, 8443);
+ ck_assert_int_eq(ports[1].is_ssl, 1);
+ ck_assert_int_eq(ports[1].is_redirect, 0);
+ ck_assert_int_eq(ports[2].protocol, 0);
+ ck_assert_int_eq(ports[2].port, 0);
+ ck_assert_int_eq(ports[2].is_ssl, 0);
+ ck_assert_int_eq(ports[2].is_redirect, 0);
+
+ test_sleep(1);
+
+ memset(client_err, 0, sizeof(client_err));
+ client_conn =
+ mg_connect_client("127.0.0.1", 8443, 1, client_err, sizeof(client_err));
+
+ ck_assert_str_ne(client_err, "");
+ ck_assert(client_conn == NULL);
+
+ memset(client_err, 0, sizeof(client_err));
+ memset(&client_options, 0, sizeof(client_options));
+ client_options.host = "127.0.0.1";
+ client_options.port = 8443;
+ client_options.client_cert = client_cert;
+ client_options.server_cert = server_cert;
+
+ client_conn = mg_connect_client_secure(&client_options,
+ client_err,
+ sizeof(client_err));
+
+ ck_assert_str_eq(client_err, "");
+ ck_assert(client_conn != NULL);
+
+ mg_printf(client_conn, "GET / HTTP/1.0\r\n\r\n");
+ client_res =
+ mg_get_response(client_conn, client_err, sizeof(client_err), 10000);
+ ck_assert_int_ge(client_res, 0);
+ ck_assert_str_eq(client_err, "");
+ client_ri = mg_get_request_info(client_conn);
+ ck_assert(client_ri != NULL);
+
+#if defined(NO_FILES)
+ ck_assert_str_eq(client_ri->local_uri, "404");
+#else
+ ck_assert_str_eq(client_ri->local_uri, "200");
+ /* TODO: ck_assert_str_eq(client_ri->request_method, "HTTP/1.0"); */
+ client_res = (int)mg_read(client_conn, client_err, sizeof(client_err));
+ ck_assert_int_gt(client_res, 0);
+ ck_assert_int_le(client_res, sizeof(client_err));
+#endif
+ mg_close_connection(client_conn);
+
+ /* TODO: A client API using a client certificate is missing */
+
+ test_sleep(1);
+
+ test_mg_stop(ctx);
+#endif
+ mark_point();
+}
+END_TEST
+
+
+static struct mg_context *g_ctx;
+
+static int
+request_test_handler(struct mg_connection *conn, void *cbdata)
+{
+ int i;
+ char chunk_data[32];
+ const struct mg_request_info *ri;
+ struct mg_context *ctx;
+ void *ud, *cud;
+ void *dummy = malloc(1);
+
+ ctx = mg_get_context(conn);
+ ud = mg_get_user_data(ctx);
+ ri = mg_get_request_info(conn);
+
+ ck_assert(ri != NULL);
+ ck_assert(ctx == g_ctx);
+ ck_assert(ud == &g_ctx);
+
+ ck_assert(dummy != NULL);
+
+ mg_set_user_connection_data(conn, (void *)&dummy);
+ cud = mg_get_user_connection_data(conn);
+ ck_assert_ptr_eq((void *)cud, (void *)&dummy);
+
+ mg_set_user_connection_data(conn, (void *)NULL);
+ cud = mg_get_user_connection_data(conn);
+ ck_assert_ptr_eq((void *)cud, (void *)NULL);
+
+ free(dummy);
+
+ ck_assert_ptr_eq((void *)cbdata, (void *)(ptrdiff_t)7);
+ strcpy(chunk_data, "123456789A123456789B123456789C");
+
+ mg_printf(conn,
+ "HTTP/1.1 200 OK\r\n"
+ "Transfer-Encoding: chunked\r\n"
+ "Content-Type: text/plain\r\n\r\n");
+
+ for (i = 1; i <= 10; i++) {
+ mg_printf(conn, "%x\r\n", i);
+ mg_write(conn, chunk_data, (unsigned)i);
+ mg_printf(conn, "\r\n");
+ }
+
+ mg_printf(conn, "0\r\n\r\n");
+ mark_point();
+
+ return 1;
+}
+
+
+#ifdef USE_WEBSOCKET
+/****************************************************************************/
+/* WEBSOCKET SERVER */
+/****************************************************************************/
+static const char *websocket_welcome_msg = "websocket welcome\n";
+static const size_t websocket_welcome_msg_len =
+ 18 /* strlen(websocket_welcome_msg) */;
+static const char *websocket_goodbye_msg = "websocket bye\n";
+static const size_t websocket_goodbye_msg_len =
+ 14 /* strlen(websocket_goodbye_msg) */;
+
+
+#if defined(DEBUG)
+static void
+WS_TEST_TRACE(const char *f, ...)
+{
+ va_list l;
+ va_start(l, f);
+ vprintf(f, l);
+ va_end(l);
+}
+#else
+#define WS_TEST_TRACE(...)
+#endif
+
+
+static int
+websock_server_connect(const struct mg_connection *conn, void *udata)
+{
+ (void)conn;
+
+ ck_assert_ptr_eq((void *)udata, (void *)(ptrdiff_t)7531);
+ WS_TEST_TRACE("Server: Websocket connected\n");
+ mark_point();
+
+ return 0; /* return 0 to accept every connection */
+}
+
+
+static void
+websock_server_ready(struct mg_connection *conn, void *udata)
+{
+ ck_assert_ptr_eq((void *)udata, (void *)(ptrdiff_t)7531);
+ ck_assert_ptr_ne((void *)conn, (void *)NULL);
+ WS_TEST_TRACE("Server: Websocket ready\n");
+
+ /* Send websocket welcome message */
+ mg_lock_connection(conn);
+ mg_websocket_write(conn,
+ WEBSOCKET_OPCODE_TEXT,
+ websocket_welcome_msg,
+ websocket_welcome_msg_len);
+ mg_unlock_connection(conn);
+
+ WS_TEST_TRACE("Server: Websocket ready X\n");
+ mark_point();
+}
+
+
+#define long_ws_buf_len_16 (500)
+#define long_ws_buf_len_64 (70000)
+static char long_ws_buf[long_ws_buf_len_64];
+
+
+static int
+websock_server_data(struct mg_connection *conn,
+ int bits,
+ char *data,
+ size_t data_len,
+ void *udata)
+{
+ (void)bits;
+
+ ck_assert_ptr_eq((void *)udata, (void *)(ptrdiff_t)7531);
+ WS_TEST_TRACE("Server: Got %u bytes from the client\n", (unsigned)data_len);
+
+ if (data_len == 3 && !memcmp(data, "bye", 3)) {
+ /* Send websocket goodbye message */
+ mg_lock_connection(conn);
+ mg_websocket_write(conn,
+ WEBSOCKET_OPCODE_TEXT,
+ websocket_goodbye_msg,
+ websocket_goodbye_msg_len);
+ mg_unlock_connection(conn);
+ } else if (data_len == 5 && !memcmp(data, "data1", 5)) {
+ mg_lock_connection(conn);
+ mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, "ok1", 3);
+ mg_unlock_connection(conn);
+ } else if (data_len == 5 && !memcmp(data, "data2", 5)) {
+ mg_lock_connection(conn);
+ mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, "ok 2", 4);
+ mg_unlock_connection(conn);
+ } else if (data_len == 5 && !memcmp(data, "data3", 5)) {
+ mg_lock_connection(conn);
+ mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, "ok - 3", 6);
+ mg_unlock_connection(conn);
+ } else if (data_len == long_ws_buf_len_16) {
+ ck_assert(memcmp(data, long_ws_buf, long_ws_buf_len_16) == 0);
+ mg_lock_connection(conn);
+ mg_websocket_write(conn,
+ WEBSOCKET_OPCODE_BINARY,
+ long_ws_buf,
+ long_ws_buf_len_16);
+ mg_unlock_connection(conn);
+ } else if (data_len == long_ws_buf_len_64) {
+ ck_assert(memcmp(data, long_ws_buf, long_ws_buf_len_64) == 0);
+ mg_lock_connection(conn);
+ mg_websocket_write(conn,
+ WEBSOCKET_OPCODE_BINARY,
+ long_ws_buf,
+ long_ws_buf_len_64);
+ mg_unlock_connection(conn);
+ } else {
+
+#if defined(__MINGW32__) || defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunreachable-code"
+#endif
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunreachable-code"
+#endif
+
+ ck_abort_msg("Got unexpected message from websocket client");
+
+
+ return 0;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+#if defined(__MINGW32__) || defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+ }
+ mark_point();
+
+ return 1; /* return 1 to keep the connetion open */
+}
+
+
+static void
+websock_server_close(const struct mg_connection *conn, void *udata)
+{
+#ifndef __MACH__
+ ck_assert_ptr_eq((void *)udata, (void *)(ptrdiff_t)7531);
+ WS_TEST_TRACE("Server: Close connection\n");
+
+ /* Can not send a websocket goodbye message here -
+ * the connection is already closed */
+
+ mark_point();
+#endif
+
+ (void)conn;
+ (void)udata;
+}
+
+
+/****************************************************************************/
+/* WEBSOCKET CLIENT */
+/****************************************************************************/
+struct tclient_data {
+ void *data;
+ size_t len;
+ int closed;
+ int clientId;
+};
+
+
+static int
+websocket_client_data_handler(struct mg_connection *conn,
+ int flags,
+ char *data,
+ size_t data_len,
+ void *user_data)
+{
+ struct mg_context *ctx = mg_get_context(conn);
+ struct tclient_data *pclient_data =
+ (struct tclient_data *)mg_get_user_data(ctx);
+
+ ck_assert_ptr_eq(user_data, (void *)pclient_data);
+
+ ck_assert(pclient_data != NULL);
+ ck_assert_int_gt(flags, 128);
+ ck_assert_int_lt(flags, 128 + 16);
+ ck_assert((flags == (int)(128 | WEBSOCKET_OPCODE_BINARY))
+ || (flags == (int)(128 | WEBSOCKET_OPCODE_TEXT)));
+
+ if (flags == (int)(128 | WEBSOCKET_OPCODE_TEXT)) {
+ WS_TEST_TRACE(
+ "Client %i received %lu bytes text data from server: %.*s\n",
+ pclient_data->clientId,
+ (unsigned long)data_len,
+ (int)data_len,
+ data);
+ } else {
+ WS_TEST_TRACE("Client %i received %lu bytes binary data from\n",
+ pclient_data->clientId,
+ (unsigned long)data_len);
+ }
+
+ pclient_data->data = malloc(data_len);
+ ck_assert(pclient_data->data != NULL);
+ memcpy(pclient_data->data, data, data_len);
+ pclient_data->len = data_len;
+
+ mark_point();
+
+ return 1;
+}
+
+
+static void
+websocket_client_close_handler(const struct mg_connection *conn,
+ void *user_data)
+{
+ struct mg_context *ctx = mg_get_context(conn);
+ struct tclient_data *pclient_data =
+ (struct tclient_data *)mg_get_user_data(ctx);
+
+#ifndef __MACH__
+ ck_assert_ptr_eq(user_data, (void *)pclient_data);
+
+ ck_assert(pclient_data != NULL);
+
+ WS_TEST_TRACE("Client %i: Close handler\n", pclient_data->clientId);
+ pclient_data->closed++;
+
+ mark_point();
+#else
+
+ (void)user_data;
+ pclient_data->closed++;
+
+#endif /* __MACH__ */
+}
+
+#endif /* USE_WEBSOCKET */
+
+
+START_TEST(test_request_handlers)
+{
+ char ebuf[100];
+ struct mg_context *ctx;
+ struct mg_connection *client_conn;
+ const struct mg_request_info *ri;
+ char uri[64];
+ char buf[1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 8];
+ const char *expected =
+ "112123123412345123456123456712345678123456789123456789A";
+ int i;
+ const char *request = "GET /U7 HTTP/1.0\r\n\r\n";
+#if defined(USE_IPV6) && defined(NO_SSL)
+ const char *HTTP_PORT = "8084,[::]:8086";
+ short ipv4_port = 8084;
+ short ipv6_port = 8086;
+#elif !defined(USE_IPV6) && defined(NO_SSL)
+ const char *HTTP_PORT = "8084";
+ short ipv4_port = 8084;
+#elif defined(USE_IPV6) && !defined(NO_SSL)
+ const char *HTTP_PORT = "8084,[::]:8086,8194r,[::]:8196r,8094s,[::]:8096s";
+ short ipv4_port = 8084;
+ short ipv4s_port = 8094;
+ short ipv4r_port = 8194;
+ short ipv6_port = 8086;
+ short ipv6s_port = 8096;
+ short ipv6r_port = 8196;
+#elif !defined(USE_IPV6) && !defined(NO_SSL)
+ const char *HTTP_PORT = "8084,8194r,8094s";
+ short ipv4_port = 8084;
+ short ipv4s_port = 8094;
+ short ipv4r_port = 8194;
+#endif
+
+ const char *OPTIONS[16];
+ const char *opt;
+ FILE *f;
+ const char *plain_file_content;
+ const char *encoded_file_content;
+ const char *cgi_script_content;
+ const char *expected_cgi_result;
+ int opt_idx = 0;
+ struct stat st;
+
+#if !defined(NO_SSL)
+ const char *ssl_cert = locate_ssl_cert();
+#endif
+
+#if defined(USE_WEBSOCKET)
+ struct tclient_data ws_client1_data = {NULL, 0, 0, 1};
+ struct tclient_data ws_client2_data = {NULL, 0, 0, 2};
+ struct tclient_data ws_client3_data = {NULL, 0, 0, 3};
+ struct tclient_data ws_client4_data = {NULL, 0, 0, 4};
+ struct mg_connection *ws_client1_conn = NULL;
+ struct mg_connection *ws_client2_conn = NULL;
+ struct mg_connection *ws_client3_conn = NULL;
+ struct mg_connection *ws_client4_conn = NULL;
+#endif
+
+ char cmd_buf[256];
+ char *cgi_env_opt;
+
+ mark_point();
+
+ memset((void *)OPTIONS, 0, sizeof(OPTIONS));
+ OPTIONS[opt_idx++] = "listening_ports";
+ OPTIONS[opt_idx++] = HTTP_PORT;
+ OPTIONS[opt_idx++] = "authentication_domain";
+ OPTIONS[opt_idx++] = "test.domain";
+#if !defined(NO_FILES)
+ OPTIONS[opt_idx++] = "document_root";
+ OPTIONS[opt_idx++] = ".";
+#endif
+#ifndef NO_SSL
+ ck_assert(ssl_cert != NULL);
+ OPTIONS[opt_idx++] = "ssl_certificate";
+ OPTIONS[opt_idx++] = ssl_cert;
+#endif
+ OPTIONS[opt_idx++] = "cgi_environment";
+ cgi_env_opt = (char *)calloc(1, 4096 /* CGI_ENVIRONMENT_SIZE */);
+ ck_assert_ptr_ne(cgi_env_opt, NULL);
+ cgi_env_opt[0] = 'x';
+ cgi_env_opt[1] = '=';
+ memset(cgi_env_opt + 2, 'y', 4090); /* Add large env field, so the server
+ * must reallocate buffers. */
+ OPTIONS[opt_idx++] = cgi_env_opt;
+
+ OPTIONS[opt_idx++] = "num_threads";
+ OPTIONS[opt_idx++] = "2";
+
+
+ ck_assert_int_le(opt_idx, (int)(sizeof(OPTIONS) / sizeof(OPTIONS[0])));
+ ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 1] == NULL);
+ ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 2] == NULL);
+
+ ctx = test_mg_start(NULL, &g_ctx, OPTIONS);
+
+ ck_assert(ctx != NULL);
+ g_ctx = ctx;
+
+ opt = mg_get_option(ctx, "listening_ports");
+ ck_assert_str_eq(opt, HTTP_PORT);
+
+ opt = mg_get_option(ctx, "cgi_environment");
+ ck_assert_ptr_ne(opt, cgi_env_opt);
+ ck_assert_int_eq((int)opt[0], (int)cgi_env_opt[0]);
+ ck_assert_int_eq((int)opt[1], (int)cgi_env_opt[1]);
+ ck_assert_int_eq((int)opt[2], (int)cgi_env_opt[2]);
+ ck_assert_int_eq((int)opt[3], (int)cgi_env_opt[3]);
+ /* full length string compare will reach limit in the implementation
+ * of the check unit test framework */
+ {
+ size_t len_check_1 = strlen(opt);
+ size_t len_check_2 = strlen(cgi_env_opt);
+ ck_assert_uint_eq(len_check_1, len_check_2);
+ }
+
+ /* We don't need the original anymore, the server has a private copy */
+ free(cgi_env_opt);
+
+ opt = mg_get_option(ctx, "throttle");
+ ck_assert_str_eq(opt, "");
+
+ opt = mg_get_option(ctx, "unknown_option_name");
+ ck_assert(opt == NULL);
+
+ for (i = 0; i < 1000; i++) {
+ sprintf(uri, "/U%u", i);
+ mg_set_request_handler(ctx, uri, request_test_handler, NULL);
+ }
+ for (i = 500; i < 800; i++) {
+ sprintf(uri, "/U%u", i);
+ mg_set_request_handler(ctx, uri, NULL, (void *)(ptrdiff_t)1);
+ }
+ for (i = 600; i >= 0; i--) {
+ sprintf(uri, "/U%u", i);
+ mg_set_request_handler(ctx, uri, NULL, (void *)(ptrdiff_t)2);
+ }
+ for (i = 750; i <= 1000; i++) {
+ sprintf(uri, "/U%u", i);
+ mg_set_request_handler(ctx, uri, NULL, (void *)(ptrdiff_t)3);
+ }
+ for (i = 5; i < 9; i++) {
+ sprintf(uri, "/U%u", i);
+ mg_set_request_handler(ctx,
+ uri,
+ request_test_handler,
+ (void *)(ptrdiff_t)i);
+ }
+
+#ifdef USE_WEBSOCKET
+ mg_set_websocket_handler(ctx,
+ "/websocket",
+ websock_server_connect,
+ websock_server_ready,
+ websock_server_data,
+ websock_server_close,
+ (void *)(ptrdiff_t)7531);
+#endif
+
+ /* Try to load non existing file */
+ client_conn = mg_download("localhost",
+ ipv4_port,
+ 0,
+ ebuf,
+ sizeof(ebuf),
+ "%s",
+ "GET /file/not/found HTTP/1.0\r\n\r\n");
+ ck_assert(client_conn != NULL);
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+ ck_assert_str_eq(ri->local_uri, "404");
+ mg_close_connection(client_conn);
+
+ /* Get data from callback */
+ client_conn = mg_download(
+ "localhost", ipv4_port, 0, ebuf, sizeof(ebuf), "%s", request);
+ ck_assert(client_conn != NULL);
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+ ck_assert_str_eq(ri->local_uri, "200");
+ i = mg_read(client_conn, buf, sizeof(buf));
+ ck_assert_int_eq(i, (int)strlen(expected));
+ buf[i] = 0;
+ ck_assert_str_eq(buf, expected);
+ mg_close_connection(client_conn);
+
+ /* Get data from callback using http://127.0.0.1 */
+ client_conn = mg_download(
+ "127.0.0.1", ipv4_port, 0, ebuf, sizeof(ebuf), "%s", request);
+ ck_assert(client_conn != NULL);
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+ ck_assert_str_eq(ri->local_uri, "200");
+ i = mg_read(client_conn, buf, sizeof(buf));
+ if ((i >= 0) && ((size_t)i < sizeof(buf))) {
+ buf[i] = 0;
+ } else {
+ ck_abort_msg(
+ "ERROR: test_request_handlers: read returned %i (>=0, <%i)",
+ (int)i,
+ (int)sizeof(buf));
+ }
+ ck_assert((int)i < (int)sizeof(buf));
+ ck_assert(i > 0);
+ ck_assert_int_eq(i, (int)strlen(expected));
+ buf[i] = 0;
+ ck_assert_str_eq(buf, expected);
+ mg_close_connection(client_conn);
+
+#if defined(USE_IPV6)
+ /* Get data from callback using http://[::1] */
+ client_conn =
+ mg_download("[::1]", ipv6_port, 0, ebuf, sizeof(ebuf), "%s", request);
+ ck_assert(client_conn != NULL);
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+ ck_assert_str_eq(ri->local_uri, "200");
+ i = mg_read(client_conn, buf, sizeof(buf));
+ ck_assert_int_eq(i, (int)strlen(expected));
+ buf[i] = 0;
+ ck_assert_str_eq(buf, expected);
+ mg_close_connection(client_conn);
+#endif
+
+#if !defined(NO_SSL)
+ /* Get data from callback using https://127.0.0.1 */
+ client_conn = mg_download(
+ "127.0.0.1", ipv4s_port, 1, ebuf, sizeof(ebuf), "%s", request);
+ ck_assert(client_conn != NULL);
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+ ck_assert_str_eq(ri->local_uri, "200");
+ i = mg_read(client_conn, buf, sizeof(buf));
+ ck_assert_int_eq(i, (int)strlen(expected));
+ buf[i] = 0;
+ ck_assert_str_eq(buf, expected);
+ mg_close_connection(client_conn);
+
+ /* Get redirect from callback using http://127.0.0.1 */
+ client_conn = mg_download(
+ "127.0.0.1", ipv4r_port, 0, ebuf, sizeof(ebuf), "%s", request);
+ ck_assert(client_conn != NULL);
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+ ck_assert_str_eq(ri->local_uri, "302");
+ i = mg_read(client_conn, buf, sizeof(buf));
+ ck_assert_int_eq(i, -1);
+ mg_close_connection(client_conn);
+#endif
+
+#if defined(USE_IPV6) && !defined(NO_SSL)
+ /* Get data from callback using https://[::1] */
+ client_conn =
+ mg_download("[::1]", ipv6s_port, 1, ebuf, sizeof(ebuf), "%s", request);
+ ck_assert(client_conn != NULL);
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+ ck_assert_str_eq(ri->local_uri, "200");
+ i = mg_read(client_conn, buf, sizeof(buf));
+ ck_assert_int_eq(i, (int)strlen(expected));
+ buf[i] = 0;
+ ck_assert_str_eq(buf, expected);
+ mg_close_connection(client_conn);
+
+ /* Get redirect from callback using http://127.0.0.1 */
+ client_conn =
+ mg_download("[::1]", ipv6r_port, 0, ebuf, sizeof(ebuf), "%s", request);
+ ck_assert(client_conn != NULL);
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+ ck_assert_str_eq(ri->local_uri, "302");
+ i = mg_read(client_conn, buf, sizeof(buf));
+ ck_assert_int_eq(i, -1);
+ mg_close_connection(client_conn);
+#endif
+
+/* It seems to be impossible to find out what the actual working
+ * directory of the CI test environment is. Before breaking another
+ * dozen of builds by trying blindly with different paths, just
+ * create the file here */
+#ifdef _WIN32
+ f = fopen("test.txt", "wb");
+#else
+ f = fopen("test.txt", "w");
+#endif
+ plain_file_content = "simple text file\n";
+ fwrite(plain_file_content, 17, 1, f);
+ fclose(f);
+
+#ifdef _WIN32
+ f = fopen("test_gz.txt.gz", "wb");
+#else
+ f = fopen("test_gz.txt.gz", "w");
+#endif
+ encoded_file_content = "\x1f\x8b\x08\x08\xf8\x9d\xcb\x55\x00\x00"
+ "test_gz.txt"
+ "\x00\x01\x11\x00\xee\xff"
+ "zipped text file"
+ "\x0a\x34\x5f\xcc\x49\x11\x00\x00\x00";
+ fwrite(encoded_file_content, 1, 52, f);
+ fclose(f);
+
+#ifdef _WIN32
+ f = fopen("test.cgi", "wb");
+ cgi_script_content = "#!test.cgi.cmd\r\n";
+ fwrite(cgi_script_content, strlen(cgi_script_content), 1, f);
+ fclose(f);
+ f = fopen("test.cgi.cmd", "w");
+ cgi_script_content = "@echo off\r\n"
+ "echo Connection: close\r\n"
+ "echo Content-Type: text/plain\r\n"
+ "echo.\r\n"
+ "echo CGI test\r\n"
+ "\r\n";
+ fwrite(cgi_script_content, strlen(cgi_script_content), 1, f);
+ fclose(f);
+#else
+ f = fopen("test.cgi", "w");
+ cgi_script_content = "#!/bin/sh\n\n"
+ "printf \"Connection: close\\r\\n\"\n"
+ "printf \"Content-Type: text/plain\\r\\n\"\n"
+ "printf \"\\r\\n\"\n"
+ "printf \"CGI test\\r\\n\"\n"
+ "\n";
+ (void)fwrite(cgi_script_content, strlen(cgi_script_content), 1, f);
+ (void)fclose(f);
+ (void)system("chmod a+x test.cgi");
+#endif
+ expected_cgi_result = "CGI test";
+
+ /* Get static data */
+ client_conn = mg_download("localhost",
+ ipv4_port,
+ 0,
+ ebuf,
+ sizeof(ebuf),
+ "%s",
+ "GET /test.txt HTTP/1.0\r\n\r\n");
+ ck_assert(client_conn != NULL);
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+
+#if defined(NO_FILES)
+ ck_assert_str_eq(ri->local_uri, "404");
+#else
+ ck_assert_str_eq(ri->local_uri, "200");
+ i = mg_read(client_conn, buf, sizeof(buf));
+ ck_assert_int_eq(i, 17);
+ if ((i >= 0) && (i < (int)sizeof(buf))) {
+ buf[i] = 0;
+ }
+ ck_assert_str_eq(buf, plain_file_content);
+#endif
+ mg_close_connection(client_conn);
+
+
+ /* Check if CGI test executable exists */
+ memset(&st, 0, sizeof(st));
+
+#if defined(_WIN32)
+ /* TODO: not yet available */
+ sprintf(ebuf, "%scgi_test.cgi", locate_test_exes());
+#else
+ sprintf(ebuf, "%scgi_test.cgi", locate_test_exes());
+
+ if (stat(ebuf, &st) != 0) {
+ fprintf(stderr, "\nFile %s not found\n", ebuf);
+ fprintf(stderr,
+ "This file needs to be compiled manually before "
+ "starting the test\n");
+ fprintf(stderr,
+ "e.g. by gcc test/cgi_test.c -o output/cgi_test.cgi\n\n");
+
+ /* Abort test with diagnostic message */
+ ck_abort_msg("Mandatory file %s must be built before starting the test",
+ ebuf);
+ }
+#endif
+
+
+/* Test with CGI test executable */
+#if defined(_WIN32)
+ sprintf(cmd_buf, "copy %s\\cgi_test.cgi cgi_test.exe", locate_test_exes());
+#else
+ sprintf(cmd_buf, "cp %s/cgi_test.cgi cgi_test.cgi", locate_test_exes());
+#endif
+ (void)system(cmd_buf);
+
+#if !defined(NO_CGI) && !defined(NO_FILES) && !defined(_WIN32)
+ /* TODO: add test for windows, check with POST */
+ client_conn = mg_download(
+ "localhost",
+ ipv4_port,
+ 0,
+ ebuf,
+ sizeof(ebuf),
+ "%s",
+ "POST /cgi_test.cgi/x/y.z HTTP/1.0\r\nContent-Length: 3\r\n\r\nABC");
+ ck_assert(client_conn != NULL);
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+ ck_assert_str_eq(ri->local_uri, "200");
+ mg_close_connection(client_conn);
+#endif
+
+ /* Get zipped static data - will not work if Accept-Encoding is not set */
+ client_conn = mg_download("localhost",
+ ipv4_port,
+ 0,
+ ebuf,
+ sizeof(ebuf),
+ "%s",
+ "GET /test_gz.txt HTTP/1.0\r\n\r\n");
+ ck_assert(client_conn != NULL);
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+ ck_assert_str_eq(ri->local_uri, "404");
+ mg_close_connection(client_conn);
+
+ /* Get zipped static data - with Accept-Encoding */
+ client_conn = mg_download(
+ "localhost",
+ ipv4_port,
+ 0,
+ ebuf,
+ sizeof(ebuf),
+ "%s",
+ "GET /test_gz.txt HTTP/1.0\r\nAccept-Encoding: gzip\r\n\r\n");
+ ck_assert(client_conn != NULL);
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+
+#if defined(NO_FILES)
+ ck_assert_str_eq(ri->local_uri, "404");
+#else
+ ck_assert_str_eq(ri->local_uri, "200");
+ i = mg_read(client_conn, buf, sizeof(buf));
+ ck_assert_int_eq(i, 52);
+ if ((i >= 0) && (i < (int)sizeof(buf))) {
+ buf[i] = 0;
+ }
+ ck_assert_int_eq(ri->content_length, 52);
+ ck_assert_str_eq(buf, encoded_file_content);
+#endif
+ mg_close_connection(client_conn);
+
+/* Get CGI generated data */
+#if !defined(NO_CGI)
+ client_conn = mg_download("localhost",
+ ipv4_port,
+ 0,
+ ebuf,
+ sizeof(ebuf),
+ "%s",
+ "GET /test.cgi HTTP/1.0\r\n\r\n");
+ ck_assert(client_conn != NULL);
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+
+#if defined(NO_FILES)
+ ck_assert_str_eq(ri->local_uri, "404");
+
+ (void)expected_cgi_result;
+ (void)cgi_script_content;
+#else
+ i = mg_read(client_conn, buf, sizeof(buf));
+ if ((i >= 0) && (i < (int)sizeof(buf))) {
+ while ((i > 0) && ((buf[i - 1] == '\r') || (buf[i - 1] == '\n'))) {
+ i--;
+ }
+ buf[i] = 0;
+ }
+ /* ck_assert_int_eq(i, (int)strlen(expected_cgi_result)); */
+ ck_assert_str_eq(buf, expected_cgi_result);
+ ck_assert_str_eq(ri->local_uri, "200");
+ mg_close_connection(client_conn);
+#endif
+
+#else
+ (void)expected_cgi_result;
+ (void)cgi_script_content;
+#endif
+
+ /* Get directory listing */
+ client_conn = mg_download("localhost",
+ ipv4_port,
+ 0,
+ ebuf,
+ sizeof(ebuf),
+ "%s",
+ "GET / HTTP/1.0\r\n\r\n");
+ ck_assert(client_conn != NULL);
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+#if defined(NO_FILES)
+ ck_assert_str_eq(ri->local_uri, "404");
+#else
+ ck_assert_str_eq(ri->local_uri, "200");
+ i = mg_read(client_conn, buf, sizeof(buf));
+ ck_assert(i > 6);
+ buf[6] = 0;
+ ck_assert_str_eq(buf, "<html>");
+#endif
+ mg_close_connection(client_conn);
+
+ /* POST to static file (will not work) */
+ client_conn = mg_download("localhost",
+ ipv4_port,
+ 0,
+ ebuf,
+ sizeof(ebuf),
+ "%s",
+ "POST /test.txt HTTP/1.0\r\n\r\n");
+ ck_assert(client_conn != NULL);
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+#if defined(NO_FILES)
+ ck_assert_str_eq(ri->local_uri, "404");
+#else
+ ck_assert_str_eq(ri->local_uri, "405");
+ i = mg_read(client_conn, buf, sizeof(buf));
+ ck_assert(i >= 29);
+ buf[29] = 0;
+ ck_assert_str_eq(buf, "Error 405: Method Not Allowed");
+#endif
+ mg_close_connection(client_conn);
+
+ /* PUT to static file (will not work) */
+ client_conn = mg_download("localhost",
+ ipv4_port,
+ 0,
+ ebuf,
+ sizeof(ebuf),
+ "%s",
+ "PUT /test.txt HTTP/1.0\r\n\r\n");
+ ck_assert(client_conn != NULL);
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+#if defined(NO_FILES)
+ ck_assert_str_eq(ri->local_uri, "405"); /* method not allowed */
+#else
+ ck_assert_str_eq(ri->local_uri, "401"); /* not authorized */
+#endif
+ mg_close_connection(client_conn);
+
+
+ /* Get data from callback using mg_connect_client instead of mg_download */
+ memset(ebuf, 0, sizeof(ebuf));
+ client_conn =
+ mg_connect_client("127.0.0.1", ipv4_port, 0, ebuf, sizeof(ebuf));
+
+ ck_assert_str_eq(ebuf, "");
+ ck_assert(client_conn != NULL);
+
+ mg_printf(client_conn, "%s", request);
+
+ i = mg_get_response(client_conn, ebuf, sizeof(ebuf), 10000);
+ ck_assert_int_ge(i, 0);
+ ck_assert_str_eq(ebuf, "");
+
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+ ck_assert_str_eq(ri->local_uri, "200");
+ i = mg_read(client_conn, buf, sizeof(buf));
+ ck_assert_int_eq(i, (int)strlen(expected));
+ buf[i] = 0;
+ ck_assert_str_eq(buf, expected);
+ mg_close_connection(client_conn);
+
+ /* Get data from callback using mg_connect_client and absolute URI */
+ memset(ebuf, 0, sizeof(ebuf));
+ client_conn =
+ mg_connect_client("localhost", ipv4_port, 0, ebuf, sizeof(ebuf));
+
+ ck_assert_str_eq(ebuf, "");
+ ck_assert(client_conn != NULL);
+
+ mg_printf(client_conn,
+ "GET http://test.domain:%d/U7 HTTP/1.0\r\n\r\n",
+ ipv4_port);
+
+ i = mg_get_response(client_conn, ebuf, sizeof(ebuf), 10000);
+ ck_assert_int_ge(i, 0);
+ ck_assert_str_eq(ebuf, "");
+
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+ ck_assert_str_eq(ri->local_uri, "200");
+ i = mg_read(client_conn, buf, sizeof(buf));
+ ck_assert_int_eq(i, (int)strlen(expected));
+ buf[i] = 0;
+ ck_assert_str_eq(buf, expected);
+ mg_close_connection(client_conn);
+
+ /* Get data from callback using mg_connect_client and absolute URI with a
+ * sub-domain */
+ memset(ebuf, 0, sizeof(ebuf));
+ client_conn =
+ mg_connect_client("localhost", ipv4_port, 0, ebuf, sizeof(ebuf));
+
+ ck_assert_str_eq(ebuf, "");
+ ck_assert(client_conn != NULL);
+
+ mg_printf(client_conn,
+ "GET http://subdomain.test.domain:%d/U7 HTTP/1.0\r\n\r\n",
+ ipv4_port);
+
+ i = mg_get_response(client_conn, ebuf, sizeof(ebuf), 10000);
+ ck_assert_int_ge(i, 0);
+ ck_assert_str_eq(ebuf, "");
+
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+ ck_assert_str_eq(ri->local_uri, "200");
+ i = mg_read(client_conn, buf, sizeof(buf));
+ ck_assert_int_eq(i, (int)strlen(expected));
+ buf[i] = 0;
+ ck_assert_str_eq(buf, expected);
+ mg_close_connection(client_conn);
+
+
+/* Websocket test */
+#ifdef USE_WEBSOCKET
+ /* Then connect a first client */
+ ws_client1_conn =
+ mg_connect_websocket_client("localhost",
+ ipv4_port,
+ 0,
+ ebuf,
+ sizeof(ebuf),
+ "/websocket",
+ NULL,
+ websocket_client_data_handler,
+ websocket_client_close_handler,
+ &ws_client1_data);
+
+ ck_assert(ws_client1_conn != NULL);
+
+ wait_not_null(
+ &(ws_client1_data.data)); /* Wait for the websocket welcome message */
+ ck_assert_int_eq(ws_client1_data.closed, 0);
+ ck_assert_int_eq(ws_client2_data.closed, 0);
+ ck_assert_int_eq(ws_client3_data.closed, 0);
+ ck_assert(ws_client2_data.data == NULL);
+ ck_assert_uint_eq(ws_client2_data.len, 0);
+ ck_assert(ws_client1_data.data != NULL);
+ ck_assert_uint_eq(ws_client1_data.len, websocket_welcome_msg_len);
+ ck_assert(!memcmp(ws_client1_data.data,
+ websocket_welcome_msg,
+ websocket_welcome_msg_len));
+ free(ws_client1_data.data);
+ ws_client1_data.data = NULL;
+ ws_client1_data.len = 0;
+
+ mg_websocket_client_write(ws_client1_conn,
+ WEBSOCKET_OPCODE_TEXT,
+ "data1",
+ 5);
+
+ wait_not_null(
+ &(ws_client1_data
+ .data)); /* Wait for the websocket acknowledge message */
+ ck_assert_int_eq(ws_client1_data.closed, 0);
+ ck_assert_int_eq(ws_client2_data.closed, 0);
+ ck_assert(ws_client2_data.data == NULL);
+ ck_assert_uint_eq(ws_client2_data.len, 0);
+ ck_assert(ws_client1_data.data != NULL);
+ ck_assert_uint_eq(ws_client1_data.len, 3);
+ ck_assert(!memcmp(ws_client1_data.data, "ok1", 3));
+ free(ws_client1_data.data);
+ ws_client1_data.data = NULL;
+ ws_client1_data.len = 0;
+
+/* Now connect a second client */
+#ifdef USE_IPV6
+ ws_client2_conn =
+ mg_connect_websocket_client("[::1]",
+ ipv6_port,
+ 0,
+ ebuf,
+ sizeof(ebuf),
+ "/websocket",
+ NULL,
+ websocket_client_data_handler,
+ websocket_client_close_handler,
+ &ws_client2_data);
+#else
+ ws_client2_conn =
+ mg_connect_websocket_client("127.0.0.1",
+ ipv4_port,
+ 0,
+ ebuf,
+ sizeof(ebuf),
+ "/websocket",
+ NULL,
+ websocket_client_data_handler,
+ websocket_client_close_handler,
+ &ws_client2_data);
+#endif
+ ck_assert(ws_client2_conn != NULL);
+
+ wait_not_null(
+ &(ws_client2_data.data)); /* Wait for the websocket welcome message */
+ ck_assert(ws_client1_data.closed == 0);
+ ck_assert(ws_client2_data.closed == 0);
+ ck_assert(ws_client1_data.data == NULL);
+ ck_assert(ws_client1_data.len == 0);
+ ck_assert(ws_client2_data.data != NULL);
+ ck_assert(ws_client2_data.len == websocket_welcome_msg_len);
+ ck_assert(!memcmp(ws_client2_data.data,
+ websocket_welcome_msg,
+ websocket_welcome_msg_len));
+ free(ws_client2_data.data);
+ ws_client2_data.data = NULL;
+ ws_client2_data.len = 0;
+
+ mg_websocket_client_write(ws_client1_conn,
+ WEBSOCKET_OPCODE_TEXT,
+ "data2",
+ 5);
+
+ wait_not_null(
+ &(ws_client1_data
+ .data)); /* Wait for the websocket acknowledge message */
+
+ ck_assert(ws_client1_data.closed == 0);
+ ck_assert(ws_client2_data.closed == 0);
+ ck_assert(ws_client2_data.data == NULL);
+ ck_assert(ws_client2_data.len == 0);
+ ck_assert(ws_client1_data.data != NULL);
+ ck_assert(ws_client1_data.len == 4);
+ ck_assert(!memcmp(ws_client1_data.data, "ok 2", 4));
+ free(ws_client1_data.data);
+ ws_client1_data.data = NULL;
+ ws_client1_data.len = 0;
+
+ mg_websocket_client_write(ws_client1_conn, WEBSOCKET_OPCODE_TEXT, "bye", 3);
+
+ wait_not_null(
+ &(ws_client1_data.data)); /* Wait for the websocket goodbye message */
+
+ ck_assert(ws_client1_data.closed == 0);
+ ck_assert(ws_client2_data.closed == 0);
+ ck_assert(ws_client2_data.data == NULL);
+ ck_assert(ws_client2_data.len == 0);
+ ck_assert(ws_client1_data.data != NULL);
+ ck_assert(ws_client1_data.len == websocket_goodbye_msg_len);
+ ck_assert(!memcmp(ws_client1_data.data,
+ websocket_goodbye_msg,
+ websocket_goodbye_msg_len));
+ free(ws_client1_data.data);
+ ws_client1_data.data = NULL;
+ ws_client1_data.len = 0;
+
+ ck_assert(ws_client1_data.closed == 0); /* Not closed */
+
+ mg_close_connection(ws_client1_conn);
+
+ test_sleep(3); /* Won't get any message */
+
+ ck_assert(ws_client1_data.closed == 1); /* Closed */
+
+ ck_assert(ws_client2_data.closed == 0);
+ ck_assert(ws_client1_data.data == NULL);
+ ck_assert(ws_client1_data.len == 0);
+ ck_assert(ws_client2_data.data == NULL);
+ ck_assert(ws_client2_data.len == 0);
+
+ mg_websocket_client_write(ws_client2_conn, WEBSOCKET_OPCODE_TEXT, "bye", 3);
+
+ wait_not_null(
+ &(ws_client2_data.data)); /* Wait for the websocket goodbye message */
+
+ ck_assert(ws_client1_data.closed == 1);
+ ck_assert(ws_client2_data.closed == 0);
+ ck_assert(ws_client1_data.data == NULL);
+ ck_assert(ws_client1_data.len == 0);
+ ck_assert(ws_client2_data.data != NULL);
+ ck_assert(ws_client2_data.len == websocket_goodbye_msg_len);
+ ck_assert(!memcmp(ws_client2_data.data,
+ websocket_goodbye_msg,
+ websocket_goodbye_msg_len));
+ free(ws_client2_data.data);
+ ws_client2_data.data = NULL;
+ ws_client2_data.len = 0;
+
+ mg_close_connection(ws_client2_conn);
+
+ test_sleep(3); /* Won't get any message */
+
+ ck_assert(ws_client1_data.closed == 1);
+ ck_assert(ws_client2_data.closed == 1);
+ ck_assert(ws_client1_data.data == NULL);
+ ck_assert(ws_client1_data.len == 0);
+ ck_assert(ws_client2_data.data == NULL);
+ ck_assert(ws_client2_data.len == 0);
+
+ /* Connect client 3 */
+ ws_client3_conn =
+ mg_connect_websocket_client("localhost",
+#if defined(NO_SSL)
+ ipv4_port,
+ 0,
+#else
+ ipv4s_port,
+ 1,
+#endif
+ ebuf,
+ sizeof(ebuf),
+ "/websocket",
+ NULL,
+ websocket_client_data_handler,
+ websocket_client_close_handler,
+ &ws_client3_data);
+
+ ck_assert(ws_client3_conn != NULL);
+
+ wait_not_null(
+ &(ws_client3_data.data)); /* Wait for the websocket welcome message */
+ ck_assert(ws_client1_data.closed == 1);
+ ck_assert(ws_client2_data.closed == 1);
+ ck_assert(ws_client3_data.closed == 0);
+ ck_assert(ws_client1_data.data == NULL);
+ ck_assert(ws_client1_data.len == 0);
+ ck_assert(ws_client2_data.data == NULL);
+ ck_assert(ws_client2_data.len == 0);
+ ck_assert(ws_client3_data.data != NULL);
+ ck_assert(ws_client3_data.len == websocket_welcome_msg_len);
+ ck_assert(!memcmp(ws_client3_data.data,
+ websocket_welcome_msg,
+ websocket_welcome_msg_len));
+ free(ws_client3_data.data);
+ ws_client3_data.data = NULL;
+ ws_client3_data.len = 0;
+
+ /* Write long data (16 bit size header) */
+ mg_websocket_client_write(ws_client3_conn,
+ WEBSOCKET_OPCODE_BINARY,
+ long_ws_buf,
+ long_ws_buf_len_16);
+
+ /* Wait for the response */
+ wait_not_null(&(ws_client3_data.data));
+
+ ck_assert_int_eq((int)ws_client3_data.len, (int)long_ws_buf_len_16);
+ ck_assert(!memcmp(ws_client3_data.data, long_ws_buf, long_ws_buf_len_16));
+ free(ws_client3_data.data);
+ ws_client3_data.data = NULL;
+ ws_client3_data.len = 0;
+
+ /* Write long data (64 bit size header) */
+ mg_websocket_client_write(ws_client3_conn,
+ WEBSOCKET_OPCODE_BINARY,
+ long_ws_buf,
+ long_ws_buf_len_64);
+
+ /* Wait for the response */
+ wait_not_null(&(ws_client3_data.data));
+
+ ck_assert_int_eq((int)ws_client3_data.len, (int)long_ws_buf_len_64);
+ ck_assert(!memcmp(ws_client3_data.data, long_ws_buf, long_ws_buf_len_64));
+ free(ws_client3_data.data);
+ ws_client3_data.data = NULL;
+ ws_client3_data.len = 0;
+
+ /* Disconnect client 3 */
+ ck_assert(ws_client3_data.closed == 0);
+ mg_close_connection(ws_client3_conn);
+ ck_assert(ws_client3_data.closed == 1);
+
+ /* Connect client 4 */
+ ws_client4_conn =
+ mg_connect_websocket_client("localhost",
+#if defined(NO_SSL)
+ ipv4_port,
+ 0,
+#else
+ ipv4s_port,
+ 1,
+#endif
+ ebuf,
+ sizeof(ebuf),
+ "/websocket",
+ NULL,
+ websocket_client_data_handler,
+ websocket_client_close_handler,
+ &ws_client4_data);
+
+ ck_assert(ws_client4_conn != NULL);
+
+ wait_not_null(
+ &(ws_client4_data.data)); /* Wait for the websocket welcome message */
+ ck_assert(ws_client1_data.closed == 1);
+ ck_assert(ws_client2_data.closed == 1);
+ ck_assert(ws_client3_data.closed == 1);
+ ck_assert(ws_client4_data.closed == 0);
+ ck_assert(ws_client4_data.data != NULL);
+ ck_assert(ws_client4_data.len == websocket_welcome_msg_len);
+ ck_assert(!memcmp(ws_client4_data.data,
+ websocket_welcome_msg,
+ websocket_welcome_msg_len));
+ free(ws_client4_data.data);
+ ws_client4_data.data = NULL;
+ ws_client4_data.len = 0;
+
+/* stop the server without closing this connection */
+
+#endif
+
+ /* Close the server */
+ g_ctx = NULL;
+ test_mg_stop(ctx);
+ mark_point();
+
+#ifdef USE_WEBSOCKET
+ for (i = 0; i < 100; i++) {
+ test_sleep(1);
+ if (ws_client3_data.closed != 0) {
+ mark_point();
+ break;
+ }
+ }
+
+ ck_assert_int_eq(ws_client4_data.closed, 1);
+
+ /* Free data in ws_client4_conn */
+ mg_close_connection(ws_client4_conn);
+
+#endif
+ mark_point();
+}
+END_TEST
+
+
+static int g_field_found_return = -999;
+
+static int
+field_found(const char *key,
+ const char *filename,
+ char *path,
+ size_t pathlen,
+ void *user_data)
+{
+ ck_assert_ptr_ne(key, NULL);
+ ck_assert_ptr_ne(filename, NULL);
+ ck_assert_ptr_ne(path, NULL);
+ ck_assert_uint_gt(pathlen, 128);
+ ck_assert_ptr_eq(user_data, (void *)&g_field_found_return);
+
+ ck_assert((g_field_found_return == FORM_FIELD_STORAGE_GET)
+ || (g_field_found_return == FORM_FIELD_STORAGE_STORE)
+ || (g_field_found_return == FORM_FIELD_STORAGE_SKIP)
+ || (g_field_found_return == FORM_FIELD_STORAGE_ABORT));
+
+ ck_assert_str_ne(key, "dontread");
+
+ if (!strcmp(key, "break_field_handler")) {
+ return FORM_FIELD_STORAGE_ABORT;
+ }
+ if (!strcmp(key, "continue_field_handler")) {
+ return FORM_FIELD_STORAGE_SKIP;
+ }
+
+ if (g_field_found_return == FORM_FIELD_STORAGE_STORE) {
+ strncpy(path, key, pathlen - 8);
+ strcat(path, ".txt");
+ }
+
+ mark_point();
+
+ return g_field_found_return;
+}
+
+
+static int g_field_step;
+
+static int
+field_get(const char *key,
+ const char *value_untruncated,
+ size_t valuelen,
+ void *user_data)
+{
+ /* Copy the untruncated value, so string compare functions can be used. */
+ /* The check unit test library does not have build in memcmp functions. */
+ char *value = (char *)malloc(valuelen + 1);
+ ck_assert(value != NULL);
+ memcpy(value, value_untruncated, valuelen);
+ value[valuelen] = 0;
+
+ ck_assert_ptr_eq(user_data, (void *)&g_field_found_return);
+ ck_assert_int_ge(g_field_step, 0);
+
+ ++g_field_step;
+ switch (g_field_step) {
+ case 1:
+ ck_assert_str_eq(key, "textin");
+ ck_assert_uint_eq(valuelen, 4);
+ ck_assert_str_eq(value, "text");
+ break;
+ case 2:
+ ck_assert_str_eq(key, "passwordin");
+ ck_assert_uint_eq(valuelen, 0);
+ ck_assert_str_eq(value, "");
+ break;
+ case 3:
+ ck_assert_str_eq(key, "radio1");
+ ck_assert_uint_eq(valuelen, 4);
+ ck_assert_str_eq(value, "val1");
+ break;
+ case 4:
+ ck_assert_str_eq(key, "radio2");
+ ck_assert_uint_eq(valuelen, 4);
+ ck_assert_str_eq(value, "val1");
+ break;
+ case 5:
+ ck_assert_str_eq(key, "check1");
+ ck_assert_uint_eq(valuelen, 4);
+ ck_assert_str_eq(value, "val1");
+ break;
+ case 6:
+ ck_assert_str_eq(key, "numberin");
+ ck_assert_uint_eq(valuelen, 1);
+ ck_assert_str_eq(value, "1");
+ break;
+ case 7:
+ ck_assert_str_eq(key, "datein");
+ ck_assert_uint_eq(valuelen, 8);
+ ck_assert_str_eq(value, "1.1.2016");
+ break;
+ case 8:
+ ck_assert_str_eq(key, "colorin");
+ ck_assert_uint_eq(valuelen, 7);
+ ck_assert_str_eq(value, "#80ff00");
+ break;
+ case 9:
+ ck_assert_str_eq(key, "rangein");
+ ck_assert_uint_eq(valuelen, 1);
+ ck_assert_str_eq(value, "3");
+ break;
+ case 10:
+ ck_assert_str_eq(key, "monthin");
+ ck_assert_uint_eq(valuelen, 0);
+ ck_assert_str_eq(value, "");
+ break;
+ case 11:
+ ck_assert_str_eq(key, "weekin");
+ ck_assert_uint_eq(valuelen, 0);
+ ck_assert_str_eq(value, "");
+ break;
+ case 12:
+ ck_assert_str_eq(key, "timein");
+ ck_assert_uint_eq(valuelen, 0);
+ ck_assert_str_eq(value, "");
+ break;
+ case 13:
+ ck_assert_str_eq(key, "datetimen");
+ ck_assert_uint_eq(valuelen, 0);
+ ck_assert_str_eq(value, "");
+ break;
+ case 14:
+ ck_assert_str_eq(key, "datetimelocalin");
+ ck_assert_uint_eq(valuelen, 0);
+ ck_assert_str_eq(value, "");
+ break;
+ case 15:
+ ck_assert_str_eq(key, "emailin");
+ ck_assert_uint_eq(valuelen, 0);
+ ck_assert_str_eq(value, "");
+ break;
+ case 16:
+ ck_assert_str_eq(key, "searchin");
+ ck_assert_uint_eq(valuelen, 0);
+ ck_assert_str_eq(value, "");
+ break;
+ case 17:
+ ck_assert_str_eq(key, "telin");
+ ck_assert_uint_eq(valuelen, 0);
+ ck_assert_str_eq(value, "");
+ break;
+ case 18:
+ ck_assert_str_eq(key, "urlin");
+ ck_assert_uint_eq(valuelen, 0);
+ ck_assert_str_eq(value, "");
+ break;
+ case 19:
+ ck_assert_str_eq(key, "filein");
+ ck_assert_uint_eq(valuelen, 0);
+ ck_assert_str_eq(value, "");
+ break;
+ case 20:
+ ck_assert_str_eq(key, "filesin");
+ ck_assert_uint_eq(valuelen, 0);
+ ck_assert_str_eq(value, "");
+ break;
+ case 21:
+ ck_assert_str_eq(key, "selectin");
+ ck_assert_uint_eq(valuelen, 4);
+ ck_assert_str_eq(value, "opt1");
+ break;
+ case 22:
+ ck_assert_str_eq(key, "message");
+ ck_assert_uint_eq(valuelen, 23);
+ ck_assert_str_eq(value, "Text area default text.");
+ break;
+ default:
+ ck_abort_msg("field_get called with g_field_step == %i",
+ (int)g_field_step);
+ }
+
+ free(value);
+ mark_point();
+
+ return 0;
+}
+
+
+static const char *myfile_content = "Content of myfile.txt\r\n";
+static const int myfile_content_rep = 500;
+
+
+static int
+field_store(const char *path, long long file_size, void *user_data)
+{
+ FILE *f;
+ ck_assert_ptr_eq(user_data, (void *)&g_field_found_return);
+ ck_assert_int_ge(g_field_step, 100);
+
+ ++g_field_step;
+ switch (g_field_step) {
+ case 101:
+ ck_assert_str_eq(path, "storeme.txt");
+ ck_assert_int_eq(file_size, 9);
+ f = fopen(path, "r");
+ ck_assert_ptr_ne(f, NULL);
+ if (f) {
+ char buf[32] = {0};
+ int i = (int)fread(buf, 1, 31, f);
+ ck_assert_int_eq(i, 9);
+ fclose(f);
+ ck_assert_str_eq(buf, "storetest");
+ }
+ break;
+ case 102:
+ ck_assert_str_eq(path, "file2store.txt");
+ ck_assert_uint_eq(23, strlen(myfile_content));
+ ck_assert_int_eq(file_size, 23 * myfile_content_rep);
+#ifdef _WIN32
+ f = fopen(path, "rb");
+#else
+ f = fopen(path, "r");
+#endif
+ ck_assert_ptr_ne(f, NULL);
+ if (f) {
+ char buf[32] = {0};
+ int r, i;
+ for (r = 0; r < myfile_content_rep; r++) {
+ i = (int)fread(buf, 1, 23, f);
+ ck_assert_int_eq(i, 23);
+ ck_assert_str_eq(buf, myfile_content);
+ }
+ i = (int)fread(buf, 1, 23, f);
+ ck_assert_int_eq(i, 0);
+ fclose(f);
+ }
+ break;
+ default:
+ ck_abort_msg("field_get called with g_field_step == %i",
+ (int)g_field_step);
+ }
+ mark_point();
+
+ return 0;
+}
+
+
+static int
+FormGet(struct mg_connection *conn, void *cbdata)
+{
+ const struct mg_request_info *req_info = mg_get_request_info(conn);
+ int ret;
+ struct mg_form_data_handler fdh = {field_found, field_get, NULL, NULL};
+
+ (void)cbdata;
+
+ ck_assert(req_info != NULL);
+
+ mg_printf(conn, "HTTP/1.0 200 OK\r\nContent-Type: text/plain\r\n\r\n");
+ fdh.user_data = (void *)&g_field_found_return;
+
+ /* Call the form handler */
+ g_field_step = 0;
+ g_field_found_return = FORM_FIELD_STORAGE_GET;
+ ret = mg_handle_form_request(conn, &fdh);
+ g_field_found_return = -888;
+ ck_assert_int_eq(ret, 22);
+ ck_assert_int_eq(g_field_step, 22);
+ mg_printf(conn, "%i\r\n", ret);
+ g_field_step = 1000;
+
+ mark_point();
+
+ return 1;
+}
+
+
+static int
+FormStore(struct mg_connection *conn,
+ void *cbdata,
+ int ret_expected,
+ int field_step_expected)
+{
+ const struct mg_request_info *req_info = mg_get_request_info(conn);
+ int ret;
+ struct mg_form_data_handler fdh = {field_found,
+ field_get,
+ field_store,
+ NULL};
+
+ (void)cbdata;
+
+ ck_assert(req_info != NULL);
+
+ mg_printf(conn, "HTTP/1.0 200 OK\r\nContent-Type: text/plain\r\n\r\n");
+ fdh.user_data = (void *)&g_field_found_return;
+
+ /* Call the form handler */
+ g_field_step = 100;
+ g_field_found_return = FORM_FIELD_STORAGE_STORE;
+ ret = mg_handle_form_request(conn, &fdh);
+ ck_assert_int_eq(ret, ret_expected);
+ ck_assert_int_eq(g_field_step, field_step_expected);
+ mg_printf(conn, "%i\r\n", ret);
+ g_field_step = 1000;
+
+ mark_point();
+
+ return 1;
+}
+
+
+static int
+FormStore1(struct mg_connection *conn, void *cbdata)
+{
+ mark_point();
+ return FormStore(conn, cbdata, 3, 101);
+}
+
+
+static int
+FormStore2(struct mg_connection *conn, void *cbdata)
+{
+ mark_point();
+ return FormStore(conn, cbdata, 4, 102);
+}
+
+
+static void
+send_chunk_stringl(struct mg_connection *conn,
+ const char *chunk,
+ unsigned int chunk_len)
+{
+ char lenbuf[16];
+ size_t lenbuf_len;
+ int ret;
+
+ mark_point();
+
+ /* First store the length information in a text buffer. */
+ sprintf(lenbuf, "%x\r\n", chunk_len);
+ lenbuf_len = strlen(lenbuf);
+
+ /* Then send length information, chunk and terminating \r\n. */
+ ret = mg_write(conn, lenbuf, lenbuf_len);
+ ck_assert_int_eq(ret, (int)lenbuf_len);
+
+ ret = mg_write(conn, chunk, chunk_len);
+ ck_assert_int_eq(ret, (int)chunk_len);
+
+ ret = mg_write(conn, "\r\n", 2);
+ ck_assert_int_eq(ret, 2);
+}
+
+
+static void
+send_chunk_string(struct mg_connection *conn, const char *chunk)
+{
+ mark_point();
+ send_chunk_stringl(conn, chunk, (unsigned int)strlen(chunk));
+ mark_point();
+}
+
+
+START_TEST(test_handle_form)
+{
+ struct mg_context *ctx;
+ struct mg_connection *client_conn;
+ const struct mg_request_info *ri;
+ const char *OPTIONS[8];
+ const char *opt;
+ int opt_idx = 0;
+ char ebuf[100];
+ const char *multipart_body;
+ const char *boundary;
+ size_t body_len, body_sent, chunk_len;
+ int sleep_cnt;
+
+ mark_point();
+
+ memset((void *)OPTIONS, 0, sizeof(OPTIONS));
+ OPTIONS[opt_idx++] = "listening_ports";
+ OPTIONS[opt_idx++] = "8884";
+ ck_assert_int_le(opt_idx, (int)(sizeof(OPTIONS) / sizeof(OPTIONS[0])));
+ ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 1] == NULL);
+ ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 2] == NULL);
+
+ ctx = test_mg_start(NULL, &g_ctx, OPTIONS);
+
+ ck_assert(ctx != NULL);
+ g_ctx = ctx;
+
+ opt = mg_get_option(ctx, "listening_ports");
+ ck_assert_str_eq(opt, "8884");
+
+ mg_set_request_handler(ctx, "/handle_form", FormGet, NULL);
+ mg_set_request_handler(ctx, "/handle_form_store", FormStore1, NULL);
+ mg_set_request_handler(ctx, "/handle_form_store2", FormStore2, NULL);
+
+ test_sleep(1);
+
+ /* Handle form: "GET" */
+ client_conn = mg_download("localhost",
+ 8884,
+ 0,
+ ebuf,
+ sizeof(ebuf),
+ "%s",
+ "GET /handle_form"
+ "?textin=text&passwordin=&radio1=val1"
+ "&radio2=val1&check1=val1&numberin=1"
+ "&datein=1.1.2016&colorin=%2380ff00"
+ "&rangein=3&monthin=&weekin=&timein="
+ "&datetimen=&datetimelocalin=&emailin="
+ "&searchin=&telin=&urlin=&filein="
+ "&filesin=&selectin=opt1"
+ "&message=Text+area+default+text. "
+ "HTTP/1.0\r\n"
+ "Host: localhost:8884\r\n"
+ "Connection: close\r\n\r\n");
+ ck_assert(client_conn != NULL);
+ for (sleep_cnt = 0; sleep_cnt < 30; sleep_cnt++) {
+ test_sleep(1);
+ if (g_field_step == 1000) {
+ break;
+ }
+ }
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+ ck_assert_str_eq(ri->local_uri, "200");
+ mg_close_connection(client_conn);
+
+ /* Handle form: "POST x-www-form-urlencoded" */
+ client_conn =
+ mg_download("localhost",
+ 8884,
+ 0,
+ ebuf,
+ sizeof(ebuf),
+ "%s",
+ "POST /handle_form HTTP/1.1\r\n"
+ "Host: localhost:8884\r\n"
+ "Connection: close\r\n"
+ "Content-Type: application/x-www-form-urlencoded\r\n"
+ "Content-Length: 263\r\n"
+ "\r\n"
+ "textin=text&passwordin=&radio1=val1&radio2=val1"
+ "&check1=val1&numberin=1&datein=1.1.2016"
+ "&colorin=%2380ff00&rangein=3&monthin=&weekin="
+ "&timein=&datetimen=&datetimelocalin=&emailin="
+ "&searchin=&telin=&urlin=&filein=&filesin="
+ "&selectin=opt1&message=Text+area+default+text.");
+ ck_assert(client_conn != NULL);
+ for (sleep_cnt = 0; sleep_cnt < 30; sleep_cnt++) {
+ test_sleep(1);
+ if (g_field_step == 1000) {
+ break;
+ }
+ }
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+ ck_assert_str_eq(ri->local_uri, "200");
+ mg_close_connection(client_conn);
+
+ /* Handle form: "POST multipart/form-data" */
+ multipart_body =
+ "--multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Disposition: form-data; name=\"textin\"\r\n"
+ "\r\n"
+ "text\r\n"
+ "--multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Disposition: form-data; name=\"passwordin\"\r\n"
+ "\r\n"
+ "\r\n"
+ "--multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Disposition: form-data; name=\"radio1\"\r\n"
+ "\r\n"
+ "val1\r\n"
+ "--multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Disposition: form-data; name=radio2\r\n"
+ "\r\n"
+ "val1\r\n"
+ "--multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Disposition: form-data; name=\"check1\"\r\n"
+ "\r\n"
+ "val1\r\n"
+ "--multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Disposition: form-data; name=\"numberin\"\r\n"
+ "\r\n"
+ "1\r\n"
+ "--multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Disposition: form-data; name=\"datein\"\r\n"
+ "\r\n"
+ "1.1.2016\r\n"
+ "--multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Disposition: form-data; name=\"colorin\"\r\n"
+ "\r\n"
+ "#80ff00\r\n"
+ "--multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Disposition: form-data; name=\"rangein\"\r\n"
+ "\r\n"
+ "3\r\n"
+ "--multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Disposition: form-data; name=\"monthin\"\r\n"
+ "\r\n"
+ "\r\n"
+ "--multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Disposition: form-data; name=\"weekin\"\r\n"
+ "\r\n"
+ "\r\n"
+ "--multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Disposition: form-data; name=\"timein\"\r\n"
+ "\r\n"
+ "\r\n"
+ "--multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Disposition: form-data; name=\"datetimen\"\r\n"
+ "\r\n"
+ "\r\n"
+ "--multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Disposition: form-data; name=\"datetimelocalin\"\r\n"
+ "\r\n"
+ "\r\n"
+ "--multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Disposition: form-data; name=\"emailin\"\r\n"
+ "\r\n"
+ "\r\n"
+ "--multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Disposition: form-data; name=\"searchin\"\r\n"
+ "\r\n"
+ "\r\n"
+ "--multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Disposition: form-data; name=\"telin\"\r\n"
+ "\r\n"
+ "\r\n"
+ "--multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Disposition: form-data; name=\"urlin\"\r\n"
+ "\r\n"
+ "\r\n"
+ "--multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Disposition: form-data; name=\"filein\"; filename=\"\"\r\n"
+ "Content-Type: application/octet-stream\r\n"
+ "\r\n"
+ "\r\n"
+ "--multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Disposition: form-data; name=filesin; filename=\r\n"
+ "Content-Type: application/octet-stream\r\n"
+ "\r\n"
+ "\r\n"
+ "--multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Disposition: form-data; name=\"selectin\"\r\n"
+ "\r\n"
+ "opt1\r\n"
+ "--multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Disposition: form-data; name=\"message\"\r\n"
+ "\r\n"
+ "Text area default text.\r\n"
+ "--multipart-form-data-boundary--see-RFC-2388--\r\n";
+ body_len = strlen(multipart_body);
+ ck_assert_uint_eq(body_len, 2368); /* not required */
+
+ client_conn =
+ mg_download("localhost",
+ 8884,
+ 0,
+ ebuf,
+ sizeof(ebuf),
+ "POST /handle_form HTTP/1.1\r\n"
+ "Host: localhost:8884\r\n"
+ "Connection: close\r\n"
+ "Content-Type: multipart/form-data; "
+ "boundary=multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Content-Length: %u\r\n"
+ "\r\n%s",
+ (unsigned int)body_len,
+ multipart_body);
+
+ ck_assert(client_conn != NULL);
+ for (sleep_cnt = 0; sleep_cnt < 30; sleep_cnt++) {
+ test_sleep(1);
+ if (g_field_step == 1000) {
+ break;
+ }
+ }
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+ ck_assert_str_eq(ri->local_uri, "200");
+ mg_close_connection(client_conn);
+
+
+ /* Handle form: "POST multipart/form-data" with chunked transfer encoding */
+ client_conn =
+ mg_download("localhost",
+ 8884,
+ 0,
+ ebuf,
+ sizeof(ebuf),
+ "%s",
+ "POST /handle_form HTTP/1.1\r\n"
+ "Host: localhost:8884\r\n"
+ "Connection: close\r\n"
+ "Content-Type: multipart/form-data; "
+ "boundary=multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Transfer-Encoding: chunked\r\n"
+ "\r\n");
+
+ ck_assert(client_conn != NULL);
+
+ body_len = strlen(multipart_body);
+ chunk_len = 1;
+ body_sent = 0;
+ while (body_len > body_sent) {
+ if (chunk_len > (body_len - body_sent)) {
+ chunk_len = body_len - body_sent;
+ }
+ ck_assert_int_gt((int)chunk_len, 0);
+ mg_printf(client_conn, "%x\r\n", (unsigned int)chunk_len);
+ mg_write(client_conn, multipart_body + body_sent, chunk_len);
+ mg_printf(client_conn, "\r\n");
+ body_sent += chunk_len;
+ chunk_len = (chunk_len % 40) + 1;
+ }
+ mg_printf(client_conn, "0\r\n");
+
+ for (sleep_cnt = 0; sleep_cnt < 30; sleep_cnt++) {
+ test_sleep(1);
+ if (g_field_step == 1000) {
+ break;
+ }
+ }
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+ ck_assert_str_eq(ri->local_uri, "200");
+ mg_close_connection(client_conn);
+
+ /* Handle form: "POST multipart/form-data" with chunked transfer
+ * encoding, using a quoted boundary string */
+ client_conn = mg_download(
+ "localhost",
+ 8884,
+ 0,
+ ebuf,
+ sizeof(ebuf),
+ "%s",
+ "POST /handle_form HTTP/1.1\r\n"
+ "Host: localhost:8884\r\n"
+ "Connection: close\r\n"
+ "Content-Type: multipart/form-data; "
+ "boundary=\"multipart-form-data-boundary--see-RFC-2388\"\r\n"
+ "Transfer-Encoding: chunked\r\n"
+ "\r\n");
+
+ ck_assert(client_conn != NULL);
+
+ body_len = strlen(multipart_body);
+ chunk_len = 1;
+ body_sent = 0;
+ while (body_len > body_sent) {
+ if (chunk_len > (body_len - body_sent)) {
+ chunk_len = body_len - body_sent;
+ }
+ ck_assert_int_gt((int)chunk_len, 0);
+ mg_printf(client_conn, "%x\r\n", (unsigned int)chunk_len);
+ mg_write(client_conn, multipart_body + body_sent, chunk_len);
+ mg_printf(client_conn, "\r\n");
+ body_sent += chunk_len;
+ chunk_len = (chunk_len % 40) + 1;
+ }
+ mg_printf(client_conn, "0\r\n");
+
+ for (sleep_cnt = 0; sleep_cnt < 30; sleep_cnt++) {
+ test_sleep(1);
+ if (g_field_step == 1000) {
+ break;
+ }
+ }
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+ ck_assert_str_eq(ri->local_uri, "200");
+ mg_close_connection(client_conn);
+
+
+ /* Now test form_store */
+
+ /* First test with GET */
+ client_conn = mg_download("localhost",
+ 8884,
+ 0,
+ ebuf,
+ sizeof(ebuf),
+ "%s",
+ "GET /handle_form_store"
+ "?storeme=storetest"
+ "&continue_field_handler=ignore"
+ "&break_field_handler=abort"
+ "&dontread=xyz "
+ "HTTP/1.0\r\n"
+ "Host: localhost:8884\r\n"
+ "Connection: close\r\n\r\n");
+
+ ck_assert(client_conn != NULL);
+
+ for (sleep_cnt = 0; sleep_cnt < 30; sleep_cnt++) {
+ test_sleep(1);
+ if (g_field_step == 1000) {
+ break;
+ }
+ }
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+ ck_assert_str_eq(ri->local_uri, "200");
+ mg_close_connection(client_conn);
+
+
+ /* Handle form: "POST x-www-form-urlencoded", chunked, store */
+ client_conn =
+ mg_download("localhost",
+ 8884,
+ 0,
+ ebuf,
+ sizeof(ebuf),
+ "%s",
+ "POST /handle_form_store HTTP/1.0\r\n"
+ "Host: localhost:8884\r\n"
+ "Connection: close\r\n"
+ "Content-Type: application/x-www-form-urlencoded\r\n"
+ "Transfer-Encoding: chunked\r\n"
+ "\r\n");
+ ck_assert(client_conn != NULL);
+
+ send_chunk_string(client_conn, "storeme=store");
+ send_chunk_string(client_conn, "test&");
+ send_chunk_string(client_conn, "continue_field_handler=ignore");
+ send_chunk_string(client_conn, "&br");
+ test_sleep(1);
+ send_chunk_string(client_conn, "eak_field_handler=abort&");
+ send_chunk_string(client_conn, "dontread=xyz");
+ mg_printf(client_conn, "0\r\n");
+
+ for (sleep_cnt = 0; sleep_cnt < 30; sleep_cnt++) {
+ test_sleep(1);
+ if (g_field_step == 1000) {
+ break;
+ }
+ }
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+ ck_assert_str_eq(ri->local_uri, "200");
+ mg_close_connection(client_conn);
+
+ /* Handle form: "POST multipart/form-data", chunked, store */
+ client_conn =
+ mg_download("localhost",
+ 8884,
+ 0,
+ ebuf,
+ sizeof(ebuf),
+ "%s",
+ "POST /handle_form_store HTTP/1.0\r\n"
+ "Host: localhost:8884\r\n"
+ "Connection: close\r\n"
+ "Content-Type: multipart/form-data; "
+ "boundary=multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Transfer-Encoding: chunked\r\n"
+ "\r\n");
+ ck_assert(client_conn != NULL);
+
+ send_chunk_string(client_conn, "--multipart-form-data-boundary");
+ send_chunk_string(client_conn, "--see-RFC-2388\r\n");
+ send_chunk_string(client_conn, "Content-Disposition: form-data; ");
+ send_chunk_string(client_conn, "name=\"storeme\"\r\n");
+ send_chunk_string(client_conn, "\r\n");
+ send_chunk_string(client_conn, "storetest\r\n");
+
+ send_chunk_string(client_conn, "--multipart-form-data-boundary-");
+ send_chunk_string(client_conn, "-see-RFC-2388\r\n");
+ send_chunk_string(client_conn, "Content-Disposition: form-data; ");
+ send_chunk_string(client_conn, "name=\"continue_field_handler\"\r\n");
+ send_chunk_string(client_conn, "\r\n");
+ send_chunk_string(client_conn, "ignore\r\n");
+
+ send_chunk_string(client_conn, "--multipart-form-data-boundary-");
+ send_chunk_string(client_conn, "-see-RFC-2388\r\n");
+ send_chunk_string(client_conn, "Content-Disposition: form-data; ");
+ send_chunk_string(client_conn, "name=\"break_field_handler\"\r\n");
+ send_chunk_string(client_conn, "\r\n");
+ send_chunk_string(client_conn, "abort\r\n");
+
+ send_chunk_string(client_conn, "--multipart-form-data-boundary-");
+ send_chunk_string(client_conn, "-see-RFC-2388\r\n");
+ send_chunk_string(client_conn, "Content-Disposition: form-data; ");
+ send_chunk_string(client_conn, "name=\"dontread\"\r\n");
+ send_chunk_string(client_conn, "\r\n");
+ send_chunk_string(client_conn, "xyz\r\n");
+ send_chunk_string(client_conn, "--multipart-form-data-boundary");
+ send_chunk_string(client_conn, "--see-RFC-2388--\r\n");
+ mg_printf(client_conn, "0\r\n");
+
+ for (sleep_cnt = 0; sleep_cnt < 30; sleep_cnt++) {
+ test_sleep(1);
+ if (g_field_step == 1000) {
+ break;
+ }
+ }
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+ ck_assert_str_eq(ri->local_uri, "200");
+ mg_close_connection(client_conn);
+
+
+ /* Handle form: "POST multipart/form-data", chunked, store, with files */
+ client_conn =
+ mg_download("localhost",
+ 8884,
+ 0,
+ ebuf,
+ sizeof(ebuf),
+ "%s",
+ "POST /handle_form_store2 HTTP/1.0\r\n"
+ "Host: localhost:8884\r\n"
+ "Connection: close\r\n"
+ "Content-Type: multipart/form-data; "
+ "boundary=multipart-form-data-boundary--see-RFC-2388\r\n"
+ "Transfer-Encoding: chunked\r\n"
+ "\r\n");
+ ck_assert(client_conn != NULL);
+
+ boundary = "--multipart-form-data-boundary--see-RFC-2388\r\n";
+
+ send_chunk_string(client_conn, boundary);
+ send_chunk_string(client_conn, "Content-Disposition: form-data; ");
+ send_chunk_string(client_conn, "name=\"storeme\"\r\n");
+ send_chunk_string(client_conn, "\r\n");
+ send_chunk_string(client_conn, "storetest\r\n");
+
+ send_chunk_string(client_conn, boundary);
+ send_chunk_string(client_conn, "Content-Disposition: form-data; ");
+ send_chunk_string(client_conn, "name=\"continue_field_handler\";");
+ send_chunk_string(client_conn, "filename=\"file_ignored.txt\"\r\n");
+ send_chunk_string(client_conn, "Content-Type: ");
+ send_chunk_string(client_conn, "application/octet-stream\r\n");
+ send_chunk_string(client_conn, "X-Ignored-Header: xyz\r\n");
+ send_chunk_string(client_conn, "\r\n");
+
+ /* send some kilobyte of data */
+ /* sending megabytes to localhost does not allways work in CI test
+ * environments (depending on the network stack) */
+ body_sent = 0;
+ do {
+ send_chunk_string(client_conn, "ignore\r\n");
+ body_sent += 8;
+ /* send some strings that are almost boundaries */
+ for (chunk_len = 1; chunk_len < strlen(boundary); chunk_len++) {
+ /* chunks from 1 byte to strlen(boundary)-1 */
+ send_chunk_stringl(client_conn, boundary, (unsigned int)chunk_len);
+ body_sent += chunk_len;
+ }
+ } while (body_sent < 8 * 1024);
+ send_chunk_string(client_conn, "\r\n");
+
+ send_chunk_string(client_conn, boundary);
+ send_chunk_string(client_conn, "Content-Disposition: form-data; ");
+ send_chunk_string(client_conn, "name=\"file2store\";");
+ send_chunk_string(client_conn, "filename=\"myfile.txt\"\r\n");
+ send_chunk_string(client_conn, "Content-Type: ");
+ send_chunk_string(client_conn, "application/octet-stream\r\n");
+ send_chunk_string(client_conn, "X-Ignored-Header: xyz\r\n");
+ send_chunk_string(client_conn, "\r\n");
+ for (body_sent = 0; (int)body_sent < (int)myfile_content_rep; body_sent++) {
+ send_chunk_string(client_conn, myfile_content);
+ }
+ send_chunk_string(client_conn, "\r\n");
+
+ send_chunk_string(client_conn, boundary);
+ send_chunk_string(client_conn, "Content-Disposition: form-data; ");
+ send_chunk_string(client_conn, "name=\"break_field_handler\"\r\n");
+ send_chunk_string(client_conn, "\r\n");
+ send_chunk_string(client_conn, "abort\r\n");
+
+ send_chunk_string(client_conn, boundary);
+ send_chunk_string(client_conn, "Content-Disposition: form-data; ");
+ send_chunk_string(client_conn, "name=\"dontread\"\r\n");
+ send_chunk_string(client_conn, "\r\n");
+ send_chunk_string(client_conn, "xyz\r\n");
+ send_chunk_string(client_conn, "--multipart-form-data-boundary");
+ send_chunk_string(client_conn, "--see-RFC-2388--\r\n");
+ mg_printf(client_conn, "0\r\n");
+
+ for (sleep_cnt = 0; sleep_cnt < 30; sleep_cnt++) {
+ test_sleep(1);
+ if (g_field_step == 1000) {
+ break;
+ }
+ }
+ ri = mg_get_request_info(client_conn);
+
+ ck_assert(ri != NULL);
+ ck_assert_str_eq(ri->local_uri, "200");
+ mg_close_connection(client_conn);
+
+
+ /* Close the server */
+ g_ctx = NULL;
+ test_mg_stop(ctx);
+ mark_point();
+}
+END_TEST
+
+
+START_TEST(test_http_auth)
+{
+#if !defined(NO_FILES)
+ const char *OPTIONS[] = {
+ "document_root",
+ ".",
+ "listening_ports",
+ "8080",
+#if !defined(NO_CACHING)
+ "static_file_max_age",
+ "0",
+#endif
+ "put_delete_auth_file",
+ "put_delete_auth_file.csv",
+ NULL,
+ };
+
+ struct mg_context *ctx;
+ struct mg_connection *client_conn;
+ char client_err[256], nonce[256];
+ const struct mg_request_info *client_ri;
+ int client_res;
+ FILE *f;
+ const char *passwd_file = ".htpasswd";
+ const char *test_file = "test_http_auth.test_file.txt";
+ const char *test_content = "test_http_auth test_file content";
+ const char *domain;
+ const char *doc_root;
+ const char *auth_request;
+ const char *str;
+ size_t len;
+ int i;
+ char HA1[256], HA2[256], HA[256];
+ char HA1_md5_buf[33], HA2_md5_buf[33], HA_md5_buf[33];
+ char *HA1_md5_ret, *HA2_md5_ret, *HA_md5_ret;
+ const char *nc = "00000001";
+ const char *cnonce = "6789ABCD";
+
+ mark_point();
+
+ /* Start with default options */
+ ctx = test_mg_start(NULL, NULL, OPTIONS);
+
+ ck_assert(ctx != NULL);
+ domain = mg_get_option(ctx, "authentication_domain");
+ ck_assert(domain != NULL);
+ len = strlen(domain);
+ ck_assert_uint_gt(len, 0);
+ ck_assert_uint_lt(len, 64);
+ doc_root = mg_get_option(ctx, "document_root");
+ ck_assert_str_eq(doc_root, ".");
+
+ /* Create a default file in the document root */
+ f = fopen(test_file, "w");
+ if (f) {
+ fprintf(f, "%s", test_content);
+ fclose(f);
+ } else {
+ ck_abort_msg("Cannot create file %s", test_file);
+ }
+
+ (void)remove(passwd_file);
+ (void)remove("put_delete_auth_file.csv");
+
+ client_res = mg_modify_passwords_file("put_delete_auth_file.csv",
+ domain,
+ "admin",
+ "adminpass");
+ ck_assert_int_eq(client_res, 1);
+
+ /* Read file before a .htpasswd file has been created */
+ memset(client_err, 0, sizeof(client_err));
+ client_conn =
+ mg_connect_client("127.0.0.1", 8080, 0, client_err, sizeof(client_err));
+
+ ck_assert_str_eq(client_err, "");
+ ck_assert(client_conn != NULL);
+
+ mg_printf(client_conn, "GET /%s HTTP/1.0\r\n\r\n", test_file);
+ client_res =
+ mg_get_response(client_conn, client_err, sizeof(client_err), 10000);
+ ck_assert_int_ge(client_res, 0);
+ ck_assert_str_eq(client_err, "");
+ client_ri = mg_get_request_info(client_conn);
+ ck_assert(client_ri != NULL);
+
+ ck_assert_str_eq(client_ri->local_uri, "200");
+ client_res = (int)mg_read(client_conn, client_err, sizeof(client_err));
+ ck_assert_int_gt(client_res, 0);
+ ck_assert_int_le(client_res, sizeof(client_err));
+ ck_assert_str_eq(client_err, test_content);
+ mg_close_connection(client_conn);
+
+ test_sleep(1);
+
+ /* Create a .htpasswd file */
+ client_res = mg_modify_passwords_file(passwd_file, domain, "user", "pass");
+ ck_assert_int_eq(client_res, 1);
+
+ client_res = mg_modify_passwords_file(NULL, domain, "user", "pass");
+ ck_assert_int_eq(client_res, 0); /* Filename is required */
+
+ test_sleep(1);
+
+ /* Repeat test after .htpasswd is created */
+ memset(client_err, 0, sizeof(client_err));
+ client_conn =
+ mg_connect_client("127.0.0.1", 8080, 0, client_err, sizeof(client_err));
+
+ ck_assert_str_eq(client_err, "");
+ ck_assert(client_conn != NULL);
+
+ mg_printf(client_conn, "GET /%s HTTP/1.0\r\n\r\n", test_file);
+ client_res =
+ mg_get_response(client_conn, client_err, sizeof(client_err), 10000);
+ ck_assert_int_ge(client_res, 0);
+ ck_assert_str_eq(client_err, "");
+ client_ri = mg_get_request_info(client_conn);
+ ck_assert(client_ri != NULL);
+
+ ck_assert_str_eq(client_ri->local_uri, "401");
+
+ auth_request = NULL;
+ for (i = 0; i < client_ri->num_headers; i++) {
+ if (!mg_strcasecmp(client_ri->http_headers[i].name,
+ "WWW-Authenticate")) {
+ ck_assert_ptr_eq(auth_request, NULL);
+ auth_request = client_ri->http_headers[i].value;
+ ck_assert_ptr_ne(auth_request, NULL);
+ }
+ }
+ ck_assert_ptr_ne(auth_request, NULL);
+ str = "Digest qop=\"auth\", realm=\"";
+ len = strlen(str);
+ ck_assert(!mg_strncasecmp(auth_request, str, len));
+ ck_assert(!strncmp(auth_request + len, domain, strlen(domain)));
+ len += strlen(domain);
+ str = "\", nonce=\"";
+ ck_assert(!strncmp(auth_request + len, str, strlen(str)));
+ len += strlen(str);
+ str = strchr(auth_request + len, '\"');
+ ck_assert_ptr_ne(str, NULL);
+ ck_assert_ptr_ne(str, auth_request + len);
+ /* nonce is from including (auth_request + len) to excluding (str) */
+ ck_assert_int_gt((ptrdiff_t)(str) - (ptrdiff_t)(auth_request + len), 0);
+ ck_assert_int_lt((ptrdiff_t)(str) - (ptrdiff_t)(auth_request + len),
+ (ptrdiff_t)sizeof(nonce));
+ memset(nonce, 0, sizeof(nonce));
+ memcpy(nonce,
+ auth_request + len,
+ (size_t)((ptrdiff_t)(str) - (ptrdiff_t)(auth_request + len)));
+ memset(HA1, 0, sizeof(HA1));
+ memset(HA2, 0, sizeof(HA2));
+ memset(HA, 0, sizeof(HA));
+ memset(HA1_md5_buf, 0, sizeof(HA1_md5_buf));
+ memset(HA2_md5_buf, 0, sizeof(HA2_md5_buf));
+ memset(HA_md5_buf, 0, sizeof(HA_md5_buf));
+
+ sprintf(HA1, "%s:%s:%s", "user", domain, "pass");
+ sprintf(HA2, "%s:/%s", "GET", test_file);
+ HA1_md5_ret = mg_md5(HA1_md5_buf, HA1, NULL);
+ HA2_md5_ret = mg_md5(HA2_md5_buf, HA2, NULL);
+
+ ck_assert_ptr_eq(HA1_md5_ret, HA1_md5_buf);
+ ck_assert_ptr_eq(HA2_md5_ret, HA2_md5_buf);
+
+ HA_md5_ret = mg_md5(HA_md5_buf, "user", ":", domain, ":", "pass", NULL);
+ ck_assert_ptr_eq(HA_md5_ret, HA_md5_buf);
+ ck_assert_str_eq(HA1_md5_ret, HA_md5_buf);
+
+ HA_md5_ret = mg_md5(HA_md5_buf, "GET", ":", "/", test_file, NULL);
+ ck_assert_ptr_eq(HA_md5_ret, HA_md5_buf);
+ ck_assert_str_eq(HA2_md5_ret, HA_md5_buf);
+
+ HA_md5_ret = mg_md5(HA_md5_buf,
+ HA1_md5_buf,
+ ":",
+ nonce,
+ ":",
+ nc,
+ ":",
+ cnonce,
+ ":",
+ "auth",
+ ":",
+ HA2_md5_buf,
+ NULL);
+ ck_assert_ptr_eq(HA_md5_ret, HA_md5_buf);
+
+ mg_close_connection(client_conn);
+
+ /* Retry with authorization */
+ memset(client_err, 0, sizeof(client_err));
+ client_conn =
+ mg_connect_client("127.0.0.1", 8080, 0, client_err, sizeof(client_err));
+
+ ck_assert_str_eq(client_err, "");
+ ck_assert(client_conn != NULL);
+
+ mg_printf(client_conn, "GET /%s HTTP/1.0\r\n", test_file);
+ mg_printf(client_conn,
+ "Authorization: Digest "
+ "username=\"%s\", "
+ "realm=\"%s\", "
+ "nonce=\"%s\", "
+ "uri=\"/%s\", "
+ "qop=auth, "
+ "nc=%s, "
+ "cnonce=\"%s\", "
+ "response=\"%s\"\r\n\r\n",
+ "user",
+ domain,
+ nonce,
+ test_file,
+ nc,
+ cnonce,
+ HA_md5_buf);
+ client_res =
+ mg_get_response(client_conn, client_err, sizeof(client_err), 10000);
+ ck_assert_int_ge(client_res, 0);
+ ck_assert_str_eq(client_err, "");
+ client_ri = mg_get_request_info(client_conn);
+ ck_assert(client_ri != NULL);
+
+ ck_assert_str_eq(client_ri->local_uri, "200");
+ client_res = (int)mg_read(client_conn, client_err, sizeof(client_err));
+ ck_assert_int_gt(client_res, 0);
+ ck_assert_int_le(client_res, sizeof(client_err));
+ ck_assert_str_eq(client_err, test_content);
+ mg_close_connection(client_conn);
+
+ test_sleep(1);
+
+ /* Retry DELETE with authorization of a user not authorized for DELETE */
+ memset(client_err, 0, sizeof(client_err));
+ client_conn =
+ mg_connect_client("127.0.0.1", 8080, 0, client_err, sizeof(client_err));
+
+ ck_assert_str_eq(client_err, "");
+ ck_assert(client_conn != NULL);
+
+ mg_printf(client_conn, "DELETE /%s HTTP/1.0\r\n", test_file);
+ mg_printf(client_conn,
+ "Authorization: Digest "
+ "username=\"%s\", "
+ "realm=\"%s\", "
+ "nonce=\"%s\", "
+ "uri=\"/%s\", "
+ "qop=auth, "
+ "nc=%s, "
+ "cnonce=\"%s\", "
+ "response=\"%s\"\r\n\r\n",
+ "user",
+ domain,
+ nonce,
+ test_file,
+ nc,
+ cnonce,
+ HA_md5_buf);
+ client_res =
+ mg_get_response(client_conn, client_err, sizeof(client_err), 10000);
+ ck_assert_int_ge(client_res, 0);
+ ck_assert_str_eq(client_err, "");
+ client_ri = mg_get_request_info(client_conn);
+ ck_assert(client_ri != NULL);
+
+ ck_assert_str_eq(client_ri->local_uri, "401");
+ mg_close_connection(client_conn);
+
+ test_sleep(1);
+
+ /* Remove the user from the .htpasswd file again */
+ client_res = mg_modify_passwords_file(passwd_file, domain, "user", NULL);
+ ck_assert_int_eq(client_res, 1);
+
+ test_sleep(1);
+
+
+ /* Try to access the file again. Expected: 401 error */
+ memset(client_err, 0, sizeof(client_err));
+ client_conn =
+ mg_connect_client("127.0.0.1", 8080, 0, client_err, sizeof(client_err));
+
+ ck_assert_str_eq(client_err, "");
+ ck_assert(client_conn != NULL);
+
+ mg_printf(client_conn, "GET /%s HTTP/1.0\r\n\r\n", test_file);
+ client_res =
+ mg_get_response(client_conn, client_err, sizeof(client_err), 10000);
+ ck_assert_int_ge(client_res, 0);
+ ck_assert_str_eq(client_err, "");
+ client_ri = mg_get_request_info(client_conn);
+ ck_assert(client_ri != NULL);
+
+ ck_assert_str_eq(client_ri->local_uri, "401");
+ mg_close_connection(client_conn);
+
+ test_sleep(1);
+
+
+ /* Now remove the password file */
+ (void)remove(passwd_file);
+ test_sleep(1);
+
+
+ /* Access to the file must work like before */
+ memset(client_err, 0, sizeof(client_err));
+ client_conn =
+ mg_connect_client("127.0.0.1", 8080, 0, client_err, sizeof(client_err));
+
+ ck_assert_str_eq(client_err, "");
+ ck_assert(client_conn != NULL);
+
+ mg_printf(client_conn, "GET /%s HTTP/1.0\r\n\r\n", test_file);
+ client_res =
+ mg_get_response(client_conn, client_err, sizeof(client_err), 10000);
+ ck_assert_int_ge(client_res, 0);
+ ck_assert_str_eq(client_err, "");
+ client_ri = mg_get_request_info(client_conn);
+ ck_assert(client_ri != NULL);
+
+ ck_assert_str_eq(client_ri->local_uri, "200");
+ client_res = (int)mg_read(client_conn, client_err, sizeof(client_err));
+ ck_assert_int_gt(client_res, 0);
+ ck_assert_int_le(client_res, sizeof(client_err));
+ ck_assert_str_eq(client_err, test_content);
+ mg_close_connection(client_conn);
+
+ test_sleep(1);
+
+
+ /* Stop the server and clean up */
+ test_mg_stop(ctx);
+ (void)remove(test_file);
+ (void)remove(passwd_file);
+ (void)remove("put_delete_auth_file.csv");
+
+#endif
+ mark_point();
+}
+END_TEST
+
+
+START_TEST(test_keep_alive)
+{
+ struct mg_context *ctx;
+ const char *OPTIONS[] =
+ { "listening_ports",
+ "8081",
+ "request_timeout_ms",
+ "10000",
+ "enable_keep_alive",
+ "yes",
+#if !defined(NO_FILES)
+ "document_root",
+ ".",
+ "enable_directory_listing",
+ "no",
+#endif
+ NULL };
+
+ struct mg_connection *client_conn;
+ char client_err[256];
+ const struct mg_request_info *client_ri;
+ int client_res, i;
+ const char *connection_header;
+
+ mark_point();
+
+ ctx = test_mg_start(NULL, NULL, OPTIONS);
+
+ ck_assert(ctx != NULL);
+
+ /* HTTP 1.1 GET request */
+ memset(client_err, 0, sizeof(client_err));
+ client_conn =
+ mg_connect_client("127.0.0.1", 8081, 0, client_err, sizeof(client_err));
+
+ ck_assert_str_eq(client_err, "");
+ ck_assert(client_conn != NULL);
+
+ mg_printf(client_conn,
+ "GET / HTTP/1.1\r\nHost: "
+ "localhost:8081\r\nConnection: keep-alive\r\n\r\n");
+ client_res =
+ mg_get_response(client_conn, client_err, sizeof(client_err), 10000);
+ ck_assert_int_ge(client_res, 0);
+ ck_assert_str_eq(client_err, "");
+ client_ri = mg_get_request_info(client_conn);
+ ck_assert(client_ri != NULL);
+
+#if defined(NO_FILES)
+ ck_assert_str_eq(client_ri->local_uri, "404");
+#else
+ ck_assert_str_eq(client_ri->local_uri, "403");
+#endif
+
+ connection_header = 0;
+ for (i = 0; i < client_ri->num_headers; i++) {
+ if (!mg_strcasecmp(client_ri->http_headers[i].name, "Connection")) {
+ ck_assert_ptr_eq(connection_header, NULL);
+ connection_header = client_ri->http_headers[i].value;
+ ck_assert_ptr_ne(connection_header, NULL);
+ }
+ }
+ /* Error replies will close the connection, even if keep-alive is set. */
+ ck_assert_ptr_ne(connection_header, NULL);
+ ck_assert_str_eq(connection_header, "close");
+ mg_close_connection(client_conn);
+
+ test_sleep(1);
+
+ /* TODO: request a file and keep alive
+ * (will only work if NO_FILES is not set). */
+
+ /* Stop the server and clean up */
+ test_mg_stop(ctx);
+
+ mark_point();
+}
+END_TEST
+
+
+START_TEST(test_error_handling)
+{
+ struct mg_context *ctx;
+ FILE *f;
+
+ char bad_thread_num[32] = "badnumber";
+
+ struct mg_callbacks callbacks;
+ char errmsg[256];
+
+ struct mg_connection *client_conn;
+ char client_err[256];
+ const struct mg_request_info *client_ri;
+ int client_res, i;
+
+ const char *OPTIONS[32];
+ int opt_cnt = 0;
+
+ mark_point();
+
+#if !defined(NO_FILES)
+ OPTIONS[opt_cnt++] = "document_root";
+ OPTIONS[opt_cnt++] = ".";
+#endif
+ OPTIONS[opt_cnt++] = "error_pages";
+ OPTIONS[opt_cnt++] = "./";
+ OPTIONS[opt_cnt++] = "listening_ports";
+ OPTIONS[opt_cnt++] = "8080";
+ OPTIONS[opt_cnt++] = "num_threads";
+ OPTIONS[opt_cnt++] = bad_thread_num;
+ OPTIONS[opt_cnt++] = "unknown_option";
+ OPTIONS[opt_cnt++] = "unknown_option_value";
+ OPTIONS[opt_cnt] = NULL;
+
+ memset(&callbacks, 0, sizeof(callbacks));
+
+ callbacks.log_message = log_msg_func;
+
+ /* test with unknown option */
+ memset(errmsg, 0, sizeof(errmsg));
+ ctx = test_mg_start(&callbacks, (void *)errmsg, OPTIONS);
+
+ /* Details of errmsg may vary, but it may not be empty */
+ ck_assert_str_ne(errmsg, "");
+ ck_assert(ctx == NULL);
+ ck_assert_str_eq(errmsg, "Invalid option: unknown_option");
+
+ /* Remove invalid option */
+ for (i = 0; OPTIONS[i]; i++) {
+ if (strstr(OPTIONS[i], "unknown_option")) {
+ OPTIONS[i] = 0;
+ }
+ }
+
+ /* Test with bad num_thread option */
+ memset(errmsg, 0, sizeof(errmsg));
+ ctx = test_mg_start(&callbacks, (void *)errmsg, OPTIONS);
+
+ /* Details of errmsg may vary, but it may not be empty */
+ ck_assert_str_ne(errmsg, "");
+ ck_assert(ctx == NULL);
+ ck_assert_str_eq(errmsg, "Invalid number of worker threads");
+
+/* Set to a number - but use a number above the limit */
+#ifdef MAX_WORKER_THREADS
+ sprintf(bad_thread_num, "%u", MAX_WORKER_THREADS + 1);
+#else
+ sprintf(bad_thread_num, "%lu", 1000000000lu);
+#endif
+
+ /* Test with bad num_thread option */
+ memset(errmsg, 0, sizeof(errmsg));
+ ctx = test_mg_start(&callbacks, (void *)errmsg, OPTIONS);
+
+ /* Details of errmsg may vary, but it may not be empty */
+ ck_assert_str_ne(errmsg, "");
+ ck_assert(ctx == NULL);
+ ck_assert_str_eq(errmsg, "Too many worker threads");
+
+
+ /* HTTP 1.0 GET request - server is not running */
+ memset(client_err, 0, sizeof(client_err));
+ client_conn =
+ mg_connect_client("127.0.0.1", 8080, 0, client_err, sizeof(client_err));
+ ck_assert(client_conn == NULL);
+
+ /* Error message detail may vary - it may not be empty ans should contain
+ * some information "connect" failed */
+ ck_assert_str_ne(client_err, "");
+ ck_assert(strstr(client_err, "connect"));
+
+
+ /* This time start the server with a valid configuration */
+ sprintf(bad_thread_num, "%i", 1);
+ memset(errmsg, 0, sizeof(errmsg));
+ ctx = test_mg_start(&callbacks, (void *)errmsg, OPTIONS);
+
+ ck_assert_str_eq(errmsg, "");
+ ck_assert(ctx != NULL);
+
+
+ /* Server is running now */
+ test_sleep(1);
+
+ /* Remove error files (in case they exist) */
+ (void)remove("error.htm");
+ (void)remove("error4xx.htm");
+ (void)remove("error404.htm");
+
+
+ /* Ask for something not existing - should get default 404 */
+ memset(client_err, 0, sizeof(client_err));
+ client_conn =
+ mg_connect_client("127.0.0.1", 8080, 0, client_err, sizeof(client_err));
+
+ ck_assert_str_eq(client_err, "");
+ ck_assert(client_conn != NULL);
+
+ mg_printf(client_conn, "GET /something/not/existing HTTP/1.0\r\n\r\n");
+ client_res =
+ mg_get_response(client_conn, client_err, sizeof(client_err), 10000);
+ ck_assert_int_ge(client_res, 0);
+ ck_assert_str_eq(client_err, "");
+ client_ri = mg_get_request_info(client_conn);
+ ck_assert(client_ri != NULL);
+
+ ck_assert_str_eq(client_ri->local_uri, "404");
+ mg_close_connection(client_conn);
+ test_sleep(1);
+
+ /* Create an error.htm file */
+ f = fopen("error.htm", "wt");
+ ck_assert(f != NULL);
+ (void)fprintf(f, "err-all");
+ (void)fclose(f);
+
+
+ /* Ask for something not existing - should get error.htm */
+ memset(client_err, 0, sizeof(client_err));
+ client_conn =
+ mg_connect_client("127.0.0.1", 8080, 0, client_err, sizeof(client_err));
+
+ ck_assert_str_eq(client_err, "");
+ ck_assert(client_conn != NULL);
+
+ mg_printf(client_conn, "GET /something/not/existing HTTP/1.0\r\n\r\n");
+ client_res =
+ mg_get_response(client_conn, client_err, sizeof(client_err), 10000);
+ ck_assert_int_ge(client_res, 0);
+ ck_assert_str_eq(client_err, "");
+ client_ri = mg_get_request_info(client_conn);
+ ck_assert(client_ri != NULL);
+
+ ck_assert_str_eq(client_ri->local_uri, "200");
+
+ client_res = (int)mg_read(client_conn, client_err, sizeof(client_err));
+ mg_close_connection(client_conn);
+ ck_assert_int_eq(client_res, 7);
+ client_err[8] = 0;
+ ck_assert_str_eq(client_err, "err-all");
+ test_sleep(1);
+
+ /* Create an error4xx.htm file */
+ f = fopen("error4xx.htm", "wt");
+ ck_assert(f != NULL);
+ (void)fprintf(f, "err-4xx");
+ (void)fclose(f);
+
+
+ /* Ask for something not existing - should get error4xx.htm */
+ memset(client_err, 0, sizeof(client_err));
+ client_conn =
+ mg_connect_client("127.0.0.1", 8080, 0, client_err, sizeof(client_err));
+
+ ck_assert_str_eq(client_err, "");
+ ck_assert(client_conn != NULL);
+
+ mg_printf(client_conn, "GET /something/not/existing HTTP/1.0\r\n\r\n");
+ client_res =
+ mg_get_response(client_conn, client_err, sizeof(client_err), 10000);
+ ck_assert_int_ge(client_res, 0);
+ ck_assert_str_eq(client_err, "");
+ client_ri = mg_get_request_info(client_conn);
+ ck_assert(client_ri != NULL);
+
+ ck_assert_str_eq(client_ri->local_uri, "200");
+
+ client_res = (int)mg_read(client_conn, client_err, sizeof(client_err));
+ mg_close_connection(client_conn);
+ ck_assert_int_eq(client_res, 7);
+ client_err[8] = 0;
+ ck_assert_str_eq(client_err, "err-4xx");
+ test_sleep(1);
+
+ /* Create an error404.htm file */
+ f = fopen("error404.htm", "wt");
+ ck_assert(f != NULL);
+ (void)fprintf(f, "err-404");
+ (void)fclose(f);
+
+
+ /* Ask for something not existing - should get error404.htm */
+ memset(client_err, 0, sizeof(client_err));
+ client_conn =
+ mg_connect_client("127.0.0.1", 8080, 0, client_err, sizeof(client_err));
+
+ ck_assert_str_eq(client_err, "");
+ ck_assert(client_conn != NULL);
+
+ mg_printf(client_conn, "GET /something/not/existing HTTP/1.0\r\n\r\n");
+ client_res =
+ mg_get_response(client_conn, client_err, sizeof(client_err), 10000);
+ ck_assert_int_ge(client_res, 0);
+ ck_assert_str_eq(client_err, "");
+ client_ri = mg_get_request_info(client_conn);
+ ck_assert(client_ri != NULL);
+
+ ck_assert_str_eq(client_ri->local_uri, "200");
+
+ client_res = (int)mg_read(client_conn, client_err, sizeof(client_err));
+ mg_close_connection(client_conn);
+ ck_assert_int_eq(client_res, 7);
+ client_err[8] = 0;
+ ck_assert_str_eq(client_err, "err-404");
+ test_sleep(1);
+
+
+ /* Ask in a malformed way - should get error4xx.htm */
+ memset(client_err, 0, sizeof(client_err));
+ client_conn =
+ mg_connect_client("127.0.0.1", 8080, 0, client_err, sizeof(client_err));
+
+ ck_assert_str_eq(client_err, "");
+ ck_assert(client_conn != NULL);
+
+ mg_printf(client_conn, "Gimme some file!\r\n\r\n");
+ client_res =
+ mg_get_response(client_conn, client_err, sizeof(client_err), 10000);
+ ck_assert_int_ge(client_res, 0);
+ ck_assert_str_eq(client_err, "");
+ client_ri = mg_get_request_info(client_conn);
+ ck_assert(client_ri != NULL);
+
+ ck_assert_str_eq(client_ri->local_uri, "200");
+
+ client_res = (int)mg_read(client_conn, client_err, sizeof(client_err));
+ mg_close_connection(client_conn);
+ ck_assert_int_eq(client_res, 7);
+ client_err[8] = 0;
+ ck_assert_str_eq(client_err, "err-4xx");
+ test_sleep(1);
+
+
+ /* Remove all error files created by this test */
+ (void)remove("error.htm");
+ (void)remove("error4xx.htm");
+ (void)remove("error404.htm");
+
+
+ /* Stop the server */
+ test_mg_stop(ctx);
+
+
+ /* HTTP 1.1 GET request - must not work, since server is already stopped */
+ memset(client_err, 0, sizeof(client_err));
+ client_conn =
+ mg_connect_client("127.0.0.1", 8080, 0, client_err, sizeof(client_err));
+
+ ck_assert(client_conn == NULL);
+ ck_assert_str_ne(client_err, "");
+
+ test_sleep(1);
+
+ mark_point();
+}
+END_TEST
+
+
+START_TEST(test_error_log_file)
+{
+ /* Server var */
+ struct mg_context *ctx;
+ const char *OPTIONS[32];
+ int opt_cnt = 0;
+
+ /* Client var */
+ struct mg_connection *client;
+ char client_err_buf[256];
+ char client_data_buf[256];
+ const struct mg_request_info *client_ri;
+
+ /* File content check var */
+ FILE *f;
+ char buf[1024];
+ int len, ok;
+
+ mark_point();
+
+ /* Set options and start server */
+ OPTIONS[opt_cnt++] = "listening_ports";
+ OPTIONS[opt_cnt++] = "8080";
+ OPTIONS[opt_cnt++] = "error_log_file";
+ OPTIONS[opt_cnt++] = "error.log";
+ OPTIONS[opt_cnt++] = "access_log_file";
+ OPTIONS[opt_cnt++] = "access.log";
+#if !defined(NO_FILES)
+ OPTIONS[opt_cnt++] = "document_root";
+ OPTIONS[opt_cnt++] = ".";
+#endif
+ OPTIONS[opt_cnt] = NULL;
+
+ ctx = test_mg_start(NULL, 0, OPTIONS);
+ ck_assert(ctx != NULL);
+
+ /* Remove log files (they may exist from previous incomplete runs of
+ * this test) */
+ (void)remove("error.log");
+ (void)remove("access.log");
+
+ /* connect client */
+ memset(client_err_buf, 0, sizeof(client_err_buf));
+ memset(client_data_buf, 0, sizeof(client_data_buf));
+
+ client = mg_download("127.0.0.1",
+ 8080,
+ 0,
+ client_err_buf,
+ sizeof(client_err_buf),
+ "GET /not_existing_file.ext HTTP/1.0\r\n\r\n");
+
+ ck_assert(ctx != NULL);
+ ck_assert_str_eq(client_err_buf, "");
+
+ client_ri = mg_get_request_info(client);
+
+ ck_assert(client_ri != NULL);
+ ck_assert_str_eq(client_ri->local_uri, "404");
+
+ /* Close the client connection */
+ mg_close_connection(client);
+
+ /* Stop the server */
+ test_mg_stop(ctx);
+
+
+ /* Check access.log */
+ memset(buf, 0, sizeof(buf));
+ f = fopen("access.log", "r");
+ ck_assert_msg(f != NULL, "Cannot open access log file");
+ ok = (NULL != fgets(buf, sizeof(buf) - 1, f));
+ (void)fclose(f);
+ ck_assert_msg(ok, "Cannot read access log file");
+ len = (int)strlen(buf);
+ ck_assert_int_gt(len, 0);
+ ok = (NULL != strstr(buf, "not_existing_file.ext"));
+ ck_assert_msg(ok, "Did not find uri in access log file");
+ ok = (NULL != strstr(buf, "404"));
+ ck_assert_msg(ok, "Did not find HTTP status code in access log file");
+
+ /* Check error.log */
+ memset(buf, 0, sizeof(buf));
+ f = fopen("error.log", "r");
+ if (f) {
+ (void)fgets(buf, sizeof(buf) - 1, f);
+ fclose(f);
+ }
+ ck_assert_msg(f == NULL,
+ "Should not create error log file on 404, but got [%s]",
+ buf);
+
+ /* Remove log files */
+ (void)remove("error.log");
+ (void)remove("access.log");
+
+ /* Start server with bad options */
+ ck_assert_str_eq(OPTIONS[0], "listening_ports");
+ OPTIONS[1] = "bad port syntax";
+
+ ctx = test_mg_start(NULL, 0, OPTIONS);
+ ck_assert_msg(
+ ctx == NULL,
+ "Should not be able to start server with bad port configuration");
+
+ /* Check access.log */
+ memset(buf, 0, sizeof(buf));
+ f = fopen("access.log", "r");
+ if (f) {
+ (void)fgets(buf, sizeof(buf) - 1, f);
+ fclose(f);
+ }
+ ck_assert_msg(
+ f == NULL,
+ "Should not create access log file if start fails, but got [%s]",
+ buf);
+
+ /* Check error.log */
+ memset(buf, 0, sizeof(buf));
+ f = fopen("error.log", "r");
+ ck_assert_msg(f != NULL, "Cannot open access log file");
+ ok = (NULL != fgets(buf, sizeof(buf) - 1, f));
+ (void)fclose(f);
+ ck_assert_msg(ok, "Cannot read access log file");
+ len = (int)strlen(buf);
+ ck_assert_int_gt(len, 0);
+ ok = (NULL != strstr(buf, "port"));
+ ck_assert_msg(ok, "Did not find port as error reason in error log file");
+
+
+ /* Remove log files */
+ (void)remove("error.log");
+ (void)remove("access.log");
+
+ mark_point();
+}
+END_TEST
+
+
+static int
+test_throttle_begin_request(struct mg_connection *conn)
+{
+ const struct mg_request_info *ri;
+ long unsigned len = 1024 * 10;
+ const char *block = "0123456789";
+ unsigned long i, blocklen;
+
+ ck_assert(conn != NULL);
+ ri = mg_get_request_info(conn);
+ ck_assert(ri != NULL);
+
+ ck_assert_str_eq(ri->request_method, "GET");
+ ck_assert_str_eq(ri->request_uri, "/throttle");
+ ck_assert_str_eq(ri->local_uri, "/throttle");
+ ck_assert_str_eq(ri->http_version, "1.0");
+ ck_assert_str_eq(ri->query_string, "q");
+ ck_assert_str_eq(ri->remote_addr, "127.0.0.1");
+
+ mg_printf(conn,
+ "HTTP/1.1 200 OK\r\n"
+ "Content-Length: %lu\r\n"
+ "Connection: close\r\n\r\n",
+ len);
+
+ blocklen = (unsigned long)strlen(block);
+
+ for (i = 0; i < len; i += blocklen) {
+ mg_write(conn, block, blocklen);
+ }
+
+ mark_point();
+
+ return 987; /* Not a valid HTTP response code,
+ * but it should be written to the log and passed to
+ * end_request. */
+}
+
+
+static void
+test_throttle_end_request(const struct mg_connection *conn,
+ int reply_status_code)
+{
+ const struct mg_request_info *ri;
+
+ ck_assert(conn != NULL);
+ ri = mg_get_request_info(conn);
+ ck_assert(ri != NULL);
+
+ ck_assert_str_eq(ri->request_method, "GET");
+ ck_assert_str_eq(ri->request_uri, "/throttle");
+ ck_assert_str_eq(ri->local_uri, "/throttle");
+ ck_assert_str_eq(ri->http_version, "1.0");
+ ck_assert_str_eq(ri->query_string, "q");
+ ck_assert_str_eq(ri->remote_addr, "127.0.0.1");
+
+ ck_assert_int_eq(reply_status_code, 987);
+}
+
+
+START_TEST(test_throttle)
+{
+ /* Server var */
+ struct mg_context *ctx;
+ struct mg_callbacks callbacks;
+ const char *OPTIONS[32];
+ int opt_cnt = 0;
+
+ /* Client var */
+ struct mg_connection *client;
+ char client_err_buf[256];
+ char client_data_buf[256];
+ const struct mg_request_info *client_ri;
+
+ /* timing test */
+ int r, data_read;
+ time_t t0, t1;
+ double dt;
+
+ mark_point();
+
+
+/* Set options and start server */
+#if !defined(NO_FILES)
+ OPTIONS[opt_cnt++] = "document_root";
+ OPTIONS[opt_cnt++] = ".";
+#endif
+ OPTIONS[opt_cnt++] = "listening_ports";
+ OPTIONS[opt_cnt++] = "8080";
+ OPTIONS[opt_cnt++] = "throttle";
+ OPTIONS[opt_cnt++] = "*=1k";
+ OPTIONS[opt_cnt] = NULL;
+
+ memset(&callbacks, 0, sizeof(callbacks));
+ callbacks.begin_request = test_throttle_begin_request;
+ callbacks.end_request = test_throttle_end_request;
+
+ ctx = test_mg_start(&callbacks, 0, OPTIONS);
+ ck_assert(ctx != NULL);
+
+ /* connect client */
+ memset(client_err_buf, 0, sizeof(client_err_buf));
+ memset(client_data_buf, 0, sizeof(client_data_buf));
+
+ strcpy(client_err_buf, "reset-content");
+ client = mg_download("127.0.0.1",
+ 8080,
+ 0,
+ client_err_buf,
+ sizeof(client_err_buf),
+ "GET /throttle?q HTTP/1.0\r\n\r\n");
+
+ ck_assert(ctx != NULL);
+ ck_assert_str_eq(client_err_buf, "");
+
+ client_ri = mg_get_request_info(client);
+
+ ck_assert(client_ri != NULL);
+ ck_assert_str_eq(client_ri->local_uri, "200");
+
+ ck_assert_int_eq(client_ri->content_length, 1024 * 10);
+
+ data_read = 0;
+ t0 = time(NULL);
+ while (data_read < client_ri->content_length) {
+ r = mg_read(client, client_data_buf, sizeof(client_data_buf));
+ ck_assert_int_ge(r, 0);
+ data_read += r;
+ }
+ t1 = time(NULL);
+ dt = difftime(t1, t0) * 1000.0; /* Elapsed time in ms - in most systems
+ * only with second resolution */
+
+ /* Time estimation: Data size is 10 kB, with 1 kB/s speed limit.
+ * The first block (1st kB) is transferred immediately, the second
+ * block (2nd kB) one second later, the third block (3rd kB) two
+ * seconds later, .. the last block (10th kB) nine seconds later.
+ * The resolution of time measurement using the "time" C library
+ * function is 1 second, so we should add +/- one second tolerance.
+ * Thus, download of 10 kB with 1 kB/s should not be faster than
+ * 8 seconds. */
+
+ /* Check if there are at least 8 seconds */
+ ck_assert_int_ge((int)dt, 8 * 1000);
+
+ /* Nothing left to read */
+ r = mg_read(client, client_data_buf, sizeof(client_data_buf));
+ ck_assert_int_eq(r, 0);
+
+ /* Close the client connection */
+ mg_close_connection(client);
+
+ /* Stop the server */
+ test_mg_stop(ctx);
+
+ mark_point();
+}
+END_TEST
+
+
+START_TEST(test_init_library)
+{
+ unsigned f_avail, f_ret;
+
+ mark_point();
+
+ f_avail = mg_check_feature(0xFF);
+ f_ret = mg_init_library(f_avail);
+ ck_assert_uint_eq(f_ret, f_avail);
+}
+END_TEST
+
+
+#define LARGE_FILE_SIZE (1024 * 1024 * 10)
+
+static int
+test_large_file_begin_request(struct mg_connection *conn)
+{
+ const struct mg_request_info *ri;
+ long unsigned len = LARGE_FILE_SIZE;
+ const char *block = "0123456789";
+ uint64_t i;
+ size_t blocklen;
+
+ ck_assert(conn != NULL);
+ ri = mg_get_request_info(conn);
+ ck_assert(ri != NULL);
+
+ ck_assert_str_eq(ri->request_method, "GET");
+ ck_assert_str_eq(ri->http_version, "1.1");
+ ck_assert_str_eq(ri->remote_addr, "127.0.0.1");
+ ck_assert_ptr_eq(ri->query_string, NULL);
+ ck_assert_ptr_ne(ri->local_uri, NULL);
+
+ mg_printf(conn,
+ "HTTP/1.1 200 OK\r\n"
+ "Content-Length: %lu\r\n"
+ "Connection: close\r\n\r\n",
+ len);
+
+ blocklen = strlen(block);
+
+ for (i = 0; i < len; i += blocklen) {
+ mg_write(conn, block, blocklen);
+ }
+
+ mark_point();
+
+ return 200;
+}
+
+
+START_TEST(test_large_file)
+{
+ /* Server var */
+ struct mg_context *ctx;
+ struct mg_callbacks callbacks;
+ const char *OPTIONS[32];
+ int opt_cnt = 0;
+#if !defined(NO_SSL)
+ const char *ssl_cert = locate_ssl_cert();
+#endif
+ char errmsg[256] = {0};
+
+ /* Client var */
+ struct mg_connection *client;
+ char client_err_buf[256];
+ char client_data_buf[256];
+ const struct mg_request_info *client_ri;
+ int64_t data_read;
+ int r;
+ int retry, retry_ok_cnt, retry_fail_cnt;
+
+ mark_point();
+
+/* Set options and start server */
+#if !defined(NO_FILES)
+ OPTIONS[opt_cnt++] = "document_root";
+ OPTIONS[opt_cnt++] = ".";
+#endif
+#if defined(NO_SSL)
+ OPTIONS[opt_cnt++] = "listening_ports";
+ OPTIONS[opt_cnt++] = "8080";
+#else
+ OPTIONS[opt_cnt++] = "listening_ports";
+ OPTIONS[opt_cnt++] = "8443s";
+ OPTIONS[opt_cnt++] = "ssl_certificate";
+ OPTIONS[opt_cnt++] = ssl_cert;
+#ifdef __MACH__
+ /* The Apple builds on Travis CI seem to have problems with TLS1.x
+ * Allow SSLv3 and TLS */
+ OPTIONS[opt_cnt++] = "ssl_protocol_version";
+ OPTIONS[opt_cnt++] = "2";
+#else
+ /* The Linux builds on Travis CI work fine with TLS1.2 */
+ OPTIONS[opt_cnt++] = "ssl_protocol_version";
+ OPTIONS[opt_cnt++] = "4";
+#endif
+ ck_assert(ssl_cert != NULL);
+#endif
+ OPTIONS[opt_cnt] = NULL;
+
+
+ memset(&callbacks, 0, sizeof(callbacks));
+ callbacks.begin_request = test_large_file_begin_request;
+ callbacks.log_message = log_msg_func;
+
+ ctx = test_mg_start(&callbacks, (void *)errmsg, OPTIONS);
+ ck_assert_str_eq(errmsg, "");
+ ck_assert(ctx != NULL);
+
+ /* Try downloading several times */
+ retry_ok_cnt = 0;
+ retry_fail_cnt = 0;
+ for (retry = 0; retry < 3; retry++) {
+ int fail = 0;
+ /* connect client */
+ memset(client_err_buf, 0, sizeof(client_err_buf));
+ memset(client_data_buf, 0, sizeof(client_data_buf));
+
+ client =
+ mg_download("127.0.0.1",
+#if defined(NO_SSL)
+ 8080,
+ 0,
+#else
+ 8443,
+ 1,
+#endif
+ client_err_buf,
+ sizeof(client_err_buf),
+ "GET /large.file HTTP/1.1\r\nHost: 127.0.0.1\r\n\r\n");
+
+ ck_assert(client != NULL);
+ ck_assert_str_eq(client_err_buf, "");
+
+ client_ri = mg_get_request_info(client);
+
+ ck_assert(client_ri != NULL);
+ ck_assert_str_eq(client_ri->local_uri, "200");
+
+ ck_assert_int_eq(client_ri->content_length, LARGE_FILE_SIZE);
+
+ data_read = 0;
+ while (data_read < client_ri->content_length) {
+ r = mg_read(client, client_data_buf, sizeof(client_data_buf));
+ if (r < 0) {
+ fail = 1;
+ break;
+ };
+ data_read += r;
+ }
+
+ /* Nothing left to read */
+ r = mg_read(client, client_data_buf, sizeof(client_data_buf));
+ if (fail) {
+ ck_assert_int_eq(r, -1);
+ retry_fail_cnt++;
+ } else {
+ ck_assert_int_eq(r, 0);
+ retry_ok_cnt++;
+ }
+
+ /* Close the client connection */
+ mg_close_connection(client);
+ }
+
+#if defined(_WIN32)
+// TODO: Check this problem on AppVeyor
+// ck_assert_int_le(retry_fail_cnt, 2);
+// ck_assert_int_ge(retry_ok_cnt, 1);
+#else
+ ck_assert_int_eq(retry_fail_cnt, 0);
+ ck_assert_int_eq(retry_ok_cnt, 3);
+#endif
+
+ /* Stop the server */
+ test_mg_stop(ctx);
+
+ mark_point();
+}
+END_TEST
+
+
+static int test_mg_store_body_con_len = 20000;
+
+
+static int
+test_mg_store_body_put_delete_handler(struct mg_connection *conn, void *ignored)
+{
+ char path[4096] = {0};
+ const struct mg_request_info *info = mg_get_request_info(conn);
+ int64_t rc;
+
+ (void)ignored;
+
+ mark_point();
+
+ sprintf(path, "./%s", info->local_uri);
+ rc = mg_store_body(conn, path);
+
+ ck_assert_int_eq(test_mg_store_body_con_len, rc);
+
+ if (rc < 0) {
+ mg_printf(conn,
+ "HTTP/1.1 500 Internal Server Error\r\n"
+ "Content-Type:text/plain;charset=UTF-8\r\n"
+ "Connection:close\r\n\r\n"
+ "%s (ret: %ld)\n",
+ path,
+ (long)rc);
+ mg_close_connection(conn);
+
+ /* Debug output for tests */
+ printf("mg_store_body(%s) failed (ret: %ld)\n", path, (long)rc);
+
+ return 500;
+ }
+
+ mg_printf(conn,
+ "HTTP/1.1 200 OK\r\n"
+ "Content-Type:text/plain;charset=UTF-8\r\n"
+ "Connection:close\r\n\r\n"
+ "%s OK (%ld bytes saved)\n",
+ path,
+ (long)rc);
+ mg_close_connection(conn);
+
+ /* Debug output for tests */
+ printf("mg_store_body(%s) OK (%ld bytes)\n", path, (long)rc);
+
+ mark_point();
+
+ return 200;
+}
+
+
+static int
+test_mg_store_body_begin_request_callback(struct mg_connection *conn)
+{
+ const struct mg_request_info *info = mg_get_request_info(conn);
+
+ mark_point();
+
+ /* Debug output for tests */
+ printf("test_mg_store_body_begin_request_callback called (%s)\n",
+ info->request_method);
+
+ if ((strcmp(info->request_method, "PUT") == 0)
+ || (strcmp(info->request_method, "DELETE") == 0)) {
+ return test_mg_store_body_put_delete_handler(conn, NULL);
+ }
+
+ mark_point();
+
+ return 0;
+}
+
+
+START_TEST(test_mg_store_body)
+{
+ /* Client data */
+ char client_err_buf[256];
+ char client_data_buf[1024];
+ struct mg_connection *client;
+ const struct mg_request_info *client_ri;
+ int r;
+ char check_data[256];
+ char *check_ptr;
+ char errmsg[256] = {0};
+
+ /* Server context handle */
+ struct mg_context *ctx;
+ struct mg_callbacks callbacks;
+ const char *options[] = {
+#if !defined(NO_FILES)
+ "document_root",
+ ".",
+#endif
+#if !defined(NO_CACHING)
+ "static_file_max_age",
+ "0",
+#endif
+ "listening_ports",
+ "127.0.0.1:8082",
+ "num_threads",
+ "1",
+ NULL
+ };
+
+ mark_point();
+
+ memset(&callbacks, 0, sizeof(callbacks));
+ callbacks.begin_request = test_mg_store_body_begin_request_callback;
+ callbacks.log_message = log_msg_func;
+
+ /* Initialize the library */
+ mg_init_library(0);
+
+ /* Start the server */
+ ctx = mg_start(&callbacks, (void *)errmsg, options);
+ ck_assert_str_eq(errmsg, "");
+ ck_assert(ctx != NULL);
+
+ /* Run the server for 15 seconds */
+ test_sleep(15);
+
+ /* Call a test client */
+ client = mg_connect_client(
+ "127.0.0.1", 8082, 0, client_err_buf, sizeof(client_err_buf));
+
+ ck_assert_str_eq(client_err_buf, "");
+ ck_assert(client != NULL);
+
+ mg_printf(client,
+ "PUT /%s HTTP/1.0\r\nContent-Length: %i\r\n\r\n",
+ "test_file_name.txt",
+ test_mg_store_body_con_len);
+
+ r = 0;
+ while (r < test_mg_store_body_con_len) {
+ int l = mg_write(client, "1234567890", 10);
+ ck_assert_int_eq(l, 10);
+ r += 10;
+ }
+
+ r = mg_get_response(client, client_err_buf, sizeof(client_err_buf), 10000);
+ ck_assert_int_ge(r, 0);
+ ck_assert_str_eq(client_err_buf, "");
+
+ client_ri = mg_get_request_info(client);
+ ck_assert(client_ri != NULL);
+
+ /* Response must be 200 OK */
+ ck_assert_ptr_ne(client_ri->request_uri, NULL);
+ ck_assert_str_eq(client_ri->request_uri, "200");
+
+ /* Read PUT response */
+ r = mg_read(client, client_data_buf, sizeof(client_data_buf) - 1);
+ ck_assert_int_gt(r, 0);
+ client_data_buf[r] = 0;
+
+ sprintf(check_data, "(%i bytes saved)", test_mg_store_body_con_len);
+ check_ptr = strstr(client_data_buf, check_data);
+ ck_assert_ptr_ne(check_ptr, NULL);
+
+ mg_close_connection(client);
+
+ /* Run the server for 5 seconds */
+ test_sleep(5);
+
+ /* Stop the server */
+ test_mg_stop(ctx);
+
+ /* Un-initialize the library */
+ mg_exit_library();
+
+ mark_point();
+}
+END_TEST
+
+
+#if defined(MG_USE_OPEN_FILE) && !defined(NO_FILES)
+
+#define FILE_IN_MEM_SIZE (1024 * 100)
+static char *file_in_mem_data;
+
+static const char *
+test_file_in_memory_open_file(const struct mg_connection *conn,
+ const char *file_path,
+ size_t *file_size)
+{
+ (void)conn;
+
+ if (strcmp(file_path, "./file_in_mem") == 0) {
+ /* File is in memory */
+ *file_size = FILE_IN_MEM_SIZE;
+ return file_in_mem_data;
+ } else {
+ /* File is not in memory */
+ return NULL;
+ }
+}
+
+
+START_TEST(test_file_in_memory)
+{
+ /* Server var */
+ struct mg_context *ctx;
+ struct mg_callbacks callbacks;
+ const char *OPTIONS[32];
+ int opt_cnt = 0;
+#if !defined(NO_SSL)
+ const char *ssl_cert = locate_ssl_cert();
+#endif
+
+ /* Client var */
+ struct mg_connection *client;
+ char client_err_buf[256];
+ char client_data_buf[256];
+ const struct mg_request_info *client_ri;
+ int64_t data_read;
+ int r, i;
+
+ /* Prepare test data */
+ file_in_mem_data = (char *)malloc(FILE_IN_MEM_SIZE);
+ ck_assert_ptr_ne(file_in_mem_data, NULL);
+ for (r = 0; r < FILE_IN_MEM_SIZE; r++) {
+ file_in_mem_data[r] = (char)(r);
+ }
+
+ /* Set options and start server */
+ OPTIONS[opt_cnt++] = "document_root";
+ OPTIONS[opt_cnt++] = ".";
+#if defined(NO_SSL)
+ OPTIONS[opt_cnt++] = "listening_ports";
+ OPTIONS[opt_cnt++] = "8080";
+#else
+ OPTIONS[opt_cnt++] = "listening_ports";
+ OPTIONS[opt_cnt++] = "8443s";
+ OPTIONS[opt_cnt++] = "ssl_certificate";
+ OPTIONS[opt_cnt++] = ssl_cert;
+ ck_assert(ssl_cert != NULL);
+#endif
+ OPTIONS[opt_cnt] = NULL;
+
+
+ memset(&callbacks, 0, sizeof(callbacks));
+ callbacks.open_file = test_file_in_memory_open_file;
+
+ ctx = test_mg_start(&callbacks, 0, OPTIONS);
+ ck_assert(ctx != NULL);
+
+ /* connect client */
+ memset(client_err_buf, 0, sizeof(client_err_buf));
+ memset(client_data_buf, 0, sizeof(client_data_buf));
+
+ client =
+ mg_download("127.0.0.1",
+#if defined(NO_SSL)
+ 8080,
+ 0,
+#else
+ 8443,
+ 1,
+#endif
+ client_err_buf,
+ sizeof(client_err_buf),
+ "GET /file_in_mem HTTP/1.1\r\nHost: 127.0.0.1\r\n\r\n");
+
+ ck_assert(client != NULL);
+ ck_assert_str_eq(client_err_buf, "");
+
+ client_ri = mg_get_request_info(client);
+
+ ck_assert(client_ri != NULL);
+ ck_assert_str_eq(client_ri->local_uri, "200");
+
+ ck_assert_int_eq(client_ri->content_length, FILE_IN_MEM_SIZE);
+
+ data_read = 0;
+ while (data_read < client_ri->content_length) {
+ r = mg_read(client, client_data_buf, sizeof(client_data_buf));
+ if (r > 0) {
+ for (i = 0; i < r; i++) {
+ ck_assert_int_eq((int)client_data_buf[i],
+ (int)file_in_mem_data[data_read + i]);
+ }
+ data_read += r;
+ }
+ }
+
+ /* Nothing left to read */
+ r = mg_read(client, client_data_buf, sizeof(client_data_buf));
+ ck_assert_int_eq(r, 0);
+
+ /* Close the client connection */
+ mg_close_connection(client);
+
+ /* Stop the server */
+ test_mg_stop(ctx);
+
+ /* Free test data */
+ free(file_in_mem_data);
+ file_in_mem_data = NULL;
+}
+END_TEST
+
+#else /* defined(MG_USE_OPEN_FILE) */
+
+START_TEST(test_file_in_memory)
+{
+ mark_point();
+}
+END_TEST
+
+#endif
+
+
+static void
+minimal_http_https_client_impl(const char *server,
+ uint16_t port,
+ int use_ssl,
+ const char *uri)
+{
+ /* Client var */
+ struct mg_connection *client;
+ char client_err_buf[256];
+ char client_data_buf[256];
+ const struct mg_request_info *client_ri;
+ int64_t data_read;
+ int r;
+
+ mark_point();
+
+ client = mg_connect_client(
+ server, port, use_ssl, client_err_buf, sizeof(client_err_buf));
+
+ ck_assert_str_eq(client_err_buf, "");
+ ck_assert(client != NULL);
+
+ mg_printf(client, "GET /%s HTTP/1.0\r\n\r\n", uri);
+
+ r = mg_get_response(client, client_err_buf, sizeof(client_err_buf), 10000);
+ ck_assert_int_ge(r, 0);
+ ck_assert_str_eq(client_err_buf, "");
+
+ client_ri = mg_get_request_info(client);
+ ck_assert(client_ri != NULL);
+
+ /* e.g.: ck_assert_str_eq(client_ri->request_uri, "200"); */
+ ck_assert_ptr_ne(client_ri->request_uri, NULL);
+ r = (int)strlen(client_ri->request_uri);
+ ck_assert_int_eq(r, 3);
+
+ data_read = 0;
+ while (data_read < client_ri->content_length) {
+ r = mg_read(client, client_data_buf, sizeof(client_data_buf));
+ if (r > 0) {
+ data_read += r;
+ }
+ }
+
+ /* Nothing left to read */
+ r = mg_read(client, client_data_buf, sizeof(client_data_buf));
+ ck_assert_int_eq(r, 0);
+
+ mark_point();
+
+ mg_close_connection(client);
+
+ mark_point();
+}
+
+
+static void
+minimal_http_client_impl(const char *server, uint16_t port, const char *uri)
+{
+ minimal_http_https_client_impl(server, port, 0, uri);
+}
+
+
+#if !defined(NO_SSL)
+static void
+minimal_https_client_impl(const char *server, uint16_t port, const char *uri)
+{
+ minimal_http_https_client_impl(server, port, 1, uri);
+}
+#endif
+
+
+START_TEST(test_minimal_client)
+{
+ mark_point();
+
+ /* Initialize the library */
+ mg_init_library(0);
+
+ mark_point();
+
+ /* Call a test client */
+ minimal_http_client_impl("192.30.253.113" /* www.github.com */,
+ 80,
+ "civetweb/civetweb/");
+
+ mark_point();
+
+ /* Un-initialize the library */
+ mg_exit_library();
+
+ mark_point();
+}
+END_TEST
+
+
+static int
+minimal_test_request_handler(struct mg_connection *conn, void *cbdata)
+{
+ const char *msg = (const char *)cbdata;
+ unsigned long len = (unsigned long)strlen(msg);
+
+ mark_point();
+
+ mg_printf(conn,
+ "HTTP/1.1 200 OK\r\n"
+ "Content-Length: %lu\r\n"
+ "Content-Type: text/plain\r\n"
+ "Connection: close\r\n\r\n",
+ len);
+
+ mg_write(conn, msg, len);
+
+ mark_point();
+
+ return 200;
+}
+
+
+START_TEST(test_minimal_http_server_callback)
+{
+ /* This test should ensure the minimum server example in
+ * docs/Embedding.md is still running. */
+
+ /* Server context handle */
+ struct mg_context *ctx;
+
+ mark_point();
+
+ /* Initialize the library */
+ mg_init_library(0);
+
+ /* Start the server */
+ ctx = test_mg_start(NULL, 0, NULL);
+ ck_assert(ctx != NULL);
+
+ /* Add some handler */
+ mg_set_request_handler(ctx,
+ "/hello",
+ minimal_test_request_handler,
+ (void *)"Hello world");
+ mg_set_request_handler(ctx,
+ "/8",
+ minimal_test_request_handler,
+ (void *)"Number eight");
+
+ /* Run the server for 15 seconds */
+ test_sleep(10);
+
+ /* Call a test client */
+ minimal_http_client_impl("127.0.0.1", 8080, "/hello");
+
+ /* Run the server for 15 seconds */
+ test_sleep(5);
+
+
+ /* Stop the server */
+ test_mg_stop(ctx);
+
+ /* Un-initialize the library */
+ mg_exit_library();
+
+ mark_point();
+}
+END_TEST
+
+
+START_TEST(test_minimal_https_server_callback)
+{
+#if !defined(NO_SSL)
+ /* This test should show a HTTPS server with enhanced
+ * security settings.
+ *
+ * Articles:
+ * https://hynek.me/articles/hardening-your-web-servers-ssl-ciphers/
+ *
+ * Scanners:
+ * https://securityheaders.io/
+ * https://www.htbridge.com/ssl/
+ * https://www.htbridge.com/websec/
+ * https://www.ssllabs.com/ssltest/
+ * https://www.qualys.com/forms/freescan/
+ */
+
+ /* Server context handle */
+ struct mg_context *ctx;
+
+ /* Server start parameters for HTTPS */
+ const char *OPTIONS[32];
+ int opt_idx = 0;
+
+ /* HTTPS port - required */
+ OPTIONS[opt_idx++] = "listening_ports";
+ OPTIONS[opt_idx++] = "8443s";
+
+ /* path to certificate file - required */
+ OPTIONS[opt_idx++] = "ssl_certificate";
+ OPTIONS[opt_idx++] = locate_ssl_cert();
+
+#if defined(LOCAL_TEST) || defined(_WIN32)
+ /* Do not set this on Travis CI, since the build containers
+ * contain older SSL libraries */
+
+ /* set minimum SSL version to TLS 1.2 - recommended */
+ OPTIONS[opt_idx++] = "ssl_protocol_version";
+ OPTIONS[opt_idx++] = "4";
+
+ /* set some modern ciphers - recommended */
+ OPTIONS[opt_idx++] = "ssl_cipher_list";
+ OPTIONS[opt_idx++] = "ECDH+AESGCM+AES256:!aNULL:!MD5:!DSS";
+#endif
+
+ /* set "HTTPS only" header - recommended */
+ OPTIONS[opt_idx++] = "strict_transport_security_max_age";
+ OPTIONS[opt_idx++] = "31622400";
+
+ /* end of options - required */
+ OPTIONS[opt_idx] = NULL;
+
+ mark_point();
+
+ /* Initialize the library */
+ mg_init_library(0);
+
+
+ /* Start the server */
+ ctx = test_mg_start(NULL, 0, OPTIONS);
+ ck_assert(ctx != NULL);
+
+ /* Add some handler */
+ mg_set_request_handler(ctx,
+ "/hello",
+ minimal_test_request_handler,
+ (void *)"Hello world");
+ mg_set_request_handler(ctx,
+ "/8",
+ minimal_test_request_handler,
+ (void *)"Number eight");
+
+ /* Run the server for 15 seconds */
+ test_sleep(10);
+
+ /* Call a test client */
+ minimal_https_client_impl("127.0.0.1", 8443, "/hello");
+
+ /* Run the server for 15 seconds */
+ test_sleep(5);
+
+
+ /* Stop the server */
+ test_mg_stop(ctx);
+
+ /* Un-initialize the library */
+ mg_exit_library();
+#endif
+ mark_point();
+}
+END_TEST
+
+
+#if !defined(REPLACE_CHECK_FOR_LOCAL_DEBUGGING)
+Suite *
+make_public_server_suite(void)
+{
+ Suite *const suite = suite_create("PublicServer");
+
+ TCase *const tcase_checktestenv = tcase_create("Check test environment");
+ TCase *const tcase_initlib = tcase_create("Init library");
+ TCase *const tcase_startthreads = tcase_create("Start threads");
+ TCase *const tcase_minimal_svr = tcase_create("Minimal Server");
+ TCase *const tcase_minimal_cli = tcase_create("Minimal Client");
+ TCase *const tcase_startstophttp = tcase_create("Start Stop HTTP Server");
+ TCase *const tcase_startstophttp_ipv6 =
+ tcase_create("Start Stop HTTP Server IPv6");
+ TCase *const tcase_startstophttps = tcase_create("Start Stop HTTPS Server");
+ TCase *const tcase_serverandclienttls = tcase_create("TLS Server Client");
+ TCase *const tcase_serverrequests = tcase_create("Server Requests");
+ TCase *const tcase_storebody = tcase_create("Store Body");
+ TCase *const tcase_handle_form = tcase_create("Handle Form");
+ TCase *const tcase_http_auth = tcase_create("HTTP Authentication");
+ TCase *const tcase_keep_alive = tcase_create("HTTP Keep Alive");
+ TCase *const tcase_error_handling = tcase_create("Error handling");
+ TCase *const tcase_throttle = tcase_create("Limit speed");
+ TCase *const tcase_large_file = tcase_create("Large file");
+ TCase *const tcase_file_in_mem = tcase_create("File in memory");
+
+
+ tcase_add_test(tcase_checktestenv, test_the_test_environment);
+ tcase_set_timeout(tcase_checktestenv, civetweb_min_test_timeout);
+ suite_add_tcase(suite, tcase_checktestenv);
+
+ tcase_add_test(tcase_initlib, test_init_library);
+ tcase_set_timeout(tcase_initlib, civetweb_min_test_timeout);
+ suite_add_tcase(suite, tcase_initlib);
+
+ tcase_add_test(tcase_startthreads, test_threading);
+ tcase_set_timeout(tcase_startthreads, civetweb_min_test_timeout);
+ suite_add_tcase(suite, tcase_startthreads);
+
+ tcase_add_test(tcase_minimal_svr, test_minimal_http_server_callback);
+ tcase_add_test(tcase_minimal_svr, test_minimal_https_server_callback);
+ tcase_set_timeout(tcase_minimal_svr, civetweb_min_server_test_timeout);
+ suite_add_tcase(suite, tcase_minimal_svr);
+
+ tcase_add_test(tcase_minimal_cli, test_minimal_client);
+ tcase_set_timeout(tcase_minimal_cli, civetweb_min_server_test_timeout);
+ suite_add_tcase(suite, tcase_minimal_cli);
+
+ tcase_add_test(tcase_startstophttp, test_mg_start_stop_http_server);
+ tcase_set_timeout(tcase_startstophttp, civetweb_min_server_test_timeout);
+ suite_add_tcase(suite, tcase_startstophttp);
+
+ tcase_add_test(tcase_startstophttp_ipv6,
+ test_mg_start_stop_http_server_ipv6);
+ tcase_set_timeout(tcase_startstophttp_ipv6,
+ civetweb_min_server_test_timeout);
+ suite_add_tcase(suite, tcase_startstophttp_ipv6);
+
+ tcase_add_test(tcase_startstophttps, test_mg_start_stop_https_server);
+ tcase_set_timeout(tcase_startstophttps, civetweb_min_server_test_timeout);
+ suite_add_tcase(suite, tcase_startstophttps);
+
+ tcase_add_test(tcase_serverandclienttls, test_mg_server_and_client_tls);
+ tcase_set_timeout(tcase_serverandclienttls,
+ civetweb_min_server_test_timeout);
+ suite_add_tcase(suite, tcase_serverandclienttls);
+
+ tcase_add_test(tcase_serverrequests, test_request_handlers);
+ tcase_set_timeout(tcase_serverrequests, civetweb_mid_server_test_timeout);
+ suite_add_tcase(suite, tcase_serverrequests);
+
+ tcase_add_test(tcase_storebody, test_mg_store_body);
+ tcase_set_timeout(tcase_storebody, civetweb_mid_server_test_timeout);
+ suite_add_tcase(suite, tcase_storebody);
+
+ tcase_add_test(tcase_handle_form, test_handle_form);
+ tcase_set_timeout(tcase_handle_form, civetweb_mid_server_test_timeout);
+ suite_add_tcase(suite, tcase_handle_form);
+
+ tcase_add_test(tcase_http_auth, test_http_auth);
+ tcase_set_timeout(tcase_http_auth, civetweb_min_server_test_timeout);
+ suite_add_tcase(suite, tcase_http_auth);
+
+ tcase_add_test(tcase_keep_alive, test_keep_alive);
+ tcase_set_timeout(tcase_keep_alive, civetweb_mid_server_test_timeout);
+ suite_add_tcase(suite, tcase_keep_alive);
+
+ tcase_add_test(tcase_error_handling, test_error_handling);
+ tcase_add_test(tcase_error_handling, test_error_log_file);
+ tcase_set_timeout(tcase_error_handling, civetweb_mid_server_test_timeout);
+ suite_add_tcase(suite, tcase_error_handling);
+
+ tcase_add_test(tcase_throttle, test_throttle);
+ tcase_set_timeout(tcase_throttle, civetweb_mid_server_test_timeout);
+ suite_add_tcase(suite, tcase_throttle);
+
+ tcase_add_test(tcase_large_file, test_large_file);
+ tcase_set_timeout(tcase_large_file, civetweb_mid_server_test_timeout);
+ suite_add_tcase(suite, tcase_large_file);
+
+ tcase_add_test(tcase_file_in_mem, test_file_in_memory);
+ tcase_set_timeout(tcase_file_in_mem, civetweb_mid_server_test_timeout);
+ suite_add_tcase(suite, tcase_file_in_mem);
+
+ return suite;
+}
+#endif
+
+
+#ifdef REPLACE_CHECK_FOR_LOCAL_DEBUGGING
+/* Used to debug test cases without using the check framework */
+/* Build command for Linux:
+gcc test/public_server.c src/civetweb.c -I include/ -I test/ -l pthread -l dl -D
+LOCAL_TEST -D REPLACE_CHECK_FOR_LOCAL_DEBUGGING -D MAIN_PUBLIC_SERVER=main
+*/
+
+static int chk_ok = 0;
+static int chk_failed = 0;
+
+
+void
+MAIN_PUBLIC_SERVER(void)
+{
+ unsigned f_avail = mg_check_feature(0xFF);
+ unsigned f_ret = mg_init_library(f_avail);
+ ck_assert_uint_eq(f_ret, f_avail);
+
+ test_the_test_environment(0);
+ test_threading(0);
+
+ test_minimal_client(0);
+
+ test_mg_start_stop_http_server(0);
+ test_mg_start_stop_https_server(0);
+ test_request_handlers(0);
+ test_mg_store_body(0);
+ test_mg_server_and_client_tls(0);
+ test_handle_form(0);
+ test_http_auth(0);
+ test_keep_alive(0);
+ test_error_handling(0);
+ test_error_log_file(0);
+ test_throttle(0);
+ test_large_file(0);
+ test_file_in_memory(0);
+
+ mg_exit_library();
+
+ printf("\nok: %i\nfailed: %i\n\n", chk_ok, chk_failed);
+}
+
+void
+_ck_assert_failed(const char *file, int line, const char *expr, ...)
+{
+ va_list va;
+ va_start(va, expr);
+ fprintf(stderr, "Error: %s, line %i\n", file, line); /* breakpoint here ! */
+ vfprintf(stderr, expr, va);
+ fprintf(stderr, "\n\n");
+ va_end(va);
+ chk_failed++;
+}
+
+void
+_ck_assert_msg(int cond, const char *file, int line, const char *expr, ...)
+{
+ va_list va;
+
+ if (cond) {
+ chk_ok++;
+ return;
+ }
+
+ va_start(va, expr);
+ fprintf(stderr, "Error: %s, line %i\n", file, line); /* breakpoint here ! */
+ vfprintf(stderr, expr, va);
+ fprintf(stderr, "\n\n");
+ va_end(va);
+ chk_failed++;
+}
+
+void
+_mark_point(const char *file, int line)
+{
+ chk_ok++;
+}
+
+void
+tcase_fn_start(const char *fname, const char *file, int line)
+{
+}
+void suite_add_tcase(Suite *s, TCase *tc){};
+void _tcase_add_test(TCase *tc,
+ TFun tf,
+ const char *fname,
+ int _signal,
+ int allowed_exit_value,
+ int start,
+ int end){};
+TCase *
+tcase_create(const char *name)
+{
+ return NULL;
+};
+Suite *
+suite_create(const char *name)
+{
+ return NULL;
+};
+void tcase_set_timeout(TCase *tc, double timeout){};
+
+#endif