?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'maint-0.2.9' into maint-0.3.3
[tor.git] / src / test / test_addr.c
blobe1a40b7e60370cb3b16e1af8b9305e04073c6dbc
1 /* Copyright (c) 2001-2004, Roger Dingledine.
2 * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
3 * Copyright (c) 2007-2017, The Tor Project, Inc. */
4 /* See LICENSE for licensing information */
5
6 #define ADDRESSMAP_PRIVATE
7 #include "orconfig.h"
8 #include "or.h"
9 #include "test.h"
10 #include "addressmap.h"
11
12 /** Mocking replacement: only handles localhost. */
13 static int
14 mock_tor_addr_lookup(const char *name, uint16_t family, tor_addr_t *addr_out)
15 {
16 if (!strcmp(name, "localhost")) {
17 if (family == AF_INET || family == AF_UNSPEC) {
18 tor_addr_from_ipv4h(addr_out, 0x7f000001);
19 return 0;
20 } else if (family == AF_INET6) {
21 char bytes[16] = { 0, 0, 0, 0, 0, 0, 0, 0,
22 0, 0, 0, 0, 0, 0, 0, 1 };
23 tor_addr_from_ipv6_bytes(addr_out, bytes);
24 return 0;
25 }
26 }
27 return -1;
28 }
29
30 static void
31 test_addr_basic(void *arg)
32 {
33 uint32_t u32;
34 uint16_t u16;
35 char *cp;
36
37 /* Test addr_port_lookup */
38 (void)arg;
39 cp = NULL; u32 = 3; u16 = 3;
40 tt_assert(!addr_port_lookup(LOG_WARN, "1.2.3.4", &cp, &u32, &u16));
41 tt_str_op(cp,OP_EQ, "1.2.3.4");
42 tt_int_op(u32,OP_EQ, 0x01020304u);
43 tt_int_op(u16,OP_EQ, 0);
44 tor_free(cp);
45 tt_assert(!addr_port_lookup(LOG_WARN, "4.3.2.1:99", &cp, &u32, &u16));
46 tt_str_op(cp,OP_EQ, "4.3.2.1");
47 tt_int_op(u32,OP_EQ, 0x04030201u);
48 tt_int_op(u16,OP_EQ, 99);
49 tor_free(cp);
50
51 MOCK(tor_addr_lookup, mock_tor_addr_lookup);
52
53 tt_assert(!addr_port_lookup(LOG_WARN, "nonexistent.address:4040",
54 &cp, NULL, &u16));
55 tt_str_op(cp,OP_EQ, "nonexistent.address");
56 tt_int_op(u16,OP_EQ, 4040);
57 tor_free(cp);
58 tt_assert(!addr_port_lookup(LOG_WARN, "localhost:9999", &cp, &u32, &u16));
59 tt_str_op(cp,OP_EQ, "localhost");
60 tt_int_op(u16,OP_EQ, 9999);
61 tt_int_op(u32,OP_EQ, 0x7f000001u);
62 tor_free(cp);
63 u32 = 3;
64 tt_assert(!addr_port_lookup(LOG_WARN, "localhost", NULL, &u32, &u16));
65 tt_ptr_op(cp,OP_EQ, NULL);
66 tt_int_op(u32,OP_EQ, 0x7f000001u);
67 tt_int_op(u16,OP_EQ, 0);
68 tor_free(cp);
69
70 tt_assert(addr_port_lookup(LOG_WARN, "localhost:3", &cp, &u32, NULL));
71 tor_free(cp);
72
73 tt_int_op(0,OP_EQ, addr_mask_get_bits(0x0u));
74 tt_int_op(32,OP_EQ, addr_mask_get_bits(0xFFFFFFFFu));
75 tt_int_op(16,OP_EQ, addr_mask_get_bits(0xFFFF0000u));
76 tt_int_op(31,OP_EQ, addr_mask_get_bits(0xFFFFFFFEu));
77 tt_int_op(1,OP_EQ, addr_mask_get_bits(0x80000000u));
78
79 /* Test inet_ntop */
80 {
81 char tmpbuf[TOR_ADDR_BUF_LEN];
82 const char *ip = "176.192.208.224";
83 struct in_addr in;
84
85 /* good round trip */
86 tt_int_op(tor_inet_pton(AF_INET, ip, &in), OP_EQ, 1);
87 tt_ptr_op(tor_inet_ntop(AF_INET, &in, tmpbuf, sizeof(tmpbuf)),
88 OP_EQ, &tmpbuf);
89 tt_str_op(tmpbuf,OP_EQ, ip);
90
91 /* just enough buffer length */
92 tt_str_op(tor_inet_ntop(AF_INET, &in, tmpbuf, strlen(ip) + 1), OP_EQ, ip);
93
94 /* too short buffer */
95 tt_ptr_op(tor_inet_ntop(AF_INET, &in, tmpbuf, strlen(ip)),OP_EQ, NULL);
96 }
97
98 done:
99 UNMOCK(tor_addr_lookup);
100 tor_free(cp);
101 }
102
103 #define test_op_ip6_(a,op,b,e1,e2) \
104 STMT_BEGIN \
105 tt_assert_test_fmt_type(a,b,e1" "#op" "e2,struct in6_addr*, \
106 (fast_memcmp(val1_->s6_addr, val2_->s6_addr, 16) op 0), \
107 char *, "%s", \
108 { char *cp; \
109 cp = print_ = tor_malloc(64); \
110 for (int ii_=0;ii_<16;++ii_) { \
111 tor_snprintf(cp, 3,"%02x", (unsigned)value_->s6_addr[ii_]); \
112 cp += 2; \
113 if (ii_ != 15) *cp++ = ':'; \
114 } \
115 }, \
116 { tor_free(print_); }, \
117 TT_EXIT_TEST_FUNCTION \
118 ); \
119 STMT_END
120
121 /** Helper: Assert that two strings both decode as IPv6 addresses with
122 * tor_inet_pton(), and both decode to the same address. */
123 #define test_pton6_same(a,b) STMT_BEGIN \
124 tt_int_op(tor_inet_pton(AF_INET6, a, &a1), OP_EQ, 1); \
125 tt_int_op(tor_inet_pton(AF_INET6, b, &a2), OP_EQ, 1); \
126 test_op_ip6_(&a1,OP_EQ,&a2,#a,#b); \
127 STMT_END
128
129 /** Helper: Assert that <b>a</b> is recognized as a bad IPv6 address by
130 * tor_inet_pton(). */
131 #define test_pton6_bad(a) \
132 tt_int_op(0, OP_EQ, tor_inet_pton(AF_INET6, a, &a1))
133
134 /** Helper: assert that <b>a</b>, when parsed by tor_inet_pton() and displayed
135 * with tor_inet_ntop(), yields <b>b</b>. Also assert that <b>b</b> parses to
136 * the same value as <b>a</b>. */
137 #define test_ntop6_reduces(a,b) STMT_BEGIN \
138 tt_int_op(tor_inet_pton(AF_INET6, a, &a1), OP_EQ, 1); \
139 tt_str_op(tor_inet_ntop(AF_INET6, &a1, buf, sizeof(buf)), OP_EQ, b); \
140 tt_int_op(tor_inet_pton(AF_INET6, b, &a2), OP_EQ, 1); \
141 test_op_ip6_(&a1, OP_EQ, &a2, a, b); \
142 STMT_END
143
144 /** Helper: assert that <b>a</b> parses by tor_inet_pton() into a address that
145 * passes tor_addr_is_internal() with <b>for_listening</b>. */
146 #define test_internal_ip(a,for_listening) STMT_BEGIN \
147 tt_int_op(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), OP_EQ, 1); \
148 t1.family = AF_INET6; \
149 if (!tor_addr_is_internal(&t1, for_listening)) \
150 TT_DIE(("%s was not internal", a)); \
151 STMT_END
152
153 /** Helper: assert that <b>a</b> parses by tor_inet_pton() into a address that
154 * does not pass tor_addr_is_internal() with <b>for_listening</b>. */
155 #define test_external_ip(a,for_listening) STMT_BEGIN \
156 tt_int_op(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), OP_EQ, 1); \
157 t1.family = AF_INET6; \
158 if (tor_addr_is_internal(&t1, for_listening)) \
159 TT_DIE(("%s was not internal", a)); \
160 STMT_END
161
162 /** Helper: Assert that <b>a</b> and <b>b</b>, when parsed by
163 * tor_inet_pton(), give addresses that compare in the order defined by
164 * <b>op</b> with tor_addr_compare(). */
165 #define test_addr_compare(a, op, b) STMT_BEGIN \
166 tt_int_op(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), OP_EQ, 1); \
167 tt_int_op(tor_inet_pton(AF_INET6, b, &t2.addr.in6_addr), OP_EQ, 1); \
168 t1.family = t2.family = AF_INET6; \
169 r = tor_addr_compare(&t1,&t2,CMP_SEMANTIC); \
170 if (!(r op 0)) \
171 TT_DIE(("Failed: tor_addr_compare(%s,%s) %s 0", a, b, #op));\
172 STMT_END
173
174 /** Helper: Assert that <b>a</b> and <b>b</b>, when parsed by
175 * tor_inet_pton(), give addresses that compare in the order defined by
176 * <b>op</b> with tor_addr_compare_masked() with <b>m</b> masked. */
177 #define test_addr_compare_masked(a, op, b, m) STMT_BEGIN \
178 tt_int_op(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), OP_EQ, 1); \
179 tt_int_op(tor_inet_pton(AF_INET6, b, &t2.addr.in6_addr), OP_EQ, 1); \
180 t1.family = t2.family = AF_INET6; \
181 r = tor_addr_compare_masked(&t1,&t2,m,CMP_SEMANTIC); \
182 if (!(r op 0)) \
183 TT_DIE(("Failed: tor_addr_compare_masked(%s,%s,%d) %s 0", \
184 a, b, m, #op)); \
185 STMT_END
186
187 /** Helper: assert that <b>xx</b> is parseable as a masked IPv6 address with
188 * ports by tor_parse_mask_addr_ports(), with family <b>f</b>, IP address
189 * as 4 32-bit words <b>ip1...ip4</b>, mask bits as <b>mm</b>, and port range
190 * as <b>pt1..pt2</b>. */
191 #define test_addr_mask_ports_parse(xx, f, ip1, ip2, ip3, ip4, mm, pt1, pt2) \
192 STMT_BEGIN \
193 tt_int_op(tor_addr_parse_mask_ports(xx, 0, &t1, &mask, &port1, &port2), \
194 OP_EQ, f); \
195 p1=tor_inet_ntop(AF_INET6, &t1.addr.in6_addr, bug, sizeof(bug)); \
196 tt_int_op(htonl(ip1), OP_EQ, tor_addr_to_in6_addr32(&t1)[0]); \
197 tt_int_op(htonl(ip2), OP_EQ, tor_addr_to_in6_addr32(&t1)[1]); \
198 tt_int_op(htonl(ip3), OP_EQ, tor_addr_to_in6_addr32(&t1)[2]); \
199 tt_int_op(htonl(ip4), OP_EQ, tor_addr_to_in6_addr32(&t1)[3]); \
200 tt_int_op(mask, OP_EQ, mm); \
201 tt_uint_op(port1, OP_EQ, pt1); \
202 tt_uint_op(port2, OP_EQ, pt2); \
203 STMT_END
204
205 /** Run unit tests for IPv6 encoding/decoding/manipulation functions. */
206 static void
207 test_addr_ip6_helpers(void *arg)
208 {
209 char buf[TOR_ADDR_BUF_LEN], bug[TOR_ADDR_BUF_LEN];
210 char rbuf[REVERSE_LOOKUP_NAME_BUF_LEN];
211 struct in6_addr a1, a2;
212 tor_addr_t t1, t2;
213 int r, i;
214 uint16_t port1, port2;
215 maskbits_t mask;
216 const char *p1;
217 struct sockaddr_storage sa_storage;
218 struct sockaddr_in *sin;
219 struct sockaddr_in6 *sin6;
220
221 /* Test tor_inet_ntop and tor_inet_pton: IPv6 */
222 (void)arg;
223 {
224 const char *ip = "2001::1234";
225 const char *ip_ffff = "::ffff:192.168.1.2";
226
227 /* good round trip */
228 tt_int_op(tor_inet_pton(AF_INET6, ip, &a1),OP_EQ, 1);
229 tt_ptr_op(tor_inet_ntop(AF_INET6, &a1, buf, sizeof(buf)),OP_EQ, &buf);
230 tt_str_op(buf,OP_EQ, ip);
231
232 /* good round trip - ::ffff:0:0 style */
233 tt_int_op(tor_inet_pton(AF_INET6, ip_ffff, &a2),OP_EQ, 1);
234 tt_ptr_op(tor_inet_ntop(AF_INET6, &a2, buf, sizeof(buf)),OP_EQ, &buf);
235 tt_str_op(buf,OP_EQ, ip_ffff);
236
237 /* just long enough buffer (remember \0) */
238 tt_str_op(tor_inet_ntop(AF_INET6, &a1, buf, strlen(ip)+1),OP_EQ, ip);
239 tt_str_op(tor_inet_ntop(AF_INET6, &a2, buf, strlen(ip_ffff)+1),OP_EQ,
240 ip_ffff);
241
242 /* too short buffer (remember \0) */
243 tt_ptr_op(tor_inet_ntop(AF_INET6, &a1, buf, strlen(ip)),OP_EQ, NULL);
244 tt_ptr_op(tor_inet_ntop(AF_INET6, &a2, buf, strlen(ip_ffff)),OP_EQ, NULL);
245 }
246
247 /* ==== Converting to and from sockaddr_t. */
248 sin = (struct sockaddr_in *)&sa_storage;
249 sin->sin_family = AF_INET;
250 sin->sin_port = htons(9090);
251 sin->sin_addr.s_addr = htonl(0x7f7f0102); /*127.127.1.2*/
252 tor_addr_from_sockaddr(&t1, (struct sockaddr *)sin, &port1);
253 tt_int_op(tor_addr_family(&t1),OP_EQ, AF_INET);
254 tt_int_op(tor_addr_to_ipv4h(&t1),OP_EQ, 0x7f7f0102);
255 tt_int_op(port1, OP_EQ, 9090);
256
257 memset(&sa_storage, 0, sizeof(sa_storage));
258 tt_int_op(sizeof(struct sockaddr_in),OP_EQ,
259 tor_addr_to_sockaddr(&t1, 1234, (struct sockaddr *)&sa_storage,
260 sizeof(sa_storage)));
261 tt_int_op(1234,OP_EQ, ntohs(sin->sin_port));
262 tt_int_op(0x7f7f0102,OP_EQ, ntohl(sin->sin_addr.s_addr));
263
264 memset(&sa_storage, 0, sizeof(sa_storage));
265 sin6 = (struct sockaddr_in6 *)&sa_storage;
266 sin6->sin6_family = AF_INET6;
267 sin6->sin6_port = htons(7070);
268 sin6->sin6_addr.s6_addr[0] = 128;
269 tor_addr_from_sockaddr(&t1, (struct sockaddr *)sin6, &port1);
270 tt_int_op(tor_addr_family(&t1),OP_EQ, AF_INET6);
271 tt_int_op(port1, OP_EQ, 7070);
272 p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 0);
273 tt_str_op(p1,OP_EQ, "8000::");
274
275 memset(&sa_storage, 0, sizeof(sa_storage));
276 tt_int_op(sizeof(struct sockaddr_in6),OP_EQ,
277 tor_addr_to_sockaddr(&t1, 9999, (struct sockaddr *)&sa_storage,
278 sizeof(sa_storage)));
279 tt_int_op(AF_INET6,OP_EQ, sin6->sin6_family);
280 tt_int_op(9999,OP_EQ, ntohs(sin6->sin6_port));
281 tt_int_op(0x80000000,OP_EQ, ntohl(S6_ADDR32(sin6->sin6_addr)[0]));
282
283 /* ==== tor_addr_lookup: static cases. (Can't test dns without knowing we
284 * have a good resolver. */
285 tt_int_op(0,OP_EQ, tor_addr_lookup("127.128.129.130", AF_UNSPEC, &t1));
286 tt_int_op(AF_INET,OP_EQ, tor_addr_family(&t1));
287 tt_int_op(tor_addr_to_ipv4h(&t1),OP_EQ, 0x7f808182);
288
289 tt_int_op(0,OP_EQ, tor_addr_lookup("9000::5", AF_UNSPEC, &t1));
290 tt_int_op(AF_INET6,OP_EQ, tor_addr_family(&t1));
291 tt_int_op(0x90,OP_EQ, tor_addr_to_in6_addr8(&t1)[0]);
292 tt_assert(tor_mem_is_zero((char*)tor_addr_to_in6_addr8(&t1)+1, 14));
293 tt_int_op(0x05,OP_EQ, tor_addr_to_in6_addr8(&t1)[15]);
294
295 /* === Test pton: valid af_inet6 */
296 /* Simple, valid parsing. */
297 r = tor_inet_pton(AF_INET6,
298 "0102:0304:0506:0708:090A:0B0C:0D0E:0F10", &a1);
299 tt_int_op(r, OP_EQ, 1);
300 for (i=0;i<16;++i) { tt_int_op(i+1,OP_EQ, (int)a1.s6_addr[i]); }
301 /* ipv4 ending. */
302 test_pton6_same("0102:0304:0506:0708:090A:0B0C:0D0E:0F10",
303 "0102:0304:0506:0708:090A:0B0C:13.14.15.16");
304 /* shortened words. */
305 test_pton6_same("0001:0099:BEEF:0000:0123:FFFF:0001:0001",
306 "1:99:BEEF:0:0123:FFFF:1:1");
307 /* zeros at the beginning */
308 test_pton6_same("0000:0000:0000:0000:0009:C0A8:0001:0001",
309 "::9:c0a8:1:1");
310 test_pton6_same("0000:0000:0000:0000:0009:C0A8:0001:0001",
311 "::9:c0a8:0.1.0.1");
312 /* zeros in the middle. */
313 test_pton6_same("fe80:0000:0000:0000:0202:1111:0001:0001",
314 "fe80::202:1111:1:1");
315 /* zeros at the end. */
316 test_pton6_same("1000:0001:0000:0007:0000:0000:0000:0000",
317 "1000:1:0:7::");
318
319 /* === Test ntop: af_inet6 */
320 test_ntop6_reduces("0:0:0:0:0:0:0:0", "::");
321
322 test_ntop6_reduces("0001:0099:BEEF:0006:0123:FFFF:0001:0001",
323 "1:99:beef:6:123:ffff:1:1");
324
325 //test_ntop6_reduces("0:0:0:0:0:0:c0a8:0101", "::192.168.1.1");
326 test_ntop6_reduces("0:0:0:0:0:ffff:c0a8:0101", "::ffff:192.168.1.1");
327 test_ntop6_reduces("0:0:0:0:0:0:c0a8:0101", "::192.168.1.1");
328 test_ntop6_reduces("002:0:0000:0:3::4", "2::3:0:0:4");
329 test_ntop6_reduces("0:0::1:0:3", "::1:0:3");
330 test_ntop6_reduces("008:0::0", "8::");
331 test_ntop6_reduces("0:0:0:0:0:ffff::1", "::ffff:0.0.0.1");
332 test_ntop6_reduces("abcd:0:0:0:0:0:7f00::", "abcd::7f00:0");
333 test_ntop6_reduces("0000:0000:0000:0000:0009:C0A8:0001:0001",
334 "::9:c0a8:1:1");
335 test_ntop6_reduces("fe80:0000:0000:0000:0202:1111:0001:0001",
336 "fe80::202:1111:1:1");
337 test_ntop6_reduces("1000:0001:0000:0007:0000:0000:0000:0000",
338 "1000:1:0:7::");
339
340 /* Bad af param */
341 tt_int_op(tor_inet_pton(AF_UNSPEC, 0, 0),OP_EQ, -1);
342
343 /* === Test pton: invalid in6. */
344 test_pton6_bad("foobar.");
345 test_pton6_bad("-1::");
346 test_pton6_bad("00001::");
347 test_pton6_bad("10000::");
348 test_pton6_bad("::10000");
349 test_pton6_bad("55555::");
350 test_pton6_bad("9:-60::");
351 test_pton6_bad("9:+60::");
352 test_pton6_bad("9|60::");
353 test_pton6_bad("0x60::");
354 test_pton6_bad("::0x60");
355 test_pton6_bad("9:0x60::");
356 test_pton6_bad("1:2:33333:4:0002:3::");
357 test_pton6_bad("1:2:3333:4:fish:3::");
358 test_pton6_bad("1:2:3:4:5:6:7:8:9");
359 test_pton6_bad("1:2:3:4:5:6:7");
360 test_pton6_bad("1:2:3:4:5:6:1.2.3.4.5");
361 test_pton6_bad("1:2:3:4:5:6:1.2.3");
362 test_pton6_bad("::1.2.3");
363 test_pton6_bad("::1.2.3.4.5");
364 test_pton6_bad("::ffff:0xff.0.0.0");
365 test_pton6_bad("::ffff:ff.0.0.0");
366 test_pton6_bad("::ffff:256.0.0.0");
367 test_pton6_bad("::ffff:-1.0.0.0");
368 test_pton6_bad("99");
369 test_pton6_bad("");
370 test_pton6_bad(".");
371 test_pton6_bad(":");
372 test_pton6_bad("1::2::3:4");
373 test_pton6_bad("a:::b:c");
374 test_pton6_bad(":::a:b:c");
375 test_pton6_bad("a:b:c:::");
376 test_pton6_bad("1.2.3.4");
377 test_pton6_bad(":1.2.3.4");
378 test_pton6_bad(".2.3.4");
379 /* Regression tests for 22789. */
380 test_pton6_bad("0xfoo");
381 test_pton6_bad("0x88");
382 test_pton6_bad("0xyxxy");
383 test_pton6_bad("0XFOO");
384 test_pton6_bad("0X88");
385 test_pton6_bad("0XYXXY");
386 test_pton6_bad("0x");
387 test_pton6_bad("0X");
388
389 /* test internal checking */
390 test_external_ip("fbff:ffff::2:7", 0);
391 test_internal_ip("fc01::2:7", 0);
392 test_internal_ip("fc01::02:7", 0);
393 test_internal_ip("fc01::002:7", 0);
394 test_internal_ip("fc01::0002:7", 0);
395 test_internal_ip("fdff:ffff::f:f", 0);
396 test_external_ip("fe00::3:f", 0);
397
398 test_external_ip("fe7f:ffff::2:7", 0);
399 test_internal_ip("fe80::2:7", 0);
400 test_internal_ip("febf:ffff::f:f", 0);
401
402 test_internal_ip("fec0::2:7:7", 0);
403 test_internal_ip("feff:ffff::e:7:7", 0);
404 test_external_ip("ff00::e:7:7", 0);
405
406 test_internal_ip("::", 0);
407 test_internal_ip("::1", 0);
408 test_internal_ip("::1", 1);
409 test_internal_ip("::", 0);
410 test_external_ip("::", 1);
411 test_external_ip("::2", 0);
412 test_external_ip("2001::", 0);
413 test_external_ip("ffff::", 0);
414
415 test_external_ip("::ffff:0.0.0.0", 1);
416 test_internal_ip("::ffff:0.0.0.0", 0);
417 test_internal_ip("::ffff:0.255.255.255", 0);
418 test_external_ip("::ffff:1.0.0.0", 0);
419
420 test_external_ip("::ffff:9.255.255.255", 0);
421 test_internal_ip("::ffff:10.0.0.0", 0);
422 test_internal_ip("::ffff:10.255.255.255", 0);
423 test_external_ip("::ffff:11.0.0.0", 0);
424
425 test_external_ip("::ffff:126.255.255.255", 0);
426 test_internal_ip("::ffff:127.0.0.0", 0);
427 test_internal_ip("::ffff:127.255.255.255", 0);
428 test_external_ip("::ffff:128.0.0.0", 0);
429
430 test_external_ip("::ffff:172.15.255.255", 0);
431 test_internal_ip("::ffff:172.16.0.0", 0);
432 test_internal_ip("::ffff:172.31.255.255", 0);
433 test_external_ip("::ffff:172.32.0.0", 0);
434
435 test_external_ip("::ffff:192.167.255.255", 0);
436 test_internal_ip("::ffff:192.168.0.0", 0);
437 test_internal_ip("::ffff:192.168.255.255", 0);
438 test_external_ip("::ffff:192.169.0.0", 0);
439
440 test_external_ip("::ffff:169.253.255.255", 0);
441 test_internal_ip("::ffff:169.254.0.0", 0);
442 test_internal_ip("::ffff:169.254.255.255", 0);
443 test_external_ip("::ffff:169.255.0.0", 0);
444
445 /* tor_addr_compare(tor_addr_t x2) */
446 test_addr_compare("ffff::", OP_EQ, "ffff::0");
447 test_addr_compare("0::3:2:1", OP_LT, "0::ffff:0.3.2.1");
448 test_addr_compare("0::2:2:1", OP_LT, "0::ffff:0.3.2.1");
449 test_addr_compare("0::ffff:0.3.2.1", OP_GT, "0::0:0:0");
450 test_addr_compare("0::ffff:5.2.2.1", OP_LT,
451 "::ffff:6.0.0.0"); /* XXXX wrong. */
452 tor_addr_parse_mask_ports("[::ffff:2.3.4.5]", 0, &t1, NULL, NULL, NULL);
453 tor_addr_parse_mask_ports("2.3.4.5", 0, &t2, NULL, NULL, NULL);
454 tt_int_op(tor_addr_compare(&t1, &t2, CMP_SEMANTIC), OP_EQ, 0);
455 tor_addr_parse_mask_ports("[::ffff:2.3.4.4]", 0, &t1, NULL, NULL, NULL);
456 tor_addr_parse_mask_ports("2.3.4.5", 0, &t2, NULL, NULL, NULL);
457 tt_int_op(tor_addr_compare(&t1, &t2, CMP_SEMANTIC), OP_LT, 0);
458
459 /* test compare_masked */
460 test_addr_compare_masked("ffff::", OP_EQ, "ffff::0", 128);
461 test_addr_compare_masked("ffff::", OP_EQ, "ffff::0", 64);
462 test_addr_compare_masked("0::2:2:1", OP_LT, "0::8000:2:1", 81);
463 test_addr_compare_masked("0::2:2:1", OP_EQ, "0::8000:2:1", 80);
464
465 /* Test undecorated tor_addr_to_str */
466 tt_int_op(AF_INET6,OP_EQ, tor_addr_parse(&t1, "[123:45:6789::5005:11]"));
467 p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 0);
468 tt_str_op(p1,OP_EQ, "123:45:6789::5005:11");
469 tt_int_op(AF_INET,OP_EQ, tor_addr_parse(&t1, "18.0.0.1"));
470 p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 0);
471 tt_str_op(p1,OP_EQ, "18.0.0.1");
472
473 /* Test decorated tor_addr_to_str */
474 tt_int_op(AF_INET6,OP_EQ, tor_addr_parse(&t1, "[123:45:6789::5005:11]"));
475 p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1);
476 tt_str_op(p1,OP_EQ, "[123:45:6789::5005:11]");
477 tt_int_op(AF_INET,OP_EQ, tor_addr_parse(&t1, "18.0.0.1"));
478 p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1);
479 tt_str_op(p1,OP_EQ, "18.0.0.1");
480
481 /* Test buffer bounds checking of tor_addr_to_str */
482 tt_int_op(AF_INET6,OP_EQ, tor_addr_parse(&t1, "::")); /* 2 + \0 */
483 tt_ptr_op(tor_addr_to_str(buf, &t1, 2, 0),OP_EQ, NULL); /* too short buf */
484 tt_str_op(tor_addr_to_str(buf, &t1, 3, 0),OP_EQ, "::");
485 tt_ptr_op(tor_addr_to_str(buf, &t1, 4, 1),OP_EQ, NULL); /* too short buf */
486 tt_str_op(tor_addr_to_str(buf, &t1, 5, 1),OP_EQ, "[::]");
487
488 tt_int_op(AF_INET6,OP_EQ, tor_addr_parse(&t1, "2000::1337")); /* 10 + \0 */
489 tt_ptr_op(tor_addr_to_str(buf, &t1, 10, 0),OP_EQ, NULL); /* too short buf */
490 tt_str_op(tor_addr_to_str(buf, &t1, 11, 0),OP_EQ, "2000::1337");
491 tt_ptr_op(tor_addr_to_str(buf, &t1, 12, 1),OP_EQ, NULL); /* too short buf */
492 tt_str_op(tor_addr_to_str(buf, &t1, 13, 1),OP_EQ, "[2000::1337]");
493
494 tt_int_op(AF_INET,OP_EQ, tor_addr_parse(&t1, "1.2.3.4")); /* 7 + \0 */
495 tt_ptr_op(tor_addr_to_str(buf, &t1, 7, 0),OP_EQ, NULL); /* too short buf */
496 tt_str_op(tor_addr_to_str(buf, &t1, 8, 0),OP_EQ, "1.2.3.4");
497
498 tt_int_op(AF_INET, OP_EQ,
499 tor_addr_parse(&t1, "255.255.255.255")); /* 15 + \0 */
500 tt_ptr_op(tor_addr_to_str(buf, &t1, 15, 0),OP_EQ, NULL); /* too short buf */
501 tt_str_op(tor_addr_to_str(buf, &t1, 16, 0),OP_EQ, "255.255.255.255");
502 tt_ptr_op(tor_addr_to_str(buf, &t1, 15, 1),OP_EQ, NULL); /* too short buf */
503 tt_str_op(tor_addr_to_str(buf, &t1, 16, 1),OP_EQ, "255.255.255.255");
504
505 t1.family = AF_UNSPEC;
506 tt_ptr_op(tor_addr_to_str(buf, &t1, sizeof(buf), 0),OP_EQ, NULL);
507
508 /* Test tor_addr_parse_PTR_name */
509 i = tor_addr_parse_PTR_name(&t1, "Foobar.baz", AF_UNSPEC, 0);
510 tt_int_op(0,OP_EQ, i);
511 i = tor_addr_parse_PTR_name(&t1, "Foobar.baz", AF_UNSPEC, 1);
512 tt_int_op(0,OP_EQ, i);
513 i = tor_addr_parse_PTR_name(&t1, "9999999999999999999999999999.in-addr.arpa",
514 AF_UNSPEC, 1);
515 tt_int_op(-1,OP_EQ, i);
516 i = tor_addr_parse_PTR_name(&t1, "1.0.168.192.in-addr.arpa",
517 AF_UNSPEC, 1);
518 tt_int_op(1,OP_EQ, i);
519 tt_int_op(tor_addr_family(&t1),OP_EQ, AF_INET);
520 p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1);
521 tt_str_op(p1,OP_EQ, "192.168.0.1");
522 i = tor_addr_parse_PTR_name(&t1, "192.168.0.99", AF_UNSPEC, 0);
523 tt_int_op(0,OP_EQ, i);
524 i = tor_addr_parse_PTR_name(&t1, "192.168.0.99", AF_UNSPEC, 1);
525 tt_int_op(1,OP_EQ, i);
526 p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1);
527 tt_str_op(p1,OP_EQ, "192.168.0.99");
528 memset(&t1, 0, sizeof(t1));
529 i = tor_addr_parse_PTR_name(&t1,
530 "0.1.2.3.4.5.6.7.8.9.a.b.c.d.e.f."
531 "f.e.e.b.1.e.b.e.e.f.f.e.e.e.d.9."
532 "ip6.ARPA",
533 AF_UNSPEC, 0);
534 tt_int_op(1,OP_EQ, i);
535 p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1);
536 tt_str_op(p1,OP_EQ, "[9dee:effe:ebe1:beef:fedc:ba98:7654:3210]");
537 /* Failing cases. */
538 i = tor_addr_parse_PTR_name(&t1,
539 "6.7.8.9.a.b.c.d.e.f."
540 "f.e.e.b.1.e.b.e.e.f.f.e.e.e.d.9."
541 "ip6.ARPA",
542 AF_UNSPEC, 0);
543 tt_int_op(i,OP_EQ, -1);
544 i = tor_addr_parse_PTR_name(&t1,
545 "6.7.8.9.a.b.c.d.e.f.a.b.c.d.e.f.0."
546 "f.e.e.b.1.e.b.e.e.f.f.e.e.e.d.9."
547 "ip6.ARPA",
548 AF_UNSPEC, 0);
549 tt_int_op(i,OP_EQ, -1);
550 i = tor_addr_parse_PTR_name(&t1,
551 "6.7.8.9.a.b.c.d.e.f.X.0.0.0.0.9."
552 "f.e.e.b.1.e.b.e.e.f.f.e.e.e.d.9."
553 "ip6.ARPA",
554 AF_UNSPEC, 0);
555 tt_int_op(i,OP_EQ, -1);
556 i = tor_addr_parse_PTR_name(&t1, "32.1.1.in-addr.arpa",
557 AF_UNSPEC, 0);
558 tt_int_op(i,OP_EQ, -1);
559 i = tor_addr_parse_PTR_name(&t1, ".in-addr.arpa",
560 AF_UNSPEC, 0);
561 tt_int_op(i,OP_EQ, -1);
562 i = tor_addr_parse_PTR_name(&t1, "1.2.3.4.5.in-addr.arpa",
563 AF_UNSPEC, 0);
564 tt_int_op(i,OP_EQ, -1);
565 i = tor_addr_parse_PTR_name(&t1, "1.2.3.4.5.in-addr.arpa",
566 AF_INET6, 0);
567 tt_int_op(i,OP_EQ, -1);
568 i = tor_addr_parse_PTR_name(&t1,
569 "6.7.8.9.a.b.c.d.e.f.a.b.c.d.e.0."
570 "f.e.e.b.1.e.b.e.e.f.f.e.e.e.d.9."
571 "ip6.ARPA",
572 AF_INET, 0);
573 tt_int_op(i,OP_EQ, -1);
574
575 /* === Test tor_addr_to_PTR_name */
576
577 /* Stage IPv4 addr */
578 memset(&sa_storage, 0, sizeof(sa_storage));
579 sin = (struct sockaddr_in *)&sa_storage;
580 sin->sin_family = AF_INET;
581 sin->sin_addr.s_addr = htonl(0x7f010203); /* 127.1.2.3 */
582 tor_addr_from_sockaddr(&t1, (struct sockaddr *)sin, NULL);
583
584 /* Check IPv4 PTR - too short buffer */
585 tt_int_op(tor_addr_to_PTR_name(rbuf, 1, &t1),OP_EQ, -1);
586 tt_int_op(tor_addr_to_PTR_name(rbuf,
587 strlen("3.2.1.127.in-addr.arpa") - 1,
588 &t1),OP_EQ, -1);
589
590 /* Check IPv4 PTR - valid addr */
591 tt_int_op(tor_addr_to_PTR_name(rbuf, sizeof(rbuf), &t1),OP_EQ,
592 strlen("3.2.1.127.in-addr.arpa"));
593 tt_str_op(rbuf,OP_EQ, "3.2.1.127.in-addr.arpa");
594
595 /* Invalid addr family */
596 t1.family = AF_UNSPEC;
597 tt_int_op(tor_addr_to_PTR_name(rbuf, sizeof(rbuf), &t1),OP_EQ, -1);
598
599 /* Stage IPv6 addr */
600 memset(&sa_storage, 0, sizeof(sa_storage));
601 sin6 = (struct sockaddr_in6 *)&sa_storage;
602 sin6->sin6_family = AF_INET6;
603 sin6->sin6_addr.s6_addr[0] = 0x80; /* 8000::abcd */
604 sin6->sin6_addr.s6_addr[14] = 0xab;
605 sin6->sin6_addr.s6_addr[15] = 0xcd;
606
607 tor_addr_from_sockaddr(&t1, (struct sockaddr *)sin6, NULL);
608
609 {
610 const char* addr_PTR = "d.c.b.a.0.0.0.0.0.0.0.0.0.0.0.0."
611 "0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.ip6.arpa";
612
613 /* Check IPv6 PTR - too short buffer */
614 tt_int_op(tor_addr_to_PTR_name(rbuf, 0, &t1),OP_EQ, -1);
615 tt_int_op(tor_addr_to_PTR_name(rbuf, strlen(addr_PTR) - 1, &t1),OP_EQ, -1);
616
617 /* Check IPv6 PTR - valid addr */
618 tt_int_op(tor_addr_to_PTR_name(rbuf, sizeof(rbuf), &t1),OP_EQ,
619 strlen(addr_PTR));
620 tt_str_op(rbuf,OP_EQ, addr_PTR);
621 }
622
623 /* XXXX turn this into a separate function; it's not all IPv6. */
624 /* test tor_addr_parse_mask_ports */
625 test_addr_mask_ports_parse("[::f]/17:47-95", AF_INET6,
626 0, 0, 0, 0x0000000f, 17, 47, 95);
627 tt_str_op(p1,OP_EQ, "::f");
628 //test_addr_parse("[::fefe:4.1.1.7/120]:999-1000");
629 //test_addr_parse_check("::fefe:401:107", 120, 999, 1000);
630 test_addr_mask_ports_parse("[::ffff:4.1.1.7]/120:443", AF_INET6,
631 0, 0, 0x0000ffff, 0x04010107, 120, 443, 443);
632 tt_str_op(p1,OP_EQ, "::ffff:4.1.1.7");
633 test_addr_mask_ports_parse("[abcd:2::44a:0]:2-65000", AF_INET6,
634 0xabcd0002, 0, 0, 0x044a0000, 128, 2, 65000);
635
636 tt_str_op(p1,OP_EQ, "abcd:2::44a:0");
637 /* Try some long addresses. */
638 r=tor_addr_parse_mask_ports("[ffff:1111:1111:1111:1111:1111:1111:1111]",
639 0, &t1, NULL, NULL, NULL);
640 tt_int_op(r, OP_EQ, AF_INET6);
641 r=tor_addr_parse_mask_ports("[ffff:1111:1111:1111:1111:1111:1111:11111]",
642 0, &t1, NULL, NULL, NULL);
643 tt_int_op(r, OP_EQ, -1);
644 r=tor_addr_parse_mask_ports("[ffff:1111:1111:1111:1111:1111:1111:1111:1]",
645 0, &t1, NULL, NULL, NULL);
646 tt_int_op(r, OP_EQ, -1);
647 r=tor_addr_parse_mask_ports(
648 "[ffff:1111:1111:1111:1111:1111:1111:ffff:"
649 "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:"
650 "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:"
651 "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]",
652 0, &t1, NULL, NULL, NULL);
653 tt_int_op(r, OP_EQ, -1);
654 /* Try some failing cases. */
655 r=tor_addr_parse_mask_ports("[fefef::]/112", 0, &t1, NULL, NULL, NULL);
656 tt_int_op(r, OP_EQ, -1);
657 r=tor_addr_parse_mask_ports("[fefe::/112", 0, &t1, NULL, NULL, NULL);
658 tt_int_op(r, OP_EQ, -1);
659 r=tor_addr_parse_mask_ports("[fefe::", 0, &t1, NULL, NULL, NULL);
660 tt_int_op(r, OP_EQ, -1);
661 r=tor_addr_parse_mask_ports("[fefe::X]", 0, &t1, NULL, NULL, NULL);
662 tt_int_op(r, OP_EQ, -1);
663 r=tor_addr_parse_mask_ports("efef::/112", 0, &t1, NULL, NULL, NULL);
664 tt_int_op(r, OP_EQ, -1);
665 r=tor_addr_parse_mask_ports("[f:f:f:f:f:f:f:f::]",0,&t1, NULL, NULL, NULL);
666 tt_int_op(r, OP_EQ, -1);
667 r=tor_addr_parse_mask_ports("[::f:f:f:f:f:f:f:f]",0,&t1, NULL, NULL, NULL);
668 tt_int_op(r, OP_EQ, -1);
669 r=tor_addr_parse_mask_ports("[f:f:f:f:f:f:f:f:f]",0,&t1, NULL, NULL, NULL);
670 tt_int_op(r, OP_EQ, -1);
671 r=tor_addr_parse_mask_ports("[f:f:f:f:f::]/fred",0,&t1,&mask, NULL, NULL);
672 tt_int_op(r, OP_EQ, -1);
673 r=tor_addr_parse_mask_ports("[f:f:f:f:f::]/255.255.0.0",
674 0,&t1, NULL, NULL, NULL);
675 tt_int_op(r, OP_EQ, -1);
676 /* This one will get rejected because it isn't a pure prefix. */
677 r=tor_addr_parse_mask_ports("1.1.2.3/255.255.64.0",0,&t1, &mask,NULL,NULL);
678 tt_int_op(r, OP_EQ, -1);
679 /* Test for V4-mapped address with mask < 96. (arguably not valid) */
680 r=tor_addr_parse_mask_ports("[::ffff:1.1.2.2/33]",0,&t1, &mask, NULL, NULL);
681 tt_int_op(r, OP_EQ, -1);
682 r=tor_addr_parse_mask_ports("1.1.2.2/33",0,&t1, &mask, NULL, NULL);
683 tt_int_op(r, OP_EQ, -1);
684 /* Try extended wildcard addresses with out TAPMP_EXTENDED_STAR*/
685 r=tor_addr_parse_mask_ports("*4",0,&t1, &mask, NULL, NULL);
686 tt_int_op(r, OP_EQ, -1);
687 r=tor_addr_parse_mask_ports("*6",0,&t1, &mask, NULL, NULL);
688 tt_int_op(r, OP_EQ, -1);
689 tt_int_op(r, OP_EQ, -1);
690 /* Try a mask with a wildcard. */
691 r=tor_addr_parse_mask_ports("*/16",0,&t1, &mask, NULL, NULL);
692 tt_int_op(r, OP_EQ, -1);
693 r=tor_addr_parse_mask_ports("*4/16",TAPMP_EXTENDED_STAR,
694 &t1, &mask, NULL, NULL);
695 tt_int_op(r, OP_EQ, -1);
696 r=tor_addr_parse_mask_ports("*6/30",TAPMP_EXTENDED_STAR,
697 &t1, &mask, NULL, NULL);
698 tt_int_op(r, OP_EQ, -1);
699 /* Basic mask tests*/
700 r=tor_addr_parse_mask_ports("1.1.2.2/31",0,&t1, &mask, NULL, NULL);
701 tt_int_op(r, OP_EQ, AF_INET);
702 tt_int_op(mask,OP_EQ,31);
703 tt_int_op(tor_addr_family(&t1),OP_EQ,AF_INET);
704 tt_int_op(tor_addr_to_ipv4h(&t1),OP_EQ,0x01010202);
705 r=tor_addr_parse_mask_ports("3.4.16.032:1-2",0,&t1, &mask, &port1, &port2);
706 tt_int_op(r, OP_EQ, AF_INET);
707 tt_int_op(mask,OP_EQ,32);
708 tt_int_op(tor_addr_family(&t1),OP_EQ,AF_INET);
709 tt_int_op(tor_addr_to_ipv4h(&t1),OP_EQ,0x03041020);
710 tt_uint_op(port1, OP_EQ, 1);
711 tt_uint_op(port2, OP_EQ, 2);
712 r=tor_addr_parse_mask_ports("1.1.2.3/255.255.128.0",0,&t1, &mask,NULL,NULL);
713 tt_int_op(r, OP_EQ, AF_INET);
714 tt_int_op(mask,OP_EQ,17);
715 tt_int_op(tor_addr_family(&t1),OP_EQ,AF_INET);
716 tt_int_op(tor_addr_to_ipv4h(&t1),OP_EQ,0x01010203);
717 r=tor_addr_parse_mask_ports("[efef::]/112",0,&t1, &mask, &port1, &port2);
718 tt_int_op(r, OP_EQ, AF_INET6);
719 tt_uint_op(port1, OP_EQ, 1);
720 tt_uint_op(port2, OP_EQ, 65535);
721 /* Try regular wildcard behavior without TAPMP_EXTENDED_STAR */
722 r=tor_addr_parse_mask_ports("*:80-443",0,&t1,&mask,&port1,&port2);
723 tt_int_op(r,OP_EQ,AF_INET); /* Old users of this always get inet */
724 tt_int_op(tor_addr_family(&t1),OP_EQ,AF_INET);
725 tt_int_op(tor_addr_to_ipv4h(&t1),OP_EQ,0);
726 tt_int_op(mask,OP_EQ,0);
727 tt_int_op(port1,OP_EQ,80);
728 tt_int_op(port2,OP_EQ,443);
729 /* Now try wildcards *with* TAPMP_EXTENDED_STAR */
730 r=tor_addr_parse_mask_ports("*:8000-9000",TAPMP_EXTENDED_STAR,
731 &t1,&mask,&port1,&port2);
732 tt_int_op(r,OP_EQ,AF_UNSPEC);
733 tt_int_op(tor_addr_family(&t1),OP_EQ,AF_UNSPEC);
734 tt_int_op(mask,OP_EQ,0);
735 tt_int_op(port1,OP_EQ,8000);
736 tt_int_op(port2,OP_EQ,9000);
737 r=tor_addr_parse_mask_ports("*4:6667",TAPMP_EXTENDED_STAR,
738 &t1,&mask,&port1,&port2);
739 tt_int_op(r,OP_EQ,AF_INET);
740 tt_int_op(tor_addr_family(&t1),OP_EQ,AF_INET);
741 tt_int_op(tor_addr_to_ipv4h(&t1),OP_EQ,0);
742 tt_int_op(mask,OP_EQ,0);
743 tt_int_op(port1,OP_EQ,6667);
744 tt_int_op(port2,OP_EQ,6667);
745 r=tor_addr_parse_mask_ports("*6",TAPMP_EXTENDED_STAR,
746 &t1,&mask,&port1,&port2);
747 tt_int_op(r,OP_EQ,AF_INET6);
748 tt_int_op(tor_addr_family(&t1),OP_EQ,AF_INET6);
749 tt_assert(tor_mem_is_zero((const char*)tor_addr_to_in6_addr32(&t1), 16));
750 tt_int_op(mask,OP_EQ,0);
751 tt_int_op(port1,OP_EQ,1);
752 tt_int_op(port2,OP_EQ,65535);
753
754 /* make sure inet address lengths >= max */
755 tt_int_op(INET_NTOA_BUF_LEN, OP_GE, sizeof("255.255.255.255"));
756 tt_int_op(TOR_ADDR_BUF_LEN, OP_GE,
757 sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"));
758
759 tt_assert(sizeof(tor_addr_t) >= sizeof(struct in6_addr));
760
761 /* get interface addresses */
762 r = get_interface_address6(LOG_DEBUG, AF_INET, &t1);
763 tt_int_op(r, OP_LE, 0); // "it worked or it didn't"
764 i = get_interface_address6(LOG_DEBUG, AF_INET6, &t2);
765 tt_int_op(i, OP_LE, 0); // "it worked or it didn't"
766
767 TT_BLATHER(("v4 address: %s (family=%d)", fmt_addr(&t1),
768 tor_addr_family(&t1)));
769 TT_BLATHER(("v6 address: %s (family=%d)", fmt_addr(&t2),
770 tor_addr_family(&t2)));
771
772 done:
773 ;
774 }
775
776 /** Test tor_addr_port_parse(). */
777 static void
778 test_addr_parse(void *arg)
779 {
780 int r;
781 tor_addr_t addr;
782 char buf[TOR_ADDR_BUF_LEN];
783 uint16_t port = 0;
784
785 /* Correct call. */
786 (void)arg;
787 r= tor_addr_port_parse(LOG_DEBUG,
788 "192.0.2.1:1234",
789 &addr, &port, -1);
790 tt_int_op(r, OP_EQ, 0);
791 tor_addr_to_str(buf, &addr, sizeof(buf), 0);
792 tt_str_op(buf,OP_EQ, "192.0.2.1");
793 tt_int_op(port,OP_EQ, 1234);
794
795 r= tor_addr_port_parse(LOG_DEBUG,
796 "[::1]:1234",
797 &addr, &port, -1);
798 tt_int_op(r, OP_EQ, 0);
799 tor_addr_to_str(buf, &addr, sizeof(buf), 0);
800 tt_str_op(buf,OP_EQ, "::1");
801 tt_int_op(port,OP_EQ, 1234);
802
803 /* Domain name. */
804 r= tor_addr_port_parse(LOG_DEBUG,
805 "torproject.org:1234",
806 &addr, &port, -1);
807 tt_int_op(r, OP_EQ, -1);
808
809 /* Only IP. */
810 r= tor_addr_port_parse(LOG_DEBUG,
811 "192.0.2.2",
812 &addr, &port, -1);
813 tt_int_op(r, OP_EQ, -1);
814
815 r= tor_addr_port_parse(LOG_DEBUG,
816 "192.0.2.2",
817 &addr, &port, 200);
818 tt_int_op(r, OP_EQ, 0);
819 tt_int_op(port,OP_EQ,200);
820
821 r= tor_addr_port_parse(LOG_DEBUG,
822 "[::1]",
823 &addr, &port, -1);
824 tt_int_op(r, OP_EQ, -1);
825
826 r= tor_addr_port_parse(LOG_DEBUG,
827 "[::1]",
828 &addr, &port, 400);
829 tt_int_op(r, OP_EQ, 0);
830 tt_int_op(port,OP_EQ,400);
831
832 /* Bad port. */
833 r= tor_addr_port_parse(LOG_DEBUG,
834 "192.0.2.2:66666",
835 &addr, &port, -1);
836 tt_int_op(r, OP_EQ, -1);
837 r= tor_addr_port_parse(LOG_DEBUG,
838 "192.0.2.2:66666",
839 &addr, &port, 200);
840 tt_int_op(r, OP_EQ, -1);
841
842 /* Only domain name */
843 r= tor_addr_port_parse(LOG_DEBUG,
844 "torproject.org",
845 &addr, &port, -1);
846 tt_int_op(r, OP_EQ, -1);
847 r= tor_addr_port_parse(LOG_DEBUG,
848 "torproject.org",
849 &addr, &port, 200);
850 tt_int_op(r, OP_EQ, -1);
851
852 /* Bad IP address */
853 r= tor_addr_port_parse(LOG_DEBUG,
854 "192.0.2:1234",
855 &addr, &port, -1);
856 tt_int_op(r, OP_EQ, -1);
857
858 /* Make sure that the default port has lower priority than the real
859 one */
860 r= tor_addr_port_parse(LOG_DEBUG,
861 "192.0.2.2:1337",
862 &addr, &port, 200);
863 tt_int_op(r, OP_EQ, 0);
864 tt_int_op(port,OP_EQ,1337);
865
866 r= tor_addr_port_parse(LOG_DEBUG,
867 "[::1]:1369",
868 &addr, &port, 200);
869 tt_int_op(r, OP_EQ, 0);
870 tt_int_op(port,OP_EQ,1369);
871
872 done:
873 ;
874 }
875
876 static void
877 update_difference(int ipv6, uint8_t *d,
878 const tor_addr_t *a, const tor_addr_t *b)
879 {
880 const int n_bytes = ipv6 ? 16 : 4;
881 uint8_t a_tmp[4], b_tmp[4];
882 const uint8_t *ba, *bb;
883 int i;
884
885 if (ipv6) {
886 ba = tor_addr_to_in6_addr8(a);
887 bb = tor_addr_to_in6_addr8(b);
888 } else {
889 set_uint32(a_tmp, tor_addr_to_ipv4n(a));
890 set_uint32(b_tmp, tor_addr_to_ipv4n(b));
891 ba = a_tmp; bb = b_tmp;
892 }
893
894 for (i = 0; i < n_bytes; ++i) {
895 d[i] |= ba[i] ^ bb[i];
896 }
897 }
898
899 static void
900 test_virtaddrmap(void *data)
901 {
902 /* Let's start with a bunch of random addresses. */
903 int ipv6, bits, iter, b;
904 virtual_addr_conf_t cfg[2];
905 uint8_t bytes[16];
906
907 (void)data;
908
909 tor_addr_parse(&cfg[0].addr, "64.65.0.0");
910 tor_addr_parse(&cfg[1].addr, "3491:c0c0::");
911
912 for (ipv6 = 0; ipv6 <= 1; ++ipv6) {
913 for (bits = 0; bits < 18; ++bits) {
914 tor_addr_t last_a;
915 cfg[ipv6].bits = bits;
916 memset(bytes, 0, sizeof(bytes));
917 tor_addr_copy(&last_a, &cfg[ipv6].addr);
918 /* Generate 128 addresses with each addr/bits combination. */
919 for (iter = 0; iter < 128; ++iter) {
920 tor_addr_t a;
921
922 get_random_virtual_addr(&cfg[ipv6], &a);
923 //printf("%s\n", fmt_addr(&a));
924 /* Make sure that the first b bits match the configured network */
925 tt_int_op(0, OP_EQ, tor_addr_compare_masked(&a, &cfg[ipv6].addr,
926 bits, CMP_EXACT));
927
928 /* And track which bits have been different between pairs of
929 * addresses */
930 update_difference(ipv6, bytes, &last_a, &a);
931 }
932
933 /* Now make sure all but the first 'bits' bits of bytes are true */
934 for (b = bits+1; b < (ipv6?128:32); ++b) {
935 tt_assert(1 & (bytes[b/8] >> (7-(b&7))));
936 }
937 }
938 }
939
940 done:
941 ;
942 }
943
944 static void
945 test_addr_localname(void *arg)
946 {
947 (void)arg;
948 tt_assert(tor_addr_hostname_is_local("localhost"));
949 tt_assert(tor_addr_hostname_is_local("LOCALHOST"));
950 tt_assert(tor_addr_hostname_is_local("LocalHost"));
951 tt_assert(tor_addr_hostname_is_local("local"));
952 tt_assert(tor_addr_hostname_is_local("LOCAL"));
953 tt_assert(tor_addr_hostname_is_local("here.now.local"));
954 tt_assert(tor_addr_hostname_is_local("here.now.LOCAL"));
955
956 tt_assert(!tor_addr_hostname_is_local(" localhost"));
957 tt_assert(!tor_addr_hostname_is_local("www.torproject.org"));
958 done:
959 ;
960 }
961
962 static void
963 test_addr_dup_ip(void *arg)
964 {
965 char *v = NULL;
966 (void)arg;
967 #define CHECK(ip, s) do { \
968 v = tor_dup_ip(ip); \
969 tt_str_op(v,OP_EQ,(s)); \
970 tor_free(v); \
971 } while (0)
972
973 CHECK(0xffffffff, "255.255.255.255");
974 CHECK(0x00000000, "0.0.0.0");
975 CHECK(0x7f000001, "127.0.0.1");
976 CHECK(0x01020304, "1.2.3.4");
977
978 #undef CHECK
979 done:
980 tor_free(v);
981 }
982
983 static void
984 test_addr_sockaddr_to_str(void *arg)
985 {
986 char *v = NULL;
987 struct sockaddr_in sin;
988 struct sockaddr_in6 sin6;
989 struct sockaddr_storage ss;
990 #ifdef HAVE_SYS_UN_H
991 struct sockaddr_un s_un;
992 #endif
993 #define CHECK(sa, s) do { \
994 v = tor_sockaddr_to_str((const struct sockaddr*) &(sa)); \
995 tt_str_op(v,OP_EQ,(s)); \
996 tor_free(v); \
997 } while (0)
998 (void)arg;
999
1000 memset(&ss,0,sizeof(ss));
1001 ss.ss_family = AF_UNSPEC;
1002 CHECK(ss, "unspec");
1003
1004 memset(&sin,0,sizeof(sin));
1005 sin.sin_family = AF_INET;
1006 sin.sin_addr.s_addr = htonl(0x7f808001);
1007 sin.sin_port = htons(1234);
1008 CHECK(sin, "127.128.128.1:1234");
1009
1010 #ifdef HAVE_SYS_UN_H
1011 memset(&s_un,0,sizeof(s_un));
1012 s_un.sun_family = AF_UNIX;
1013 strlcpy(s_un.sun_path, "/here/is/a/path", sizeof(s_un.sun_path));
1014 CHECK(s_un, "unix:/here/is/a/path");
1015 #endif /* defined(HAVE_SYS_UN_H) */
1016
1017 memset(&sin6,0,sizeof(sin6));
1018 sin6.sin6_family = AF_INET6;
1019 memcpy(sin6.sin6_addr.s6_addr, "\x20\x00\x00\x00\x00\x00\x00\x00"
1020 "\x00\x1a\x2b\x3c\x4d\x5e\x00\x01", 16);
1021 sin6.sin6_port = htons(1234);
1022 CHECK(sin6, "[2000::1a:2b3c:4d5e:1]:1234");
1023
1024 done:
1025 tor_free(v);
1026 }
1027
1028 static void
1029 test_addr_is_loopback(void *data)
1030 {
1031 static const struct loopback_item {
1032 const char *name;
1033 int is_loopback;
1034 } loopback_items[] = {
1035 { "::1", 1 },
1036 { "127.0.0.1", 1 },
1037 { "127.99.100.101", 1 },
1038 { "128.99.100.101", 0 },
1039 { "8.8.8.8", 0 },
1040 { "0.0.0.0", 0 },
1041 { "::2", 0 },
1042 { "::", 0 },
1043 { "::1.0.0.0", 0 },
1044 { NULL, 0 }
1045 };
1046
1047 int i;
1048 tor_addr_t addr;
1049 (void)data;
1050
1051 for (i=0; loopback_items[i].name; ++i) {
1052 tt_int_op(tor_addr_parse(&addr, loopback_items[i].name), OP_GE, 0);
1053 tt_int_op(tor_addr_is_loopback(&addr), OP_EQ,
1054 loopback_items[i].is_loopback);
1055 }
1056
1057 tor_addr_make_unspec(&addr);
1058 tt_int_op(tor_addr_is_loopback(&addr), OP_EQ, 0);
1059
1060 done:
1061 ;
1062 }
1063
1064 static void
1065 test_addr_make_null(void *data)
1066 {
1067 tor_addr_t *addr = tor_malloc(sizeof(*addr));
1068 tor_addr_t *zeros = tor_malloc_zero(sizeof(*addr));
1069 char buf[TOR_ADDR_BUF_LEN];
1070 (void) data;
1071 /* Ensure that before tor_addr_make_null, addr != 0's */
1072 memset(addr, 1, sizeof(*addr));
1073 tt_int_op(fast_memcmp(addr, zeros, sizeof(*addr)), OP_NE, 0);
1074 /* Test with AF == AF_INET */
1075 zeros->family = AF_INET;
1076 tor_addr_make_null(addr, AF_INET);
1077 tt_int_op(fast_memcmp(addr, zeros, sizeof(*addr)), OP_EQ, 0);
1078 tt_str_op(tor_addr_to_str(buf, addr, sizeof(buf), 0), OP_EQ, "0.0.0.0");
1079 /* Test with AF == AF_INET6 */
1080 memset(addr, 1, sizeof(*addr));
1081 zeros->family = AF_INET6;
1082 tor_addr_make_null(addr, AF_INET6);
1083 tt_int_op(fast_memcmp(addr, zeros, sizeof(*addr)), OP_EQ, 0);
1084 tt_str_op(tor_addr_to_str(buf, addr, sizeof(buf), 0), OP_EQ, "::");
1085 done:
1086 tor_free(addr);
1087 tor_free(zeros);
1088 }
1089
1090 #define ADDR_LEGACY(name) \
1091 { #name, test_addr_ ## name , 0, NULL, NULL }
1092
1093 struct testcase_t addr_tests[] = {
1094 ADDR_LEGACY(basic),
1095 ADDR_LEGACY(ip6_helpers),
1096 ADDR_LEGACY(parse),
1097 { "virtaddr", test_virtaddrmap, 0, NULL, NULL },
1098 { "localname", test_addr_localname, 0, NULL, NULL },
1099 { "dup_ip", test_addr_dup_ip, 0, NULL, NULL },
1100 { "sockaddr_to_str", test_addr_sockaddr_to_str, 0, NULL, NULL },
1101 { "is_loopback", test_addr_is_loopback, 0, NULL, NULL },
1102 { "make_null", test_addr_make_null, 0, NULL, NULL },
1103 END_OF_TESTCASES
1104 };
1105
The Onion Router