public.c 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898
  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. #ifdef _MSC_VER
  22. #define _CRT_SECURE_NO_WARNINGS
  23. #endif
  24. #include <stdlib.h>
  25. #include <stdio.h>
  26. #include <time.h>
  27. #include "public.h"
  28. #include <civetweb.h>
  29. #if defined(_WIN32)
  30. #include <Windows.h>
  31. #define mg_Sleep(x) (Sleep(x * 1000))
  32. #else
  33. #include <unistd.h>
  34. #define mg_Sleep(x) (sleep(x))
  35. #endif
  36. /* This unit test file uses the excellent Check unit testing library.
  37. * The API documentation is available here:
  38. * http://check.sourceforge.net/doc/check_html/index.html
  39. */
  40. START_TEST(test_mg_version)
  41. {
  42. const char *ver = mg_version();
  43. unsigned major = 0, minor = 0;
  44. int ret;
  45. ck_assert(ver != NULL);
  46. ck_assert_str_eq(ver, CIVETWEB_VERSION);
  47. /* check structure of version string */
  48. ret = sscanf(ver, "%u.%u", &major, &minor);
  49. ck_assert_int_eq(ret, 2);
  50. ck_assert_uint_ge(major, 1);
  51. }
  52. END_TEST
  53. START_TEST(test_mg_get_valid_options)
  54. {
  55. int i;
  56. const struct mg_option *default_options = mg_get_valid_options();
  57. ck_assert(default_options != NULL);
  58. for (i = 0; default_options[i].name != NULL; i++) {
  59. ck_assert(default_options[i].name != NULL);
  60. ck_assert(strlen(default_options[i].name) > 0);
  61. ck_assert(((int)default_options[i].type) > 0);
  62. }
  63. ck_assert(i > 0);
  64. }
  65. END_TEST
  66. START_TEST(test_mg_get_builtin_mime_type)
  67. {
  68. ck_assert_str_eq(mg_get_builtin_mime_type("x.txt"), "text/plain");
  69. ck_assert_str_eq(mg_get_builtin_mime_type("x.html"), "text/html");
  70. ck_assert_str_eq(mg_get_builtin_mime_type("x.HTML"), "text/html");
  71. ck_assert_str_eq(mg_get_builtin_mime_type("x.hTmL"), "text/html");
  72. ck_assert_str_eq(mg_get_builtin_mime_type("/abc/def/ghi.htm"), "text/html");
  73. ck_assert_str_eq(mg_get_builtin_mime_type("x.unknown_extention_xyz"),
  74. "text/plain");
  75. }
  76. END_TEST
  77. START_TEST(test_mg_strncasecmp)
  78. {
  79. ck_assert(mg_strncasecmp("abc", "abc", 3) == 0);
  80. ck_assert(mg_strncasecmp("abc", "abcd", 3) == 0);
  81. ck_assert(mg_strncasecmp("abc", "abcd", 4) != 0);
  82. ck_assert(mg_strncasecmp("a", "A", 1) == 0);
  83. ck_assert(mg_strncasecmp("A", "B", 1) < 0);
  84. ck_assert(mg_strncasecmp("A", "b", 1) < 0);
  85. ck_assert(mg_strncasecmp("a", "B", 1) < 0);
  86. ck_assert(mg_strncasecmp("a", "b", 1) < 0);
  87. ck_assert(mg_strncasecmp("b", "A", 1) > 0);
  88. ck_assert(mg_strncasecmp("B", "A", 1) > 0);
  89. ck_assert(mg_strncasecmp("b", "a", 1) > 0);
  90. ck_assert(mg_strncasecmp("B", "a", 1) > 0);
  91. ck_assert(mg_strncasecmp("xAx", "xBx", 3) < 0);
  92. ck_assert(mg_strncasecmp("xAx", "xbx", 3) < 0);
  93. ck_assert(mg_strncasecmp("xax", "xBx", 3) < 0);
  94. ck_assert(mg_strncasecmp("xax", "xbx", 3) < 0);
  95. ck_assert(mg_strncasecmp("xbx", "xAx", 3) > 0);
  96. ck_assert(mg_strncasecmp("xBx", "xAx", 3) > 0);
  97. ck_assert(mg_strncasecmp("xbx", "xax", 3) > 0);
  98. ck_assert(mg_strncasecmp("xBx", "xax", 3) > 0);
  99. }
  100. END_TEST
  101. START_TEST(test_mg_get_cookie)
  102. {
  103. char buf[32];
  104. int ret;
  105. const char *longcookie = "key1=1; key2=2; key3; key4=4; key5=; key6; "
  106. "key7=this+is+it; key8=8; key9";
  107. /* invalid result buffer */
  108. ret = mg_get_cookie("", "notfound", NULL, 999);
  109. ck_assert_int_eq(ret, -2);
  110. /* zero size result buffer */
  111. ret = mg_get_cookie("", "notfound", buf, 0);
  112. ck_assert_int_eq(ret, -2);
  113. /* too small result buffer */
  114. ret = mg_get_cookie("key=toooooooooolong", "key", buf, 4);
  115. ck_assert_int_eq(ret, -3);
  116. /* key not found in string */
  117. ret = mg_get_cookie("", "notfound", buf, sizeof(buf));
  118. ck_assert_int_eq(ret, -1);
  119. ret = mg_get_cookie(longcookie, "notfound", buf, sizeof(buf));
  120. ck_assert_int_eq(ret, -1);
  121. /* key not found in string */
  122. ret = mg_get_cookie("key1=1; key2=2; key3=3", "notfound", buf, sizeof(buf));
  123. ck_assert_int_eq(ret, -1);
  124. /* keys are found as first, middle and last key */
  125. memset(buf, 77, sizeof(buf));
  126. ret = mg_get_cookie("key1=1; key2=2; key3=3", "key1", buf, sizeof(buf));
  127. ck_assert_int_eq(ret, 1);
  128. ck_assert_str_eq("1", buf);
  129. memset(buf, 77, sizeof(buf));
  130. ret = mg_get_cookie("key1=1; key2=2; key3=3", "key2", buf, sizeof(buf));
  131. ck_assert_int_eq(ret, 1);
  132. ck_assert_str_eq("2", buf);
  133. memset(buf, 77, sizeof(buf));
  134. ret = mg_get_cookie("key1=1; key2=2; key3=3", "key3", buf, sizeof(buf));
  135. ck_assert_int_eq(ret, 1);
  136. ck_assert_str_eq("3", buf);
  137. /* longer value in the middle of a longer string */
  138. memset(buf, 77, sizeof(buf));
  139. ret = mg_get_cookie(longcookie, "key7", buf, sizeof(buf));
  140. ck_assert_int_eq(ret, 10);
  141. ck_assert_str_eq("this+is+it", buf);
  142. /* key with = but without value in the middle of a longer string */
  143. memset(buf, 77, sizeof(buf));
  144. ret = mg_get_cookie(longcookie, "key5", buf, sizeof(buf));
  145. ck_assert_int_eq(ret, 0);
  146. ck_assert_str_eq("", buf);
  147. /* key without = and without value in the middle of a longer string */
  148. memset(buf, 77, sizeof(buf));
  149. ret = mg_get_cookie(longcookie, "key6", buf, sizeof(buf));
  150. ck_assert_int_eq(ret, -1);
  151. /* TODO: mg_get_cookie and mg_get_var(2) should have the same behavior */
  152. }
  153. END_TEST
  154. START_TEST(test_mg_get_var)
  155. {
  156. char buf[32];
  157. int ret;
  158. const char *shortquery = "key1=1&key2=2&key3=3";
  159. const char *longquery = "key1=1&key2=2&key3&key4=4&key5=&key6&"
  160. "key7=this+is+it&key8=8&key9&&key10=&&"
  161. "key7=that+is+it&key12=12";
  162. /* invalid result buffer */
  163. ret = mg_get_var2("", 0, "notfound", NULL, 999, 0);
  164. ck_assert_int_eq(ret, -2);
  165. /* zero size result buffer */
  166. ret = mg_get_var2("", 0, "notfound", buf, 0, 0);
  167. ck_assert_int_eq(ret, -2);
  168. /* too small result buffer */
  169. ret = mg_get_var2("key=toooooooooolong", 19, "key", buf, 4, 0);
  170. /* ck_assert_int_eq(ret, -3);
  171. --> TODO: mg_get_cookie returns -3, mg_get_var -2. This should be
  172. unified. */
  173. ck_assert(ret < 0);
  174. /* key not found in string */
  175. ret = mg_get_var2("", 0, "notfound", buf, sizeof(buf), 0);
  176. ck_assert_int_eq(ret, -1);
  177. ret = mg_get_var2(
  178. longquery, strlen(longquery), "notfound", buf, sizeof(buf), 0);
  179. ck_assert_int_eq(ret, -1);
  180. /* key not found in string */
  181. ret = mg_get_var2(
  182. shortquery, strlen(shortquery), "notfound", buf, sizeof(buf), 0);
  183. ck_assert_int_eq(ret, -1);
  184. /* key not found in string */
  185. ret = mg_get_var2("key1=1&key2=2&key3=3&notfound=here",
  186. strlen(shortquery),
  187. "notfound",
  188. buf,
  189. sizeof(buf),
  190. 0);
  191. ck_assert_int_eq(ret, -1);
  192. /* key not found in string */
  193. ret = mg_get_var2(
  194. shortquery, strlen(shortquery), "key1", buf, sizeof(buf), 1);
  195. ck_assert_int_eq(ret, -1);
  196. /* keys are found as first, middle and last key */
  197. memset(buf, 77, sizeof(buf));
  198. ret = mg_get_var2(
  199. shortquery, strlen(shortquery), "key1", buf, sizeof(buf), 0);
  200. ck_assert_int_eq(ret, 1);
  201. ck_assert_str_eq("1", buf);
  202. memset(buf, 77, sizeof(buf));
  203. ret = mg_get_var2(
  204. shortquery, strlen(shortquery), "key2", buf, sizeof(buf), 0);
  205. ck_assert_int_eq(ret, 1);
  206. ck_assert_str_eq("2", buf);
  207. memset(buf, 77, sizeof(buf));
  208. ret = mg_get_var2(
  209. shortquery, strlen(shortquery), "key3", buf, sizeof(buf), 0);
  210. ck_assert_int_eq(ret, 1);
  211. ck_assert_str_eq("3", buf);
  212. /* longer value in the middle of a longer string */
  213. memset(buf, 77, sizeof(buf));
  214. ret =
  215. mg_get_var2(longquery, strlen(longquery), "key7", buf, sizeof(buf), 0);
  216. ck_assert_int_eq(ret, 10);
  217. ck_assert_str_eq("this is it", buf);
  218. /* longer value in the middle of a longer string - seccond occurance of key
  219. */
  220. memset(buf, 77, sizeof(buf));
  221. ret =
  222. mg_get_var2(longquery, strlen(longquery), "key7", buf, sizeof(buf), 1);
  223. ck_assert_int_eq(ret, 10);
  224. ck_assert_str_eq("that is it", buf);
  225. /* key with = but without value in the middle of a longer string */
  226. memset(buf, 77, sizeof(buf));
  227. ret =
  228. mg_get_var2(longquery, strlen(longquery), "key5", buf, sizeof(buf), 0);
  229. ck_assert_int_eq(ret, 0);
  230. ck_assert_str_eq(buf, "");
  231. /* key without = and without value in the middle of a longer string */
  232. memset(buf, 77, sizeof(buf));
  233. ret =
  234. mg_get_var2(longquery, strlen(longquery), "key6", buf, sizeof(buf), 0);
  235. ck_assert_int_eq(ret, -1);
  236. ck_assert_str_eq(buf, "");
  237. /* TODO: this is the same situation as with mg_get_value */
  238. }
  239. END_TEST
  240. START_TEST(test_mg_md5)
  241. {
  242. char buf[33];
  243. char *ret;
  244. const char *long_str =
  245. "_123456789A123456789B123456789C123456789D123456789E123456789F123456789"
  246. "G123456789H123456789I123456789J123456789K123456789L123456789M123456789"
  247. "N123456789O123456789P123456789Q123456789R123456789S123456789T123456789"
  248. "U123456789V123456789W123456789X123456789Y123456789Z";
  249. memset(buf, 77, sizeof(buf));
  250. ret = mg_md5(buf, NULL);
  251. ck_assert_str_eq(buf, "d41d8cd98f00b204e9800998ecf8427e");
  252. ck_assert_str_eq(ret, "d41d8cd98f00b204e9800998ecf8427e");
  253. ck_assert_ptr_eq(ret, buf);
  254. memset(buf, 77, sizeof(buf));
  255. ret = mg_md5(buf, "The quick brown fox jumps over the lazy dog.", NULL);
  256. ck_assert_str_eq(buf, "e4d909c290d0fb1ca068ffaddf22cbd0");
  257. ck_assert_str_eq(ret, "e4d909c290d0fb1ca068ffaddf22cbd0");
  258. ck_assert_ptr_eq(ret, buf);
  259. memset(buf, 77, sizeof(buf));
  260. ret = mg_md5(buf,
  261. "",
  262. "The qu",
  263. "ick bro",
  264. "",
  265. "wn fox ju",
  266. "m",
  267. "ps over the la",
  268. "",
  269. "",
  270. "zy dog.",
  271. "",
  272. NULL);
  273. ck_assert_str_eq(buf, "e4d909c290d0fb1ca068ffaddf22cbd0");
  274. ck_assert_str_eq(ret, "e4d909c290d0fb1ca068ffaddf22cbd0");
  275. ck_assert_ptr_eq(ret, buf);
  276. memset(buf, 77, sizeof(buf));
  277. ret = mg_md5(buf, long_str, NULL);
  278. ck_assert_str_eq(buf, "1cb13cf9f16427807f081b2138241f08");
  279. ck_assert_str_eq(ret, "1cb13cf9f16427807f081b2138241f08");
  280. ck_assert_ptr_eq(ret, buf);
  281. memset(buf, 77, sizeof(buf));
  282. ret = mg_md5(buf, long_str + 1, NULL);
  283. ck_assert_str_eq(buf, "cf62d3264334154f5779d3694cc5093f");
  284. ck_assert_str_eq(ret, "cf62d3264334154f5779d3694cc5093f");
  285. ck_assert_ptr_eq(ret, buf);
  286. }
  287. END_TEST
  288. START_TEST(test_mg_url_encode)
  289. {
  290. char buf[20];
  291. int ret;
  292. memset(buf, 77, sizeof(buf));
  293. ret = mg_url_encode("abc", buf, sizeof(buf));
  294. ck_assert_int_eq(3, ret);
  295. ck_assert_str_eq("abc", buf);
  296. memset(buf, 77, sizeof(buf));
  297. ret = mg_url_encode("a%b/c&d.e", buf, sizeof(buf));
  298. ck_assert_int_eq(15, ret);
  299. ck_assert_str_eq("a%25b%2fc%26d.e", buf);
  300. memset(buf, 77, sizeof(buf));
  301. ret = mg_url_encode("%%%", buf, 4);
  302. ck_assert_int_eq(-1, ret);
  303. ck_assert_str_eq("%25", buf);
  304. }
  305. END_TEST
  306. START_TEST(test_mg_url_decode)
  307. {
  308. char buf[20];
  309. int ret;
  310. ret = mg_url_decode("abc", 3, buf, sizeof(buf), 0);
  311. ck_assert_int_eq(ret, 3);
  312. ck_assert_str_eq(buf, "abc");
  313. ret = mg_url_decode("abcdef", 3, buf, sizeof(buf), 0);
  314. ck_assert_int_eq(ret, 3);
  315. ck_assert_str_eq(buf, "abc");
  316. ret = mg_url_decode("x+y", 3, buf, sizeof(buf), 0);
  317. ck_assert_int_eq(ret, 3);
  318. ck_assert_str_eq(buf, "x+y");
  319. ret = mg_url_decode("x+y", 3, buf, sizeof(buf), 1);
  320. ck_assert_int_eq(ret, 3);
  321. ck_assert_str_eq(buf, "x y");
  322. ret = mg_url_decode("%25", 3, buf, sizeof(buf), 1);
  323. ck_assert_int_eq(ret, 1);
  324. ck_assert_str_eq(buf, "%");
  325. }
  326. END_TEST
  327. START_TEST(test_mg_start_stop_http_server)
  328. {
  329. struct mg_context *ctx;
  330. const char *OPTIONS[] = {
  331. "document_root", ".", "listening_ports", "8080", NULL,
  332. };
  333. size_t ports_cnt;
  334. int ports[16];
  335. int ssl[16];
  336. memset(ports, 0, sizeof(ports));
  337. memset(ssl, 0, sizeof(ssl));
  338. ctx = mg_start(NULL, NULL, OPTIONS);
  339. ck_assert(ctx != NULL);
  340. ports_cnt = mg_get_ports(ctx, 16, ports, ssl);
  341. ck_assert_uint_eq(ports_cnt, 1);
  342. ck_assert_int_eq(ports[0], 8080);
  343. ck_assert_int_eq(ssl[0], 0);
  344. ck_assert_int_eq(ports[1], 0);
  345. ck_assert_int_eq(ssl[1], 0);
  346. mg_Sleep(1);
  347. mg_stop(ctx);
  348. }
  349. END_TEST
  350. START_TEST(test_mg_start_stop_https_server)
  351. {
  352. struct mg_context *ctx;
  353. const char *OPTIONS[] = {
  354. "document_root",
  355. ".",
  356. "listening_ports",
  357. "8080,8443s",
  358. "ssl_certificate",
  359. "../resources/ssl_cert.pem", // TODO: check working path of CI test
  360. // system
  361. NULL,
  362. };
  363. size_t ports_cnt;
  364. int ports[16];
  365. int ssl[16];
  366. memset(ports, 0, sizeof(ports));
  367. memset(ssl, 0, sizeof(ssl));
  368. ctx = mg_start(NULL, NULL, OPTIONS);
  369. ck_assert(ctx != NULL);
  370. ports_cnt = mg_get_ports(ctx, 16, ports, ssl);
  371. ck_assert_uint_eq(ports_cnt, 2);
  372. ck_assert_int_eq(ports[0], 8080);
  373. ck_assert_int_eq(ssl[0], 0);
  374. ck_assert_int_eq(ports[1], 8443);
  375. ck_assert_int_eq(ssl[1], 1);
  376. ck_assert_int_eq(ports[2], 0);
  377. ck_assert_int_eq(ssl[2], 0);
  378. mg_Sleep(1);
  379. mg_stop(ctx);
  380. }
  381. END_TEST
  382. static struct mg_context *g_ctx;
  383. static int request_test_handler(struct mg_connection *conn, void *cbdata)
  384. {
  385. int i;
  386. char chunk_data[32];
  387. const struct mg_request_info *ri;
  388. struct mg_context *ctx;
  389. void *ud, *cud;
  390. ctx = mg_get_context(conn);
  391. ud = mg_get_user_data(ctx);
  392. ri = mg_get_request_info(conn);
  393. ck_assert(ri != NULL);
  394. ck_assert(ctx == g_ctx);
  395. ck_assert(ud == &g_ctx);
  396. mg_set_user_connection_data(conn, (void *)6543);
  397. cud = mg_get_user_connection_data(conn);
  398. ck_assert(cud == (void *)6543);
  399. ck_assert(cbdata == (void *)7);
  400. strcpy(chunk_data, "123456789A123456789B123456789C");
  401. mg_printf(conn,
  402. "HTTP/1.1 200 OK\r\n"
  403. "Transfer-Encoding: chunked\r\n"
  404. "Content-Type: text/plain\r\n\r\n");
  405. for (i = 1; i <= 10; i++) {
  406. mg_printf(conn, "%x\r\n", i);
  407. mg_write(conn, chunk_data, (unsigned)i);
  408. mg_printf(conn, "\r\n");
  409. }
  410. mg_printf(conn, "0\r\n\r\n");
  411. return 1;
  412. }
  413. START_TEST(test_request_handlers)
  414. {
  415. char ebuf[100];
  416. struct mg_context *ctx;
  417. struct mg_connection *conn;
  418. const struct mg_request_info *ri;
  419. char uri[64];
  420. char buf[1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 8];
  421. const char *expected =
  422. "112123123412345123456123456712345678123456789123456789A";
  423. int i;
  424. const char *request = "GET /U7 HTTP/1.0\r\n\r\n";
  425. #if defined(USE_IPV6) && defined(NO_SSL)
  426. const char *HTTP_PORT = "8084,[::]:8086";
  427. short ipv4_port = 8084;
  428. short ipv6_port = 8086;
  429. #elif !defined(USE_IPV6) && defined(NO_SSL)
  430. const char *HTTP_PORT = "8084";
  431. short ipv4_port = 8084;
  432. #elif defined(USE_IPV6) && !defined(NO_SSL)
  433. const char *HTTP_PORT = "8084,[::]:8086,8194r,[::]:8196r,8094s,[::]:8096s";
  434. short ipv4_port = 8084;
  435. short ipv4s_port = 8094;
  436. short ipv4r_port = 8194;
  437. short ipv6_port = 8086;
  438. short ipv6s_port = 8096;
  439. short ipv6r_port = 8196;
  440. #elif !defined(USE_IPV6) && !defined(NO_SSL)
  441. const char *HTTP_PORT = "8084,8194r,8094s";
  442. short ipv4_port = 8084;
  443. short ipv4s_port = 8094;
  444. short ipv4r_port = 8194;
  445. #endif
  446. const char *OPTIONS[8]; /* initializer list here is rejected by CI test */
  447. const char *opt;
  448. FILE *f;
  449. memset((void *)OPTIONS, 0, sizeof(OPTIONS));
  450. OPTIONS[0] = "listening_ports";
  451. OPTIONS[1] = HTTP_PORT;
  452. OPTIONS[2] = "document_root";
  453. OPTIONS[3] = ".";
  454. #ifndef NO_SSL
  455. OPTIONS[4] = "ssl_certificate";
  456. OPTIONS[5] = "../resources/ssl_cert.pem";
  457. #endif
  458. ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 1] == NULL);
  459. ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 2] == NULL);
  460. ctx = mg_start(NULL, &g_ctx, OPTIONS);
  461. ck_assert(ctx != NULL);
  462. g_ctx = ctx;
  463. opt = mg_get_option(ctx, "listening_ports");
  464. ck_assert_str_eq(opt, HTTP_PORT);
  465. opt = mg_get_option(ctx, "cgi_environment");
  466. ck_assert_str_eq(opt, "");
  467. opt = mg_get_option(ctx, "unknown_option_name");
  468. ck_assert(opt == NULL);
  469. for (i = 0; i < 1000; i++) {
  470. sprintf(uri, "/U%u", i);
  471. mg_set_request_handler(ctx, uri, request_test_handler, NULL);
  472. }
  473. for (i = 500; i < 800; i++) {
  474. sprintf(uri, "/U%u", i);
  475. mg_set_request_handler(ctx, uri, NULL, (void *)1);
  476. }
  477. for (i = 600; i >= 0; i--) {
  478. sprintf(uri, "/U%u", i);
  479. mg_set_request_handler(ctx, uri, NULL, (void *)2);
  480. }
  481. for (i = 750; i <= 1000; i++) {
  482. sprintf(uri, "/U%u", i);
  483. mg_set_request_handler(ctx, uri, NULL, (void *)3);
  484. }
  485. for (i = 5; i < 9; i++) {
  486. sprintf(uri, "/U%u", i);
  487. mg_set_request_handler(
  488. ctx, uri, request_test_handler, (void *)(ptrdiff_t)i);
  489. }
  490. /* Try to load non existing file */
  491. conn = mg_download("localhost",
  492. ipv4_port,
  493. 0,
  494. ebuf,
  495. sizeof(ebuf),
  496. "%s",
  497. "GET /file/not/found HTTP/1.0\r\n\r\n");
  498. ck_assert(conn != NULL);
  499. ri = mg_get_request_info(conn);
  500. ck_assert(ri != NULL);
  501. ck_assert_str_eq(ri->uri, "404");
  502. mg_close_connection(conn);
  503. /* Get data from callback */
  504. conn = mg_download(
  505. "localhost", ipv4_port, 0, ebuf, sizeof(ebuf), "%s", request);
  506. ck_assert(conn != NULL);
  507. ri = mg_get_request_info(conn);
  508. ck_assert(ri != NULL);
  509. ck_assert_str_eq(ri->uri, "200");
  510. i = mg_read(conn, buf, sizeof(buf));
  511. ck_assert_int_eq(i, (int)strlen(expected));
  512. buf[i] = 0;
  513. ck_assert_str_eq(buf, expected);
  514. mg_close_connection(conn);
  515. /* Get data from callback using http://127.0.0.1 */
  516. conn = mg_download(
  517. "127.0.0.1", ipv4_port, 0, ebuf, sizeof(ebuf), "%s", request);
  518. ck_assert(conn != NULL);
  519. ri = mg_get_request_info(conn);
  520. ck_assert(ri != NULL);
  521. ck_assert_str_eq(ri->uri, "200");
  522. i = mg_read(conn, buf, sizeof(buf));
  523. ck_assert_int_eq(i, (int)strlen(expected));
  524. buf[i] = 0;
  525. ck_assert_str_eq(buf, expected);
  526. mg_close_connection(conn);
  527. #if defined(USE_IPV6)
  528. /* Get data from callback using http://[::1] */
  529. conn =
  530. mg_download("[::1]", ipv6_port, 0, ebuf, sizeof(ebuf), "%s", request);
  531. ck_assert(conn != NULL);
  532. ri = mg_get_request_info(conn);
  533. ck_assert(ri != NULL);
  534. ck_assert_str_eq(ri->uri, "200");
  535. i = mg_read(conn, buf, sizeof(buf));
  536. ck_assert_int_eq(i, (int)strlen(expected));
  537. buf[i] = 0;
  538. ck_assert_str_eq(buf, expected);
  539. mg_close_connection(conn);
  540. #endif
  541. #if !defined(NO_SSL)
  542. /* Get data from callback using https://127.0.0.1 */
  543. conn = mg_download(
  544. "127.0.0.1", ipv4s_port, 1, ebuf, sizeof(ebuf), "%s", request);
  545. ck_assert(conn != NULL);
  546. ri = mg_get_request_info(conn);
  547. ck_assert(ri != NULL);
  548. ck_assert_str_eq(ri->uri, "200");
  549. i = mg_read(conn, buf, sizeof(buf));
  550. ck_assert_int_eq(i, (int)strlen(expected));
  551. buf[i] = 0;
  552. ck_assert_str_eq(buf, expected);
  553. mg_close_connection(conn);
  554. /* Get redirect from callback using http://127.0.0.1 */
  555. conn = mg_download(
  556. "127.0.0.1", ipv4r_port, 0, ebuf, sizeof(ebuf), "%s", request);
  557. ck_assert(conn != NULL);
  558. ri = mg_get_request_info(conn);
  559. ck_assert(ri != NULL);
  560. ck_assert_str_eq(ri->uri, "302");
  561. i = mg_read(conn, buf, sizeof(buf));
  562. ck_assert_int_eq(i, -1);
  563. mg_close_connection(conn);
  564. #endif
  565. #if defined(USE_IPV6) && !defined(NO_SSL)
  566. /* Get data from callback using https://[::1] */
  567. conn =
  568. mg_download("[::1]", ipv6s_port, 1, ebuf, sizeof(ebuf), "%s", request);
  569. ck_assert(conn != NULL);
  570. ri = mg_get_request_info(conn);
  571. ck_assert(ri != NULL);
  572. ck_assert_str_eq(ri->uri, "200");
  573. i = mg_read(conn, buf, sizeof(buf));
  574. ck_assert_int_eq(i, (int)strlen(expected));
  575. buf[i] = 0;
  576. ck_assert_str_eq(buf, expected);
  577. mg_close_connection(conn);
  578. /* Get redirect from callback using http://127.0.0.1 */
  579. conn =
  580. mg_download("[::1]", ipv6r_port, 0, ebuf, sizeof(ebuf), "%s", request);
  581. ck_assert(conn != NULL);
  582. ri = mg_get_request_info(conn);
  583. ck_assert(ri != NULL);
  584. ck_assert_str_eq(ri->uri, "302");
  585. i = mg_read(conn, buf, sizeof(buf));
  586. ck_assert_int_eq(i, -1);
  587. mg_close_connection(conn);
  588. #endif
  589. /* It seems to be impossible to find out what the actual working
  590. * directory of the CI test environment is. Before breaking another
  591. * dozen of builds by trying blindly with different paths, just
  592. * create the file here */
  593. #ifdef _WIN32
  594. f = fopen("test.txt", "wb");
  595. #else
  596. f = fopen("test.txt", "w");
  597. #endif
  598. fwrite("simple text file\n", 17, 1, f);
  599. fclose(f);
  600. /* Get static data */
  601. conn = mg_download("localhost",
  602. ipv4_port,
  603. 0,
  604. ebuf,
  605. sizeof(ebuf),
  606. "%s",
  607. "GET /test.txt HTTP/1.0\r\n\r\n");
  608. ck_assert(conn != NULL);
  609. ri = mg_get_request_info(conn);
  610. ck_assert(ri != NULL);
  611. ck_assert_str_eq(ri->uri, "200");
  612. i = mg_read(conn, buf, sizeof(buf));
  613. ck_assert_int_eq(i, 17);
  614. if ((i >= 0) && (i < (int)sizeof(buf))) {
  615. buf[i] = 0;
  616. }
  617. ck_assert_str_eq(buf, "simple text file\n");
  618. mg_close_connection(conn);
  619. /* Get directory listing */
  620. conn = mg_download("localhost",
  621. ipv4_port,
  622. 0,
  623. ebuf,
  624. sizeof(ebuf),
  625. "%s",
  626. "GET / HTTP/1.0\r\n\r\n");
  627. ck_assert(conn != NULL);
  628. ri = mg_get_request_info(conn);
  629. ck_assert(ri != NULL);
  630. ck_assert_str_eq(ri->uri, "200");
  631. i = mg_read(conn, buf, sizeof(buf));
  632. ck_assert(i > 6);
  633. buf[6] = 0;
  634. ck_assert_str_eq(buf, "<html>");
  635. mg_close_connection(conn);
  636. /* POST to static file (will not work) */
  637. conn = mg_download("localhost",
  638. ipv4_port,
  639. 0,
  640. ebuf,
  641. sizeof(ebuf),
  642. "%s",
  643. "POST /test.txt HTTP/1.0\r\n\r\n");
  644. ck_assert(conn != NULL);
  645. ri = mg_get_request_info(conn);
  646. ck_assert(ri != NULL);
  647. ck_assert_str_eq(ri->uri, "405");
  648. i = mg_read(conn, buf, sizeof(buf));
  649. ck_assert(i >= 29);
  650. buf[29] = 0;
  651. ck_assert_str_eq(buf, "Error 405: Method Not Allowed");
  652. mg_close_connection(conn);
  653. /* PUT to static file (will not work) */
  654. conn = mg_download("localhost",
  655. ipv4_port,
  656. 0,
  657. ebuf,
  658. sizeof(ebuf),
  659. "%s",
  660. "PUT /test.txt HTTP/1.0\r\n\r\n");
  661. ck_assert(conn != NULL);
  662. ri = mg_get_request_info(conn);
  663. ck_assert(ri != NULL);
  664. ck_assert_str_eq(ri->uri, "401"); /* not authorized */
  665. mg_close_connection(conn);
  666. /* TODO: Test websockets */
  667. /* Close the server */
  668. g_ctx = NULL;
  669. mg_stop(ctx);
  670. mg_Sleep(1);
  671. }
  672. END_TEST
  673. Suite *make_public_suite(void)
  674. {
  675. Suite *const suite = suite_create("Public");
  676. TCase *const version = tcase_create("Version");
  677. TCase *const get_valid_options = tcase_create("Options");
  678. TCase *const get_builtin_mime_type = tcase_create("MIME types");
  679. TCase *const tstrncasecmp = tcase_create("strcasecmp");
  680. TCase *const urlencodingdecoding = tcase_create("URL encoding decoding");
  681. TCase *const cookies = tcase_create("Cookies and variables");
  682. TCase *const md5 = tcase_create("MD5");
  683. TCase *const startstophttp = tcase_create("Start Stop HTTP Server");
  684. TCase *const startstophttps = tcase_create("Start Stop HTTPS Server");
  685. tcase_add_test(version, test_mg_version);
  686. suite_add_tcase(suite, version);
  687. tcase_add_test(get_valid_options, test_mg_get_valid_options);
  688. suite_add_tcase(suite, get_valid_options);
  689. tcase_add_test(get_builtin_mime_type, test_mg_get_builtin_mime_type);
  690. suite_add_tcase(suite, get_builtin_mime_type);
  691. tcase_add_test(tstrncasecmp, test_mg_strncasecmp);
  692. suite_add_tcase(suite, tstrncasecmp);
  693. tcase_add_test(urlencodingdecoding, test_mg_url_encode);
  694. tcase_add_test(urlencodingdecoding, test_mg_url_decode);
  695. suite_add_tcase(suite, urlencodingdecoding);
  696. tcase_add_test(cookies, test_mg_get_cookie);
  697. tcase_add_test(cookies, test_mg_get_var);
  698. suite_add_tcase(suite, cookies);
  699. tcase_add_test(md5, test_mg_md5);
  700. suite_add_tcase(suite, md5);
  701. tcase_add_test(startstophttp, test_mg_start_stop_http_server);
  702. tcase_add_test(startstophttp, test_request_handlers);
  703. suite_add_tcase(suite, startstophttp);
  704. tcase_add_test(startstophttps, test_mg_start_stop_https_server);
  705. suite_add_tcase(suite, startstophttps);
  706. return suite;
  707. }
  708. #ifdef REPLACE_CHECK_FOR_LOCAL_DEBUGGING
  709. /* Used to debug test cases without using the check framework */
  710. static int chk_ok = 0;
  711. static int chk_failed = 0;
  712. void main(void)
  713. {
  714. test_mg_start_stop_http_server(0);
  715. test_mg_start_stop_https_server(0);
  716. test_request_handlers(0);
  717. printf("\nok: %i\nfailed: %i\n\n", chk_ok, chk_failed);
  718. }
  719. void _ck_assert_failed(const char *file, int line, const char *expr, ...)
  720. {
  721. va_list va;
  722. va_start(va, expr);
  723. fprintf(stderr, "Error: %s, line %i\n", file, line); /* breakpoint here ! */
  724. vfprintf(stderr, expr, va);
  725. va_end(va);
  726. chk_failed++;
  727. }
  728. void _mark_point(const char *file, int line) { chk_ok++; }
  729. void tcase_fn_start(const char *fname, const char *file, int line) {}
  730. void suite_add_tcase(Suite *s, TCase *tc){};
  731. void _tcase_add_test(TCase *tc,
  732. TFun tf,
  733. const char *fname,
  734. int _signal,
  735. int allowed_exit_value,
  736. int start,
  737. int end){};
  738. TCase *tcase_create(const char *name) { return NULL; };
  739. Suite *suite_create(const char *name) { return NULL; };
  740. #endif