xref: /freebsd/lib/libc/tests/nss/getproto_test.c (revision a0b9e2e854027e6ff61fb075a1309dbc71c42b54)
1 /*-
2  * Copyright (c) 2006 Michael Bushkov <bushman@freebsd.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  */
27 
28 #include <sys/cdefs.h>
29 __FBSDID("$FreeBSD$");
30 
31 #include <arpa/inet.h>
32 #include <assert.h>
33 #include <errno.h>
34 #include <netdb.h>
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <stringlist.h>
39 #include <unistd.h>
40 
41 #include <atf-c.h>
42 
43 #include "testutil.h"
44 
45 enum test_methods {
46 	TEST_GETPROTOENT,
47 	TEST_GETPROTOBYNAME,
48 	TEST_GETPROTOBYNUMBER,
49 	TEST_GETPROTOENT_2PASS,
50 	TEST_BUILD_SNAPSHOT
51 };
52 
53 DECLARE_TEST_DATA(protoent)
54 DECLARE_TEST_FILE_SNAPSHOT(protoent)
55 DECLARE_1PASS_TEST(protoent)
56 DECLARE_2PASS_TEST(protoent)
57 
58 static void clone_protoent(struct protoent *, struct protoent const *);
59 static int compare_protoent(struct protoent *, struct protoent *, void *);
60 static void dump_protoent(struct protoent *);
61 static void free_protoent(struct protoent *);
62 
63 static void sdump_protoent(struct protoent *, char *, size_t);
64 static int protoent_read_snapshot_func(struct protoent *, char *);
65 
66 static int protoent_check_ambiguity(struct protoent_test_data *,
67 	struct protoent *);
68 static int protoent_fill_test_data(struct protoent_test_data *);
69 static int protoent_test_correctness(struct protoent *, void *);
70 static int protoent_test_getprotobyname(struct protoent *, void *);
71 static int protoent_test_getprotobynumber(struct protoent *, void *);
72 static int protoent_test_getprotoent(struct protoent *, void *);
73 
74 IMPLEMENT_TEST_DATA(protoent)
75 IMPLEMENT_TEST_FILE_SNAPSHOT(protoent)
76 IMPLEMENT_1PASS_TEST(protoent)
77 IMPLEMENT_2PASS_TEST(protoent)
78 
79 static void
80 clone_protoent(struct protoent *dest, struct protoent const *src)
81 {
82 	assert(dest != NULL);
83 	assert(src != NULL);
84 
85 	char **cp;
86 	int aliases_num;
87 
88 	memset(dest, 0, sizeof(struct protoent));
89 
90 	if (src->p_name != NULL) {
91 		dest->p_name = strdup(src->p_name);
92 		assert(dest->p_name != NULL);
93 	}
94 
95 	dest->p_proto = src->p_proto;
96 
97 	if (src->p_aliases != NULL) {
98 		aliases_num = 0;
99 		for (cp = src->p_aliases; *cp; ++cp)
100 			++aliases_num;
101 
102 		dest->p_aliases = calloc(aliases_num + 1, sizeof(char *));
103 		assert(dest->p_aliases != NULL);
104 
105 		for (cp = src->p_aliases; *cp; ++cp) {
106 			dest->p_aliases[cp - src->p_aliases] = strdup(*cp);
107 			assert(dest->p_aliases[cp - src->p_aliases] != NULL);
108 		}
109 	}
110 }
111 
112 static void
113 free_protoent(struct protoent *pe)
114 {
115 	char **cp;
116 
117 	assert(pe != NULL);
118 
119 	free(pe->p_name);
120 
121 	for (cp = pe->p_aliases; *cp; ++cp)
122 		free(*cp);
123 	free(pe->p_aliases);
124 }
125 
126 static  int
127 compare_protoent(struct protoent *pe1, struct protoent *pe2, void *mdata)
128 {
129 	char **c1, **c2;
130 
131 	if (pe1 == pe2)
132 		return 0;
133 
134 	if ((pe1 == NULL) || (pe2 == NULL))
135 		goto errfin;
136 
137 	if ((strcmp(pe1->p_name, pe2->p_name) != 0) ||
138 		(pe1->p_proto != pe2->p_proto))
139 			goto errfin;
140 
141 	c1 = pe1->p_aliases;
142 	c2 = pe2->p_aliases;
143 
144 	if ((pe1->p_aliases == NULL) || (pe2->p_aliases == NULL))
145 		goto errfin;
146 
147 	for (;*c1 && *c2; ++c1, ++c2)
148 		if (strcmp(*c1, *c2) != 0)
149 			goto errfin;
150 
151 	if ((*c1 != NULL) || (*c2 != NULL))
152 		goto errfin;
153 
154 	return 0;
155 
156 errfin:
157 	if (mdata == NULL) {
158 		printf("following structures are not equal:\n");
159 		dump_protoent(pe1);
160 		dump_protoent(pe2);
161 	}
162 
163 	return (-1);
164 }
165 
166 static void
167 sdump_protoent(struct protoent *pe, char *buffer, size_t buflen)
168 {
169 	char **cp;
170 	int written;
171 
172 	written = snprintf(buffer, buflen, "%s %d",
173 		pe->p_name, pe->p_proto);
174 	buffer += written;
175 	if (written > (int)buflen)
176 		return;
177 	buflen -= written;
178 
179 	if (pe->p_aliases != NULL) {
180 		if (*(pe->p_aliases) != NULL) {
181 			for (cp = pe->p_aliases; *cp; ++cp) {
182 				written = snprintf(buffer, buflen, " %s", *cp);
183 				buffer += written;
184 				if (written > (int)buflen)
185 					return;
186 				buflen -= written;
187 
188 				if (buflen == 0)
189 					return;
190 			}
191 		} else
192 			snprintf(buffer, buflen, " noaliases");
193 	} else
194 		snprintf(buffer, buflen, " (null)");
195 }
196 
197 static int
198 protoent_read_snapshot_func(struct protoent *pe, char *line)
199 {
200 	StringList *sl;
201 	char *s, *ps, *ts;
202 	int i;
203 
204 	printf("1 line read from snapshot:\n%s\n", line);
205 
206 	i = 0;
207 	sl = NULL;
208 	ps = line;
209 	memset(pe, 0, sizeof(struct protoent));
210 	while ( (s = strsep(&ps, " ")) != NULL) {
211 		switch (i) {
212 			case 0:
213 				pe->p_name = strdup(s);
214 				assert(pe->p_name != NULL);
215 			break;
216 
217 			case 1:
218 				pe->p_proto = (int)strtol(s, &ts, 10);
219 				if (*ts != '\0') {
220 					free(pe->p_name);
221 					return (-1);
222 				}
223 			break;
224 
225 			default:
226 				if (sl == NULL) {
227 					if (strcmp(s, "(null)") == 0)
228 						return (0);
229 
230 					sl = sl_init();
231 					assert(sl != NULL);
232 
233 					if (strcmp(s, "noaliases") != 0) {
234 						ts = strdup(s);
235 						assert(ts != NULL);
236 						sl_add(sl, ts);
237 					}
238 				} else {
239 					ts = strdup(s);
240 					assert(ts != NULL);
241 					sl_add(sl, ts);
242 				}
243 			break;
244 		}
245 		++i;
246 	}
247 
248 	if (i < 3) {
249 		free(pe->p_name);
250 		memset(pe, 0, sizeof(struct protoent));
251 		return (-1);
252 	}
253 
254 	sl_add(sl, NULL);
255 	pe->p_aliases = sl->sl_str;
256 
257 	/* NOTE: is it a dirty hack or not? */
258 	free(sl);
259 	return (0);
260 }
261 
262 static void
263 dump_protoent(struct protoent *result)
264 {
265 	if (result != NULL) {
266 		char buffer[1024];
267 		sdump_protoent(result, buffer, sizeof(buffer));
268 		printf("%s\n", buffer);
269 	} else
270 		printf("(null)\n");
271 }
272 
273 static int
274 protoent_fill_test_data(struct protoent_test_data *td)
275 {
276 	struct protoent *pe;
277 
278 	setprotoent(1);
279 	while ((pe = getprotoent()) != NULL) {
280 		if (protoent_test_correctness(pe, NULL) == 0)
281 			TEST_DATA_APPEND(protoent, td, pe);
282 		else
283 			return (-1);
284 	}
285 	endprotoent();
286 
287 	return (0);
288 }
289 
290 static int
291 protoent_test_correctness(struct protoent *pe, void *mdata __unused)
292 {
293 	printf("testing correctness with the following data:\n");
294 	dump_protoent(pe);
295 
296 	if (pe == NULL)
297 		goto errfin;
298 
299 	if (pe->p_name == NULL)
300 		goto errfin;
301 
302 	if (pe->p_proto < 0)
303 		goto errfin;
304 
305 	if (pe->p_aliases == NULL)
306 		goto errfin;
307 
308 	printf("correct\n");
309 
310 	return (0);
311 errfin:
312 	printf("incorrect\n");
313 
314 	return (-1);
315 }
316 
317 /* protoent_check_ambiguity() is needed when one port+proto is associated with
318  * more than one piece (these cases are usually marked as PROBLEM in
319  * /etc/peices. This functions is needed also when one piece+proto is
320  * associated with several ports. We have to check all the protoent structures
321  * to make sure that pe really exists and correct */
322 static int
323 protoent_check_ambiguity(struct protoent_test_data *td, struct protoent *pe)
324 {
325 
326 	return (TEST_DATA_FIND(protoent, td, pe, compare_protoent,
327 		NULL) != NULL ? 0 : -1);
328 }
329 
330 static int
331 protoent_test_getprotobyname(struct protoent *pe_model, void *mdata)
332 {
333 	char **alias;
334 	struct protoent *pe;
335 
336 	printf("testing getprotobyname() with the following data:\n");
337 	dump_protoent(pe_model);
338 
339 	pe = getprotobyname(pe_model->p_name);
340 	if (protoent_test_correctness(pe, NULL) != 0)
341 		goto errfin;
342 
343 	if ((compare_protoent(pe, pe_model, NULL) != 0) &&
344 	    (protoent_check_ambiguity((struct protoent_test_data *)mdata, pe)
345 	    !=0))
346 	    goto errfin;
347 
348 	for (alias = pe_model->p_aliases; *alias; ++alias) {
349 		pe = getprotobyname(*alias);
350 
351 		if (protoent_test_correctness(pe, NULL) != 0)
352 			goto errfin;
353 
354 		if ((compare_protoent(pe, pe_model, NULL) != 0) &&
355 		    (protoent_check_ambiguity(
356 		    (struct protoent_test_data *)mdata, pe) != 0))
357 		    goto errfin;
358 	}
359 
360 	printf("ok\n");
361 	return (0);
362 
363 errfin:
364 	printf("not ok\n");
365 
366 	return (-1);
367 }
368 
369 static int
370 protoent_test_getprotobynumber(struct protoent *pe_model, void *mdata)
371 {
372 	struct protoent *pe;
373 
374 	printf("testing getprotobyport() with the following data...\n");
375 	dump_protoent(pe_model);
376 
377 	pe = getprotobynumber(pe_model->p_proto);
378 	if ((protoent_test_correctness(pe, NULL) != 0) ||
379 	    ((compare_protoent(pe, pe_model, NULL) != 0) &&
380 	    (protoent_check_ambiguity((struct protoent_test_data *)mdata, pe)
381 	    != 0))) {
382 		printf("not ok\n");
383 		return (-1);
384 	} else {
385 		printf("ok\n");
386 		return (0);
387 	}
388 }
389 
390 static int
391 protoent_test_getprotoent(struct protoent *pe, void *mdata __unused)
392 {
393 	/* Only correctness can be checked when doing 1-pass test for
394 	 * getprotoent(). */
395 	return (protoent_test_correctness(pe, NULL));
396 }
397 
398 static int
399 run_tests(const char *snapshot_file, enum test_methods method)
400 {
401 	struct protoent_test_data td, td_snap, td_2pass;
402 	int rv;
403 
404 	TEST_DATA_INIT(protoent, &td, clone_protoent, free_protoent);
405 	TEST_DATA_INIT(protoent, &td_snap, clone_protoent, free_protoent);
406 	if (snapshot_file != NULL) {
407 		if (access(snapshot_file, W_OK | R_OK) != 0) {
408 			if (errno == ENOENT)
409 				method = TEST_BUILD_SNAPSHOT;
410 			else {
411 				printf("can't access the file %s\n",
412 				    snapshot_file);
413 
414 				rv = -1;
415 				goto fin;
416 			}
417 		} else {
418 			if (method == TEST_BUILD_SNAPSHOT) {
419 				rv = 0;
420 				goto fin;
421 			}
422 
423 			TEST_SNAPSHOT_FILE_READ(protoent, snapshot_file,
424 				&td_snap, protoent_read_snapshot_func);
425 		}
426 	}
427 
428 	rv = protoent_fill_test_data(&td);
429 	if (rv == -1)
430 		return (-1);
431 	switch (method) {
432 	case TEST_GETPROTOBYNAME:
433 		if (snapshot_file == NULL)
434 			rv = DO_1PASS_TEST(protoent, &td,
435 				protoent_test_getprotobyname, (void *)&td);
436 		else
437 			rv = DO_1PASS_TEST(protoent, &td_snap,
438 				protoent_test_getprotobyname, (void *)&td_snap);
439 		break;
440 	case TEST_GETPROTOBYNUMBER:
441 		if (snapshot_file == NULL)
442 			rv = DO_1PASS_TEST(protoent, &td,
443 				protoent_test_getprotobynumber, (void *)&td);
444 		else
445 			rv = DO_1PASS_TEST(protoent, &td_snap,
446 				protoent_test_getprotobynumber, (void *)&td_snap);
447 		break;
448 	case TEST_GETPROTOENT:
449 		if (snapshot_file == NULL)
450 			rv = DO_1PASS_TEST(protoent, &td,
451 				protoent_test_getprotoent, (void *)&td);
452 		else
453 			rv = DO_2PASS_TEST(protoent, &td, &td_snap,
454 				compare_protoent, NULL);
455 		break;
456 	case TEST_GETPROTOENT_2PASS:
457 		TEST_DATA_INIT(protoent, &td_2pass, clone_protoent,
458 		    free_protoent);
459 		rv = protoent_fill_test_data(&td_2pass);
460 		if (rv != -1)
461 			rv = DO_2PASS_TEST(protoent, &td, &td_2pass,
462 				compare_protoent, NULL);
463 		TEST_DATA_DESTROY(protoent, &td_2pass);
464 		break;
465 	case TEST_BUILD_SNAPSHOT:
466 		if (snapshot_file != NULL)
467 			rv = TEST_SNAPSHOT_FILE_WRITE(protoent, snapshot_file,
468 			    &td, sdump_protoent);
469 		break;
470 	default:
471 		rv = 0;
472 		break;
473 	}
474 
475 fin:
476 	TEST_DATA_DESTROY(protoent, &td_snap);
477 	TEST_DATA_DESTROY(protoent, &td);
478 
479 	return (rv);
480 }
481 
482 #define	SNAPSHOT_FILE	"snapshot_proto"
483 
484 ATF_TC_WITHOUT_HEAD(build_snapshot);
485 ATF_TC_BODY(build_snapshot, tc)
486 {
487 
488 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_BUILD_SNAPSHOT) == 0);
489 }
490 
491 ATF_TC_WITHOUT_HEAD(getprotoent);
492 ATF_TC_BODY(getprotoent, tc)
493 {
494 
495 	ATF_REQUIRE(run_tests(NULL, TEST_GETPROTOENT) == 0);
496 }
497 
498 ATF_TC_WITHOUT_HEAD(getprotoent_with_snapshot);
499 ATF_TC_BODY(getprotoent_with_snapshot, tc)
500 {
501 
502 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_BUILD_SNAPSHOT) == 0);
503 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_GETPROTOENT) == 0);
504 }
505 
506 ATF_TC_WITHOUT_HEAD(getprotoent_with_two_pass);
507 ATF_TC_BODY(getprotoent_with_two_pass, tc)
508 {
509 
510 	ATF_REQUIRE(run_tests(NULL, TEST_GETPROTOENT_2PASS) == 0);
511 }
512 
513 ATF_TC_WITHOUT_HEAD(getprotobyname);
514 ATF_TC_BODY(getprotobyname, tc)
515 {
516 
517 	ATF_REQUIRE(run_tests(NULL, TEST_GETPROTOBYNAME) == 0);
518 }
519 
520 ATF_TC_WITHOUT_HEAD(getprotobyname_with_snapshot);
521 ATF_TC_BODY(getprotobyname_with_snapshot, tc)
522 {
523 
524 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_BUILD_SNAPSHOT) == 0);
525 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_GETPROTOBYNAME) == 0);
526 }
527 
528 ATF_TC_WITHOUT_HEAD(getprotobynumber);
529 ATF_TC_BODY(getprotobynumber, tc)
530 {
531 
532 	ATF_REQUIRE(run_tests(NULL, TEST_GETPROTOBYNUMBER) == 0);
533 }
534 
535 ATF_TC_WITHOUT_HEAD(getprotobynumber_with_snapshot);
536 ATF_TC_BODY(getprotobynumber_with_snapshot, tc)
537 {
538 
539 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_BUILD_SNAPSHOT) == 0);
540 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_GETPROTOBYNUMBER) == 0);
541 }
542 
543 ATF_TP_ADD_TCS(tp)
544 {
545 
546 	ATF_TP_ADD_TC(tp, build_snapshot);
547 	ATF_TP_ADD_TC(tp, getprotoent);
548 	ATF_TP_ADD_TC(tp, getprotoent_with_snapshot);
549 	ATF_TP_ADD_TC(tp, getprotoent_with_two_pass);
550 	ATF_TP_ADD_TC(tp, getprotobyname);
551 	ATF_TP_ADD_TC(tp, getprotobyname_with_snapshot);
552 	ATF_TP_ADD_TC(tp, getprotobynumber);
553 	ATF_TP_ADD_TC(tp, getprotobynumber_with_snapshot);
554 
555 	return (atf_no_error());
556 }
557