update changelog
[debian/iodine.git] / tests / common.c
1 #include <check.h>
2 #include <common.h>
3 #include <unistd.h>
4 #include <sys/socket.h>
5 #include <netdb.h>
6
7 START_TEST(test_topdomain_ok)
8 {
9         char *error;
10
11         fail_if(check_topdomain("foo.0123456789.qwertyuiop.asdfghjkl.zxcvbnm.com", &error));
12
13         /* Not allowed to start with dot */
14         fail_unless(check_topdomain(".foo.0123456789.qwertyuiop.asdfghjkl.zxcvbnm.com", &error));
15         fail_if(strcmp("Starts with a dot", error));
16
17         /* Test missing error msg ptr */
18         fail_unless(check_topdomain(".foo", NULL));
19 }
20 END_TEST
21
22 START_TEST(test_topdomain_length)
23 {
24         char *error;
25
26         /* Test empty and too short */
27         fail_unless(check_topdomain("", &error));
28         fail_if(strcmp("Too short (< 3)", error));
29         fail_unless(check_topdomain("a", &error));
30         fail_if(strcmp("Too short (< 3)", error));
31         fail_unless(check_topdomain(".a", &error));
32         fail_if(strcmp("Too short (< 3)", error));
33         fail_unless(check_topdomain("a.", &error));
34         fail_if(strcmp("Too short (< 3)", error));
35         fail_unless(check_topdomain("ab", &error));
36         fail_if(strcmp("Too short (< 3)", error));
37         fail_if(check_topdomain("a.b", &error));
38         fail_if(strcmp("Too short (< 3)", error));
39
40         /* Test too long (over 128, need rest of space for data) */
41         fail_unless(check_topdomain(
42                 "abcd12345.abcd12345.abcd12345.abcd12345.abcd12345."
43                 "abcd12345.abcd12345.abcd12345.abcd12345.abcd12345."
44                 "abcd12345.abcd12345.foo129xxx", &error));
45         fail_if(strcmp("Too long (> 128)", error));
46         fail_if(check_topdomain(
47                 "abcd12345.abcd12345.abcd12345.abcd12345.abcd12345."
48                 "abcd12345.abcd12345.abcd12345.abcd12345.abcd12345."
49                 "abcd12345.abcd12345.foo128xx", &error));
50 }
51 END_TEST
52
53 START_TEST(test_topdomain_chunks)
54 {
55         char *error;
56
57         /* Must have at least one dot */
58         fail_if(check_topdomain("abcde.gh", &error));
59         fail_unless(check_topdomain("abcdefgh", &error));
60         fail_if(strcmp("No dots", error));
61
62         /* Not two consecutive dots */
63         fail_unless(check_topdomain("abc..defgh", &error));
64         fail_if(strcmp("Consecutive dots", error));
65
66         /* Not end with a dots */
67         fail_unless(check_topdomain("abc.defgh.", &error));
68         fail_if(strcmp("Ends with a dot", error));
69
70         /* No chunk longer than 63 chars */
71         fail_if(check_topdomain("123456789012345678901234567890"
72                 "123456789012345678901234567890333.com", &error));
73         fail_unless(check_topdomain("123456789012345678901234567890"
74                 "1234567890123456789012345678904444.com", &error));
75         fail_if(strcmp("Too long domain part (> 63)", error));
76
77         fail_if(check_topdomain("abc.123456789012345678901234567890"
78                 "123456789012345678901234567890333.com", &error));
79         fail_unless(check_topdomain("abc.123456789012345678901234567890"
80                 "1234567890123456789012345678904444.com", &error));
81         fail_if(strcmp("Too long domain part (> 63)", error));
82
83         fail_if(check_topdomain("abc.123456789012345678901234567890"
84                 "123456789012345678901234567890333", &error));
85         fail_unless(check_topdomain("abc.123456789012345678901234567890"
86                 "1234567890123456789012345678904444", &error));
87         fail_if(strcmp("Too long domain part (> 63)", error));
88 }
89 END_TEST
90
91 START_TEST(test_parse_format_ipv4)
92 {
93         char *host = "192.168.2.10";
94         char *formatted;
95         struct sockaddr_storage addr;
96         struct sockaddr_in *v4addr;
97         int addr_len;
98
99         addr_len = get_addr(host, 53, AF_INET, 0, &addr);
100         fail_unless(addr_len == sizeof(struct sockaddr_in));
101
102         v4addr = (struct sockaddr_in *) &addr;
103         fail_unless(v4addr->sin_addr.s_addr == htonl(0xc0a8020a));
104         fail_unless(v4addr->sin_port == htons(53));
105
106         formatted = format_addr(&addr, addr_len);
107         fail_if(strcmp(host, formatted));
108 }
109 END_TEST
110
111 START_TEST(test_parse_format_ipv4_listen_all)
112 {
113         char *host = "0.0.0.0";
114         char *formatted;
115         struct sockaddr_storage addr;
116         struct sockaddr_in *v4addr;
117         int addr_len;
118
119         addr_len = get_addr(NULL, 53, AF_INET, AI_PASSIVE, &addr);
120         fail_unless(addr_len == sizeof(struct sockaddr_in));
121
122         v4addr = (struct sockaddr_in *) &addr;
123         fail_unless(v4addr->sin_addr.s_addr == htonl(0x00000000));
124         fail_unless(v4addr->sin_port == htons(53));
125
126         formatted = format_addr(&addr, addr_len);
127         fail_if(strcmp(host, formatted));
128 }
129 END_TEST
130
131 START_TEST(test_parse_format_ipv6)
132 {
133         char *host = "2001:0db8:0505:0::123:0abc";
134         char *compact = "2001:db8:505::123:abc";
135         unsigned char v6_bits[] = {
136                 0x20, 0x01, 0x0d, 0xb8, 0x05, 0x05, 0x00, 0x00,
137                 0x00, 0x00, 0x00, 0x00, 0x01, 0x23, 0x0a, 0xbc,
138         };
139         char *formatted;
140         struct sockaddr_storage addr;
141         struct sockaddr_in6 *v6addr;
142         int addr_len;
143
144         addr_len = get_addr(host, 53, AF_UNSPEC, 0, &addr);
145         fail_unless(addr_len == sizeof(struct sockaddr_in6));
146
147         v6addr = (struct sockaddr_in6 *) &addr;
148         fail_if(memcmp(&v6addr->sin6_addr, v6_bits, sizeof(v6_bits)));
149         fail_unless(v6addr->sin6_port == htons(53));
150
151         formatted = format_addr(&addr, addr_len);
152         fail_if(strcmp(compact, formatted));
153 }
154 END_TEST
155
156 START_TEST(test_parse_format_ipv4_mapped_ipv6)
157 {
158         char *v4mapped = "::FFFF:192.168.2.10";
159         char *host = "192.168.2.10";
160         unsigned char v6_bits[] = {
161                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
162                 0x00, 0x00, 0xff, 0xff, 0xc0, 0xa8, 0x02, 0x0a,
163         };
164         char *formatted;
165         struct sockaddr_storage addr;
166         struct sockaddr_in6 *v6addr;
167         int addr_len;
168
169         addr_len = get_addr(v4mapped, 53, AF_INET6, 0, &addr);
170         fail_unless(addr_len == sizeof(struct sockaddr_in6));
171
172         v6addr = (struct sockaddr_in6 *) &addr;
173         fail_if(memcmp(&v6addr->sin6_addr, v6_bits, sizeof(v6_bits)));
174         fail_unless(v6addr->sin6_port == htons(53));
175
176         /* Format as IPv4 address */
177         formatted = format_addr(&addr, addr_len);
178         fail_if(strcmp(host, formatted));
179 }
180 END_TEST
181
182 TCase *
183 test_common_create_tests()
184 {
185         TCase *tc;
186         int sock;
187
188         tc = tcase_create("Common");
189         tcase_add_test(tc, test_topdomain_ok);
190         tcase_add_test(tc, test_topdomain_length);
191         tcase_add_test(tc, test_topdomain_chunks);
192         tcase_add_test(tc, test_parse_format_ipv4);
193         tcase_add_test(tc, test_parse_format_ipv4_listen_all);
194
195         /* Tests require IPv6 support */
196         sock = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
197         if (sock >= 0) {
198                 close(sock);
199                 tcase_add_test(tc, test_parse_format_ipv6);
200                 tcase_add_test(tc, test_parse_format_ipv4_mapped_ipv6);
201         }
202         return tc;
203 }