private.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436
  1. /* Copyright (c) 2015 the Civetweb developers
  2. *
  3. * Permission is hereby granted, free of charge, to any person obtaining a copy
  4. * of this software and associated documentation files (the "Software"), to deal
  5. * in the Software without restriction, including without limitation the rights
  6. * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  7. * copies of the Software, and to permit persons to whom the Software is
  8. * furnished to do so, subject to the following conditions:
  9. *
  10. * The above copyright notice and this permission notice shall be included in
  11. * all copies or substantial portions of the Software.
  12. *
  13. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14. * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15. * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  16. * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  17. * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  18. * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  19. * THE SOFTWARE.
  20. */
  21. /**
  22. * We include the source file so that we have access to the internal private
  23. * static functions
  24. */
  25. #ifdef _MSC_VER
  26. #define _CRT_SECURE_NO_WARNINGS
  27. #define CIVETWEB_API static
  28. #endif
  29. #include "../src/civetweb.c"
  30. #include <stdlib.h>
  31. #include "private.h"
  32. /* This unit test file uses the excellent Check unit testing library.
  33. * The API documentation is available here:
  34. * http://check.sourceforge.net/doc/check_html/index.html
  35. */
  36. START_TEST(test_parse_http_message)
  37. {
  38. /* Adapted from unit_test.c */
  39. /* Copyright (c) 2013-2015 the Civetweb developers */
  40. /* Copyright (c) 2004-2013 Sergey Lyubka */
  41. struct mg_request_info ri;
  42. char empty[] = "";
  43. char req1[] = "GET / HTTP/1.1\r\n\r\n";
  44. char req2[] = "BLAH / HTTP/1.1\r\n\r\n";
  45. char req3[] = "GET / HTTP/1.1\r\nBah\r\n";
  46. char req4[] = "GET / HTTP/1.1\r\nA: foo bar\r\nB: bar\r\nbaz\r\n\r\n";
  47. char req5[] = "GET / HTTP/1.1\r\n\r\n";
  48. char req6[] = "G";
  49. char req7[] = " blah ";
  50. char req8[] = " HTTP/1.1 200 OK \n\n";
  51. char req9[] = "HTTP/1.1 200 OK\r\nConnection: close\r\n\r\n";
  52. ck_assert_int_eq(sizeof(req9) - 1,
  53. parse_http_message(req9, sizeof(req9), &ri));
  54. ck_assert_int_eq(1, ri.num_headers);
  55. ck_assert_int_eq(sizeof(req1) - 1,
  56. parse_http_message(req1, sizeof(req1), &ri));
  57. ck_assert_str_eq("1.1", ri.http_version);
  58. ck_assert_int_eq(0, ri.num_headers);
  59. ck_assert_int_eq(-1, parse_http_message(req2, sizeof(req2), &ri));
  60. ck_assert_int_eq(0, parse_http_message(req3, sizeof(req3), &ri));
  61. ck_assert_int_eq(0, parse_http_message(req6, sizeof(req6), &ri));
  62. ck_assert_int_eq(0, parse_http_message(req7, sizeof(req7), &ri));
  63. ck_assert_int_eq(0, parse_http_message(empty, 0, &ri));
  64. ck_assert_int_eq(sizeof(req8) - 1,
  65. parse_http_message(req8, sizeof(req8), &ri));
  66. /* TODO(lsm): Fix this. Header value may span multiple lines. */
  67. ck_assert_int_eq(sizeof(req4) - 1,
  68. parse_http_message(req4, sizeof(req4), &ri));
  69. ck_assert_str_eq("1.1", ri.http_version);
  70. ck_assert_int_eq(3, ri.num_headers);
  71. ck_assert_str_eq("A", ri.http_headers[0].name);
  72. ck_assert_str_eq("foo bar", ri.http_headers[0].value);
  73. ck_assert_str_eq("B", ri.http_headers[1].name);
  74. ck_assert_str_eq("bar", ri.http_headers[1].value);
  75. ck_assert_str_eq("baz\r\n\r", ri.http_headers[2].name);
  76. ck_assert_str_eq("", ri.http_headers[2].value);
  77. ck_assert_int_eq(sizeof(req5) - 1,
  78. parse_http_message(req5, sizeof(req5), &ri));
  79. ck_assert_str_eq("GET", ri.request_method);
  80. ck_assert_str_eq("1.1", ri.http_version);
  81. }
  82. END_TEST
  83. START_TEST(test_should_keep_alive)
  84. {
  85. /* Adapted from unit_test.c */
  86. /* Copyright (c) 2013-2015 the Civetweb developers */
  87. /* Copyright (c) 2004-2013 Sergey Lyubka */
  88. struct mg_connection conn;
  89. struct mg_context ctx;
  90. char req1[] = "GET / HTTP/1.1\r\n\r\n";
  91. char req2[] = "GET / HTTP/1.0\r\n\r\n";
  92. char req3[] = "GET / HTTP/1.1\r\nConnection: close\r\n\r\n";
  93. char req4[] = "GET / HTTP/1.1\r\nConnection: keep-alive\r\n\r\n";
  94. char yes[] = "yes";
  95. char no[] = "no";
  96. memset(&conn, 0, sizeof(conn));
  97. conn.ctx = &ctx;
  98. ck_assert_int_eq(parse_http_message(req1, sizeof(req1), &conn.request_info),
  99. sizeof(req1) - 1);
  100. ctx.config[ENABLE_KEEP_ALIVE] = no;
  101. ck_assert_int_eq(should_keep_alive(&conn), 0);
  102. ctx.config[ENABLE_KEEP_ALIVE] = yes;
  103. ck_assert_int_eq(should_keep_alive(&conn), 1);
  104. conn.must_close = 1;
  105. ck_assert_int_eq(should_keep_alive(&conn), 0);
  106. conn.must_close = 0;
  107. parse_http_message(req2, sizeof(req2), &conn.request_info);
  108. ck_assert_int_eq(should_keep_alive(&conn), 0);
  109. parse_http_message(req3, sizeof(req3), &conn.request_info);
  110. ck_assert_int_eq(should_keep_alive(&conn), 0);
  111. parse_http_message(req4, sizeof(req4), &conn.request_info);
  112. ck_assert_int_eq(should_keep_alive(&conn), 1);
  113. conn.status_code = 401;
  114. ck_assert_int_eq(should_keep_alive(&conn), 0);
  115. conn.status_code = 200;
  116. conn.must_close = 1;
  117. ck_assert_int_eq(should_keep_alive(&conn), 0);
  118. }
  119. END_TEST
  120. START_TEST(test_match_prefix)
  121. {
  122. /* Adapted from unit_test.c */
  123. /* Copyright (c) 2013-2015 the Civetweb developers */
  124. /* Copyright (c) 2004-2013 Sergey Lyubka */
  125. ck_assert_int_eq(4, match_prefix("/api", 4, "/api"));
  126. ck_assert_int_eq(3, match_prefix("/a/", 3, "/a/b/c"));
  127. ck_assert_int_eq(-1, match_prefix("/a/", 3, "/ab/c"));
  128. ck_assert_int_eq(4, match_prefix("/*/", 3, "/ab/c"));
  129. ck_assert_int_eq(6, match_prefix("**", 2, "/a/b/c"));
  130. ck_assert_int_eq(2, match_prefix("/*", 2, "/a/b/c"));
  131. ck_assert_int_eq(2, match_prefix("*/*", 3, "/a/b/c"));
  132. ck_assert_int_eq(5, match_prefix("**/", 3, "/a/b/c"));
  133. ck_assert_int_eq(5, match_prefix("**.foo|**.bar", 13, "a.bar"));
  134. ck_assert_int_eq(2, match_prefix("a|b|cd", 6, "cdef"));
  135. ck_assert_int_eq(2, match_prefix("a|b|c?", 6, "cdef"));
  136. ck_assert_int_eq(1, match_prefix("a|?|cd", 6, "cdef"));
  137. ck_assert_int_eq(-1, match_prefix("/a/**.cgi", 9, "/foo/bar/x.cgi"));
  138. ck_assert_int_eq(12, match_prefix("/a/**.cgi", 9, "/a/bar/x.cgi"));
  139. ck_assert_int_eq(5, match_prefix("**/", 3, "/a/b/c"));
  140. ck_assert_int_eq(-1, match_prefix("**/$", 4, "/a/b/c"));
  141. ck_assert_int_eq(5, match_prefix("**/$", 4, "/a/b/"));
  142. ck_assert_int_eq(0, match_prefix("$", 1, ""));
  143. ck_assert_int_eq(-1, match_prefix("$", 1, "x"));
  144. ck_assert_int_eq(1, match_prefix("*$", 2, "x"));
  145. ck_assert_int_eq(1, match_prefix("/$", 2, "/"));
  146. ck_assert_int_eq(-1, match_prefix("**/$", 4, "/a/b/c"));
  147. ck_assert_int_eq(5, match_prefix("**/$", 4, "/a/b/"));
  148. ck_assert_int_eq(0, match_prefix("*", 1, "/hello/"));
  149. ck_assert_int_eq(-1, match_prefix("**.a$|**.b$", 11, "/a/b.b/"));
  150. ck_assert_int_eq(6, match_prefix("**.a$|**.b$", 11, "/a/b.b"));
  151. ck_assert_int_eq(6, match_prefix("**.a$|**.b$", 11, "/a/B.A"));
  152. ck_assert_int_eq(5, match_prefix("**o$", 4, "HELLO"));
  153. }
  154. END_TEST
  155. START_TEST(test_remove_double_dots_and_double_slashes)
  156. {
  157. /* Adapted from unit_test.c */
  158. /* Copyright (c) 2013-2015 the Civetweb developers */
  159. /* Copyright (c) 2004-2013 Sergey Lyubka */
  160. struct {
  161. char before[20], after[20];
  162. } data[] = {
  163. {"////a", "/a"},
  164. {"/.....", "/."},
  165. {"/......", "/"},
  166. {"...", "..."},
  167. {"/...///", "/./"},
  168. {"/a...///", "/a.../"},
  169. {"/.x", "/.x"},
  170. {"/\\", "/"},
  171. {"/a\\", "/a\\"},
  172. {"/a\\\\...", "/a\\."},
  173. };
  174. size_t i;
  175. for (i = 0; i < ARRAY_SIZE(data); i++) {
  176. remove_double_dots_and_double_slashes(data[i].before);
  177. ck_assert_str_eq(data[i].before, data[i].after);
  178. }
  179. }
  180. END_TEST
  181. START_TEST(test_is_valid_uri)
  182. {
  183. ck_assert_int_eq(1, is_valid_uri("/api"));
  184. ck_assert_int_eq(0, is_valid_uri("api"));
  185. ck_assert_int_eq(1, is_valid_uri("*"));
  186. ck_assert_int_eq(0, is_valid_uri("*xy"));
  187. }
  188. END_TEST
  189. START_TEST(test_next_option)
  190. {
  191. /* Adapted from unit_test.c */
  192. /* Copyright (c) 2013-2015 the Civetweb developers */
  193. /* Copyright (c) 2004-2013 Sergey Lyubka */
  194. const char *p, *list = "x/8,/y**=1;2k,z";
  195. struct vec a, b;
  196. int i;
  197. ck_assert(next_option(NULL, &a, &b) == NULL);
  198. for (i = 0, p = list; (p = next_option(p, &a, &b)) != NULL; i++) {
  199. ck_assert(i != 0 || (a.ptr == list && a.len == 3 && b.len == 0));
  200. ck_assert(i != 1 || (a.ptr == list + 4 && a.len == 4 &&
  201. b.ptr == list + 9 && b.len == 4));
  202. ck_assert(i != 2 || (a.ptr == list + 14 && a.len == 1 && b.len == 0));
  203. }
  204. }
  205. END_TEST
  206. START_TEST(test_skip_quoted)
  207. {
  208. /* Adapted from unit_test.c */
  209. /* Copyright (c) 2013-2015 the Civetweb developers */
  210. /* Copyright (c) 2004-2013 Sergey Lyubka */
  211. char x[] = "a=1, b=2, c='hi \' there', d='here\\, there'", *s = x, *p;
  212. p = skip_quoted(&s, ", ", ", ", 0);
  213. ck_assert(p != NULL && !strcmp(p, "a=1"));
  214. p = skip_quoted(&s, ", ", ", ", 0);
  215. ck_assert(p != NULL && !strcmp(p, "b=2"));
  216. p = skip_quoted(&s, ",", " ", 0);
  217. ck_assert(p != NULL && !strcmp(p, "c='hi \' there'"));
  218. p = skip_quoted(&s, ",", " ", '\\');
  219. ck_assert(p != NULL && !strcmp(p, "d='here, there'"));
  220. ck_assert(*s == 0);
  221. }
  222. END_TEST
  223. static int alloc_printf(char **buf, size_t size, const char *fmt, ...)
  224. {
  225. /* Test helper function - adapted from unit_test.c */
  226. /* Copyright (c) 2013-2015 the Civetweb developers */
  227. /* Copyright (c) 2004-2013 Sergey Lyubka */
  228. va_list ap;
  229. int ret = 0;
  230. va_start(ap, fmt);
  231. ret = alloc_vprintf(buf, size, fmt, ap);
  232. va_end(ap);
  233. return ret;
  234. }
  235. START_TEST(test_alloc_vprintf)
  236. {
  237. /* Adapted from unit_test.c */
  238. /* Copyright (c) 2013-2015 the Civetweb developers */
  239. /* Copyright (c) 2004-2013 Sergey Lyubka */
  240. char buf[MG_BUF_LEN], *p = buf;
  241. ck_assert(alloc_printf(&p, sizeof(buf), "%s", "hi") == 2);
  242. ck_assert(p == buf);
  243. ck_assert(alloc_printf(&p, sizeof(buf), "%s", "") == 0);
  244. ck_assert(alloc_printf(&p, sizeof(buf), "") == 0);
  245. /* Pass small buffer, make sure alloc_printf allocates */
  246. ck_assert(alloc_printf(&p, 1, "%s", "hello") == 5);
  247. ck_assert(p != buf);
  248. mg_free(p);
  249. }
  250. END_TEST
  251. START_TEST(test_mg_strcasestr)
  252. {
  253. /* Adapted from unit_test.c */
  254. /* Copyright (c) 2013-2015 the Civetweb developers */
  255. /* Copyright (c) 2004-2013 Sergey Lyubka */
  256. static const char *big1 = "abcdef";
  257. ck_assert(mg_strcasestr("Y", "X") == NULL);
  258. ck_assert(mg_strcasestr("Y", "y") != NULL);
  259. ck_assert(mg_strcasestr(big1, "X") == NULL);
  260. ck_assert(mg_strcasestr(big1, "CD") == big1 + 2);
  261. ck_assert(mg_strcasestr("aa", "AAB") == NULL);
  262. }
  263. END_TEST
  264. START_TEST(test_encode_decode)
  265. {
  266. char buf[64];
  267. const char *alpha = "abcdefghijklmnopqrstuvwxyz";
  268. const char *alpha_enc = "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXo=";
  269. const char *nonalpha = " !\"#$%&'()*+,-./0123456789:;<=>?@";
  270. const char *nonalpha_enc = "ICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9A";
  271. const char *nonalpha_url =
  272. "%20!%22%23%24%25%26'()*%2B%2C-.%2F0123456789%3A%3B%3C%3D%3E%3F%40";
  273. int ret;
  274. size_t len;
  275. #if defined(USE_WEBSOCKET) || defined(USE_LUA)
  276. memset(buf, 77, sizeof(buf));
  277. base64_encode((unsigned char *)"a", 1, buf);
  278. ck_assert_str_eq(buf, "YQ==");
  279. memset(buf, 77, sizeof(buf));
  280. base64_encode((unsigned char *)"ab", 1, buf);
  281. ck_assert_str_eq(buf, "YQ==");
  282. memset(buf, 77, sizeof(buf));
  283. base64_encode((unsigned char *)"ab", 2, buf);
  284. ck_assert_str_eq(buf, "YWI=");
  285. memset(buf, 77, sizeof(buf));
  286. base64_encode((unsigned char *)alpha, 3, buf);
  287. ck_assert_str_eq(buf, "YWJj");
  288. memset(buf, 77, sizeof(buf));
  289. base64_encode((unsigned char *)alpha, 4, buf);
  290. ck_assert_str_eq(buf, "YWJjZA==");
  291. memset(buf, 77, sizeof(buf));
  292. base64_encode((unsigned char *)alpha, 5, buf);
  293. ck_assert_str_eq(buf, "YWJjZGU=");
  294. memset(buf, 77, sizeof(buf));
  295. base64_encode((unsigned char *)alpha, 6, buf);
  296. ck_assert_str_eq(buf, "YWJjZGVm");
  297. memset(buf, 77, sizeof(buf));
  298. base64_encode((unsigned char *)alpha, (int)strlen(alpha), buf);
  299. ck_assert_str_eq(buf, alpha_enc);
  300. memset(buf, 77, sizeof(buf));
  301. base64_encode((unsigned char *)nonalpha, (int)strlen(nonalpha), buf);
  302. ck_assert_str_eq(buf, nonalpha_enc);
  303. #endif
  304. #if defined(USE_LUA)
  305. memset(buf, 77, sizeof(buf));
  306. len = 9999;
  307. ret = base64_decode(
  308. (unsigned char *)alpha_enc, (int)strlen(alpha_enc), buf, &len);
  309. ck_assert_int_eq(ret, -1);
  310. ck_assert_uint_eq((unsigned int)len, (unsigned int)strlen(alpha));
  311. ck_assert_str_eq(buf, alpha);
  312. memset(buf, 77, sizeof(buf));
  313. len = 9999;
  314. ret = base64_decode((unsigned char *)"AAA*AAA", 7, buf, &len);
  315. ck_assert_int_eq(ret, 3);
  316. #endif
  317. memset(buf, 77, sizeof(buf));
  318. ret = mg_url_encode(alpha, buf, sizeof(buf));
  319. ck_assert_int_eq(ret, strlen(buf));
  320. ck_assert_int_eq(ret, strlen(alpha));
  321. ck_assert_str_eq(buf, alpha);
  322. memset(buf, 77, sizeof(buf));
  323. ret = mg_url_encode(alpha, buf, sizeof(buf));
  324. ck_assert_int_eq(ret, strlen(buf));
  325. ck_assert_int_eq(ret, strlen(nonalpha_url));
  326. ck_assert_str_eq(buf, nonalpha_url);
  327. memset(buf, 77, sizeof(buf));
  328. ret = mg_url_decode(alpha, strlen(alpha), buf, sizeof(buf), 0);
  329. ck_assert_int_eq(ret, strlen(buf));
  330. ck_assert_int_eq(ret, strlen(alpha));
  331. ck_assert_str_eq(buf, alpha);
  332. memset(buf, 77, sizeof(buf));
  333. ret =
  334. mg_url_decode(nonalpha_url, strlen(nonalpha_url), buf, sizeof(buf), 0);
  335. ck_assert_int_eq(ret, strlen(buf));
  336. ck_assert_int_eq(ret, strlen(nonalpha));
  337. ck_assert_str_eq(buf, nonalpha);
  338. /* len could be unused, if base64_decode is not tested because USE_LUA is
  339. * not defined */
  340. (void)len;
  341. }
  342. END_TEST
  343. Suite *make_private_suite(void)
  344. {
  345. Suite *const suite = suite_create("Private");
  346. TCase *const http_message = tcase_create("HTTP Message");
  347. TCase *const url_parsing = tcase_create("URL Parsing");
  348. TCase *const internal_parse = tcase_create("Internal Parsing");
  349. TCase *const encode_decode = tcase_create("Encode Decode");
  350. tcase_add_test(http_message, test_parse_http_message);
  351. tcase_add_test(http_message, test_should_keep_alive);
  352. suite_add_tcase(suite, http_message);
  353. tcase_add_test(url_parsing, test_match_prefix);
  354. tcase_add_test(url_parsing, test_remove_double_dots_and_double_slashes);
  355. tcase_add_test(url_parsing, test_is_valid_uri);
  356. suite_add_tcase(suite, url_parsing);
  357. tcase_add_test(internal_parse, test_next_option);
  358. tcase_add_test(internal_parse, test_skip_quoted);
  359. tcase_add_test(internal_parse, test_mg_strcasestr);
  360. tcase_add_test(internal_parse, test_alloc_vprintf);
  361. suite_add_tcase(suite, internal_parse);
  362. tcase_add_test(encode_decode, test_encode_decode);
  363. suite_add_tcase(suite, encode_decode);
  364. return suite;
  365. }