Imported Upstream version 1.24
[platform/upstream/connman.git] / unit / test-ippool.c
1 /*
2  *
3  *  Connection Manager
4  *
5  *  Copyright (C) 2012  BWM CarIT GmbH. All rights reserved.
6  *
7  *  This program is free software; you can redistribute it and/or modify
8  *  it under the terms of the GNU General Public License version 2 as
9  *  published by the Free Software Foundation.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, write to the Free Software
18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19  *
20  */
21
22 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25
26 #include <glib.h>
27
28 #include "../src/connman.h"
29
30 /* #define DEBUG */
31 #ifdef DEBUG
32 #include <stdio.h>
33
34 #define LOG(fmt, arg...) do { \
35         fprintf(stdout, "%s:%s() " fmt "\n", \
36                         __FILE__, __func__ , ## arg); \
37 } while (0)
38 #else
39 #define LOG(fmt, arg...)
40 #endif
41
42 static void test_case_1(void)
43 {
44         struct connman_ippool *pool;
45         int i;
46
47         __connman_ippool_init();
48
49         pool = __connman_ippool_create(23, 1, 500, NULL, NULL);
50         g_assert(!pool);
51
52         for (i = 0; i < 100000; i++) {
53                 pool = __connman_ippool_create(23, 1, 20, NULL, NULL);
54                 g_assert(pool);
55
56                 __connman_ippool_unref(pool);
57         }
58
59         __connman_ippool_cleanup();
60 }
61
62 static void test_case_2(void)
63 {
64         struct connman_ippool *pool;
65         const char *gateway;
66         const char *broadcast;
67         const char *subnet_mask;
68         const char *start_ip;
69         const char *end_ip;
70         int i;
71
72         __connman_ippool_init();
73
74         /* Test the IP range */
75         for (i = 1; i < 254; i++) {
76                 pool = __connman_ippool_create(23, 1, i, NULL, NULL);
77                 g_assert(pool);
78
79                 gateway = __connman_ippool_get_gateway(pool);
80                 broadcast = __connman_ippool_get_broadcast(pool);
81                 subnet_mask = __connman_ippool_get_subnet_mask(pool);
82                 start_ip = __connman_ippool_get_start_ip(pool);
83                 end_ip = __connman_ippool_get_end_ip(pool);
84
85                 g_assert(gateway);
86                 g_assert(broadcast);
87                 g_assert(subnet_mask);
88                 g_assert(start_ip);
89                 g_assert(end_ip);
90
91                 LOG("\n\tIP range %s --> %s\n"
92                         "\tgateway %s broadcast %s mask %s", start_ip, end_ip,
93                         gateway, broadcast, subnet_mask);
94
95                 __connman_ippool_unref(pool);
96         }
97
98         __connman_ippool_cleanup();
99 }
100
101 static void test_case_3(void)
102 {
103         struct connman_ippool *pool;
104         const char *gateway;
105         const char *broadcast;
106         const char *subnet_mask;
107         const char *start_ip;
108         const char *end_ip;
109         GSList *list = NULL, *it;
110         int i = 0;
111
112         __connman_ippool_init();
113
114         /*
115          *                                             Number of addresses
116          * 24-bit block         10.0.0.0    – 10.255.255.255    16,777,216
117          * 20-bit block         172.16.0.0  – 172.31.255.255     1,048,576
118          * 16-bit block         192.168.0.0 – 192.168.255.255       65,536
119          *
120          * Total                                                17,891,328
121          *
122          * Total numbers of 256 blocks:                             69,888
123          */
124
125         /*
126          * Completely exhaust the first two pools because they are a bit
127          * too large.
128          */
129         __connman_ippool_newaddr(45, "10.0.0.1", 8);
130         __connman_ippool_newaddr(46, "172.16.0.1", 11);
131
132         while (TRUE) {
133                 pool = __connman_ippool_create(23, 1, 100, NULL, NULL);
134                 if (!pool)
135                         break;
136                 i += 1;
137
138                 list = g_slist_prepend(list, pool);
139
140                 gateway = __connman_ippool_get_gateway(pool);
141                 broadcast = __connman_ippool_get_broadcast(pool);
142                 subnet_mask = __connman_ippool_get_subnet_mask(pool);
143                 start_ip = __connman_ippool_get_start_ip(pool);
144                 end_ip = __connman_ippool_get_end_ip(pool);
145
146                 g_assert(gateway);
147                 g_assert(broadcast);
148                 g_assert(subnet_mask);
149                 g_assert(start_ip);
150                 g_assert(end_ip);
151         }
152
153         g_assert(i == 255);
154
155         LOG("Number of blocks %d", i);
156
157         for (it = list; it; it = it->next) {
158                 pool = it->data;
159
160                 __connman_ippool_unref(pool);
161         }
162
163         g_slist_free(list);
164
165         __connman_ippool_cleanup();
166 }
167
168 static void collision_cb(struct connman_ippool *pool, void *user_data)
169 {
170         int *flag = user_data;
171
172         LOG("collision detected");
173
174         g_assert(*flag == 0);
175         g_assert(pool);
176
177         *flag = 1;
178 }
179
180 static void test_case_4(void)
181 {
182         struct connman_ippool *pool;
183         const char *gateway;
184         const char *broadcast;
185         const char *subnet_mask;
186         const char *start_ip;
187         const char *end_ip;
188         int flag;
189
190         __connman_ippool_init();
191
192         /* Test the IP range collision */
193
194         flag = 0;
195         pool = __connman_ippool_create(23, 1, 100, collision_cb, &flag);
196         g_assert(pool);
197
198         gateway = __connman_ippool_get_gateway(pool);
199         broadcast = __connman_ippool_get_broadcast(pool);
200         subnet_mask = __connman_ippool_get_subnet_mask(pool);
201         start_ip = __connman_ippool_get_start_ip(pool);
202         end_ip = __connman_ippool_get_end_ip(pool);
203
204         g_assert(gateway);
205         g_assert(broadcast);
206         g_assert(subnet_mask);
207         g_assert(start_ip);
208         g_assert(end_ip);
209
210         LOG("\n\tIP range %s --> %s\n"
211                 "\tgateway %s broadcast %s mask %s", start_ip, end_ip,
212                 gateway, broadcast, subnet_mask);
213
214         __connman_ippool_newaddr(23, start_ip, 24);
215
216         g_assert(flag == 0);
217
218         __connman_ippool_newaddr(42, start_ip, 16);
219
220         g_assert(flag == 1);
221
222         __connman_ippool_unref(pool);
223
224         flag = 0;
225
226         pool = __connman_ippool_create(23, 1, 100, collision_cb, &flag);
227         g_assert(pool);
228
229         gateway = __connman_ippool_get_gateway(pool);
230         broadcast = __connman_ippool_get_broadcast(pool);
231         subnet_mask = __connman_ippool_get_subnet_mask(pool);
232         start_ip = __connman_ippool_get_start_ip(pool);
233         end_ip = __connman_ippool_get_end_ip(pool);
234
235         g_assert(gateway);
236         g_assert(broadcast);
237         g_assert(subnet_mask);
238         g_assert(start_ip);
239         g_assert(end_ip);
240
241         LOG("\n\tIP range %s --> %s\n"
242                 "\tgateway %s broadcast %s mask %s", start_ip, end_ip,
243                 gateway, broadcast, subnet_mask);
244
245         __connman_ippool_newaddr(45, start_ip, 22);
246
247         g_assert(flag == 1);
248
249         __connman_ippool_unref(pool);
250
251         __connman_ippool_cleanup();
252 }
253
254 static void test_case_5(void)
255 {
256         struct connman_ippool *pool;
257         const char *gateway;
258         const char *broadcast;
259         const char *subnet_mask;
260         const char *start_ip;
261         const char *end_ip;
262         int flag;
263
264         __connman_ippool_init();
265
266         /* Test the IP range collision */
267
268         flag = 0;
269         start_ip = "192.168.1.2";
270         __connman_ippool_newaddr(25, start_ip, 24);
271         g_assert(flag == 0);
272
273         /* pool should return 192.168.0.1 now */
274         pool = __connman_ippool_create(26, 1, 100, collision_cb, &flag);
275         g_assert(pool);
276
277         gateway = __connman_ippool_get_gateway(pool);
278         broadcast = __connman_ippool_get_broadcast(pool);
279         subnet_mask = __connman_ippool_get_subnet_mask(pool);
280         start_ip = __connman_ippool_get_start_ip(pool);
281         end_ip = __connman_ippool_get_end_ip(pool);
282
283         g_assert(gateway);
284         g_assert(broadcast);
285         g_assert(subnet_mask);
286         g_assert(start_ip);
287         g_assert(end_ip);
288
289         g_assert_cmpstr(gateway, ==, "192.168.0.1");
290         g_assert_cmpstr(broadcast, ==, "192.168.0.255");
291         g_assert_cmpstr(subnet_mask, ==, "255.255.255.0");
292         g_assert_cmpstr(start_ip, ==, "192.168.0.1");
293         g_assert_cmpstr(end_ip, ==, "192.168.0.101");
294
295         LOG("\n\tIP range %s --> %s\n"
296                 "\tgateway %s broadcast %s mask %s", start_ip, end_ip,
297                 gateway, broadcast, subnet_mask);
298
299         __connman_ippool_unref(pool);
300
301         /*
302          * Now create the pool again, we should not get collision
303          * with existing allocated address.
304          */
305
306         /* pool should return 192.168.2.1 now */
307         flag = 0;
308         pool = __connman_ippool_create(23, 1, 100, collision_cb, &flag);
309         g_assert(pool);
310
311         gateway = __connman_ippool_get_gateway(pool);
312         broadcast = __connman_ippool_get_broadcast(pool);
313         subnet_mask = __connman_ippool_get_subnet_mask(pool);
314         start_ip = __connman_ippool_get_start_ip(pool);
315         end_ip = __connman_ippool_get_end_ip(pool);
316
317         g_assert(gateway);
318         g_assert(broadcast);
319         g_assert(subnet_mask);
320         g_assert(start_ip);
321         g_assert(end_ip);
322
323         g_assert_cmpstr(gateway, ==, "192.168.2.1");
324         g_assert_cmpstr(broadcast, ==, "192.168.2.255");
325         g_assert_cmpstr(subnet_mask, ==, "255.255.255.0");
326         g_assert_cmpstr(start_ip, ==, "192.168.2.1");
327         g_assert_cmpstr(end_ip, ==, "192.168.2.101");
328
329         LOG("\n\tIP range %s --> %s\n"
330                 "\tgateway %s broadcast %s mask %s", start_ip, end_ip,
331                 gateway, broadcast, subnet_mask);
332
333         g_assert(flag == 0);
334
335         __connman_ippool_unref(pool);
336
337         __connman_ippool_cleanup();
338 }
339
340 static void test_case_6(void)
341 {
342         struct connman_ippool *pool;
343         const char *gateway;
344         const char *broadcast;
345         const char *subnet_mask;
346         const char *start_ip;
347         const char *end_ip;
348         int flag;
349
350         __connman_ippool_init();
351
352         /* Test the IP range collision */
353
354         flag = 0;
355         start_ip = "192.168.1.2";
356         __connman_ippool_newaddr(25, start_ip, 24);
357         g_assert(flag == 0);
358
359         flag = 0;
360         start_ip = "192.168.0.2";
361         __connman_ippool_newaddr(25, start_ip, 24);
362         g_assert(flag == 0);
363
364         /* pool should return 192.168.2.1 now */
365         pool = __connman_ippool_create(26, 1, 100, collision_cb, &flag);
366         g_assert(pool);
367
368         gateway = __connman_ippool_get_gateway(pool);
369         broadcast = __connman_ippool_get_broadcast(pool);
370         subnet_mask = __connman_ippool_get_subnet_mask(pool);
371         start_ip = __connman_ippool_get_start_ip(pool);
372         end_ip = __connman_ippool_get_end_ip(pool);
373
374         g_assert(gateway);
375         g_assert(broadcast);
376         g_assert(subnet_mask);
377         g_assert(start_ip);
378         g_assert(end_ip);
379
380         g_assert_cmpstr(gateway, ==, "192.168.2.1");
381         g_assert_cmpstr(broadcast, ==, "192.168.2.255");
382         g_assert_cmpstr(subnet_mask, ==, "255.255.255.0");
383         g_assert_cmpstr(start_ip, ==, "192.168.2.1");
384         g_assert_cmpstr(end_ip, ==, "192.168.2.101");
385
386         LOG("\n\tIP range %s --> %s\n"
387                 "\tgateway %s broadcast %s mask %s", start_ip, end_ip,
388                 gateway, broadcast, subnet_mask);
389
390         __connman_ippool_unref(pool);
391
392         /*
393          * Now create the pool again, we should not get collision
394          * with existing allocated address.
395          */
396
397         /* pool should return 192.168.3.1 now */
398         flag = 0;
399         pool = __connman_ippool_create(23, 1, 100, collision_cb, &flag);
400         g_assert(pool);
401
402         gateway = __connman_ippool_get_gateway(pool);
403         broadcast = __connman_ippool_get_broadcast(pool);
404         subnet_mask = __connman_ippool_get_subnet_mask(pool);
405         start_ip = __connman_ippool_get_start_ip(pool);
406         end_ip = __connman_ippool_get_end_ip(pool);
407
408         g_assert(gateway);
409         g_assert(broadcast);
410         g_assert(subnet_mask);
411         g_assert(start_ip);
412         g_assert(end_ip);
413
414         g_assert_cmpstr(gateway, ==, "192.168.3.1");
415         g_assert_cmpstr(broadcast, ==, "192.168.3.255");
416         g_assert_cmpstr(subnet_mask, ==, "255.255.255.0");
417         g_assert_cmpstr(start_ip, ==, "192.168.3.1");
418         g_assert_cmpstr(end_ip, ==, "192.168.3.101");
419
420         LOG("\n\tIP range %s --> %s\n"
421                 "\tgateway %s broadcast %s mask %s", start_ip, end_ip,
422                 gateway, broadcast, subnet_mask);
423
424         g_assert(flag == 0);
425
426         flag = 0;
427         start_ip = "192.168.3.2";
428         __connman_ippool_newaddr(25, start_ip, 24);
429         g_assert(flag == 1);
430
431         __connman_ippool_unref(pool);
432
433         __connman_ippool_cleanup();
434 }
435
436 int main(int argc, char *argv[])
437 {
438         g_test_init(&argc, &argv, NULL);
439
440         g_test_add_func("/ippool/Test case 1", test_case_1);
441         g_test_add_func("/ippool/Test case 2", test_case_2);
442         g_test_add_func("/ippool/Test case 3", test_case_3);
443         g_test_add_func("/ippool/Test case 4", test_case_4);
444         g_test_add_func("/ippool/Test case 5", test_case_5);
445         g_test_add_func("/ippool/Test case 6", test_case_6);
446
447         return g_test_run();
448 }