1 /*- 2 * Copyright (c) 2005 Robert N. M. Watson 3 * Copyright (c) 2015 Mark Johnston 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27 28 #include <sys/cdefs.h> 29 __FBSDID("$FreeBSD$"); 30 31 #include <sys/types.h> 32 #include <sys/socket.h> 33 #include <sys/stat.h> 34 #include <sys/sysctl.h> 35 #include <sys/un.h> 36 37 #include <errno.h> 38 #include <fcntl.h> 39 #include <limits.h> 40 #include <stdio.h> 41 #include <stdlib.h> 42 #include <string.h> 43 #include <unistd.h> 44 45 #include <atf-c.h> 46 47 /* 48 * UNIX domain sockets allow file descriptors to be passed via "ancillary 49 * data", or control messages. This regression test is intended to exercise 50 * this facility, both performing some basic tests that it operates, and also 51 * causing some kernel edge cases to execute, such as garbage collection when 52 * there are cyclic file descriptor references. Right now we test only with 53 * stream sockets, but ideally we'd also test with datagram sockets. 54 */ 55 56 static void 57 domainsocketpair(int *fdp) 58 { 59 60 ATF_REQUIRE_MSG(socketpair(PF_UNIX, SOCK_STREAM, 0, fdp) != -1, 61 "socketpair(PF_UNIX, SOCK_STREAM) failed: %s", strerror(errno)); 62 } 63 64 static void 65 closesocketpair(int *fdp) 66 { 67 68 close(fdp[0]); 69 close(fdp[1]); 70 } 71 72 static void 73 devnull(int *fdp) 74 { 75 int fd; 76 77 fd = open("/dev/null", O_RDONLY); 78 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno)); 79 *fdp = fd; 80 } 81 82 static void 83 tempfile(int *fdp) 84 { 85 char path[PATH_MAX]; 86 int fd; 87 88 snprintf(path, PATH_MAX, "%s/unix_passfd.XXXXXXXXXXXXXXX", 89 getenv("TMPDIR") == NULL ? "/tmp" : getenv("TMPDIR")); 90 fd = mkstemp(path); 91 ATF_REQUIRE_MSG(fd != -1, "mkstemp(%s) failed", path); 92 (void)unlink(path); 93 *fdp = fd; 94 } 95 96 static void 97 dofstat(int fd, struct stat *sb) 98 { 99 100 ATF_REQUIRE_MSG(fstat(fd, sb) == 0, 101 "fstat failed: %s", strerror(errno)); 102 } 103 104 static int 105 getnfds(void) 106 { 107 size_t len; 108 int mib[4], n, rc; 109 110 len = sizeof(n); 111 mib[0] = CTL_KERN; 112 mib[1] = KERN_PROC; 113 mib[2] = KERN_PROC_NFDS; 114 mib[3] = 0; 115 116 rc = sysctl(mib, 4, &n, &len, NULL, 0); 117 ATF_REQUIRE_MSG(rc != -1, "sysctl(KERN_PROC_NFDS) failed"); 118 return (n); 119 } 120 121 static void 122 samefile(struct stat *sb1, struct stat *sb2) 123 { 124 125 ATF_REQUIRE_MSG(sb1->st_dev == sb2->st_dev, "different device"); 126 ATF_REQUIRE_MSG(sb1->st_ino == sb2->st_ino, "different inode"); 127 } 128 129 static size_t 130 sendfd_payload(int sockfd, int send_fd, void *payload, size_t paylen) 131 { 132 struct iovec iovec; 133 char message[CMSG_SPACE(sizeof(int))]; 134 struct cmsghdr *cmsghdr; 135 struct msghdr msghdr; 136 ssize_t len; 137 138 bzero(&msghdr, sizeof(msghdr)); 139 bzero(&message, sizeof(message)); 140 141 msghdr.msg_control = message; 142 msghdr.msg_controllen = sizeof(message); 143 144 iovec.iov_base = payload; 145 iovec.iov_len = paylen; 146 147 msghdr.msg_iov = &iovec; 148 msghdr.msg_iovlen = 1; 149 150 cmsghdr = (struct cmsghdr *)(void *)message; 151 cmsghdr->cmsg_len = CMSG_LEN(sizeof(int)); 152 cmsghdr->cmsg_level = SOL_SOCKET; 153 cmsghdr->cmsg_type = SCM_RIGHTS; 154 memcpy(CMSG_DATA(cmsghdr), &send_fd, sizeof(int)); 155 156 len = sendmsg(sockfd, &msghdr, MSG_DONTWAIT); 157 ATF_REQUIRE_MSG(len != -1, "sendmsg failed: %s", strerror(errno)); 158 return ((size_t)len); 159 } 160 161 static void 162 sendfd(int sockfd, int send_fd) 163 { 164 size_t len; 165 char ch; 166 167 ch = 0; 168 len = sendfd_payload(sockfd, send_fd, &ch, sizeof(ch)); 169 ATF_REQUIRE_MSG(len == sizeof(ch), 170 "sendmsg: %zu bytes sent; expected %zu; %s", len, sizeof(ch), 171 strerror(errno)); 172 } 173 174 static bool 175 localcreds(int sockfd) 176 { 177 socklen_t sz; 178 int rc, val; 179 180 sz = sizeof(val); 181 rc = getsockopt(sockfd, 0, LOCAL_CREDS, &val, &sz); 182 ATF_REQUIRE_MSG(rc != -1, "getsockopt(LOCAL_CREDS) failed: %s", 183 strerror(errno)); 184 return (val != 0); 185 } 186 187 static void 188 recvfd_payload(int sockfd, int *recv_fd, void *buf, size_t buflen) 189 { 190 struct cmsghdr *cmsghdr; 191 char message[CMSG_SPACE(SOCKCREDSIZE(CMGROUP_MAX)) + 192 CMSG_SPACE(sizeof(int))]; 193 struct msghdr msghdr; 194 struct iovec iovec; 195 ssize_t len; 196 bool foundcreds; 197 198 bzero(&msghdr, sizeof(msghdr)); 199 200 msghdr.msg_control = message; 201 msghdr.msg_controllen = sizeof(message); 202 203 iovec.iov_base = buf; 204 iovec.iov_len = buflen; 205 206 msghdr.msg_iov = &iovec; 207 msghdr.msg_iovlen = 1; 208 209 len = recvmsg(sockfd, &msghdr, 0); 210 ATF_REQUIRE_MSG(len != -1, "recvmsg failed: %s", strerror(errno)); 211 ATF_REQUIRE_MSG((size_t)len == buflen, 212 "recvmsg: %zd bytes received; expected %zd", len, buflen); 213 214 cmsghdr = CMSG_FIRSTHDR(&msghdr); 215 ATF_REQUIRE_MSG(cmsghdr != NULL, 216 "recvmsg: did not receive control message"); 217 foundcreds = false; 218 *recv_fd = -1; 219 for (; cmsghdr != NULL; cmsghdr = CMSG_NXTHDR(&msghdr, cmsghdr)) { 220 if (cmsghdr->cmsg_level == SOL_SOCKET && 221 cmsghdr->cmsg_type == SCM_RIGHTS && 222 cmsghdr->cmsg_len == CMSG_LEN(sizeof(int))) { 223 memcpy(recv_fd, CMSG_DATA(cmsghdr), sizeof(int)); 224 ATF_REQUIRE(*recv_fd != -1); 225 } else if (cmsghdr->cmsg_level == SOL_SOCKET && 226 cmsghdr->cmsg_type == SCM_CREDS) 227 foundcreds = true; 228 } 229 ATF_REQUIRE_MSG(*recv_fd != -1, 230 "recvmsg: did not receive single-fd message"); 231 ATF_REQUIRE_MSG(!localcreds(sockfd) || foundcreds, 232 "recvmsg: expected credentials were not received"); 233 } 234 235 static void 236 recvfd(int sockfd, int *recv_fd) 237 { 238 char ch = 0; 239 240 recvfd_payload(sockfd, recv_fd, &ch, sizeof(ch)); 241 } 242 243 /* 244 * Put a temporary file into a UNIX domain socket, then take it out and make 245 * sure it's the same file. First time around, don't close the reference 246 * after sending. 247 */ 248 ATF_TC_WITHOUT_HEAD(simple_send_fd); 249 ATF_TC_BODY(simple_send_fd, tc) 250 { 251 struct stat getfd_stat, putfd_stat; 252 int fd[2], getfd, putfd; 253 254 domainsocketpair(fd); 255 tempfile(&putfd); 256 dofstat(putfd, &putfd_stat); 257 sendfd(fd[0], putfd); 258 recvfd(fd[1], &getfd); 259 dofstat(getfd, &getfd_stat); 260 samefile(&putfd_stat, &getfd_stat); 261 close(putfd); 262 close(getfd); 263 closesocketpair(fd); 264 } 265 266 /* 267 * Same as simple_send_fd, only close the file reference after sending, so that 268 * the only reference is the descriptor in the UNIX domain socket buffer. 269 */ 270 ATF_TC_WITHOUT_HEAD(send_and_close); 271 ATF_TC_BODY(send_and_close, tc) 272 { 273 struct stat getfd_stat, putfd_stat; 274 int fd[2], getfd, putfd; 275 276 domainsocketpair(fd); 277 tempfile(&putfd); 278 dofstat(putfd, &putfd_stat); 279 sendfd(fd[0], putfd); 280 close(putfd); 281 recvfd(fd[1], &getfd); 282 dofstat(getfd, &getfd_stat); 283 samefile(&putfd_stat, &getfd_stat); 284 close(getfd); 285 closesocketpair(fd); 286 } 287 288 /* 289 * Put a temporary file into a UNIX domain socket, then close both endpoints 290 * causing garbage collection to kick off. 291 */ 292 ATF_TC_WITHOUT_HEAD(send_and_cancel); 293 ATF_TC_BODY(send_and_cancel, tc) 294 { 295 int fd[2], putfd; 296 297 domainsocketpair(fd); 298 tempfile(&putfd); 299 sendfd(fd[0], putfd); 300 close(putfd); 301 closesocketpair(fd); 302 } 303 304 /* 305 * Send two files. Then receive them. Make sure they are returned in the 306 * right order, and both get there. 307 */ 308 ATF_TC_WITHOUT_HEAD(two_files); 309 ATF_TC_BODY(two_files, tc) 310 { 311 struct stat getfd_1_stat, getfd_2_stat, putfd_1_stat, putfd_2_stat; 312 int fd[2], getfd_1, getfd_2, putfd_1, putfd_2; 313 314 domainsocketpair(fd); 315 tempfile(&putfd_1); 316 tempfile(&putfd_2); 317 dofstat(putfd_1, &putfd_1_stat); 318 dofstat(putfd_2, &putfd_2_stat); 319 sendfd(fd[0], putfd_1); 320 sendfd(fd[0], putfd_2); 321 close(putfd_1); 322 close(putfd_2); 323 recvfd(fd[1], &getfd_1); 324 recvfd(fd[1], &getfd_2); 325 dofstat(getfd_1, &getfd_1_stat); 326 dofstat(getfd_2, &getfd_2_stat); 327 samefile(&putfd_1_stat, &getfd_1_stat); 328 samefile(&putfd_2_stat, &getfd_2_stat); 329 close(getfd_1); 330 close(getfd_2); 331 closesocketpair(fd); 332 } 333 334 /* 335 * Big bundling test. Send an endpoint of the UNIX domain socket over itself, 336 * closing the door behind it. 337 */ 338 ATF_TC_WITHOUT_HEAD(bundle); 339 ATF_TC_BODY(bundle, tc) 340 { 341 int fd[2], getfd; 342 343 domainsocketpair(fd); 344 345 sendfd(fd[0], fd[0]); 346 close(fd[0]); 347 recvfd(fd[1], &getfd); 348 close(getfd); 349 close(fd[1]); 350 } 351 352 /* 353 * Big bundling test part two: Send an endpoint of the UNIX domain socket over 354 * itself, close the door behind it, and never remove it from the other end. 355 */ 356 ATF_TC_WITHOUT_HEAD(bundle_cancel); 357 ATF_TC_BODY(bundle_cancel, tc) 358 { 359 int fd[2]; 360 361 domainsocketpair(fd); 362 sendfd(fd[0], fd[0]); 363 sendfd(fd[1], fd[0]); 364 closesocketpair(fd); 365 } 366 367 /* 368 * Test for PR 151758: Send an character device over the UNIX domain socket 369 * and then close both sockets to orphan the device. 370 */ 371 ATF_TC_WITHOUT_HEAD(devfs_orphan); 372 ATF_TC_BODY(devfs_orphan, tc) 373 { 374 int fd[2], putfd; 375 376 domainsocketpair(fd); 377 devnull(&putfd); 378 sendfd(fd[0], putfd); 379 close(putfd); 380 closesocketpair(fd); 381 } 382 383 #define LOCAL_SENDSPACE_SYSCTL "net.local.stream.sendspace" 384 385 /* 386 * Test for PR 181741. Receiver sets LOCAL_CREDS, and kernel prepends a 387 * control message to the data. Sender sends large payload using a non-blocking 388 * socket. Payload + SCM_RIGHTS + LOCAL_CREDS hit socket buffer limit, and 389 * receiver receives truncated data. 390 */ 391 ATF_TC_WITHOUT_HEAD(rights_creds_payload); 392 ATF_TC_BODY(rights_creds_payload, tc) 393 { 394 const int on = 1; 395 u_long sendspace; 396 size_t len; 397 void *buf; 398 int fd[2], getfd, putfd, rc; 399 400 len = sizeof(sendspace); 401 rc = sysctlbyname(LOCAL_SENDSPACE_SYSCTL, &sendspace, 402 &len, NULL, 0); 403 ATF_REQUIRE_MSG(rc != -1, 404 "sysctl %s failed: %s", LOCAL_SENDSPACE_SYSCTL, strerror(errno)); 405 406 buf = calloc(1, sendspace); 407 ATF_REQUIRE(buf != NULL); 408 409 domainsocketpair(fd); 410 tempfile(&putfd); 411 412 rc = fcntl(fd[0], F_SETFL, O_NONBLOCK); 413 ATF_REQUIRE_MSG(rc != -1, "fcntl(O_NONBLOCK) failed: %s", 414 strerror(errno)); 415 rc = setsockopt(fd[1], 0, LOCAL_CREDS, &on, sizeof(on)); 416 ATF_REQUIRE_MSG(rc != -1, "setsockopt(LOCAL_CREDS) failed: %s", 417 strerror(errno)); 418 419 len = sendfd_payload(fd[0], putfd, buf, sendspace); 420 ATF_REQUIRE_MSG(len < sendspace, "sendmsg: %zu bytes sent", len); 421 recvfd_payload(fd[1], &getfd, buf, len); 422 423 close(putfd); 424 close(getfd); 425 closesocketpair(fd); 426 } 427 428 /* 429 * Test for PR 131876. Receiver uses a control message buffer that is too 430 * small for the incoming SCM_RIGHTS message, so the message is truncated. 431 * The kernel must not leak the copied right into the receiver's namespace. 432 */ 433 ATF_TC_WITHOUT_HEAD(truncated_rights); 434 ATF_TC_BODY(truncated_rights, tc) 435 { 436 struct iovec iovec; 437 struct msghdr msghdr; 438 char buf[16], message[CMSG_SPACE(0)]; 439 ssize_t len; 440 int fd[2], nfds, putfd; 441 442 atf_tc_expect_fail("PR 131876: " 443 "FD leak when 'control' message is truncated"); 444 445 memset(buf, 42, sizeof(buf)); 446 domainsocketpair(fd); 447 devnull(&putfd); 448 nfds = getnfds(); 449 450 len = sendfd_payload(fd[0], putfd, buf, sizeof(buf)); 451 ATF_REQUIRE_MSG(len == sizeof(buf), 452 "sendmsg: %zd bytes sent; expected %zu; %s", len, sizeof(buf), 453 strerror(errno)); 454 455 bzero(&msghdr, sizeof(msghdr)); 456 bzero(message, sizeof(message)); 457 458 iovec.iov_base = buf; 459 iovec.iov_len = sizeof(buf); 460 msghdr.msg_control = message; 461 msghdr.msg_controllen = sizeof(message); 462 msghdr.msg_iov = &iovec; 463 msghdr.msg_iovlen = 1; 464 465 len = recvmsg(fd[1], &msghdr, 0); 466 ATF_REQUIRE_MSG(len != -1, "recvmsg failed: %s", strerror(errno)); 467 ATF_REQUIRE_MSG((size_t)len == sizeof(buf), 468 "recvmsg: %zd bytes received; expected %zd", len, sizeof(buf)); 469 for (size_t i = 0; i < sizeof(buf); i++) 470 ATF_REQUIRE_MSG(buf[i] == 42, "unexpected buffer contents"); 471 472 ATF_REQUIRE_MSG((msghdr.msg_flags & MSG_CTRUNC) != 0, 473 "MSG_CTRUNC not set after truncation"); 474 ATF_REQUIRE(getnfds() == nfds); 475 476 close(putfd); 477 closesocketpair(fd); 478 } 479 480 ATF_TC_WITHOUT_HEAD(copyout_rights_error); 481 ATF_TC_BODY(copyout_rights_error, tc) 482 { 483 struct iovec iovec; 484 struct msghdr msghdr; 485 char buf[16]; 486 ssize_t len; 487 int fd[2], error, nfds, putfd; 488 489 atf_tc_expect_fail("PR 131876: " 490 "FD leak when copyout of rights returns an error"); 491 492 memset(buf, 0, sizeof(buf)); 493 domainsocketpair(fd); 494 devnull(&putfd); 495 nfds = getnfds(); 496 497 sendfd_payload(fd[0], putfd, buf, sizeof(buf)); 498 499 bzero(&msghdr, sizeof(msghdr)); 500 501 iovec.iov_base = buf; 502 iovec.iov_len = sizeof(buf); 503 msghdr.msg_control = (char *)-1; /* trigger EFAULT */ 504 msghdr.msg_controllen = CMSG_SPACE(sizeof(int)); 505 msghdr.msg_iov = &iovec; 506 msghdr.msg_iovlen = 1; 507 508 len = recvmsg(fd[1], &msghdr, 0); 509 error = errno; 510 ATF_REQUIRE_MSG(len == -1, "recvmsg succeeded: %zd", len); 511 ATF_REQUIRE_MSG(errno == EFAULT, "expected EFAULT, got %d (%s)", 512 error, strerror(errno)); 513 514 /* Verify that no FDs were leaked. */ 515 ATF_REQUIRE(getnfds() == nfds); 516 517 close(putfd); 518 closesocketpair(fd); 519 } 520 521 ATF_TP_ADD_TCS(tp) 522 { 523 524 ATF_TP_ADD_TC(tp, simple_send_fd); 525 ATF_TP_ADD_TC(tp, send_and_close); 526 ATF_TP_ADD_TC(tp, send_and_cancel); 527 ATF_TP_ADD_TC(tp, two_files); 528 ATF_TP_ADD_TC(tp, bundle); 529 ATF_TP_ADD_TC(tp, bundle_cancel); 530 ATF_TP_ADD_TC(tp, devfs_orphan); 531 ATF_TP_ADD_TC(tp, rights_creds_payload); 532 ATF_TP_ADD_TC(tp, truncated_rights); 533 ATF_TP_ADD_TC(tp, copyout_rights_error); 534 535 return (atf_no_error()); 536 } 537