From 19fcec84d8d7d21e796c7624e521b60d28ee21ed Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 20:45:59 +0200 Subject: Adding upstream version 16.2.11+ds. Signed-off-by: Daniel Baumann --- src/civetweb/test/public_func.c | 546 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 546 insertions(+) create mode 100644 src/civetweb/test/public_func.c (limited to 'src/civetweb/test/public_func.c') diff --git a/src/civetweb/test/public_func.c b/src/civetweb/test/public_func.c new file mode 100644 index 000000000..deb3dd5a5 --- /dev/null +++ b/src/civetweb/test/public_func.c @@ -0,0 +1,546 @@ +/* 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 +#include + +#include "public_func.h" +#include + +/* 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 + */ + +START_TEST(test_mg_version) +{ + const char *ver = mg_version(); + unsigned major = 0, minor = 0; + unsigned feature_files, feature_https, feature_cgi, feature_ipv6, + feature_websocket, feature_lua, feature_duktape, feature_caching; + unsigned expect_files = 0, expect_https = 0, expect_cgi = 0, + expect_ipv6 = 0, expect_websocket = 0, expect_lua = 0, + expect_duktape = 0, expect_caching = 0; + int ret, len; + char *buf; + + ck_assert(ver != NULL); + ck_assert_str_eq(ver, CIVETWEB_VERSION); + + /* check structure of version string */ + ret = sscanf(ver, "%u.%u", &major, &minor); + ck_assert_int_eq(ret, 2); + ck_assert_uint_ge(major, 1); + if (major == 1) { + ck_assert_uint_ge(minor, 8); /* current version is 1.8 */ + } + + /* check feature */ + feature_files = mg_check_feature(1); + feature_https = mg_check_feature(2); + feature_cgi = mg_check_feature(4); + feature_ipv6 = mg_check_feature(8); + feature_websocket = mg_check_feature(16); + feature_lua = mg_check_feature(32); + feature_duktape = mg_check_feature(64); + feature_caching = mg_check_feature(128); + +#if !defined(NO_FILES) + expect_files = 1; +#endif +#if !defined(NO_SSL) + expect_https = 1; +#endif +#if !defined(NO_CGI) + expect_cgi = 1; +#endif +#if defined(USE_IPV6) + expect_ipv6 = 1; +#endif +#if defined(USE_WEBSOCKET) + expect_websocket = 1; +#endif +#if defined(USE_LUA) + expect_lua = 1; +#endif +#if defined(USE_DUKTAPE) + expect_duktape = 1; +#endif +#if !defined(NO_CACHING) + expect_caching = 1; +#endif + + ck_assert_uint_eq(expect_files, !!feature_files); + ck_assert_uint_eq(expect_https, !!feature_https); + ck_assert_uint_eq(expect_cgi, !!feature_cgi); + ck_assert_uint_eq(expect_ipv6, !!feature_ipv6); + ck_assert_uint_eq(expect_websocket, !!feature_websocket); + ck_assert_uint_eq(expect_lua, !!feature_lua); + ck_assert_uint_eq(expect_duktape, !!feature_duktape); + ck_assert_uint_eq(expect_caching, !!feature_caching); + + /* get system information */ + len = mg_get_system_info(NULL, 0); + ck_assert_int_gt(len, 0); + buf = (char *)malloc((unsigned)len + 1); + ck_assert_ptr_ne(buf, NULL); + ret = mg_get_system_info(buf, len + 1); + ck_assert_int_eq(len, ret); + ret = (int)strlen(buf); + ck_assert_int_eq(len, ret); + free(buf); +} +END_TEST + + +START_TEST(test_mg_get_valid_options) +{ + int i; + const struct mg_option *default_options = mg_get_valid_options(); + + ck_assert(default_options != NULL); + + for (i = 0; default_options[i].name != NULL; i++) { + ck_assert(default_options[i].name != NULL); + ck_assert(strlen(default_options[i].name) > 0); + ck_assert(((int)default_options[i].type) > 0); + } + + ck_assert(i > 0); +} +END_TEST + + +START_TEST(test_mg_get_builtin_mime_type) +{ + ck_assert_str_eq(mg_get_builtin_mime_type("x.txt"), "text/plain"); + ck_assert_str_eq(mg_get_builtin_mime_type("x.html"), "text/html"); + ck_assert_str_eq(mg_get_builtin_mime_type("x.HTML"), "text/html"); + ck_assert_str_eq(mg_get_builtin_mime_type("x.hTmL"), "text/html"); + ck_assert_str_eq(mg_get_builtin_mime_type("/abc/def/ghi.htm"), "text/html"); + ck_assert_str_eq(mg_get_builtin_mime_type("x.unknown_extention_xyz"), + "text/plain"); +} +END_TEST + + +START_TEST(test_mg_strncasecmp) +{ + ck_assert(mg_strncasecmp("abc", "abc", 3) == 0); + ck_assert(mg_strncasecmp("abc", "abcd", 3) == 0); + ck_assert(mg_strncasecmp("abc", "abcd", 4) != 0); + ck_assert(mg_strncasecmp("a", "A", 1) == 0); + + ck_assert(mg_strncasecmp("A", "B", 1) < 0); + ck_assert(mg_strncasecmp("A", "b", 1) < 0); + ck_assert(mg_strncasecmp("a", "B", 1) < 0); + ck_assert(mg_strncasecmp("a", "b", 1) < 0); + ck_assert(mg_strncasecmp("b", "A", 1) > 0); + ck_assert(mg_strncasecmp("B", "A", 1) > 0); + ck_assert(mg_strncasecmp("b", "a", 1) > 0); + ck_assert(mg_strncasecmp("B", "a", 1) > 0); + + ck_assert(mg_strncasecmp("xAx", "xBx", 3) < 0); + ck_assert(mg_strncasecmp("xAx", "xbx", 3) < 0); + ck_assert(mg_strncasecmp("xax", "xBx", 3) < 0); + ck_assert(mg_strncasecmp("xax", "xbx", 3) < 0); + ck_assert(mg_strncasecmp("xbx", "xAx", 3) > 0); + ck_assert(mg_strncasecmp("xBx", "xAx", 3) > 0); + ck_assert(mg_strncasecmp("xbx", "xax", 3) > 0); + ck_assert(mg_strncasecmp("xBx", "xax", 3) > 0); +} +END_TEST + + +START_TEST(test_mg_get_cookie) +{ + char buf[32]; + int ret; + const char *longcookie = "key1=1; key2=2; key3; key4=4; key5=; key6; " + "key7=this+is+it; key8=8; key9"; + + /* invalid result buffer */ + ret = mg_get_cookie("", "notfound", NULL, 999); + ck_assert_int_eq(ret, -2); + + /* zero size result buffer */ + ret = mg_get_cookie("", "notfound", buf, 0); + ck_assert_int_eq(ret, -2); + + /* too small result buffer */ + ret = mg_get_cookie("key=toooooooooolong", "key", buf, 4); + ck_assert_int_eq(ret, -3); + + /* key not found in string */ + ret = mg_get_cookie("", "notfound", buf, sizeof(buf)); + ck_assert_int_eq(ret, -1); + + ret = mg_get_cookie(longcookie, "notfound", buf, sizeof(buf)); + ck_assert_int_eq(ret, -1); + + /* key not found in string */ + ret = mg_get_cookie("key1=1; key2=2; key3=3", "notfound", buf, sizeof(buf)); + ck_assert_int_eq(ret, -1); + + /* keys are found as first, middle and last key */ + memset(buf, 77, sizeof(buf)); + ret = mg_get_cookie("key1=1; key2=2; key3=3", "key1", buf, sizeof(buf)); + ck_assert_int_eq(ret, 1); + ck_assert_str_eq("1", buf); + + memset(buf, 77, sizeof(buf)); + ret = mg_get_cookie("key1=1; key2=2; key3=3", "key2", buf, sizeof(buf)); + ck_assert_int_eq(ret, 1); + ck_assert_str_eq("2", buf); + + memset(buf, 77, sizeof(buf)); + ret = mg_get_cookie("key1=1; key2=2; key3=3", "key3", buf, sizeof(buf)); + ck_assert_int_eq(ret, 1); + ck_assert_str_eq("3", buf); + + /* longer value in the middle of a longer string */ + memset(buf, 77, sizeof(buf)); + ret = mg_get_cookie(longcookie, "key7", buf, sizeof(buf)); + ck_assert_int_eq(ret, 10); + ck_assert_str_eq("this+is+it", buf); + + /* key with = but without value in the middle of a longer string */ + memset(buf, 77, sizeof(buf)); + ret = mg_get_cookie(longcookie, "key5", buf, sizeof(buf)); + ck_assert_int_eq(ret, 0); + ck_assert_str_eq("", buf); + + /* key without = and without value in the middle of a longer string */ + memset(buf, 77, sizeof(buf)); + ret = mg_get_cookie(longcookie, "key6", buf, sizeof(buf)); + ck_assert_int_eq(ret, -1); + /* TODO: mg_get_cookie and mg_get_var(2) should have the same behavior */ +} +END_TEST + + +START_TEST(test_mg_get_var) +{ + char buf[32]; + int ret; + const char *shortquery = "key1=1&key2=2&key3=3"; + const char *longquery = "key1=1&key2=2&key3&key4=4&key5=&key6&" + "key7=this+is+it&key8=8&key9&&key10=&&" + "key7=that+is+it&key12=12"; + + /* invalid result buffer */ + ret = mg_get_var2("", 0, "notfound", NULL, 999, 0); + ck_assert_int_eq(ret, -2); + + /* zero size result buffer */ + ret = mg_get_var2("", 0, "notfound", buf, 0, 0); + ck_assert_int_eq(ret, -2); + + /* too small result buffer */ + ret = mg_get_var2("key=toooooooooolong", 19, "key", buf, 4, 0); + /* ck_assert_int_eq(ret, -3); + --> TODO: mg_get_cookie returns -3, mg_get_var -2. This should be + unified. */ + ck_assert(ret < 0); + + /* key not found in string */ + ret = mg_get_var2("", 0, "notfound", buf, sizeof(buf), 0); + ck_assert_int_eq(ret, -1); + + ret = mg_get_var2( + longquery, strlen(longquery), "notfound", buf, sizeof(buf), 0); + ck_assert_int_eq(ret, -1); + + /* key not found in string */ + ret = mg_get_var2( + shortquery, strlen(shortquery), "notfound", buf, sizeof(buf), 0); + ck_assert_int_eq(ret, -1); + + /* key not found in string */ + ret = mg_get_var2("key1=1&key2=2&key3=3¬found=here", + strlen(shortquery), + "notfound", + buf, + sizeof(buf), + 0); + ck_assert_int_eq(ret, -1); + + /* key not found in string */ + ret = mg_get_var2( + shortquery, strlen(shortquery), "key1", buf, sizeof(buf), 1); + ck_assert_int_eq(ret, -1); + + /* keys are found as first, middle and last key */ + memset(buf, 77, sizeof(buf)); + ret = mg_get_var2( + shortquery, strlen(shortquery), "key1", buf, sizeof(buf), 0); + ck_assert_int_eq(ret, 1); + ck_assert_str_eq("1", buf); + + memset(buf, 77, sizeof(buf)); + ret = mg_get_var2( + shortquery, strlen(shortquery), "key2", buf, sizeof(buf), 0); + ck_assert_int_eq(ret, 1); + ck_assert_str_eq("2", buf); + + memset(buf, 77, sizeof(buf)); + ret = mg_get_var2( + shortquery, strlen(shortquery), "key3", buf, sizeof(buf), 0); + ck_assert_int_eq(ret, 1); + ck_assert_str_eq("3", buf); + + /* mg_get_var call mg_get_var2 with last argument 0 */ + memset(buf, 77, sizeof(buf)); + ret = mg_get_var(shortquery, strlen(shortquery), "key1", buf, sizeof(buf)); + ck_assert_int_eq(ret, 1); + ck_assert_str_eq("1", buf); + + /* longer value in the middle of a longer string */ + memset(buf, 77, sizeof(buf)); + ret = + mg_get_var2(longquery, strlen(longquery), "key7", buf, sizeof(buf), 0); + ck_assert_int_eq(ret, 10); + ck_assert_str_eq("this is it", buf); + + /* longer value in the middle of a longer string - seccond occurance of key + */ + memset(buf, 77, sizeof(buf)); + ret = + mg_get_var2(longquery, strlen(longquery), "key7", buf, sizeof(buf), 1); + ck_assert_int_eq(ret, 10); + ck_assert_str_eq("that is it", buf); + + /* key with = but without value in the middle of a longer string */ + memset(buf, 77, sizeof(buf)); + ret = + mg_get_var2(longquery, strlen(longquery), "key5", buf, sizeof(buf), 0); + ck_assert_int_eq(ret, 0); + ck_assert_str_eq(buf, ""); + + /* key without = and without value in the middle of a longer string */ + memset(buf, 77, sizeof(buf)); + ret = + mg_get_var2(longquery, strlen(longquery), "key6", buf, sizeof(buf), 0); + ck_assert_int_eq(ret, -1); + ck_assert_str_eq(buf, ""); + /* TODO: this is the same situation as with mg_get_value */ +} +END_TEST + + +START_TEST(test_mg_md5) +{ + char buf[33]; + char *ret; + const char *long_str = + "_123456789A123456789B123456789C123456789D123456789E123456789F123456789" + "G123456789H123456789I123456789J123456789K123456789L123456789M123456789" + "N123456789O123456789P123456789Q123456789R123456789S123456789T123456789" + "U123456789V123456789W123456789X123456789Y123456789Z"; + + memset(buf, 77, sizeof(buf)); + ret = mg_md5(buf, NULL); + ck_assert_str_eq(buf, "d41d8cd98f00b204e9800998ecf8427e"); + ck_assert_str_eq(ret, "d41d8cd98f00b204e9800998ecf8427e"); + ck_assert_ptr_eq(ret, buf); + + memset(buf, 77, sizeof(buf)); + ret = mg_md5(buf, "The quick brown fox jumps over the lazy dog.", NULL); + ck_assert_str_eq(buf, "e4d909c290d0fb1ca068ffaddf22cbd0"); + ck_assert_str_eq(ret, "e4d909c290d0fb1ca068ffaddf22cbd0"); + ck_assert_ptr_eq(ret, buf); + + memset(buf, 77, sizeof(buf)); + ret = mg_md5(buf, + "", + "The qu", + "ick bro", + "", + "wn fox ju", + "m", + "ps over the la", + "", + "", + "zy dog.", + "", + NULL); + ck_assert_str_eq(buf, "e4d909c290d0fb1ca068ffaddf22cbd0"); + ck_assert_str_eq(ret, "e4d909c290d0fb1ca068ffaddf22cbd0"); + ck_assert_ptr_eq(ret, buf); + + memset(buf, 77, sizeof(buf)); + ret = mg_md5(buf, long_str, NULL); + ck_assert_str_eq(buf, "1cb13cf9f16427807f081b2138241f08"); + ck_assert_str_eq(ret, "1cb13cf9f16427807f081b2138241f08"); + ck_assert_ptr_eq(ret, buf); + + memset(buf, 77, sizeof(buf)); + ret = mg_md5(buf, long_str + 1, NULL); + ck_assert_str_eq(buf, "cf62d3264334154f5779d3694cc5093f"); + ck_assert_str_eq(ret, "cf62d3264334154f5779d3694cc5093f"); + ck_assert_ptr_eq(ret, buf); +} +END_TEST + + +START_TEST(test_mg_url_encode) +{ + char buf[20]; + int ret; + + memset(buf, 77, sizeof(buf)); + ret = mg_url_encode("abc", buf, sizeof(buf)); + ck_assert_int_eq(3, ret); + ck_assert_str_eq("abc", buf); + + memset(buf, 77, sizeof(buf)); + ret = mg_url_encode("a%b/c&d.e", buf, sizeof(buf)); + ck_assert_int_eq(15, ret); + ck_assert_str_eq("a%25b%2fc%26d.e", buf); + + memset(buf, 77, sizeof(buf)); + ret = mg_url_encode("%%%", buf, 4); + ck_assert_int_eq(-1, ret); + ck_assert_str_eq("%25", buf); +} +END_TEST + + +START_TEST(test_mg_url_decode) +{ + char buf[20]; + int ret; + + ret = mg_url_decode("abc", 3, buf, sizeof(buf), 0); + ck_assert_int_eq(ret, 3); + ck_assert_str_eq(buf, "abc"); + + ret = mg_url_decode("abcdef", 3, buf, sizeof(buf), 0); + ck_assert_int_eq(ret, 3); + ck_assert_str_eq(buf, "abc"); + + ret = mg_url_decode("x+y", 3, buf, sizeof(buf), 0); + ck_assert_int_eq(ret, 3); + ck_assert_str_eq(buf, "x+y"); + + ret = mg_url_decode("x+y", 3, buf, sizeof(buf), 1); + ck_assert_int_eq(ret, 3); + ck_assert_str_eq(buf, "x y"); + + ret = mg_url_decode("%25", 3, buf, sizeof(buf), 1); + ck_assert_int_eq(ret, 1); + ck_assert_str_eq(buf, "%"); +} +END_TEST + + +START_TEST(test_mg_get_response_code_text) +{ + int i; + size_t j, len; + const char *resp; + + for (i = 100; i < 600; i++) { + resp = mg_get_response_code_text(NULL, i); + ck_assert_ptr_ne(resp, NULL); + len = strlen(resp); + ck_assert_uint_gt(len, 1); + ck_assert_uint_lt(len, 32); + for (j = 0; j < len; j++) { + if (resp[j] == ' ') { + /* space is valid */ + } else if (resp[j] == '-') { + /* hyphen is valid */ + } else if (resp[j] >= 'A' && resp[j] <= 'Z') { + /* A-Z is valid */ + } else if (resp[j] >= 'a' && resp[j] <= 'z') { + /* a-z is valid */ + } else { + ck_abort_msg("Found letter %c (%02xh) in %s", + resp[j], + resp[j], + resp); + } + } + } +} +END_TEST + + +#if !defined(REPLACE_CHECK_FOR_LOCAL_DEBUGGING) +Suite * +make_public_func_suite(void) +{ + Suite *const suite = suite_create("PublicFunc"); + + TCase *const tcase_version = tcase_create("Version"); + TCase *const tcase_get_valid_options = tcase_create("Options"); + TCase *const tcase_get_builtin_mime_type = tcase_create("MIME types"); + TCase *const tcase_strncasecmp = tcase_create("strcasecmp"); + TCase *const tcase_urlencodingdecoding = + tcase_create("URL encoding decoding"); + TCase *const tcase_cookies = tcase_create("Cookies and variables"); + TCase *const tcase_md5 = tcase_create("MD5"); + TCase *const tcase_aux = tcase_create("Aux functions"); + + tcase_add_test(tcase_version, test_mg_version); + tcase_set_timeout(tcase_version, civetweb_min_test_timeout); + suite_add_tcase(suite, tcase_version); + + tcase_add_test(tcase_get_valid_options, test_mg_get_valid_options); + tcase_set_timeout(tcase_get_valid_options, civetweb_min_test_timeout); + suite_add_tcase(suite, tcase_get_valid_options); + + tcase_add_test(tcase_get_builtin_mime_type, test_mg_get_builtin_mime_type); + tcase_set_timeout(tcase_get_builtin_mime_type, civetweb_min_test_timeout); + suite_add_tcase(suite, tcase_get_builtin_mime_type); + + tcase_add_test(tcase_strncasecmp, test_mg_strncasecmp); + tcase_set_timeout(tcase_strncasecmp, civetweb_min_test_timeout); + suite_add_tcase(suite, tcase_strncasecmp); + + tcase_add_test(tcase_urlencodingdecoding, test_mg_url_encode); + tcase_add_test(tcase_urlencodingdecoding, test_mg_url_decode); + tcase_set_timeout(tcase_urlencodingdecoding, civetweb_min_test_timeout); + suite_add_tcase(suite, tcase_urlencodingdecoding); + + tcase_add_test(tcase_cookies, test_mg_get_cookie); + tcase_add_test(tcase_cookies, test_mg_get_var); + tcase_set_timeout(tcase_cookies, civetweb_min_test_timeout); + suite_add_tcase(suite, tcase_cookies); + + tcase_add_test(tcase_md5, test_mg_md5); + tcase_set_timeout(tcase_md5, civetweb_min_test_timeout); + suite_add_tcase(suite, tcase_md5); + + tcase_add_test(tcase_aux, test_mg_get_response_code_text); + tcase_set_timeout(tcase_aux, civetweb_min_test_timeout); + suite_add_tcase(suite, tcase_aux); + + return suite; +} +#endif -- cgit v1.2.3