test_circuitlist.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469
  1. /* Copyright (c) 2013-2017, The Tor Project, Inc. */
  2. /* See LICENSE for licensing information */
  3. #define TOR_CHANNEL_INTERNAL_
  4. #define CIRCUITBUILD_PRIVATE
  5. #define CIRCUITLIST_PRIVATE
  6. #define HS_CIRCUITMAP_PRIVATE
  7. #include "or.h"
  8. #include "channel.h"
  9. #include "circuitbuild.h"
  10. #include "circuitlist.h"
  11. #include "hs_circuitmap.h"
  12. #include "test.h"
  13. #include "log_test_helpers.h"
  14. static channel_t *
  15. new_fake_channel(void)
  16. {
  17. channel_t *chan = tor_malloc_zero(sizeof(channel_t));
  18. channel_init(chan);
  19. return chan;
  20. }
  21. static struct {
  22. int ncalls;
  23. void *cmux;
  24. void *circ;
  25. cell_direction_t dir;
  26. } cam;
  27. static void
  28. circuitmux_attach_mock(circuitmux_t *cmux, circuit_t *circ,
  29. cell_direction_t dir)
  30. {
  31. ++cam.ncalls;
  32. cam.cmux = cmux;
  33. cam.circ = circ;
  34. cam.dir = dir;
  35. }
  36. static struct {
  37. int ncalls;
  38. void *cmux;
  39. void *circ;
  40. } cdm;
  41. static void
  42. circuitmux_detach_mock(circuitmux_t *cmux, circuit_t *circ)
  43. {
  44. ++cdm.ncalls;
  45. cdm.cmux = cmux;
  46. cdm.circ = circ;
  47. }
  48. #define GOT_CMUX_ATTACH(mux_, circ_, dir_) do { \
  49. tt_int_op(cam.ncalls, OP_EQ, 1); \
  50. tt_ptr_op(cam.cmux, OP_EQ, (mux_)); \
  51. tt_ptr_op(cam.circ, OP_EQ, (circ_)); \
  52. tt_int_op(cam.dir, OP_EQ, (dir_)); \
  53. memset(&cam, 0, sizeof(cam)); \
  54. } while (0)
  55. #define GOT_CMUX_DETACH(mux_, circ_) do { \
  56. tt_int_op(cdm.ncalls, OP_EQ, 1); \
  57. tt_ptr_op(cdm.cmux, OP_EQ, (mux_)); \
  58. tt_ptr_op(cdm.circ, OP_EQ, (circ_)); \
  59. memset(&cdm, 0, sizeof(cdm)); \
  60. } while (0)
  61. static void
  62. test_clist_maps(void *arg)
  63. {
  64. channel_t *ch1 = new_fake_channel();
  65. channel_t *ch2 = new_fake_channel();
  66. channel_t *ch3 = new_fake_channel();
  67. or_circuit_t *or_c1=NULL, *or_c2=NULL;
  68. (void) arg;
  69. MOCK(circuitmux_attach_circuit, circuitmux_attach_mock);
  70. MOCK(circuitmux_detach_circuit, circuitmux_detach_mock);
  71. memset(&cam, 0, sizeof(cam));
  72. memset(&cdm, 0, sizeof(cdm));
  73. tt_assert(ch1);
  74. tt_assert(ch2);
  75. tt_assert(ch3);
  76. ch1->cmux = tor_malloc(1);
  77. ch2->cmux = tor_malloc(1);
  78. ch3->cmux = tor_malloc(1);
  79. or_c1 = or_circuit_new(100, ch2);
  80. tt_assert(or_c1);
  81. GOT_CMUX_ATTACH(ch2->cmux, or_c1, CELL_DIRECTION_IN);
  82. tt_int_op(or_c1->p_circ_id, OP_EQ, 100);
  83. tt_ptr_op(or_c1->p_chan, OP_EQ, ch2);
  84. or_c2 = or_circuit_new(100, ch1);
  85. tt_assert(or_c2);
  86. GOT_CMUX_ATTACH(ch1->cmux, or_c2, CELL_DIRECTION_IN);
  87. tt_int_op(or_c2->p_circ_id, OP_EQ, 100);
  88. tt_ptr_op(or_c2->p_chan, OP_EQ, ch1);
  89. circuit_set_n_circid_chan(TO_CIRCUIT(or_c1), 200, ch1);
  90. GOT_CMUX_ATTACH(ch1->cmux, or_c1, CELL_DIRECTION_OUT);
  91. circuit_set_n_circid_chan(TO_CIRCUIT(or_c2), 200, ch2);
  92. GOT_CMUX_ATTACH(ch2->cmux, or_c2, CELL_DIRECTION_OUT);
  93. tt_ptr_op(circuit_get_by_circid_channel(200, ch1), OP_EQ, TO_CIRCUIT(or_c1));
  94. tt_ptr_op(circuit_get_by_circid_channel(200, ch2), OP_EQ, TO_CIRCUIT(or_c2));
  95. tt_ptr_op(circuit_get_by_circid_channel(100, ch2), OP_EQ, TO_CIRCUIT(or_c1));
  96. /* Try the same thing again, to test the "fast" path. */
  97. tt_ptr_op(circuit_get_by_circid_channel(100, ch2), OP_EQ, TO_CIRCUIT(or_c1));
  98. tt_assert(circuit_id_in_use_on_channel(100, ch2));
  99. tt_assert(! circuit_id_in_use_on_channel(101, ch2));
  100. /* Try changing the circuitid and channel of that circuit. */
  101. circuit_set_p_circid_chan(or_c1, 500, ch3);
  102. GOT_CMUX_DETACH(ch2->cmux, TO_CIRCUIT(or_c1));
  103. GOT_CMUX_ATTACH(ch3->cmux, TO_CIRCUIT(or_c1), CELL_DIRECTION_IN);
  104. tt_ptr_op(circuit_get_by_circid_channel(100, ch2), OP_EQ, NULL);
  105. tt_assert(! circuit_id_in_use_on_channel(100, ch2));
  106. tt_ptr_op(circuit_get_by_circid_channel(500, ch3), OP_EQ, TO_CIRCUIT(or_c1));
  107. /* Now let's see about destroy handling. */
  108. tt_assert(! circuit_id_in_use_on_channel(205, ch2));
  109. tt_assert(circuit_id_in_use_on_channel(200, ch2));
  110. channel_note_destroy_pending(ch2, 200);
  111. channel_note_destroy_pending(ch2, 205);
  112. channel_note_destroy_pending(ch1, 100);
  113. tt_assert(circuit_id_in_use_on_channel(205, ch2))
  114. tt_assert(circuit_id_in_use_on_channel(200, ch2));
  115. tt_assert(circuit_id_in_use_on_channel(100, ch1));
  116. tt_assert(TO_CIRCUIT(or_c2)->n_delete_pending != 0);
  117. tt_ptr_op(circuit_get_by_circid_channel(200, ch2), OP_EQ, TO_CIRCUIT(or_c2));
  118. tt_ptr_op(circuit_get_by_circid_channel(100, ch1), OP_EQ, TO_CIRCUIT(or_c2));
  119. /* Okay, now free ch2 and make sure that the circuit ID is STILL not
  120. * usable, because we haven't declared the destroy to be nonpending */
  121. tt_int_op(cdm.ncalls, OP_EQ, 0);
  122. circuit_free(TO_CIRCUIT(or_c2));
  123. or_c2 = NULL; /* prevent free */
  124. tt_int_op(cdm.ncalls, OP_EQ, 2);
  125. memset(&cdm, 0, sizeof(cdm));
  126. tt_assert(circuit_id_in_use_on_channel(200, ch2));
  127. tt_assert(circuit_id_in_use_on_channel(100, ch1));
  128. tt_ptr_op(circuit_get_by_circid_channel(200, ch2), OP_EQ, NULL);
  129. tt_ptr_op(circuit_get_by_circid_channel(100, ch1), OP_EQ, NULL);
  130. /* Now say that the destroy is nonpending */
  131. channel_note_destroy_not_pending(ch2, 200);
  132. tt_ptr_op(circuit_get_by_circid_channel(200, ch2), OP_EQ, NULL);
  133. channel_note_destroy_not_pending(ch1, 100);
  134. tt_ptr_op(circuit_get_by_circid_channel(100, ch1), OP_EQ, NULL);
  135. tt_assert(! circuit_id_in_use_on_channel(200, ch2));
  136. tt_assert(! circuit_id_in_use_on_channel(100, ch1));
  137. done:
  138. if (or_c1)
  139. circuit_free(TO_CIRCUIT(or_c1));
  140. if (or_c2)
  141. circuit_free(TO_CIRCUIT(or_c2));
  142. if (ch1)
  143. tor_free(ch1->cmux);
  144. if (ch2)
  145. tor_free(ch2->cmux);
  146. if (ch3)
  147. tor_free(ch3->cmux);
  148. tor_free(ch1);
  149. tor_free(ch2);
  150. tor_free(ch3);
  151. UNMOCK(circuitmux_attach_circuit);
  152. UNMOCK(circuitmux_detach_circuit);
  153. }
  154. static void
  155. test_rend_token_maps(void *arg)
  156. {
  157. or_circuit_t *c1, *c2, *c3, *c4;
  158. origin_circuit_t *c5;
  159. const uint8_t tok1[REND_TOKEN_LEN] = "The cat can't tell y";
  160. const uint8_t tok2[REND_TOKEN_LEN] = "ou its name, and it ";
  161. const uint8_t tok3[REND_TOKEN_LEN] = "doesn't really care.";
  162. /* -- Adapted from a quote by Fredrik Lundh. */
  163. (void)arg;
  164. (void)tok1; //xxxx
  165. hs_circuitmap_init();
  166. c1 = or_circuit_new(0, NULL);
  167. c2 = or_circuit_new(0, NULL);
  168. c3 = or_circuit_new(0, NULL);
  169. c4 = or_circuit_new(0, NULL);
  170. c5 = origin_circuit_new();
  171. /* Make sure we really filled up the tok* variables */
  172. tt_int_op(tok1[REND_TOKEN_LEN-1], OP_EQ, 'y');
  173. tt_int_op(tok2[REND_TOKEN_LEN-1], OP_EQ, ' ');
  174. tt_int_op(tok3[REND_TOKEN_LEN-1], OP_EQ, '.');
  175. /* No maps; nothing there. */
  176. tt_ptr_op(NULL, OP_EQ, hs_circuitmap_get_rend_circ_relay_side(tok1));
  177. tt_ptr_op(NULL, OP_EQ, hs_circuitmap_get_intro_circ_v2_relay_side(tok1));
  178. hs_circuitmap_register_rend_circ_relay_side(c1, tok1);
  179. hs_circuitmap_register_intro_circ_v2_relay_side(c2, tok2);
  180. tt_ptr_op(NULL, OP_EQ, hs_circuitmap_get_rend_circ_relay_side(tok3));
  181. tt_ptr_op(NULL, OP_EQ, hs_circuitmap_get_intro_circ_v2_relay_side(tok3));
  182. tt_ptr_op(NULL, OP_EQ, hs_circuitmap_get_rend_circ_relay_side(tok2));
  183. tt_ptr_op(NULL, OP_EQ, hs_circuitmap_get_intro_circ_v2_relay_side(tok1));
  184. /* Without purpose set, we don't get the circuits */
  185. tt_ptr_op(NULL, OP_EQ, hs_circuitmap_get_rend_circ_relay_side(tok1));
  186. tt_ptr_op(NULL, OP_EQ, hs_circuitmap_get_intro_circ_v2_relay_side(tok2));
  187. c1->base_.purpose = CIRCUIT_PURPOSE_REND_POINT_WAITING;
  188. c2->base_.purpose = CIRCUIT_PURPOSE_INTRO_POINT;
  189. /* Okay, make sure they show up now. */
  190. tt_ptr_op(c1, OP_EQ, hs_circuitmap_get_rend_circ_relay_side(tok1));
  191. tt_ptr_op(c2, OP_EQ, hs_circuitmap_get_intro_circ_v2_relay_side(tok2));
  192. /* Two items at the same place with the same token. */
  193. c3->base_.purpose = CIRCUIT_PURPOSE_REND_POINT_WAITING;
  194. hs_circuitmap_register_rend_circ_relay_side(c3, tok2);
  195. tt_ptr_op(c2, OP_EQ, hs_circuitmap_get_intro_circ_v2_relay_side(tok2));
  196. tt_ptr_op(c3, OP_EQ, hs_circuitmap_get_rend_circ_relay_side(tok2));
  197. /* Marking a circuit makes it not get returned any more */
  198. circuit_mark_for_close(TO_CIRCUIT(c1), END_CIRC_REASON_FINISHED);
  199. tt_ptr_op(NULL, OP_EQ, hs_circuitmap_get_rend_circ_relay_side(tok1));
  200. circuit_free(TO_CIRCUIT(c1));
  201. c1 = NULL;
  202. /* Freeing a circuit makes it not get returned any more. */
  203. circuit_free(TO_CIRCUIT(c2));
  204. c2 = NULL;
  205. tt_ptr_op(NULL, OP_EQ, hs_circuitmap_get_intro_circ_v2_relay_side(tok2));
  206. /* c3 -- are you still there? */
  207. tt_ptr_op(c3, OP_EQ, hs_circuitmap_get_rend_circ_relay_side(tok2));
  208. /* Change its cookie. This never happens in Tor per se, but hey. */
  209. c3->base_.purpose = CIRCUIT_PURPOSE_INTRO_POINT;
  210. hs_circuitmap_register_intro_circ_v2_relay_side(c3, tok3);
  211. tt_ptr_op(NULL, OP_EQ, hs_circuitmap_get_rend_circ_relay_side(tok2));
  212. tt_ptr_op(c3, OP_EQ, hs_circuitmap_get_intro_circ_v2_relay_side(tok3));
  213. /* Now replace c3 with c4. */
  214. c4->base_.purpose = CIRCUIT_PURPOSE_INTRO_POINT;
  215. hs_circuitmap_register_intro_circ_v2_relay_side(c4, tok3);
  216. tt_ptr_op(c4, OP_EQ, hs_circuitmap_get_intro_circ_v2_relay_side(tok3));
  217. tt_ptr_op(TO_CIRCUIT(c3)->hs_token, OP_EQ, NULL);
  218. tt_ptr_op(TO_CIRCUIT(c4)->hs_token, OP_NE, NULL);
  219. tt_mem_op(TO_CIRCUIT(c4)->hs_token->token, OP_EQ, tok3, REND_TOKEN_LEN);
  220. /* Now clear c4's cookie. */
  221. hs_circuitmap_remove_circuit(TO_CIRCUIT(c4));
  222. tt_ptr_op(TO_CIRCUIT(c4)->hs_token, OP_EQ, NULL);
  223. tt_ptr_op(NULL, OP_EQ, hs_circuitmap_get_intro_circ_v2_relay_side(tok3));
  224. /* Now let's do a check for the client-side rend circuitmap */
  225. c5->base_.purpose = CIRCUIT_PURPOSE_C_ESTABLISH_REND;
  226. hs_circuitmap_register_rend_circ_client_side(c5, tok1);
  227. tt_ptr_op(c5, OP_EQ, hs_circuitmap_get_rend_circ_client_side(tok1));
  228. tt_ptr_op(NULL, OP_EQ, hs_circuitmap_get_rend_circ_client_side(tok2));
  229. done:
  230. if (c1)
  231. circuit_free(TO_CIRCUIT(c1));
  232. if (c2)
  233. circuit_free(TO_CIRCUIT(c2));
  234. if (c3)
  235. circuit_free(TO_CIRCUIT(c3));
  236. if (c4)
  237. circuit_free(TO_CIRCUIT(c4));
  238. if (c5)
  239. circuit_free(TO_CIRCUIT(c5));
  240. }
  241. static void
  242. mock_channel_dump_statistics(channel_t *chan, int severity)
  243. {
  244. (void)chan;
  245. (void)severity;
  246. }
  247. static void
  248. test_pick_circid(void *arg)
  249. {
  250. bitarray_t *ba = NULL;
  251. channel_t *chan1, *chan2;
  252. circid_t circid;
  253. int i;
  254. (void) arg;
  255. MOCK(channel_dump_statistics, mock_channel_dump_statistics);
  256. chan1 = tor_malloc_zero(sizeof(channel_t));
  257. chan2 = tor_malloc_zero(sizeof(channel_t));
  258. chan2->wide_circ_ids = 1;
  259. chan1->cmux = circuitmux_alloc();
  260. chan2->cmux = circuitmux_alloc();
  261. /* CIRC_ID_TYPE_NEITHER is supposed to create a warning. */
  262. chan1->circ_id_type = CIRC_ID_TYPE_NEITHER;
  263. setup_full_capture_of_logs(LOG_WARN);
  264. tt_int_op(0, OP_EQ, get_unique_circ_id_by_chan(chan1));
  265. expect_single_log_msg_containing("Trying to pick a circuit ID for a "
  266. "connection from a client with no identity.");
  267. teardown_capture_of_logs();
  268. /* Basic tests, with no collisions */
  269. chan1->circ_id_type = CIRC_ID_TYPE_LOWER;
  270. for (i = 0; i < 50; ++i) {
  271. circid = get_unique_circ_id_by_chan(chan1);
  272. tt_uint_op(0, OP_LT, circid);
  273. tt_uint_op(circid, OP_LT, (1<<15));
  274. }
  275. chan1->circ_id_type = CIRC_ID_TYPE_HIGHER;
  276. for (i = 0; i < 50; ++i) {
  277. circid = get_unique_circ_id_by_chan(chan1);
  278. tt_uint_op((1<<15), OP_LT, circid);
  279. tt_uint_op(circid, OP_LT, (1<<16));
  280. }
  281. chan2->circ_id_type = CIRC_ID_TYPE_LOWER;
  282. for (i = 0; i < 50; ++i) {
  283. circid = get_unique_circ_id_by_chan(chan2);
  284. tt_uint_op(0, OP_LT, circid);
  285. tt_uint_op(circid, OP_LT, (1u<<31));
  286. }
  287. chan2->circ_id_type = CIRC_ID_TYPE_HIGHER;
  288. for (i = 0; i < 50; ++i) {
  289. circid = get_unique_circ_id_by_chan(chan2);
  290. tt_uint_op((1u<<31), OP_LT, circid);
  291. }
  292. /* Now make sure that we can behave well when we are full up on circuits */
  293. chan1->circ_id_type = CIRC_ID_TYPE_LOWER;
  294. chan2->circ_id_type = CIRC_ID_TYPE_LOWER;
  295. chan1->wide_circ_ids = chan2->wide_circ_ids = 0;
  296. ba = bitarray_init_zero((1<<15));
  297. for (i = 0; i < (1<<15); ++i) {
  298. circid = get_unique_circ_id_by_chan(chan1);
  299. if (circid == 0) {
  300. tt_int_op(i, OP_GT, (1<<14));
  301. break;
  302. }
  303. tt_uint_op(circid, OP_LT, (1<<15));
  304. tt_assert(! bitarray_is_set(ba, circid));
  305. bitarray_set(ba, circid);
  306. channel_mark_circid_unusable(chan1, circid);
  307. }
  308. tt_int_op(i, OP_LT, (1<<15));
  309. /* Make sure that being full on chan1 does not interfere with chan2 */
  310. for (i = 0; i < 100; ++i) {
  311. circid = get_unique_circ_id_by_chan(chan2);
  312. tt_uint_op(circid, OP_GT, 0);
  313. tt_uint_op(circid, OP_LT, (1<<15));
  314. channel_mark_circid_unusable(chan2, circid);
  315. }
  316. done:
  317. circuitmux_free(chan1->cmux);
  318. circuitmux_free(chan2->cmux);
  319. tor_free(chan1);
  320. tor_free(chan2);
  321. bitarray_free(ba);
  322. circuit_free_all();
  323. teardown_capture_of_logs();
  324. UNMOCK(channel_dump_statistics);
  325. }
  326. /** Test that the circuit pools of our HS circuitmap are isolated based on
  327. * their token type. */
  328. static void
  329. test_hs_circuitmap_isolation(void *arg)
  330. {
  331. or_circuit_t *circ1 = NULL;
  332. origin_circuit_t *circ2 = NULL;
  333. or_circuit_t *circ3 = NULL;
  334. origin_circuit_t *circ4 = NULL;
  335. (void)arg;
  336. hs_circuitmap_init();
  337. {
  338. const uint8_t tok1[REND_TOKEN_LEN] = "bet i got some of th";
  339. circ1 = or_circuit_new(0, NULL);
  340. tt_assert(circ1);
  341. circ1->base_.purpose = CIRCUIT_PURPOSE_REND_POINT_WAITING;
  342. /* check that circuitmap is empty right? */
  343. tt_ptr_op(NULL, OP_EQ, hs_circuitmap_get_rend_circ_relay_side(tok1));
  344. /* Register circ1 with tok1 as relay-side rend circ */
  345. hs_circuitmap_register_rend_circ_relay_side(circ1, tok1);
  346. /* check that service-side getters don't work */
  347. tt_ptr_op(NULL, OP_EQ, hs_circuitmap_get_rend_circ_service_side(tok1));
  348. tt_ptr_op(NULL, OP_EQ, hs_circuitmap_get_intro_circ_v2_service_side(tok1));
  349. /* Check that the right getter works. */
  350. tt_ptr_op(circ1, OP_EQ, hs_circuitmap_get_rend_circ_relay_side(tok1));
  351. }
  352. {
  353. const uint8_t tok2[REND_TOKEN_LEN] = "you dont know anythi";
  354. circ2 = origin_circuit_new();
  355. tt_assert(circ2);
  356. circ2->base_.purpose = CIRCUIT_PURPOSE_S_ESTABLISH_INTRO;
  357. circ3 = or_circuit_new(0, NULL);
  358. tt_assert(circ3);
  359. circ3->base_.purpose = CIRCUIT_PURPOSE_INTRO_POINT;
  360. circ4 = origin_circuit_new();
  361. tt_assert(circ4);
  362. circ4->base_.purpose = CIRCUIT_PURPOSE_S_ESTABLISH_INTRO;
  363. /* Register circ2 with tok2 as service-side intro v2 circ */
  364. hs_circuitmap_register_intro_circ_v2_service_side(circ2, tok2);
  365. /* Register circ3 with tok2 again but for different purpose */
  366. hs_circuitmap_register_intro_circ_v2_relay_side(circ3, tok2);
  367. /* Check that the getters work */
  368. tt_ptr_op(circ2, OP_EQ,
  369. hs_circuitmap_get_intro_circ_v2_service_side(tok2));
  370. tt_ptr_op(circ3, OP_EQ, hs_circuitmap_get_intro_circ_v2_relay_side(tok2));
  371. /* Register circ4 with tok2: it should override circ2 */
  372. hs_circuitmap_register_intro_circ_v2_service_side(circ4, tok2);
  373. /* check that relay-side getters don't work */
  374. tt_ptr_op(NULL, OP_EQ, hs_circuitmap_get_rend_circ_relay_side(tok2));
  375. /* Check that the getter returns circ4; the last circuit registered with
  376. * that token. */
  377. tt_ptr_op(circ4, OP_EQ,
  378. hs_circuitmap_get_intro_circ_v2_service_side(tok2));
  379. }
  380. done:
  381. circuit_free(TO_CIRCUIT(circ1));
  382. circuit_free(TO_CIRCUIT(circ2));
  383. circuit_free(TO_CIRCUIT(circ3));
  384. circuit_free(TO_CIRCUIT(circ4));
  385. }
  386. struct testcase_t circuitlist_tests[] = {
  387. { "maps", test_clist_maps, TT_FORK, NULL, NULL },
  388. { "rend_token_maps", test_rend_token_maps, TT_FORK, NULL, NULL },
  389. { "pick_circid", test_pick_circid, TT_FORK, NULL, NULL },
  390. { "hs_circuitmap_isolation", test_hs_circuitmap_isolation,
  391. TT_FORK, NULL, NULL },
  392. END_OF_TESTCASES
  393. };