xref: /freebsd/tools/regression/capsicum/syscalls/cap_fcntls_limit.c (revision aa24f48b361effe51163877d84f1b70d32b77e04) 
1 /*-
2  * Copyright (c) 2012 The FreeBSD Foundation
3  * All rights reserved.
4  *
5  * This software was developed by Pawel Jakub Dawidek under sponsorship from
6  * the FreeBSD Foundation.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  */
29 
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
32 
33 #include <sys/types.h>
34 #include <sys/capsicum.h>
35 #include <sys/procdesc.h>
36 #include <sys/socket.h>
37 #include <sys/wait.h>
38 
39 #include <err.h>
40 #include <errno.h>
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <unistd.h>
44 
45 #include "misc.h"
46 
47 static void
48 fcntl_tests_0(int fd)
49 {
50 	uint32_t fcntlrights;
51 
52 	fcntlrights = 0;
53 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
54 	CHECK(fcntlrights == CAP_FCNTL_ALL);
55 
56 	CHECK(fcntl(fd, F_GETFD) == 0);
57 	CHECK(fcntl(fd, F_SETFD, FD_CLOEXEC) == 0);
58 	CHECK(fcntl(fd, F_GETFD) == FD_CLOEXEC);
59 	CHECK(fcntl(fd, F_SETFD, 0) == 0);
60 	CHECK(fcntl(fd, F_GETFD) == 0);
61 
62 	CHECK(fcntl(fd, F_GETFL) == O_RDWR);
63 	CHECK(fcntl(fd, F_SETFL, O_NONBLOCK) == 0);
64 	CHECK(fcntl(fd, F_GETFL) == (O_RDWR | O_NONBLOCK));
65 	CHECK(fcntl(fd, F_SETFL, 0) == 0);
66 	CHECK(fcntl(fd, F_GETFL) == O_RDWR);
67 
68 	errno = 0;
69 	CHECK(cap_fcntls_limit(fd, ~CAP_FCNTL_ALL) == -1);
70 	CHECK(errno == EINVAL);
71 	CHECK(cap_fcntls_limit(fd, CAP_FCNTL_GETFL | CAP_FCNTL_SETFL) == 0);
72 	fcntlrights = 0;
73 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
74 	CHECK(fcntlrights == (CAP_FCNTL_GETFL | CAP_FCNTL_SETFL));
75 	CHECK(cap_fcntls_limit(fd, CAP_FCNTL_GETFL | CAP_FCNTL_SETFL) == 0);
76 	fcntlrights = 0;
77 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
78 	CHECK(fcntlrights == (CAP_FCNTL_GETFL | CAP_FCNTL_SETFL));
79 
80 	CHECK(fcntl(fd, F_GETFD) == 0);
81 	CHECK(fcntl(fd, F_SETFD, FD_CLOEXEC) == 0);
82 	CHECK(fcntl(fd, F_GETFD) == FD_CLOEXEC);
83 	CHECK(fcntl(fd, F_SETFD, 0) == 0);
84 	CHECK(fcntl(fd, F_GETFD) == 0);
85 
86 	CHECK(fcntl(fd, F_GETFL) == O_RDWR);
87 	CHECK(fcntl(fd, F_SETFL, O_NONBLOCK) == 0);
88 	CHECK(fcntl(fd, F_GETFL) == (O_RDWR | O_NONBLOCK));
89 	CHECK(fcntl(fd, F_SETFL, 0) == 0);
90 	CHECK(fcntl(fd, F_GETFL) == O_RDWR);
91 
92 	CHECK(cap_fcntls_limit(fd, CAP_FCNTL_GETFL) == 0);
93 	fcntlrights = 0;
94 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
95 	CHECK(fcntlrights == CAP_FCNTL_GETFL);
96 	errno = 0;
97 	CHECK(cap_fcntls_limit(fd, CAP_FCNTL_GETFL | CAP_FCNTL_SETFL) == -1);
98 	CHECK(errno == ENOTCAPABLE);
99 	fcntlrights = 0;
100 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
101 	CHECK(fcntlrights == CAP_FCNTL_GETFL);
102 
103 	CHECK(fcntl(fd, F_GETFD) == 0);
104 	CHECK(fcntl(fd, F_SETFD, FD_CLOEXEC) == 0);
105 	CHECK(fcntl(fd, F_GETFD) == FD_CLOEXEC);
106 	CHECK(fcntl(fd, F_SETFD, 0) == 0);
107 	CHECK(fcntl(fd, F_GETFD) == 0);
108 
109 	CHECK(fcntl(fd, F_GETFL) == O_RDWR);
110 	errno = 0;
111 	CHECK(fcntl(fd, F_SETFL, O_NONBLOCK) == -1);
112 	CHECK(errno == ENOTCAPABLE);
113 	CHECK(fcntl(fd, F_GETFL) == O_RDWR);
114 	errno = 0;
115 	CHECK(fcntl(fd, F_SETFL, 0) == -1);
116 	CHECK(errno == ENOTCAPABLE);
117 	CHECK(fcntl(fd, F_GETFL) == O_RDWR);
118 
119 	CHECK(cap_fcntls_limit(fd, 0) == 0);
120 	fcntlrights = CAP_FCNTL_ALL;
121 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
122 	CHECK(fcntlrights == 0);
123 	errno = 0;
124 	CHECK(cap_fcntls_limit(fd, CAP_FCNTL_GETFL | CAP_FCNTL_SETFL) == -1);
125 	CHECK(errno == ENOTCAPABLE);
126 	fcntlrights = CAP_FCNTL_ALL;
127 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
128 	CHECK(fcntlrights == 0);
129 	errno = 0;
130 	CHECK(cap_fcntls_limit(fd, CAP_FCNTL_GETFL) == -1);
131 	CHECK(errno == ENOTCAPABLE);
132 	fcntlrights = CAP_FCNTL_ALL;
133 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
134 	CHECK(fcntlrights == 0);
135 
136 	CHECK(fcntl(fd, F_GETFD) == 0);
137 	CHECK(fcntl(fd, F_SETFD, FD_CLOEXEC) == 0);
138 	CHECK(fcntl(fd, F_GETFD) == FD_CLOEXEC);
139 	CHECK(fcntl(fd, F_SETFD, 0) == 0);
140 	CHECK(fcntl(fd, F_GETFD) == 0);
141 
142 	errno = 0;
143 	CHECK(fcntl(fd, F_GETFL) == -1);
144 	CHECK(errno == ENOTCAPABLE);
145 	errno = 0;
146 	CHECK(fcntl(fd, F_SETFL, O_NONBLOCK) == -1);
147 	CHECK(errno == ENOTCAPABLE);
148 	errno = 0;
149 	CHECK(fcntl(fd, F_SETFL, 0) == -1);
150 	CHECK(errno == ENOTCAPABLE);
151 	errno = 0;
152 	CHECK(fcntl(fd, F_GETFL) == -1);
153 	CHECK(errno == ENOTCAPABLE);
154 }
155 
156 static void
157 fcntl_tests_1(int fd)
158 {
159 	uint32_t fcntlrights;
160 	cap_rights_t rights;
161 
162 	CHECK(cap_fcntls_limit(fd, CAP_FCNTL_GETFL) == 0);
163 	fcntlrights = 0;
164 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
165 	CHECK(fcntlrights == CAP_FCNTL_GETFL);
166 
167 	CAP_ALL(&rights);
168 	cap_rights_clear(&rights, CAP_FCNTL);
169 	CHECK(cap_rights_limit(fd, &rights) == 0);
170 
171 	fcntlrights = CAP_FCNTL_ALL;
172 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
173 	CHECK(fcntlrights == 0);
174 
175 	errno = 0;
176 	CHECK(cap_fcntls_limit(fd, CAP_FCNTL_GETFL | CAP_FCNTL_SETFL) == -1);
177 	CHECK(errno == ENOTCAPABLE);
178 	fcntlrights = CAP_FCNTL_ALL;
179 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
180 	CHECK(fcntlrights == 0);
181 	errno = 0;
182 	CHECK(cap_fcntls_limit(fd, CAP_FCNTL_GETFL) == -1);
183 	CHECK(errno == ENOTCAPABLE);
184 	fcntlrights = CAP_FCNTL_ALL;
185 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
186 	CHECK(fcntlrights == 0);
187 
188 	CHECK(fcntl(fd, F_GETFD) == 0);
189 	CHECK(fcntl(fd, F_SETFD, FD_CLOEXEC) == 0);
190 	CHECK(fcntl(fd, F_GETFD) == FD_CLOEXEC);
191 	CHECK(fcntl(fd, F_SETFD, 0) == 0);
192 	CHECK(fcntl(fd, F_GETFD) == 0);
193 
194 	errno = 0;
195 	CHECK(fcntl(fd, F_GETFL) == -1);
196 	CHECK(errno == ENOTCAPABLE);
197 	errno = 0;
198 	CHECK(fcntl(fd, F_SETFL, O_NONBLOCK) == -1);
199 	CHECK(errno == ENOTCAPABLE);
200 	errno = 0;
201 	CHECK(fcntl(fd, F_SETFL, 0) == -1);
202 	CHECK(errno == ENOTCAPABLE);
203 	errno = 0;
204 	CHECK(fcntl(fd, F_GETFL) == -1);
205 	CHECK(errno == ENOTCAPABLE);
206 }
207 
208 static void
209 fcntl_tests_2(int fd)
210 {
211 	uint32_t fcntlrights;
212 	cap_rights_t rights;
213 
214 	CAP_ALL(&rights);
215 	cap_rights_clear(&rights, CAP_FCNTL);
216 	CHECK(cap_rights_limit(fd, &rights) == 0);
217 
218 	fcntlrights = CAP_FCNTL_ALL;
219 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
220 	CHECK(fcntlrights == 0);
221 
222 	errno = 0;
223 	CHECK(cap_fcntls_limit(fd, CAP_FCNTL_GETFL | CAP_FCNTL_SETFL) == -1);
224 	CHECK(errno == ENOTCAPABLE);
225 	fcntlrights = CAP_FCNTL_ALL;
226 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
227 	CHECK(fcntlrights == 0);
228 	errno = 0;
229 	CHECK(cap_fcntls_limit(fd, CAP_FCNTL_GETFL) == -1);
230 	CHECK(errno == ENOTCAPABLE);
231 	fcntlrights = CAP_FCNTL_ALL;
232 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
233 	CHECK(fcntlrights == 0);
234 
235 	CHECK(fcntl(fd, F_GETFD) == 0);
236 	CHECK(fcntl(fd, F_SETFD, FD_CLOEXEC) == 0);
237 	CHECK(fcntl(fd, F_GETFD) == FD_CLOEXEC);
238 	CHECK(fcntl(fd, F_SETFD, 0) == 0);
239 	CHECK(fcntl(fd, F_GETFD) == 0);
240 
241 	errno = 0;
242 	CHECK(fcntl(fd, F_GETFL) == -1);
243 	CHECK(errno == ENOTCAPABLE);
244 	errno = 0;
245 	CHECK(fcntl(fd, F_SETFL, O_NONBLOCK) == -1);
246 	CHECK(errno == ENOTCAPABLE);
247 	errno = 0;
248 	CHECK(fcntl(fd, F_SETFL, 0) == -1);
249 	CHECK(errno == ENOTCAPABLE);
250 	errno = 0;
251 	CHECK(fcntl(fd, F_GETFL) == -1);
252 	CHECK(errno == ENOTCAPABLE);
253 }
254 
255 static void
256 fcntl_tests_send_0(int sock)
257 {
258 	int fd;
259 
260 	CHECK((fd = socket(AF_UNIX, SOCK_STREAM, 0)) >= 0);
261 	CHECK(descriptor_send(sock, fd) == 0);
262 	CHECK(close(fd) == 0);
263 
264 	CHECK((fd = socket(AF_UNIX, SOCK_STREAM, 0)) >= 0);
265 	CHECK(cap_fcntls_limit(fd, CAP_FCNTL_GETFL | CAP_FCNTL_SETFL) == 0);
266 	CHECK(descriptor_send(sock, fd) == 0);
267 	CHECK(close(fd) == 0);
268 
269 	CHECK((fd = socket(AF_UNIX, SOCK_STREAM, 0)) >= 0);
270 	CHECK(cap_fcntls_limit(fd, CAP_FCNTL_GETFL) == 0);
271 	CHECK(descriptor_send(sock, fd) == 0);
272 	CHECK(close(fd) == 0);
273 
274 	CHECK((fd = socket(AF_UNIX, SOCK_STREAM, 0)) >= 0);
275 	CHECK(cap_fcntls_limit(fd, 0) == 0);
276 	CHECK(descriptor_send(sock, fd) == 0);
277 	CHECK(close(fd) == 0);
278 }
279 
280 static void
281 fcntl_tests_recv_0(int sock)
282 {
283 	uint32_t fcntlrights;
284 	int fd;
285 
286 	CHECK(descriptor_recv(sock, &fd) == 0);
287 
288 	fcntlrights = 0;
289 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
290 	CHECK(fcntlrights == CAP_FCNTL_ALL);
291 
292 	CHECK(fcntl(fd, F_GETFD) == 0);
293 	CHECK(fcntl(fd, F_SETFD, FD_CLOEXEC) == 0);
294 	CHECK(fcntl(fd, F_GETFD) == FD_CLOEXEC);
295 	CHECK(fcntl(fd, F_SETFD, 0) == 0);
296 	CHECK(fcntl(fd, F_GETFD) == 0);
297 
298 	CHECK(fcntl(fd, F_GETFL) == O_RDWR);
299 	CHECK(fcntl(fd, F_SETFL, O_NONBLOCK) == 0);
300 	CHECK(fcntl(fd, F_GETFL) == (O_RDWR | O_NONBLOCK));
301 	CHECK(fcntl(fd, F_SETFL, 0) == 0);
302 	CHECK(fcntl(fd, F_GETFL) == O_RDWR);
303 
304 	CHECK(close(fd) == 0);
305 
306 	CHECK(descriptor_recv(sock, &fd) == 0);
307 
308 	fcntlrights = 0;
309 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
310 	CHECK(fcntlrights == (CAP_FCNTL_GETFL | CAP_FCNTL_SETFL));
311 	CHECK(cap_fcntls_limit(fd, CAP_FCNTL_GETFL | CAP_FCNTL_SETFL) == 0);
312 	fcntlrights = 0;
313 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
314 	CHECK(fcntlrights == (CAP_FCNTL_GETFL | CAP_FCNTL_SETFL));
315 
316 	CHECK(fcntl(fd, F_GETFD) == 0);
317 	CHECK(fcntl(fd, F_SETFD, FD_CLOEXEC) == 0);
318 	CHECK(fcntl(fd, F_GETFD) == FD_CLOEXEC);
319 	CHECK(fcntl(fd, F_SETFD, 0) == 0);
320 	CHECK(fcntl(fd, F_GETFD) == 0);
321 
322 	CHECK(fcntl(fd, F_GETFL) == O_RDWR);
323 	CHECK(fcntl(fd, F_SETFL, O_NONBLOCK) == 0);
324 	CHECK(fcntl(fd, F_GETFL) == (O_RDWR | O_NONBLOCK));
325 	CHECK(fcntl(fd, F_SETFL, 0) == 0);
326 	CHECK(fcntl(fd, F_GETFL) == O_RDWR);
327 
328 	CHECK(close(fd) == 0);
329 
330 	CHECK(descriptor_recv(sock, &fd) == 0);
331 
332 	fcntlrights = 0;
333 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
334 	CHECK(fcntlrights == CAP_FCNTL_GETFL);
335 	errno = 0;
336 	CHECK(cap_fcntls_limit(fd, CAP_FCNTL_GETFL | CAP_FCNTL_SETFL) == -1);
337 	CHECK(errno == ENOTCAPABLE);
338 	fcntlrights = 0;
339 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
340 	CHECK(fcntlrights == CAP_FCNTL_GETFL);
341 	CHECK(cap_fcntls_limit(fd, CAP_FCNTL_GETFL) == 0);
342 	fcntlrights = 0;
343 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
344 	CHECK(fcntlrights == CAP_FCNTL_GETFL);
345 
346 	CHECK(fcntl(fd, F_GETFD) == 0);
347 	CHECK(fcntl(fd, F_SETFD, FD_CLOEXEC) == 0);
348 	CHECK(fcntl(fd, F_GETFD) == FD_CLOEXEC);
349 	CHECK(fcntl(fd, F_SETFD, 0) == 0);
350 	CHECK(fcntl(fd, F_GETFD) == 0);
351 
352 	CHECK(fcntl(fd, F_GETFL) == O_RDWR);
353 	errno = 0;
354 	CHECK(fcntl(fd, F_SETFL, O_NONBLOCK) == -1);
355 	CHECK(errno == ENOTCAPABLE);
356 	CHECK(fcntl(fd, F_GETFL) == O_RDWR);
357 	errno = 0;
358 	CHECK(fcntl(fd, F_SETFL, 0) == -1);
359 	CHECK(errno == ENOTCAPABLE);
360 	CHECK(fcntl(fd, F_GETFL) == O_RDWR);
361 
362 	CHECK(close(fd) == 0);
363 
364 	CHECK(descriptor_recv(sock, &fd) == 0);
365 
366 	fcntlrights = 0;
367 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
368 	CHECK(fcntlrights == 0);
369 	errno = 0;
370 	CHECK(cap_fcntls_limit(fd, CAP_FCNTL_GETFL | CAP_FCNTL_SETFL) == -1);
371 	CHECK(errno == ENOTCAPABLE);
372 	fcntlrights = 0;
373 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
374 	CHECK(fcntlrights == 0);
375 	errno = 0;
376 	CHECK(cap_fcntls_limit(fd, CAP_FCNTL_GETFL) == -1);
377 	CHECK(errno == ENOTCAPABLE);
378 	fcntlrights = 0;
379 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
380 	CHECK(fcntlrights == 0);
381 	errno = 0;
382 	CHECK(cap_fcntls_limit(fd, CAP_FCNTL_SETFL) == -1);
383 	CHECK(errno == ENOTCAPABLE);
384 	fcntlrights = 0;
385 	CHECK(cap_fcntls_get(fd, &fcntlrights) == 0);
386 	CHECK(fcntlrights == 0);
387 
388 	CHECK(fcntl(fd, F_GETFD) == 0);
389 	CHECK(fcntl(fd, F_SETFD, FD_CLOEXEC) == 0);
390 	CHECK(fcntl(fd, F_GETFD) == FD_CLOEXEC);
391 	CHECK(fcntl(fd, F_SETFD, 0) == 0);
392 	CHECK(fcntl(fd, F_GETFD) == 0);
393 
394 	errno = 0;
395 	CHECK(fcntl(fd, F_GETFL) == -1);
396 	CHECK(errno == ENOTCAPABLE);
397 	errno = 0;
398 	CHECK(fcntl(fd, F_SETFL, O_NONBLOCK) == -1);
399 	CHECK(errno == ENOTCAPABLE);
400 	errno = 0;
401 	CHECK(fcntl(fd, F_SETFL, 0) == -1);
402 	CHECK(errno == ENOTCAPABLE);
403 	errno = 0;
404 	CHECK(fcntl(fd, F_GETFL) == -1);
405 	CHECK(errno == ENOTCAPABLE);
406 
407 	CHECK(close(fd) == 0);
408 }
409 
410 int
411 main(void)
412 {
413 	int fd, pfd, sp[2];
414 	pid_t pid;
415 
416 	printf("1..870\n");
417 
418 	CHECK((fd = socket(AF_UNIX, SOCK_STREAM, 0)) >= 0);
419 	fcntl_tests_0(fd);
420 	CHECK(close(fd) == 0);
421 
422 	CHECK((fd = socket(AF_UNIX, SOCK_STREAM, 0)) >= 0);
423 	fcntl_tests_1(fd);
424 	CHECK(close(fd) == 0);
425 
426 	CHECK((fd = socket(AF_UNIX, SOCK_STREAM, 0)) >= 0);
427 	fcntl_tests_2(fd);
428 	CHECK(close(fd) == 0);
429 
430 	/* Child inherits descriptor and operates on it first. */
431 	CHECK((fd = socket(AF_UNIX, SOCK_STREAM, 0)) >= 0);
432 	CHECK((pid = fork()) >= 0);
433 	if (pid == 0) {
434 		fcntl_tests_0(fd);
435 		CHECK(close(fd) == 0);
436 		exit(0);
437 	} else {
438 		CHECK(waitpid(pid, NULL, 0) == pid);
439 		fcntl_tests_0(fd);
440 	}
441 	CHECK(close(fd) == 0);
442 
443 	/* Child inherits descriptor, but operates on it after parent. */
444 	CHECK((fd = socket(AF_UNIX, SOCK_STREAM, 0)) >= 0);
445 	CHECK((pid = fork()) >= 0);
446 	if (pid == 0) {
447 		sleep(1);
448 		fcntl_tests_0(fd);
449 		CHECK(close(fd) == 0);
450 		exit(0);
451 	} else {
452 		fcntl_tests_0(fd);
453 		CHECK(waitpid(pid, NULL, 0) == pid);
454 	}
455 	CHECK(close(fd) == 0);
456 
457 	/* Child inherits descriptor and operates on it first. */
458 	CHECK((fd = socket(AF_UNIX, SOCK_STREAM, 0)) >= 0);
459 	CHECK((pid = pdfork(&pfd, 0)) >= 0);
460 	if (pid == 0) {
461 		fcntl_tests_1(fd);
462 		exit(0);
463 	} else {
464 		CHECK(pdwait(pfd) == 0);
465 /*
466 		It fails with EBADF, which I believe is a bug.
467 		CHECK(close(pfd) == 0);
468 */
469 		fcntl_tests_1(fd);
470 	}
471 	CHECK(close(fd) == 0);
472 
473 	/* Child inherits descriptor, but operates on it after parent. */
474 	CHECK((fd = socket(AF_UNIX, SOCK_STREAM, 0)) >= 0);
475 	CHECK((pid = pdfork(&pfd, 0)) >= 0);
476 	if (pid == 0) {
477 		sleep(1);
478 		fcntl_tests_1(fd);
479 		exit(0);
480 	} else {
481 		fcntl_tests_1(fd);
482 		CHECK(pdwait(pfd) == 0);
483 /*
484 		It fails with EBADF, which I believe is a bug.
485 		CHECK(close(pfd) == 0);
486 */
487 	}
488 	CHECK(close(fd) == 0);
489 
490 	/* Child inherits descriptor and operates on it first. */
491 	CHECK((fd = socket(AF_UNIX, SOCK_STREAM, 0)) >= 0);
492 	CHECK((pid = fork()) >= 0);
493 	if (pid == 0) {
494 		fcntl_tests_2(fd);
495 		exit(0);
496 	} else {
497 		CHECK(waitpid(pid, NULL, 0) == pid);
498 		fcntl_tests_2(fd);
499 	}
500 	CHECK(close(fd) == 0);
501 
502 	/* Child inherits descriptor, but operates on it after parent. */
503 	CHECK((fd = socket(AF_UNIX, SOCK_STREAM, 0)) >= 0);
504 	CHECK((pid = fork()) >= 0);
505 	if (pid == 0) {
506 		sleep(1);
507 		fcntl_tests_2(fd);
508 		exit(0);
509 	} else {
510 		fcntl_tests_2(fd);
511 		CHECK(waitpid(pid, NULL, 0) == pid);
512 	}
513 	CHECK(close(fd) == 0);
514 
515 	/* Send descriptors from parent to child. */
516 	CHECK(socketpair(AF_UNIX, SOCK_STREAM, 0, sp) == 0);
517 	CHECK((pid = fork()) >= 0);
518 	if (pid == 0) {
519 		CHECK(close(sp[0]) == 0);
520 		fcntl_tests_recv_0(sp[1]);
521 		CHECK(close(sp[1]) == 0);
522 		exit(0);
523 	} else {
524 		CHECK(close(sp[1]) == 0);
525 		fcntl_tests_send_0(sp[0]);
526 		CHECK(waitpid(pid, NULL, 0) == pid);
527 		CHECK(close(sp[0]) == 0);
528 	}
529 
530 	/* Send descriptors from child to parent. */
531 	CHECK(socketpair(AF_UNIX, SOCK_STREAM, 0, sp) == 0);
532 	CHECK((pid = fork()) >= 0);
533 	if (pid == 0) {
534 		CHECK(close(sp[0]) == 0);
535 		fcntl_tests_send_0(sp[1]);
536 		CHECK(close(sp[1]) == 0);
537 		exit(0);
538 	} else {
539 		CHECK(close(sp[1]) == 0);
540 		fcntl_tests_recv_0(sp[0]);
541 		CHECK(waitpid(pid, NULL, 0) == pid);
542 		CHECK(close(sp[0]) == 0);
543 	}
544 
545 	exit(0);
546 }
547