unix_passfd_test.c revision 337464
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: stable/11/tests/sys/kern/unix_passfd_test.c 337464 2018-08-08 17:10:32Z markj $"); 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 56static void 57domainsocketpair(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 64static void 65closesocketpair(int *fdp) 66{ 67 68 close(fdp[0]); 69 close(fdp[1]); 70} 71 72static void 73devnull(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 82static void 83tempfile(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 96static void 97dofstat(int fd, struct stat *sb) 98{ 99 100 ATF_REQUIRE_MSG(fstat(fd, sb) == 0, 101 "fstat failed: %s", strerror(errno)); 102} 103 104static int 105getnfds(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 121static void 122samefile(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 129static void 130sendfd_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, 0); 157 ATF_REQUIRE_MSG(len != -1, "sendmsg failed: %s", strerror(errno)); 158 ATF_REQUIRE_MSG((size_t)len == paylen, 159 "sendmsg: %zd messages sent; expected: %zu; %s", len, paylen, 160 strerror(errno)); 161} 162 163static void 164sendfd(int sockfd, int send_fd) 165{ 166 char ch = 0; 167 168 sendfd_payload(sockfd, send_fd, &ch, sizeof(ch)); 169} 170 171static void 172recvfd_payload(int sockfd, int *recv_fd, void *buf, size_t buflen) 173{ 174 struct cmsghdr *cmsghdr; 175 char message[CMSG_SPACE(SOCKCREDSIZE(CMGROUP_MAX)) + 176 CMSG_SPACE(sizeof(int))]; 177 struct msghdr msghdr; 178 struct iovec iovec; 179 ssize_t len; 180 181 bzero(&msghdr, sizeof(msghdr)); 182 183 msghdr.msg_control = message; 184 msghdr.msg_controllen = sizeof(message); 185 186 iovec.iov_base = buf; 187 iovec.iov_len = buflen; 188 189 msghdr.msg_iov = &iovec; 190 msghdr.msg_iovlen = 1; 191 192 len = recvmsg(sockfd, &msghdr, 0); 193 ATF_REQUIRE_MSG(len != -1, "recvmsg failed: %s", strerror(errno)); 194 ATF_REQUIRE_MSG((size_t)len == buflen, 195 "recvmsg: %zd bytes received; expected %zd", len, buflen); 196 197 cmsghdr = CMSG_FIRSTHDR(&msghdr); 198 ATF_REQUIRE_MSG(cmsghdr != NULL, 199 "recvmsg: did not receive control message"); 200 *recv_fd = -1; 201 for (; cmsghdr != NULL; cmsghdr = CMSG_NXTHDR(&msghdr, cmsghdr)) { 202 if (cmsghdr->cmsg_level == SOL_SOCKET && 203 cmsghdr->cmsg_type == SCM_RIGHTS && 204 cmsghdr->cmsg_len == CMSG_LEN(sizeof(int))) { 205 memcpy(recv_fd, CMSG_DATA(cmsghdr), sizeof(int)); 206 ATF_REQUIRE(*recv_fd != -1); 207 } 208 } 209 ATF_REQUIRE_MSG(*recv_fd != -1, 210 "recvmsg: did not receive single-fd message"); 211} 212 213static void 214recvfd(int sockfd, int *recv_fd) 215{ 216 char ch = 0; 217 218 recvfd_payload(sockfd, recv_fd, &ch, sizeof(ch)); 219} 220 221/* 222 * Put a temporary file into a UNIX domain socket, then take it out and make 223 * sure it's the same file. First time around, don't close the reference 224 * after sending. 225 */ 226ATF_TC_WITHOUT_HEAD(simple_send_fd); 227ATF_TC_BODY(simple_send_fd, tc) 228{ 229 struct stat getfd_stat, putfd_stat; 230 int fd[2], getfd, putfd; 231 232 domainsocketpair(fd); 233 tempfile(&putfd); 234 dofstat(putfd, &putfd_stat); 235 sendfd(fd[0], putfd); 236 recvfd(fd[1], &getfd); 237 dofstat(getfd, &getfd_stat); 238 samefile(&putfd_stat, &getfd_stat); 239 close(putfd); 240 close(getfd); 241 closesocketpair(fd); 242} 243 244/* 245 * Same as simple_send_fd, only close the file reference after sending, so that 246 * the only reference is the descriptor in the UNIX domain socket buffer. 247 */ 248ATF_TC_WITHOUT_HEAD(send_and_close); 249ATF_TC_BODY(send_and_close, 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 close(putfd); 259 recvfd(fd[1], &getfd); 260 dofstat(getfd, &getfd_stat); 261 samefile(&putfd_stat, &getfd_stat); 262 close(getfd); 263 closesocketpair(fd); 264} 265 266/* 267 * Put a temporary file into a UNIX domain socket, then close both endpoints 268 * causing garbage collection to kick off. 269 */ 270ATF_TC_WITHOUT_HEAD(send_and_cancel); 271ATF_TC_BODY(send_and_cancel, tc) 272{ 273 int fd[2], putfd; 274 275 domainsocketpair(fd); 276 tempfile(&putfd); 277 sendfd(fd[0], putfd); 278 close(putfd); 279 closesocketpair(fd); 280} 281 282/* 283 * Send two files. Then receive them. Make sure they are returned in the 284 * right order, and both get there. 285 */ 286ATF_TC_WITHOUT_HEAD(two_files); 287ATF_TC_BODY(two_files, tc) 288{ 289 struct stat getfd_1_stat, getfd_2_stat, putfd_1_stat, putfd_2_stat; 290 int fd[2], getfd_1, getfd_2, putfd_1, putfd_2; 291 292 domainsocketpair(fd); 293 tempfile(&putfd_1); 294 tempfile(&putfd_2); 295 dofstat(putfd_1, &putfd_1_stat); 296 dofstat(putfd_2, &putfd_2_stat); 297 sendfd(fd[0], putfd_1); 298 sendfd(fd[0], putfd_2); 299 close(putfd_1); 300 close(putfd_2); 301 recvfd(fd[1], &getfd_1); 302 recvfd(fd[1], &getfd_2); 303 dofstat(getfd_1, &getfd_1_stat); 304 dofstat(getfd_2, &getfd_2_stat); 305 samefile(&putfd_1_stat, &getfd_1_stat); 306 samefile(&putfd_2_stat, &getfd_2_stat); 307 close(getfd_1); 308 close(getfd_2); 309 closesocketpair(fd); 310} 311 312/* 313 * Big bundling test. Send an endpoint of the UNIX domain socket over itself, 314 * closing the door behind it. 315 */ 316ATF_TC_WITHOUT_HEAD(bundle); 317ATF_TC_BODY(bundle, tc) 318{ 319 int fd[2], getfd; 320 321 domainsocketpair(fd); 322 323 sendfd(fd[0], fd[0]); 324 close(fd[0]); 325 recvfd(fd[1], &getfd); 326 close(getfd); 327 close(fd[1]); 328} 329 330/* 331 * Big bundling test part two: Send an endpoint of the UNIX domain socket over 332 * itself, close the door behind it, and never remove it from the other end. 333 */ 334ATF_TC_WITHOUT_HEAD(bundle_cancel); 335ATF_TC_BODY(bundle_cancel, tc) 336{ 337 int fd[2]; 338 339 domainsocketpair(fd); 340 sendfd(fd[0], fd[0]); 341 sendfd(fd[1], fd[0]); 342 closesocketpair(fd); 343} 344 345/* 346 * Test for PR 151758: Send an character device over the UNIX domain socket 347 * and then close both sockets to orphan the device. 348 */ 349ATF_TC_WITHOUT_HEAD(devfs_orphan); 350ATF_TC_BODY(devfs_orphan, tc) 351{ 352 int fd[2], putfd; 353 354 domainsocketpair(fd); 355 devnull(&putfd); 356 sendfd(fd[0], putfd); 357 close(putfd); 358 closesocketpair(fd); 359} 360 361#define LOCAL_SENDSPACE_SYSCTL "net.local.stream.sendspace" 362 363/* 364 * Test for PR 181741. Receiver sets LOCAL_CREDS, and kernel prepends a 365 * control message to the data. Sender sends large payload. 366 * Payload + SCM_RIGHTS + LOCAL_CREDS hit socket buffer limit, and receiver 367 * receives truncated data. 368 */ 369ATF_TC_WITHOUT_HEAD(rights_creds_payload); 370ATF_TC_BODY(rights_creds_payload, tc) 371{ 372 const int on = 1; 373 u_long sendspace; 374 size_t len; 375 void *buf; 376 int fd[2], getfd, putfd, rc; 377 378 atf_tc_expect_fail("PR 181741: Packet loss when 'control' messages " 379 "are present with large data"); 380 381 len = sizeof(sendspace); 382 rc = sysctlbyname(LOCAL_SENDSPACE_SYSCTL, &sendspace, 383 &len, NULL, 0); 384 ATF_REQUIRE_MSG(rc != -1, 385 "sysctl %s failed: %s", LOCAL_SENDSPACE_SYSCTL, strerror(errno)); 386 387 buf = calloc(1, sendspace); 388 ATF_REQUIRE(buf != NULL); 389 390 domainsocketpair(fd); 391 rc = setsockopt(fd[1], 0, LOCAL_CREDS, &on, sizeof(on)); 392 ATF_REQUIRE_MSG(rc != -1, "setsockopt(LOCAL_CREDS) failed: %s", 393 strerror(errno)); 394 tempfile(&putfd); 395 sendfd_payload(fd[0], putfd, buf, sendspace); 396 recvfd_payload(fd[1], &getfd, buf, sendspace); 397 close(putfd); 398 close(getfd); 399 closesocketpair(fd); 400} 401 402/* 403 * Test for PR 131876. Receiver uses a control message buffer that is too 404 * small for the incoming SCM_RIGHTS message, so the message is truncated. 405 * The kernel must not leak the copied right into the receiver's namespace. 406 */ 407ATF_TC_WITHOUT_HEAD(truncated_rights); 408ATF_TC_BODY(truncated_rights, tc) 409{ 410 struct iovec iovec; 411 struct msghdr msghdr; 412 char buf[16], message[CMSG_SPACE(0)]; 413 ssize_t len; 414 int fd[2], nfds, putfd; 415 416 atf_tc_expect_fail("PR 131876: " 417 "FD leak when 'control' message is truncated"); 418 419 memset(buf, 42, sizeof(buf)); 420 domainsocketpair(fd); 421 devnull(&putfd); 422 nfds = getnfds(); 423 424 sendfd_payload(fd[0], putfd, buf, sizeof(buf)); 425 426 bzero(&msghdr, sizeof(msghdr)); 427 bzero(message, sizeof(message)); 428 429 iovec.iov_base = buf; 430 iovec.iov_len = sizeof(buf); 431 msghdr.msg_control = message; 432 msghdr.msg_controllen = sizeof(message); 433 msghdr.msg_iov = &iovec; 434 msghdr.msg_iovlen = 1; 435 436 len = recvmsg(fd[1], &msghdr, 0); 437 ATF_REQUIRE_MSG(len != -1, "recvmsg failed: %s", strerror(errno)); 438 ATF_REQUIRE_MSG((size_t)len == sizeof(buf), 439 "recvmsg: %zd bytes received; expected %zd", len, sizeof(buf)); 440 for (size_t i = 0; i < sizeof(buf); i++) 441 ATF_REQUIRE_MSG(buf[i] == 42, "unexpected buffer contents"); 442 443 ATF_REQUIRE_MSG((msghdr.msg_flags & MSG_CTRUNC) != 0, 444 "MSG_CTRUNC not set after truncation"); 445 ATF_REQUIRE(getnfds() == nfds); 446 447 close(putfd); 448 closesocketpair(fd); 449} 450 451ATF_TC_WITHOUT_HEAD(copyout_rights_error); 452ATF_TC_BODY(copyout_rights_error, tc) 453{ 454 struct iovec iovec; 455 struct msghdr msghdr; 456 char buf[16]; 457 ssize_t len; 458 int fd[2], error, nfds, putfd; 459 460 atf_tc_expect_fail("PR 131876: " 461 "FD leak when copyout of rights returns an error"); 462 463 memset(buf, 0, sizeof(buf)); 464 domainsocketpair(fd); 465 devnull(&putfd); 466 nfds = getnfds(); 467 468 sendfd_payload(fd[0], putfd, buf, sizeof(buf)); 469 470 bzero(&msghdr, sizeof(msghdr)); 471 472 iovec.iov_base = buf; 473 iovec.iov_len = sizeof(buf); 474 msghdr.msg_control = (char *)-1; /* trigger EFAULT */ 475 msghdr.msg_controllen = CMSG_SPACE(sizeof(int)); 476 msghdr.msg_iov = &iovec; 477 msghdr.msg_iovlen = 1; 478 479 len = recvmsg(fd[1], &msghdr, 0); 480 error = errno; 481 ATF_REQUIRE_MSG(len == -1, "recvmsg succeeded: %zd", len); 482 ATF_REQUIRE_MSG(errno == EFAULT, "expected EFAULT, got %d (%s)", 483 error, strerror(errno)); 484 485 /* Verify that no FDs were leaked. */ 486 ATF_REQUIRE(getnfds() == nfds); 487 488 close(putfd); 489 closesocketpair(fd); 490} 491 492ATF_TP_ADD_TCS(tp) 493{ 494 495 ATF_TP_ADD_TC(tp, simple_send_fd); 496 ATF_TP_ADD_TC(tp, send_and_close); 497 ATF_TP_ADD_TC(tp, send_and_cancel); 498 ATF_TP_ADD_TC(tp, two_files); 499 ATF_TP_ADD_TC(tp, bundle); 500 ATF_TP_ADD_TC(tp, bundle_cancel); 501 ATF_TP_ADD_TC(tp, devfs_orphan); 502 ATF_TP_ADD_TC(tp, rights_creds_payload); 503 ATF_TP_ADD_TC(tp, truncated_rights); 504 ATF_TP_ADD_TC(tp, copyout_rights_error); 505 506 return (atf_no_error()); 507} 508