1/* 2 * $OpenBSD: dup2test.c,v 1.3 2003/07/31 21:48:08 deraadt Exp $ 3 * $OpenBSD: dup2_self.c,v 1.3 2003/07/31 21:48:08 deraadt Exp $ 4 * $OpenBSD: fcntl_dup.c,v 1.2 2003/07/31 21:48:08 deraadt Exp $ 5 * 6 * Written by Artur Grabowski <art@openbsd.org> 2002 Public Domain. 7 * 8 * $FreeBSD: releng/11.0/tests/sys/file/dup_test.c 281432 2015-04-11 10:14:59Z ngie $ 9 */ 10 11/* 12 * Test #1: check if dup(2) works. 13 * Test #2: check if dup2(2) works. 14 * Test #3: check if dup2(2) returned a fd we asked for. 15 * Test #4: check if dup2(2) cleared close-on-exec flag for duped fd. 16 * Test #5: check if dup2(2) allows to dup fd to itself. 17 * Test #6: check if dup2(2) returned a fd we asked for. 18 * Test #7: check if dup2(2) did not clear close-on-exec flag for duped fd. 19 * Test #8: check if fcntl(F_DUPFD) works. 20 * Test #9: check if fcntl(F_DUPFD) cleared close-on-exec flag for duped fd. 21 * Test #10: check if dup2() to a fd > current maximum number of open files 22 * limit work. 23 * Test #11: check if fcntl(F_DUP2FD) works. 24 * Test #12: check if fcntl(F_DUP2FD) returned a fd we asked for. 25 * Test #13: check if fcntl(F_DUP2FD) cleared close-on-exec flag for duped fd. 26 * Test #14: check if fcntl(F_DUP2FD) allows to dup fd to itself. 27 * Test #15: check if fcntl(F_DUP2FD) returned a fd we asked for. 28 * Test #16: check if fcntl(F_DUP2FD) did not clear close-on-exec flag for 29 * duped fd. 30 * Test #17: check if fcntl(F_DUP2FD) to a fd > current maximum number of open 31 * files limit work. 32 * Test #18: check if fcntl(F_DUPFD_CLOEXEC) works. 33 * Test #19: check if fcntl(F_DUPFD_CLOEXEC) set close-on-exec flag for duped 34 * fd. 35 * Test #20: check if fcntl(F_DUP2FD_CLOEXEC) works. 36 * Test #21: check if fcntl(F_DUP2FD_CLOEXEC) returned a fd we asked for. 37 * Test #22: check if fcntl(F_DUP2FD_CLOEXEC) set close-on-exec flag for duped 38 * fd. 39 * Test #23: check if fcntl(F_DUP2FD_CLOEXEC) to a fd > current maximum number 40 * of open files limit work. 41 * Test #24: check if dup3(O_CLOEXEC) works. 42 * Test #25: check if dup3(O_CLOEXEC) returned a fd we asked for. 43 * Test #26: check if dup3(O_CLOEXEC) set close-on-exec flag for duped fd. 44 * Test #27: check if dup3(0) works. 45 * Test #28: check if dup3(0) returned a fd we asked for. 46 * Test #29: check if dup3(0) cleared close-on-exec flag for duped fd. 47 * Test #30: check if dup3(O_CLOEXEC) fails if oldfd == newfd. 48 * Test #31: check if dup3(0) fails if oldfd == newfd. 49 * Test #32: check if dup3(O_CLOEXEC) to a fd > current maximum number of 50 * open files limit work. 51 */ 52 53#include <sys/types.h> 54#include <sys/time.h> 55#include <sys/resource.h> 56 57#include <err.h> 58#include <fcntl.h> 59#include <stdio.h> 60#include <stdlib.h> 61#include <unistd.h> 62 63static int getafile(void); 64 65static int 66getafile(void) 67{ 68 int fd; 69 70 char temp[] = "/tmp/dup2XXXXXXXXX"; 71 if ((fd = mkstemp(temp)) < 0) 72 err(1, "mkstemp"); 73 remove(temp); 74 if (ftruncate(fd, 1024) != 0) 75 err(1, "ftruncate"); 76 return (fd); 77} 78 79int 80main(int __unused argc, char __unused *argv[]) 81{ 82 struct rlimit rlp; 83 int orgfd, fd1, fd2, test = 0; 84 85 orgfd = getafile(); 86 87 printf("1..32\n"); 88 89 /* If dup(2) ever work? */ 90 if ((fd1 = dup(orgfd)) < 0) 91 err(1, "dup"); 92 printf("ok %d - dup(2) works\n", ++test); 93 94 /* Set close-on-exec */ 95 if (fcntl(fd1, F_SETFD, 1) != 0) 96 err(1, "fcntl(F_SETFD)"); 97 98 /* If dup2(2) ever work? */ 99 if ((fd2 = dup2(fd1, fd1 + 1)) < 0) 100 err(1, "dup2"); 101 printf("ok %d - dup2(2) works\n", ++test); 102 103 /* Do we get the right fd? */ 104 ++test; 105 if (fd2 != fd1 + 1) 106 printf("no ok %d - dup2(2) didn't give us the right fd\n", 107 test); 108 else 109 printf("ok %d - dup2(2) returned a correct fd\n", test); 110 111 /* Was close-on-exec cleared? */ 112 ++test; 113 if (fcntl(fd2, F_GETFD) != 0) 114 printf("not ok %d - dup2(2) didn't clear close-on-exec\n", 115 test); 116 else 117 printf("ok %d - dup2(2) cleared close-on-exec\n", test); 118 119 /* 120 * Dup to itself. 121 * 122 * We're testing a small tweak in dup2 semantics. 123 * Normally dup and dup2 will clear the close-on-exec 124 * flag on the new fd (which appears to be an implementation 125 * mistake from start and not some planned behavior). 126 * In today's implementations of dup and dup2 we have to make 127 * an effort to really clear that flag. But all tested 128 * implementations of dup2 have another tweak. If we 129 * dup2(old, new) when old == new, the syscall short-circuits 130 * and returns early (because there is no need to do all the 131 * work (and there is a risk for serious mistakes)). 132 * So although the docs say that dup2 should "take 'old', 133 * close 'new' perform a dup(2) of 'old' into 'new'" 134 * the docs are not really followed because close-on-exec 135 * is not cleared on 'new'. 136 * 137 * Since everyone has this bug, we pretend that this is 138 * the way it is supposed to be and test here that it really 139 * works that way. 140 * 141 * This is a fine example on where two separate implementation 142 * fuckups take out each other and make the end-result the way 143 * it was meant to be. 144 */ 145 if ((fd2 = dup2(fd1, fd1)) < 0) 146 err(1, "dup2"); 147 printf("ok %d - dup2(2) to itself works\n", ++test); 148 149 /* Do we get the right fd? */ 150 ++test; 151 if (fd2 != fd1) 152 printf("not ok %d - dup2(2) didn't give us the right fd\n", 153 test); 154 else 155 printf("ok %d - dup2(2) to itself returned a correct fd\n", 156 test); 157 158 /* Was close-on-exec cleared? */ 159 ++test; 160 if (fcntl(fd2, F_GETFD) == 0) 161 printf("not ok %d - dup2(2) cleared close-on-exec\n", test); 162 else 163 printf("ok %d - dup2(2) didn't clear close-on-exec\n", test); 164 165 /* Does fcntl(F_DUPFD) work? */ 166 if ((fd2 = fcntl(fd1, F_DUPFD, 10)) < 0) 167 err(1, "fcntl(F_DUPFD)"); 168 if (fd2 < 10) 169 printf("not ok %d - fcntl(F_DUPFD) returned wrong fd %d\n", 170 ++test, fd2); 171 else 172 printf("ok %d - fcntl(F_DUPFD) works\n", ++test); 173 174 /* Was close-on-exec cleared? */ 175 ++test; 176 if (fcntl(fd2, F_GETFD) != 0) 177 printf( 178 "not ok %d - fcntl(F_DUPFD) didn't clear close-on-exec\n", 179 test); 180 else 181 printf("ok %d - fcntl(F_DUPFD) cleared close-on-exec\n", test); 182 183 ++test; 184 if (getrlimit(RLIMIT_NOFILE, &rlp) < 0) 185 err(1, "getrlimit"); 186 if ((fd2 = dup2(fd1, rlp.rlim_cur + 1)) >= 0) 187 printf("not ok %d - dup2(2) bypassed NOFILE limit\n", test); 188 else 189 printf("ok %d - dup2(2) didn't bypass NOFILE limit\n", test); 190 191 /* If fcntl(F_DUP2FD) ever work? */ 192 if ((fd2 = fcntl(fd1, F_DUP2FD, fd1 + 1)) < 0) 193 err(1, "fcntl(F_DUP2FD)"); 194 printf("ok %d - fcntl(F_DUP2FD) works\n", ++test); 195 196 /* Do we get the right fd? */ 197 ++test; 198 if (fd2 != fd1 + 1) 199 printf( 200 "no ok %d - fcntl(F_DUP2FD) didn't give us the right fd\n", 201 test); 202 else 203 printf("ok %d - fcntl(F_DUP2FD) returned a correct fd\n", 204 test); 205 206 /* Was close-on-exec cleared? */ 207 ++test; 208 if (fcntl(fd2, F_GETFD) != 0) 209 printf( 210 "not ok %d - fcntl(F_DUP2FD) didn't clear close-on-exec\n", 211 test); 212 else 213 printf("ok %d - fcntl(F_DUP2FD) cleared close-on-exec\n", 214 test); 215 216 /* Dup to itself */ 217 if ((fd2 = fcntl(fd1, F_DUP2FD, fd1)) < 0) 218 err(1, "fcntl(F_DUP2FD)"); 219 printf("ok %d - fcntl(F_DUP2FD) to itself works\n", ++test); 220 221 /* Do we get the right fd? */ 222 ++test; 223 if (fd2 != fd1) 224 printf( 225 "not ok %d - fcntl(F_DUP2FD) didn't give us the right fd\n", 226 test); 227 else 228 printf( 229 "ok %d - fcntl(F_DUP2FD) to itself returned a correct fd\n", 230 test); 231 232 /* Was close-on-exec cleared? */ 233 ++test; 234 if (fcntl(fd2, F_GETFD) == 0) 235 printf("not ok %d - fcntl(F_DUP2FD) cleared close-on-exec\n", 236 test); 237 else 238 printf("ok %d - fcntl(F_DUP2FD) didn't clear close-on-exec\n", 239 test); 240 241 ++test; 242 if (getrlimit(RLIMIT_NOFILE, &rlp) < 0) 243 err(1, "getrlimit"); 244 if ((fd2 = fcntl(fd1, F_DUP2FD, rlp.rlim_cur + 1)) >= 0) 245 printf("not ok %d - fcntl(F_DUP2FD) bypassed NOFILE limit\n", 246 test); 247 else 248 printf("ok %d - fcntl(F_DUP2FD) didn't bypass NOFILE limit\n", 249 test); 250 251 /* Does fcntl(F_DUPFD_CLOEXEC) work? */ 252 if ((fd2 = fcntl(fd1, F_DUPFD_CLOEXEC, 10)) < 0) 253 err(1, "fcntl(F_DUPFD_CLOEXEC)"); 254 if (fd2 < 10) 255 printf("not ok %d - fcntl(F_DUPFD_CLOEXEC) returned wrong fd %d\n", 256 ++test, fd2); 257 else 258 printf("ok %d - fcntl(F_DUPFD_CLOEXEC) works\n", ++test); 259 260 /* Was close-on-exec cleared? */ 261 ++test; 262 if (fcntl(fd2, F_GETFD) != 1) 263 printf( 264 "not ok %d - fcntl(F_DUPFD_CLOEXEC) didn't set close-on-exec\n", 265 test); 266 else 267 printf("ok %d - fcntl(F_DUPFD_CLOEXEC) set close-on-exec\n", 268 test); 269 270 /* If fcntl(F_DUP2FD_CLOEXEC) ever work? */ 271 if ((fd2 = fcntl(fd1, F_DUP2FD_CLOEXEC, fd1 + 1)) < 0) 272 err(1, "fcntl(F_DUP2FD_CLOEXEC)"); 273 printf("ok %d - fcntl(F_DUP2FD_CLOEXEC) works\n", ++test); 274 275 /* Do we get the right fd? */ 276 ++test; 277 if (fd2 != fd1 + 1) 278 printf( 279 "no ok %d - fcntl(F_DUP2FD_CLOEXEC) didn't give us the right fd\n", 280 test); 281 else 282 printf("ok %d - fcntl(F_DUP2FD_CLOEXEC) returned a correct fd\n", 283 test); 284 285 /* Was close-on-exec set? */ 286 ++test; 287 if (fcntl(fd2, F_GETFD) != FD_CLOEXEC) 288 printf( 289 "not ok %d - fcntl(F_DUP2FD_CLOEXEC) didn't set close-on-exec\n", 290 test); 291 else 292 printf("ok %d - fcntl(F_DUP2FD_CLOEXEC) set close-on-exec\n", 293 test); 294 295 /* 296 * It is unclear what F_DUP2FD_CLOEXEC should do when duplicating a 297 * file descriptor onto itself. 298 */ 299 300 ++test; 301 if (getrlimit(RLIMIT_NOFILE, &rlp) < 0) 302 err(1, "getrlimit"); 303 if ((fd2 = fcntl(fd1, F_DUP2FD_CLOEXEC, rlp.rlim_cur + 1)) >= 0) 304 printf("not ok %d - fcntl(F_DUP2FD_CLOEXEC) bypassed NOFILE limit\n", 305 test); 306 else 307 printf("ok %d - fcntl(F_DUP2FD_CLOEXEC) didn't bypass NOFILE limit\n", 308 test); 309 310 /* Does dup3(O_CLOEXEC) ever work? */ 311 if ((fd2 = dup3(fd1, fd1 + 1, O_CLOEXEC)) < 0) 312 err(1, "dup3(O_CLOEXEC)"); 313 printf("ok %d - dup3(O_CLOEXEC) works\n", ++test); 314 315 /* Do we get the right fd? */ 316 ++test; 317 if (fd2 != fd1 + 1) 318 printf( 319 "no ok %d - dup3(O_CLOEXEC) didn't give us the right fd\n", 320 test); 321 else 322 printf("ok %d - dup3(O_CLOEXEC) returned a correct fd\n", 323 test); 324 325 /* Was close-on-exec set? */ 326 ++test; 327 if (fcntl(fd2, F_GETFD) != FD_CLOEXEC) 328 printf( 329 "not ok %d - dup3(O_CLOEXEC) didn't set close-on-exec\n", 330 test); 331 else 332 printf("ok %d - dup3(O_CLOEXEC) set close-on-exec\n", 333 test); 334 335 /* Does dup3(0) ever work? */ 336 if ((fd2 = dup3(fd1, fd1 + 1, 0)) < 0) 337 err(1, "dup3(0)"); 338 printf("ok %d - dup3(0) works\n", ++test); 339 340 /* Do we get the right fd? */ 341 ++test; 342 if (fd2 != fd1 + 1) 343 printf( 344 "no ok %d - dup3(0) didn't give us the right fd\n", 345 test); 346 else 347 printf("ok %d - dup3(0) returned a correct fd\n", 348 test); 349 350 /* Was close-on-exec cleared? */ 351 ++test; 352 if (fcntl(fd2, F_GETFD) != 0) 353 printf( 354 "not ok %d - dup3(0) didn't clear close-on-exec\n", 355 test); 356 else 357 printf("ok %d - dup3(0) cleared close-on-exec\n", 358 test); 359 360 /* dup3() does not allow duplicating to the same fd */ 361 ++test; 362 if (dup3(fd1, fd1, O_CLOEXEC) != -1) 363 printf( 364 "not ok %d - dup3(fd1, fd1, O_CLOEXEC) succeeded\n", test); 365 else 366 printf("ok %d - dup3(fd1, fd1, O_CLOEXEC) failed\n", test); 367 368 ++test; 369 if (dup3(fd1, fd1, 0) != -1) 370 printf( 371 "not ok %d - dup3(fd1, fd1, 0) succeeded\n", test); 372 else 373 printf("ok %d - dup3(fd1, fd1, 0) failed\n", test); 374 375 ++test; 376 if (getrlimit(RLIMIT_NOFILE, &rlp) < 0) 377 err(1, "getrlimit"); 378 if ((fd2 = dup3(fd1, rlp.rlim_cur + 1, O_CLOEXEC)) >= 0) 379 printf("not ok %d - dup3(O_CLOEXEC) bypassed NOFILE limit\n", 380 test); 381 else 382 printf("ok %d - dup3(O_CLOEXEC) didn't bypass NOFILE limit\n", 383 test); 384 385 return (0); 386} 387