test_channeltls.c 9.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333
  1. /* Copyright (c) 2014-2015, The Tor Project, Inc. */
  2. /* See LICENSE for licensing information */
  3. #include <math.h>
  4. #define TOR_CHANNEL_INTERNAL_
  5. #include "or.h"
  6. #include "address.h"
  7. #include "buffers.h"
  8. #include "channel.h"
  9. #include "channeltls.h"
  10. #include "connection_or.h"
  11. #include "config.h"
  12. /* For init/free stuff */
  13. #include "scheduler.h"
  14. #include "tortls.h"
  15. /* Test suite stuff */
  16. #include "test.h"
  17. #include "fakechans.h"
  18. /* The channeltls unit tests */
  19. static void test_channeltls_create(void *arg);
  20. static void test_channeltls_num_bytes_queued(void *arg);
  21. static void test_channeltls_overhead_estimate(void *arg);
  22. /* Mocks used by channeltls unit tests */
  23. static size_t tlschan_buf_datalen_mock(const buf_t *buf);
  24. static or_connection_t * tlschan_connection_or_connect_mock(
  25. const tor_addr_t *addr,
  26. uint16_t port,
  27. const char *digest,
  28. channel_tls_t *tlschan);
  29. static int tlschan_is_local_addr_mock(const tor_addr_t *addr);
  30. /* Fake close method */
  31. static void tlschan_fake_close_method(channel_t *chan);
  32. /* Flags controlling behavior of channeltls unit test mocks */
  33. static int tlschan_local = 0;
  34. static const buf_t * tlschan_buf_datalen_mock_target = NULL;
  35. static size_t tlschan_buf_datalen_mock_size = 0;
  36. /* Thing to cast to fake tor_tls_t * to appease assert_connection_ok() */
  37. static int fake_tortls = 0; /* Bleh... */
  38. static void
  39. test_channeltls_create(void *arg)
  40. {
  41. tor_addr_t test_addr;
  42. channel_t *ch = NULL;
  43. const char test_digest[DIGEST_LEN] = {
  44. 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
  45. 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14 };
  46. (void)arg;
  47. /* Set up a fake address to fake-connect to */
  48. test_addr.family = AF_INET;
  49. test_addr.addr.in_addr.s_addr = htonl(0x01020304);
  50. /* For this test we always want the address to be treated as non-local */
  51. tlschan_local = 0;
  52. /* Install is_local_addr() mock */
  53. MOCK(is_local_addr, tlschan_is_local_addr_mock);
  54. /* Install mock for connection_or_connect() */
  55. MOCK(connection_or_connect, tlschan_connection_or_connect_mock);
  56. /* Try connecting */
  57. ch = channel_tls_connect(&test_addr, 567, test_digest);
  58. tt_assert(ch != NULL);
  59. done:
  60. if (ch) {
  61. MOCK(scheduler_release_channel, scheduler_release_channel_mock);
  62. /*
  63. * Use fake close method that doesn't try to do too much to fake
  64. * orconn
  65. */
  66. ch->close = tlschan_fake_close_method;
  67. channel_mark_for_close(ch);
  68. free_fake_channel(ch);
  69. UNMOCK(scheduler_release_channel);
  70. }
  71. UNMOCK(connection_or_connect);
  72. UNMOCK(is_local_addr);
  73. return;
  74. }
  75. static void
  76. test_channeltls_num_bytes_queued(void *arg)
  77. {
  78. tor_addr_t test_addr;
  79. channel_t *ch = NULL;
  80. const char test_digest[DIGEST_LEN] = {
  81. 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
  82. 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14 };
  83. channel_tls_t *tlschan = NULL;
  84. size_t len;
  85. int fake_outbuf = 0, n;
  86. (void)arg;
  87. /* Set up a fake address to fake-connect to */
  88. test_addr.family = AF_INET;
  89. test_addr.addr.in_addr.s_addr = htonl(0x01020304);
  90. /* For this test we always want the address to be treated as non-local */
  91. tlschan_local = 0;
  92. /* Install is_local_addr() mock */
  93. MOCK(is_local_addr, tlschan_is_local_addr_mock);
  94. /* Install mock for connection_or_connect() */
  95. MOCK(connection_or_connect, tlschan_connection_or_connect_mock);
  96. /* Try connecting */
  97. ch = channel_tls_connect(&test_addr, 567, test_digest);
  98. tt_assert(ch != NULL);
  99. /*
  100. * Next, we have to test ch->num_bytes_queued, which is
  101. * channel_tls_num_bytes_queued_method. We can't mock
  102. * connection_get_outbuf_len() directly because it's static INLINE
  103. * in connection.h, but we can mock buf_datalen(). Note that
  104. * if bufferevents ever work, this will break with them enabled.
  105. */
  106. tt_assert(ch->num_bytes_queued != NULL);
  107. tlschan = BASE_CHAN_TO_TLS(ch);
  108. tt_assert(tlschan != NULL);
  109. if (TO_CONN(tlschan->conn)->outbuf == NULL) {
  110. /* We need an outbuf to make sure buf_datalen() gets called */
  111. fake_outbuf = 1;
  112. TO_CONN(tlschan->conn)->outbuf = buf_new();
  113. }
  114. tlschan_buf_datalen_mock_target = TO_CONN(tlschan->conn)->outbuf;
  115. tlschan_buf_datalen_mock_size = 1024;
  116. MOCK(buf_datalen, tlschan_buf_datalen_mock);
  117. len = ch->num_bytes_queued(ch);
  118. tt_int_op(len, ==, tlschan_buf_datalen_mock_size);
  119. /*
  120. * We also cover num_cells_writeable here; since wide_circ_ids = 0 on
  121. * the fake tlschans, cell_network_size returns 512, and so with
  122. * tlschan_buf_datalen_mock_size == 1024, we should be able to write
  123. * ceil((OR_CONN_HIGHWATER - 1024) / 512) = ceil(OR_CONN_HIGHWATER / 512)
  124. * - 2 cells.
  125. */
  126. n = ch->num_cells_writeable(ch);
  127. tt_int_op(n, ==, CEIL_DIV(OR_CONN_HIGHWATER, 512) - 2);
  128. UNMOCK(buf_datalen);
  129. tlschan_buf_datalen_mock_target = NULL;
  130. tlschan_buf_datalen_mock_size = 0;
  131. if (fake_outbuf) {
  132. buf_free(TO_CONN(tlschan->conn)->outbuf);
  133. TO_CONN(tlschan->conn)->outbuf = NULL;
  134. }
  135. done:
  136. if (ch) {
  137. MOCK(scheduler_release_channel, scheduler_release_channel_mock);
  138. /*
  139. * Use fake close method that doesn't try to do too much to fake
  140. * orconn
  141. */
  142. ch->close = tlschan_fake_close_method;
  143. channel_mark_for_close(ch);
  144. free_fake_channel(ch);
  145. UNMOCK(scheduler_release_channel);
  146. }
  147. UNMOCK(connection_or_connect);
  148. UNMOCK(is_local_addr);
  149. return;
  150. }
  151. static void
  152. test_channeltls_overhead_estimate(void *arg)
  153. {
  154. tor_addr_t test_addr;
  155. channel_t *ch = NULL;
  156. const char test_digest[DIGEST_LEN] = {
  157. 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
  158. 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14 };
  159. float r;
  160. channel_tls_t *tlschan = NULL;
  161. (void)arg;
  162. /* Set up a fake address to fake-connect to */
  163. test_addr.family = AF_INET;
  164. test_addr.addr.in_addr.s_addr = htonl(0x01020304);
  165. /* For this test we always want the address to be treated as non-local */
  166. tlschan_local = 0;
  167. /* Install is_local_addr() mock */
  168. MOCK(is_local_addr, tlschan_is_local_addr_mock);
  169. /* Install mock for connection_or_connect() */
  170. MOCK(connection_or_connect, tlschan_connection_or_connect_mock);
  171. /* Try connecting */
  172. ch = channel_tls_connect(&test_addr, 567, test_digest);
  173. tt_assert(ch != NULL);
  174. /* First case: silly low ratios should get clamped to 1.0f */
  175. tlschan = BASE_CHAN_TO_TLS(ch);
  176. tt_assert(tlschan != NULL);
  177. tlschan->conn->bytes_xmitted = 128;
  178. tlschan->conn->bytes_xmitted_by_tls = 64;
  179. r = ch->get_overhead_estimate(ch);
  180. tt_assert(fabsf(r - 1.0f) < 1E-12);
  181. tlschan->conn->bytes_xmitted_by_tls = 127;
  182. r = ch->get_overhead_estimate(ch);
  183. tt_assert(fabsf(r - 1.0f) < 1E-12);
  184. /* Now middle of the range */
  185. tlschan->conn->bytes_xmitted_by_tls = 192;
  186. r = ch->get_overhead_estimate(ch);
  187. tt_assert(fabsf(r - 1.5f) < 1E-12);
  188. /* Now above the 2.0f clamp */
  189. tlschan->conn->bytes_xmitted_by_tls = 257;
  190. r = ch->get_overhead_estimate(ch);
  191. tt_assert(fabsf(r - 2.0f) < 1E-12);
  192. tlschan->conn->bytes_xmitted_by_tls = 512;
  193. r = ch->get_overhead_estimate(ch);
  194. tt_assert(fabsf(r - 2.0f) < 1E-12);
  195. done:
  196. if (ch) {
  197. MOCK(scheduler_release_channel, scheduler_release_channel_mock);
  198. /*
  199. * Use fake close method that doesn't try to do too much to fake
  200. * orconn
  201. */
  202. ch->close = tlschan_fake_close_method;
  203. channel_mark_for_close(ch);
  204. free_fake_channel(ch);
  205. UNMOCK(scheduler_release_channel);
  206. }
  207. UNMOCK(connection_or_connect);
  208. UNMOCK(is_local_addr);
  209. return;
  210. }
  211. static size_t
  212. tlschan_buf_datalen_mock(const buf_t *buf)
  213. {
  214. if (buf != NULL && buf == tlschan_buf_datalen_mock_target) {
  215. return tlschan_buf_datalen_mock_size;
  216. } else {
  217. return buf_datalen__real(buf);
  218. }
  219. }
  220. static or_connection_t *
  221. tlschan_connection_or_connect_mock(const tor_addr_t *addr,
  222. uint16_t port,
  223. const char *digest,
  224. channel_tls_t *tlschan)
  225. {
  226. or_connection_t *result = NULL;
  227. tt_assert(addr != NULL);
  228. tt_assert(port != 0);
  229. tt_assert(digest != NULL);
  230. tt_assert(tlschan != NULL);
  231. /* Make a fake orconn */
  232. result = tor_malloc_zero(sizeof(*result));
  233. result->base_.magic = OR_CONNECTION_MAGIC;
  234. result->base_.state = OR_CONN_STATE_OPEN;
  235. result->base_.type = CONN_TYPE_OR;
  236. result->base_.socket_family = addr->family;
  237. result->base_.address = tor_strdup("<fake>");
  238. memcpy(&(result->base_.addr), addr, sizeof(tor_addr_t));
  239. result->base_.port = port;
  240. memcpy(result->identity_digest, digest, DIGEST_LEN);
  241. result->chan = tlschan;
  242. memcpy(&(result->real_addr), addr, sizeof(tor_addr_t));
  243. result->tls = (tor_tls_t *)((void *)(&fake_tortls));
  244. done:
  245. return result;
  246. }
  247. static void
  248. tlschan_fake_close_method(channel_t *chan)
  249. {
  250. channel_tls_t *tlschan = NULL;
  251. tt_assert(chan != NULL);
  252. tt_int_op(chan->magic, ==, TLS_CHAN_MAGIC);
  253. tlschan = BASE_CHAN_TO_TLS(chan);
  254. tt_assert(tlschan != NULL);
  255. /* Just free the fake orconn */
  256. tor_free(tlschan->conn->base_.address);
  257. tor_free(tlschan->conn);
  258. channel_closed(chan);
  259. done:
  260. return;
  261. }
  262. static int
  263. tlschan_is_local_addr_mock(const tor_addr_t *addr)
  264. {
  265. tt_assert(addr != NULL);
  266. done:
  267. return tlschan_local;
  268. }
  269. struct testcase_t channeltls_tests[] = {
  270. { "create", test_channeltls_create, TT_FORK, NULL, NULL },
  271. { "num_bytes_queued", test_channeltls_num_bytes_queued,
  272. TT_FORK, NULL, NULL },
  273. { "overhead_estimate", test_channeltls_overhead_estimate,
  274. TT_FORK, NULL, NULL },
  275. END_OF_TESTCASES
  276. };