1 /*- 2 * Copyright (c) 1995 S�ren Schmidt 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 * in this position and unchanged. 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 * 3. The name of the author may not be used to endorse or promote products 15 * derived from this software without specific prior written permission 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 32 /* XXX we use functions that might not exist. */ 33 #include "opt_compat.h" 34 #include "opt_inet6.h" 35 36 #include <sys/param.h> 37 #include <sys/proc.h> 38 #include <sys/systm.h> 39 #include <sys/sysproto.h> 40 #include <sys/fcntl.h> 41 #include <sys/file.h> 42 #include <sys/limits.h> 43 #include <sys/lock.h> 44 #include <sys/malloc.h> 45 #include <sys/mutex.h> 46 #include <sys/mbuf.h> 47 #include <sys/socket.h> 48 #include <sys/socketvar.h> 49 #include <sys/syscallsubr.h> 50 #include <sys/uio.h> 51 #include <sys/syslog.h> 52 #include <sys/un.h> 53 54 #include <net/if.h> 55 #include <netinet/in.h> 56 #include <netinet/in_systm.h> 57 #include <netinet/ip.h> 58 #ifdef INET6 59 #include <netinet/ip6.h> 60 #include <netinet6/ip6_var.h> 61 #include <netinet6/in6_var.h> 62 #endif 63 64 #ifdef COMPAT_LINUX32 65 #include <machine/../linux32/linux.h> 66 #include <machine/../linux32/linux32_proto.h> 67 #else 68 #include <machine/../linux/linux.h> 69 #include <machine/../linux/linux_proto.h> 70 #endif 71 #include <compat/linux/linux_socket.h> 72 #include <compat/linux/linux_util.h> 73 74 static int do_sa_get(struct sockaddr **, const struct osockaddr *, int *, 75 struct malloc_type *); 76 static int linux_to_bsd_domain(int); 77 78 /* 79 * Reads a linux sockaddr and does any necessary translation. 80 * Linux sockaddrs don't have a length field, only a family. 81 */ 82 static int 83 linux_getsockaddr(struct sockaddr **sap, const struct osockaddr *osa, int len) 84 { 85 int osalen = len; 86 87 return (do_sa_get(sap, osa, &osalen, M_SONAME)); 88 } 89 90 /* 91 * Copy the osockaddr structure pointed to by osa to kernel, adjust 92 * family and convert to sockaddr. 93 */ 94 static int 95 do_sa_get(struct sockaddr **sap, const struct osockaddr *osa, int *osalen, 96 struct malloc_type *mtype) 97 { 98 int error=0, bdom; 99 struct sockaddr *sa; 100 struct osockaddr *kosa; 101 int alloclen; 102 #ifdef INET6 103 int oldv6size; 104 struct sockaddr_in6 *sin6; 105 #endif 106 107 if (*osalen < 2 || *osalen > UCHAR_MAX || !osa) 108 return (EINVAL); 109 110 alloclen = *osalen; 111 #ifdef INET6 112 oldv6size = 0; 113 /* 114 * Check for old (pre-RFC2553) sockaddr_in6. We may accept it 115 * if it's a v4-mapped address, so reserve the proper space 116 * for it. 117 */ 118 if (alloclen == sizeof (struct sockaddr_in6) - sizeof (u_int32_t)) { 119 alloclen = sizeof (struct sockaddr_in6); 120 oldv6size = 1; 121 } 122 #endif 123 124 kosa = malloc(alloclen, mtype, M_WAITOK); 125 126 if ((error = copyin(osa, kosa, *osalen))) 127 goto out; 128 129 bdom = linux_to_bsd_domain(kosa->sa_family); 130 if (bdom == -1) { 131 error = EAFNOSUPPORT; 132 goto out; 133 } 134 135 #ifdef INET6 136 /* 137 * Older Linux IPv6 code uses obsolete RFC2133 struct sockaddr_in6, 138 * which lacks the scope id compared with RFC2553 one. If we detect 139 * the situation, reject the address and write a message to system log. 140 * 141 * Still accept addresses for which the scope id is not used. 142 */ 143 if (oldv6size && bdom == AF_INET6) { 144 sin6 = (struct sockaddr_in6 *)kosa; 145 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr) || 146 (!IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr) && 147 !IN6_IS_ADDR_SITELOCAL(&sin6->sin6_addr) && 148 !IN6_IS_ADDR_V4COMPAT(&sin6->sin6_addr) && 149 !IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr) && 150 !IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr))) { 151 sin6->sin6_scope_id = 0; 152 } else { 153 log(LOG_DEBUG, 154 "obsolete pre-RFC2553 sockaddr_in6 rejected\n"); 155 error = EINVAL; 156 goto out; 157 } 158 } else 159 #endif 160 if (bdom == AF_INET) { 161 alloclen = sizeof(struct sockaddr_in); 162 if (*osalen < alloclen) { 163 error = EINVAL; 164 goto out; 165 } 166 } 167 168 sa = (struct sockaddr *) kosa; 169 sa->sa_family = bdom; 170 sa->sa_len = alloclen; 171 172 *sap = sa; 173 *osalen = alloclen; 174 return (0); 175 176 out: 177 free(kosa, mtype); 178 return (error); 179 } 180 181 static int 182 linux_to_bsd_domain(int domain) 183 { 184 185 switch (domain) { 186 case LINUX_AF_UNSPEC: 187 return (AF_UNSPEC); 188 case LINUX_AF_UNIX: 189 return (AF_LOCAL); 190 case LINUX_AF_INET: 191 return (AF_INET); 192 case LINUX_AF_INET6: 193 return (AF_INET6); 194 case LINUX_AF_AX25: 195 return (AF_CCITT); 196 case LINUX_AF_IPX: 197 return (AF_IPX); 198 case LINUX_AF_APPLETALK: 199 return (AF_APPLETALK); 200 } 201 return (-1); 202 } 203 204 static int 205 bsd_to_linux_domain(int domain) 206 { 207 208 switch (domain) { 209 case AF_UNSPEC: 210 return (LINUX_AF_UNSPEC); 211 case AF_LOCAL: 212 return (LINUX_AF_UNIX); 213 case AF_INET: 214 return (LINUX_AF_INET); 215 case AF_INET6: 216 return (LINUX_AF_INET6); 217 case AF_CCITT: 218 return (LINUX_AF_AX25); 219 case AF_IPX: 220 return (LINUX_AF_IPX); 221 case AF_APPLETALK: 222 return (LINUX_AF_APPLETALK); 223 } 224 return (-1); 225 } 226 227 static int 228 linux_to_bsd_sockopt_level(int level) 229 { 230 231 switch (level) { 232 case LINUX_SOL_SOCKET: 233 return (SOL_SOCKET); 234 } 235 return (level); 236 } 237 238 static int 239 bsd_to_linux_sockopt_level(int level) 240 { 241 242 switch (level) { 243 case SOL_SOCKET: 244 return (LINUX_SOL_SOCKET); 245 } 246 return (level); 247 } 248 249 static int 250 linux_to_bsd_ip_sockopt(int opt) 251 { 252 253 switch (opt) { 254 case LINUX_IP_TOS: 255 return (IP_TOS); 256 case LINUX_IP_TTL: 257 return (IP_TTL); 258 case LINUX_IP_OPTIONS: 259 return (IP_OPTIONS); 260 case LINUX_IP_MULTICAST_IF: 261 return (IP_MULTICAST_IF); 262 case LINUX_IP_MULTICAST_TTL: 263 return (IP_MULTICAST_TTL); 264 case LINUX_IP_MULTICAST_LOOP: 265 return (IP_MULTICAST_LOOP); 266 case LINUX_IP_ADD_MEMBERSHIP: 267 return (IP_ADD_MEMBERSHIP); 268 case LINUX_IP_DROP_MEMBERSHIP: 269 return (IP_DROP_MEMBERSHIP); 270 case LINUX_IP_HDRINCL: 271 return (IP_HDRINCL); 272 } 273 return (-1); 274 } 275 276 static int 277 linux_to_bsd_so_sockopt(int opt) 278 { 279 280 switch (opt) { 281 case LINUX_SO_DEBUG: 282 return (SO_DEBUG); 283 case LINUX_SO_REUSEADDR: 284 return (SO_REUSEADDR); 285 case LINUX_SO_TYPE: 286 return (SO_TYPE); 287 case LINUX_SO_ERROR: 288 return (SO_ERROR); 289 case LINUX_SO_DONTROUTE: 290 return (SO_DONTROUTE); 291 case LINUX_SO_BROADCAST: 292 return (SO_BROADCAST); 293 case LINUX_SO_SNDBUF: 294 return (SO_SNDBUF); 295 case LINUX_SO_RCVBUF: 296 return (SO_RCVBUF); 297 case LINUX_SO_KEEPALIVE: 298 return (SO_KEEPALIVE); 299 case LINUX_SO_OOBINLINE: 300 return (SO_OOBINLINE); 301 case LINUX_SO_LINGER: 302 return (SO_LINGER); 303 case LINUX_SO_PASSCRED: 304 return (LOCAL_CREDS); 305 case LINUX_SO_PEERCRED: 306 return (LOCAL_PEERCRED); 307 case LINUX_SO_RCVLOWAT: 308 return (SO_RCVLOWAT); 309 case LINUX_SO_SNDLOWAT: 310 return (SO_SNDLOWAT); 311 case LINUX_SO_RCVTIMEO: 312 return (SO_RCVTIMEO); 313 case LINUX_SO_SNDTIMEO: 314 return (SO_SNDTIMEO); 315 case LINUX_SO_TIMESTAMP: 316 return (SO_TIMESTAMP); 317 case LINUX_SO_ACCEPTCONN: 318 return (SO_ACCEPTCONN); 319 } 320 return (-1); 321 } 322 323 static int 324 linux_to_bsd_msg_flags(int flags) 325 { 326 int ret_flags = 0; 327 328 if (flags & LINUX_MSG_OOB) 329 ret_flags |= MSG_OOB; 330 if (flags & LINUX_MSG_PEEK) 331 ret_flags |= MSG_PEEK; 332 if (flags & LINUX_MSG_DONTROUTE) 333 ret_flags |= MSG_DONTROUTE; 334 if (flags & LINUX_MSG_CTRUNC) 335 ret_flags |= MSG_CTRUNC; 336 if (flags & LINUX_MSG_TRUNC) 337 ret_flags |= MSG_TRUNC; 338 if (flags & LINUX_MSG_DONTWAIT) 339 ret_flags |= MSG_DONTWAIT; 340 if (flags & LINUX_MSG_EOR) 341 ret_flags |= MSG_EOR; 342 if (flags & LINUX_MSG_WAITALL) 343 ret_flags |= MSG_WAITALL; 344 if (flags & LINUX_MSG_NOSIGNAL) 345 ret_flags |= MSG_NOSIGNAL; 346 #if 0 /* not handled */ 347 if (flags & LINUX_MSG_PROXY) 348 ; 349 if (flags & LINUX_MSG_FIN) 350 ; 351 if (flags & LINUX_MSG_SYN) 352 ; 353 if (flags & LINUX_MSG_CONFIRM) 354 ; 355 if (flags & LINUX_MSG_RST) 356 ; 357 if (flags & LINUX_MSG_ERRQUEUE) 358 ; 359 #endif 360 return ret_flags; 361 } 362 363 /* 364 * If bsd_to_linux_sockaddr() or linux_to_bsd_sockaddr() faults, then the 365 * native syscall will fault. Thus, we don't really need to check the 366 * return values for these functions. 367 */ 368 369 static int 370 bsd_to_linux_sockaddr(struct sockaddr *arg) 371 { 372 struct sockaddr sa; 373 size_t sa_len = sizeof(struct sockaddr); 374 int error; 375 376 if ((error = copyin(arg, &sa, sa_len))) 377 return (error); 378 379 *(u_short *)&sa = sa.sa_family; 380 381 error = copyout(&sa, arg, sa_len); 382 383 return (error); 384 } 385 386 static int 387 linux_to_bsd_sockaddr(struct sockaddr *arg, int len) 388 { 389 struct sockaddr sa; 390 size_t sa_len = sizeof(struct sockaddr); 391 int error; 392 393 if ((error = copyin(arg, &sa, sa_len))) 394 return (error); 395 396 sa.sa_family = *(sa_family_t *)&sa; 397 sa.sa_len = len; 398 399 error = copyout(&sa, arg, sa_len); 400 401 return (error); 402 } 403 404 405 static int 406 linux_sa_put(struct osockaddr *osa) 407 { 408 struct osockaddr sa; 409 int error, bdom; 410 411 /* 412 * Only read/write the osockaddr family part, the rest is 413 * not changed. 414 */ 415 error = copyin(osa, &sa, sizeof(sa.sa_family)); 416 if (error) 417 return (error); 418 419 bdom = bsd_to_linux_domain(sa.sa_family); 420 if (bdom == -1) 421 return (EINVAL); 422 423 sa.sa_family = bdom; 424 error = copyout(&sa, osa, sizeof(sa.sa_family)); 425 if (error) 426 return (error); 427 428 return (0); 429 } 430 431 static int 432 linux_to_bsd_cmsg_type(int cmsg_type) 433 { 434 435 switch (cmsg_type) { 436 case LINUX_SCM_RIGHTS: 437 return (SCM_RIGHTS); 438 case LINUX_SCM_CREDENTIALS: 439 return (SCM_CREDS); 440 } 441 return (-1); 442 } 443 444 static int 445 bsd_to_linux_cmsg_type(int cmsg_type) 446 { 447 448 switch (cmsg_type) { 449 case SCM_RIGHTS: 450 return (LINUX_SCM_RIGHTS); 451 case SCM_CREDS: 452 return (LINUX_SCM_CREDENTIALS); 453 } 454 return (-1); 455 } 456 457 static int 458 linux_to_bsd_msghdr(struct msghdr *bhdr, const struct l_msghdr *lhdr) 459 { 460 if (lhdr->msg_controllen > INT_MAX) 461 return (ENOBUFS); 462 463 bhdr->msg_name = PTRIN(lhdr->msg_name); 464 bhdr->msg_namelen = lhdr->msg_namelen; 465 bhdr->msg_iov = PTRIN(lhdr->msg_iov); 466 bhdr->msg_iovlen = lhdr->msg_iovlen; 467 bhdr->msg_control = PTRIN(lhdr->msg_control); 468 469 /* 470 * msg_controllen is skipped since BSD and LINUX control messages 471 * are potentially different sizes (e.g. the cred structure used 472 * by SCM_CREDS is different between the two operating system). 473 * 474 * The caller can set it (if necessary) after converting all the 475 * control messages. 476 */ 477 478 bhdr->msg_flags = linux_to_bsd_msg_flags(lhdr->msg_flags); 479 return (0); 480 } 481 482 static int 483 bsd_to_linux_msghdr(const struct msghdr *bhdr, struct l_msghdr *lhdr) 484 { 485 lhdr->msg_name = PTROUT(bhdr->msg_name); 486 lhdr->msg_namelen = bhdr->msg_namelen; 487 lhdr->msg_iov = PTROUT(bhdr->msg_iov); 488 lhdr->msg_iovlen = bhdr->msg_iovlen; 489 lhdr->msg_control = PTROUT(bhdr->msg_control); 490 491 /* 492 * msg_controllen is skipped since BSD and LINUX control messages 493 * are potentially different sizes (e.g. the cred structure used 494 * by SCM_CREDS is different between the two operating system). 495 * 496 * The caller can set it (if necessary) after converting all the 497 * control messages. 498 */ 499 500 /* msg_flags skipped */ 501 return (0); 502 } 503 504 static int 505 linux_set_socket_flags(struct thread *td, int s, int flags) 506 { 507 int error; 508 509 if (flags & LINUX_SOCK_NONBLOCK) { 510 error = kern_fcntl(td, s, F_SETFL, O_NONBLOCK); 511 if (error) 512 return (error); 513 } 514 if (flags & LINUX_SOCK_CLOEXEC) { 515 error = kern_fcntl(td, s, F_SETFD, FD_CLOEXEC); 516 if (error) 517 return (error); 518 } 519 return (0); 520 } 521 522 static int 523 linux_sendit(struct thread *td, int s, struct msghdr *mp, int flags, 524 struct mbuf *control, enum uio_seg segflg) 525 { 526 struct sockaddr *to; 527 int error; 528 529 if (mp->msg_name != NULL) { 530 error = linux_getsockaddr(&to, mp->msg_name, mp->msg_namelen); 531 if (error) 532 return (error); 533 mp->msg_name = to; 534 } else 535 to = NULL; 536 537 error = kern_sendit(td, s, mp, linux_to_bsd_msg_flags(flags), control, 538 segflg); 539 540 if (to) 541 free(to, M_SONAME); 542 return (error); 543 } 544 545 /* Return 0 if IP_HDRINCL is set for the given socket. */ 546 static int 547 linux_check_hdrincl(struct thread *td, int s) 548 { 549 int error, optval, size_val; 550 551 size_val = sizeof(optval); 552 error = kern_getsockopt(td, s, IPPROTO_IP, IP_HDRINCL, 553 &optval, UIO_SYSSPACE, &size_val); 554 if (error) 555 return (error); 556 557 return (optval == 0); 558 } 559 560 struct linux_sendto_args { 561 int s; 562 l_uintptr_t msg; 563 int len; 564 int flags; 565 l_uintptr_t to; 566 int tolen; 567 }; 568 569 /* 570 * Updated sendto() when IP_HDRINCL is set: 571 * tweak endian-dependent fields in the IP packet. 572 */ 573 static int 574 linux_sendto_hdrincl(struct thread *td, struct linux_sendto_args *linux_args) 575 { 576 /* 577 * linux_ip_copysize defines how many bytes we should copy 578 * from the beginning of the IP packet before we customize it for BSD. 579 * It should include all the fields we modify (ip_len and ip_off). 580 */ 581 #define linux_ip_copysize 8 582 583 struct ip *packet; 584 struct msghdr msg; 585 struct iovec aiov[1]; 586 int error; 587 588 /* Check that the packet isn't too big or too small. */ 589 if (linux_args->len < linux_ip_copysize || 590 linux_args->len > IP_MAXPACKET) 591 return (EINVAL); 592 593 packet = (struct ip *)malloc(linux_args->len, M_TEMP, M_WAITOK); 594 595 /* Make kernel copy of the packet to be sent */ 596 if ((error = copyin(PTRIN(linux_args->msg), packet, 597 linux_args->len))) 598 goto goout; 599 600 /* Convert fields from Linux to BSD raw IP socket format */ 601 packet->ip_len = linux_args->len; 602 packet->ip_off = ntohs(packet->ip_off); 603 604 /* Prepare the msghdr and iovec structures describing the new packet */ 605 msg.msg_name = PTRIN(linux_args->to); 606 msg.msg_namelen = linux_args->tolen; 607 msg.msg_iov = aiov; 608 msg.msg_iovlen = 1; 609 msg.msg_control = NULL; 610 msg.msg_flags = 0; 611 aiov[0].iov_base = (char *)packet; 612 aiov[0].iov_len = linux_args->len; 613 error = linux_sendit(td, linux_args->s, &msg, linux_args->flags, 614 NULL, UIO_SYSSPACE); 615 goout: 616 free(packet, M_TEMP); 617 return (error); 618 } 619 620 struct linux_socket_args { 621 int domain; 622 int type; 623 int protocol; 624 }; 625 626 static int 627 linux_socket(struct thread *td, struct linux_socket_args *args) 628 { 629 struct socket_args /* { 630 int domain; 631 int type; 632 int protocol; 633 } */ bsd_args; 634 int retval_socket, socket_flags; 635 636 bsd_args.protocol = args->protocol; 637 socket_flags = args->type & ~LINUX_SOCK_TYPE_MASK; 638 if (socket_flags & ~(LINUX_SOCK_CLOEXEC | LINUX_SOCK_NONBLOCK)) 639 return (EINVAL); 640 bsd_args.type = args->type & LINUX_SOCK_TYPE_MASK; 641 if (bsd_args.type < 0 || bsd_args.type > LINUX_SOCK_MAX) 642 return (EINVAL); 643 bsd_args.domain = linux_to_bsd_domain(args->domain); 644 if (bsd_args.domain == -1) 645 return (EAFNOSUPPORT); 646 647 retval_socket = socket(td, &bsd_args); 648 if (retval_socket) 649 return (retval_socket); 650 651 retval_socket = linux_set_socket_flags(td, td->td_retval[0], 652 socket_flags); 653 if (retval_socket) { 654 (void)kern_close(td, td->td_retval[0]); 655 goto out; 656 } 657 658 if (bsd_args.type == SOCK_RAW 659 && (bsd_args.protocol == IPPROTO_RAW || bsd_args.protocol == 0) 660 && bsd_args.domain == PF_INET) { 661 /* It's a raw IP socket: set the IP_HDRINCL option. */ 662 int hdrincl; 663 664 hdrincl = 1; 665 /* We ignore any error returned by kern_setsockopt() */ 666 kern_setsockopt(td, td->td_retval[0], IPPROTO_IP, IP_HDRINCL, 667 &hdrincl, UIO_SYSSPACE, sizeof(hdrincl)); 668 } 669 #ifdef INET6 670 /* 671 * Linux AF_INET6 socket has IPV6_V6ONLY setsockopt set to 0 by default 672 * and some apps depend on this. So, set V6ONLY to 0 for Linux apps. 673 * For simplicity we do this unconditionally of the net.inet6.ip6.v6only 674 * sysctl value. 675 */ 676 if (bsd_args.domain == PF_INET6) { 677 int v6only; 678 679 v6only = 0; 680 /* We ignore any error returned by setsockopt() */ 681 kern_setsockopt(td, td->td_retval[0], IPPROTO_IPV6, IPV6_V6ONLY, 682 &v6only, UIO_SYSSPACE, sizeof(v6only)); 683 } 684 #endif 685 686 out: 687 return (retval_socket); 688 } 689 690 struct linux_bind_args { 691 int s; 692 l_uintptr_t name; 693 int namelen; 694 }; 695 696 static int 697 linux_bind(struct thread *td, struct linux_bind_args *args) 698 { 699 struct sockaddr *sa; 700 int error; 701 702 error = linux_getsockaddr(&sa, PTRIN(args->name), 703 args->namelen); 704 if (error) 705 return (error); 706 707 error = kern_bind(td, args->s, sa); 708 free(sa, M_SONAME); 709 if (error == EADDRNOTAVAIL && args->namelen != sizeof(struct sockaddr_in)) 710 return (EINVAL); 711 return (error); 712 } 713 714 struct linux_connect_args { 715 int s; 716 l_uintptr_t name; 717 int namelen; 718 }; 719 int linux_connect(struct thread *, struct linux_connect_args *); 720 721 int 722 linux_connect(struct thread *td, struct linux_connect_args *args) 723 { 724 struct socket *so; 725 struct sockaddr *sa; 726 u_int fflag; 727 int error; 728 729 error = linux_getsockaddr(&sa, (struct osockaddr *)PTRIN(args->name), 730 args->namelen); 731 if (error) 732 return (error); 733 734 error = kern_connect(td, args->s, sa); 735 free(sa, M_SONAME); 736 if (error != EISCONN) 737 return (error); 738 739 /* 740 * Linux doesn't return EISCONN the first time it occurs, 741 * when on a non-blocking socket. Instead it returns the 742 * error getsockopt(SOL_SOCKET, SO_ERROR) would return on BSD. 743 * 744 * XXXRW: Instead of using fgetsock(), check that it is a 745 * socket and use the file descriptor reference instead of 746 * creating a new one. 747 */ 748 error = fgetsock(td, args->s, &so, &fflag); 749 if (error == 0) { 750 error = EISCONN; 751 if (fflag & FNONBLOCK) { 752 SOCK_LOCK(so); 753 if (so->so_emuldata == 0) 754 error = so->so_error; 755 so->so_emuldata = (void *)1; 756 SOCK_UNLOCK(so); 757 } 758 fputsock(so); 759 } 760 return (error); 761 } 762 763 struct linux_listen_args { 764 int s; 765 int backlog; 766 }; 767 768 static int 769 linux_listen(struct thread *td, struct linux_listen_args *args) 770 { 771 struct listen_args /* { 772 int s; 773 int backlog; 774 } */ bsd_args; 775 776 bsd_args.s = args->s; 777 bsd_args.backlog = args->backlog; 778 return (listen(td, &bsd_args)); 779 } 780 781 static int 782 linux_accept_common(struct thread *td, int s, l_uintptr_t addr, 783 l_uintptr_t namelen, int flags) 784 { 785 struct accept_args /* { 786 int s; 787 struct sockaddr * __restrict name; 788 socklen_t * __restrict anamelen; 789 } */ bsd_args; 790 int error; 791 792 if (flags & ~(LINUX_SOCK_CLOEXEC | LINUX_SOCK_NONBLOCK)) 793 return (EINVAL); 794 795 bsd_args.s = s; 796 /* XXX: */ 797 bsd_args.name = (struct sockaddr * __restrict)PTRIN(addr); 798 bsd_args.anamelen = PTRIN(namelen);/* XXX */ 799 error = accept(td, &bsd_args); 800 bsd_to_linux_sockaddr((struct sockaddr *)bsd_args.name); 801 if (error) { 802 if (error == EFAULT && namelen != sizeof(struct sockaddr_in)) 803 return (EINVAL); 804 return (error); 805 } 806 807 /* 808 * linux appears not to copy flags from the parent socket to the 809 * accepted one, so we must clear the flags in the new descriptor 810 * and apply the requested flags. 811 */ 812 error = kern_fcntl(td, td->td_retval[0], F_SETFL, 0); 813 if (error) 814 goto out; 815 error = linux_set_socket_flags(td, td->td_retval[0], flags); 816 if (error) 817 goto out; 818 if (addr) 819 error = linux_sa_put(PTRIN(addr)); 820 821 out: 822 if (error) { 823 (void)kern_close(td, td->td_retval[0]); 824 td->td_retval[0] = 0; 825 } 826 return (error); 827 } 828 829 struct linux_accept_args { 830 int s; 831 l_uintptr_t addr; 832 l_uintptr_t namelen; 833 }; 834 835 static int 836 linux_accept(struct thread *td, struct linux_accept_args *args) 837 { 838 839 return (linux_accept_common(td, args->s, args->addr, 840 args->namelen, 0)); 841 } 842 843 struct linux_accept4_args { 844 int s; 845 l_uintptr_t addr; 846 l_uintptr_t namelen; 847 int flags; 848 }; 849 850 static int 851 linux_accept4(struct thread *td, struct linux_accept4_args *args) 852 { 853 854 return (linux_accept_common(td, args->s, args->addr, 855 args->namelen, args->flags)); 856 } 857 858 struct linux_getsockname_args { 859 int s; 860 l_uintptr_t addr; 861 l_uintptr_t namelen; 862 }; 863 864 static int 865 linux_getsockname(struct thread *td, struct linux_getsockname_args *args) 866 { 867 struct getsockname_args /* { 868 int fdes; 869 struct sockaddr * __restrict asa; 870 socklen_t * __restrict alen; 871 } */ bsd_args; 872 int error; 873 874 bsd_args.fdes = args->s; 875 /* XXX: */ 876 bsd_args.asa = (struct sockaddr * __restrict)PTRIN(args->addr); 877 bsd_args.alen = PTRIN(args->namelen); /* XXX */ 878 error = getsockname(td, &bsd_args); 879 bsd_to_linux_sockaddr((struct sockaddr *)bsd_args.asa); 880 if (error) 881 return (error); 882 error = linux_sa_put(PTRIN(args->addr)); 883 if (error) 884 return (error); 885 return (0); 886 } 887 888 struct linux_getpeername_args { 889 int s; 890 l_uintptr_t addr; 891 l_uintptr_t namelen; 892 }; 893 894 static int 895 linux_getpeername(struct thread *td, struct linux_getpeername_args *args) 896 { 897 struct getpeername_args /* { 898 int fdes; 899 caddr_t asa; 900 int *alen; 901 } */ bsd_args; 902 int error; 903 904 bsd_args.fdes = args->s; 905 bsd_args.asa = (struct sockaddr *)PTRIN(args->addr); 906 bsd_args.alen = (int *)PTRIN(args->namelen); 907 error = getpeername(td, &bsd_args); 908 bsd_to_linux_sockaddr((struct sockaddr *)bsd_args.asa); 909 if (error) 910 return (error); 911 error = linux_sa_put(PTRIN(args->addr)); 912 if (error) 913 return (error); 914 return (0); 915 } 916 917 struct linux_socketpair_args { 918 int domain; 919 int type; 920 int protocol; 921 l_uintptr_t rsv; 922 }; 923 924 static int 925 linux_socketpair(struct thread *td, struct linux_socketpair_args *args) 926 { 927 struct socketpair_args /* { 928 int domain; 929 int type; 930 int protocol; 931 int *rsv; 932 } */ bsd_args; 933 int error, socket_flags; 934 int sv[2]; 935 936 bsd_args.domain = linux_to_bsd_domain(args->domain); 937 if (bsd_args.domain != PF_LOCAL) 938 return (EAFNOSUPPORT); 939 940 socket_flags = args->type & ~LINUX_SOCK_TYPE_MASK; 941 if (socket_flags & ~(LINUX_SOCK_CLOEXEC | LINUX_SOCK_NONBLOCK)) 942 return (EINVAL); 943 bsd_args.type = args->type & LINUX_SOCK_TYPE_MASK; 944 if (bsd_args.type < 0 || bsd_args.type > LINUX_SOCK_MAX) 945 return (EINVAL); 946 947 if (args->protocol != 0 && args->protocol != PF_UNIX) 948 949 /* 950 * Use of PF_UNIX as protocol argument is not right, 951 * but Linux does it. 952 * Do not map PF_UNIX as its Linux value is identical 953 * to FreeBSD one. 954 */ 955 return (EPROTONOSUPPORT); 956 else 957 bsd_args.protocol = 0; 958 bsd_args.rsv = (int *)PTRIN(args->rsv); 959 error = kern_socketpair(td, bsd_args.domain, bsd_args.type, 960 bsd_args.protocol, sv); 961 if (error) 962 return (error); 963 error = linux_set_socket_flags(td, sv[0], socket_flags); 964 if (error) 965 goto out; 966 error = linux_set_socket_flags(td, sv[1], socket_flags); 967 if (error) 968 goto out; 969 970 error = copyout(sv, bsd_args.rsv, 2 * sizeof(int)); 971 972 out: 973 if (error) { 974 (void)kern_close(td, sv[0]); 975 (void)kern_close(td, sv[1]); 976 } 977 return (error); 978 } 979 980 struct linux_send_args { 981 int s; 982 l_uintptr_t msg; 983 int len; 984 int flags; 985 }; 986 987 static int 988 linux_send(struct thread *td, struct linux_send_args *args) 989 { 990 struct sendto_args /* { 991 int s; 992 caddr_t buf; 993 int len; 994 int flags; 995 caddr_t to; 996 int tolen; 997 } */ bsd_args; 998 999 bsd_args.s = args->s; 1000 bsd_args.buf = (caddr_t)PTRIN(args->msg); 1001 bsd_args.len = args->len; 1002 bsd_args.flags = args->flags; 1003 bsd_args.to = NULL; 1004 bsd_args.tolen = 0; 1005 return sendto(td, &bsd_args); 1006 } 1007 1008 struct linux_recv_args { 1009 int s; 1010 l_uintptr_t msg; 1011 int len; 1012 int flags; 1013 }; 1014 1015 static int 1016 linux_recv(struct thread *td, struct linux_recv_args *args) 1017 { 1018 struct recvfrom_args /* { 1019 int s; 1020 caddr_t buf; 1021 int len; 1022 int flags; 1023 struct sockaddr *from; 1024 socklen_t fromlenaddr; 1025 } */ bsd_args; 1026 1027 bsd_args.s = args->s; 1028 bsd_args.buf = (caddr_t)PTRIN(args->msg); 1029 bsd_args.len = args->len; 1030 bsd_args.flags = linux_to_bsd_msg_flags(args->flags); 1031 bsd_args.from = NULL; 1032 bsd_args.fromlenaddr = 0; 1033 return (recvfrom(td, &bsd_args)); 1034 } 1035 1036 static int 1037 linux_sendto(struct thread *td, struct linux_sendto_args *args) 1038 { 1039 struct msghdr msg; 1040 struct iovec aiov; 1041 int error; 1042 1043 if (linux_check_hdrincl(td, args->s) == 0) 1044 /* IP_HDRINCL set, tweak the packet before sending */ 1045 return (linux_sendto_hdrincl(td, args)); 1046 1047 msg.msg_name = PTRIN(args->to); 1048 msg.msg_namelen = args->tolen; 1049 msg.msg_iov = &aiov; 1050 msg.msg_iovlen = 1; 1051 msg.msg_control = NULL; 1052 msg.msg_flags = 0; 1053 aiov.iov_base = PTRIN(args->msg); 1054 aiov.iov_len = args->len; 1055 error = linux_sendit(td, args->s, &msg, args->flags, NULL, 1056 UIO_USERSPACE); 1057 return (error); 1058 } 1059 1060 struct linux_recvfrom_args { 1061 int s; 1062 l_uintptr_t buf; 1063 int len; 1064 int flags; 1065 l_uintptr_t from; 1066 l_uintptr_t fromlen; 1067 }; 1068 1069 static int 1070 linux_recvfrom(struct thread *td, struct linux_recvfrom_args *args) 1071 { 1072 struct recvfrom_args /* { 1073 int s; 1074 caddr_t buf; 1075 size_t len; 1076 int flags; 1077 struct sockaddr * __restrict from; 1078 socklen_t * __restrict fromlenaddr; 1079 } */ bsd_args; 1080 size_t len; 1081 int error; 1082 1083 if ((error = copyin(PTRIN(args->fromlen), &len, sizeof(size_t)))) 1084 return (error); 1085 1086 bsd_args.s = args->s; 1087 bsd_args.buf = PTRIN(args->buf); 1088 bsd_args.len = args->len; 1089 bsd_args.flags = linux_to_bsd_msg_flags(args->flags); 1090 /* XXX: */ 1091 bsd_args.from = (struct sockaddr * __restrict)PTRIN(args->from); 1092 bsd_args.fromlenaddr = PTRIN(args->fromlen);/* XXX */ 1093 1094 linux_to_bsd_sockaddr((struct sockaddr *)bsd_args.from, len); 1095 error = recvfrom(td, &bsd_args); 1096 bsd_to_linux_sockaddr((struct sockaddr *)bsd_args.from); 1097 1098 if (error) 1099 return (error); 1100 if (args->from) { 1101 error = linux_sa_put((struct osockaddr *) 1102 PTRIN(args->from)); 1103 if (error) 1104 return (error); 1105 } 1106 return (0); 1107 } 1108 1109 struct linux_sendmsg_args { 1110 int s; 1111 l_uintptr_t msg; 1112 int flags; 1113 }; 1114 1115 static int 1116 linux_sendmsg(struct thread *td, struct linux_sendmsg_args *args) 1117 { 1118 struct cmsghdr *cmsg; 1119 struct cmsgcred cmcred; 1120 struct mbuf *control; 1121 struct msghdr msg; 1122 struct l_cmsghdr linux_cmsg; 1123 struct l_cmsghdr *ptr_cmsg; 1124 struct l_msghdr linux_msg; 1125 struct iovec *iov; 1126 socklen_t datalen; 1127 struct sockaddr *sa; 1128 sa_family_t sa_family; 1129 void *data; 1130 int error; 1131 1132 error = copyin(PTRIN(args->msg), &linux_msg, sizeof(linux_msg)); 1133 if (error) 1134 return (error); 1135 1136 /* 1137 * Some Linux applications (ping) define a non-NULL control data 1138 * pointer, but a msg_controllen of 0, which is not allowed in the 1139 * FreeBSD system call interface. NULL the msg_control pointer in 1140 * order to handle this case. This should be checked, but allows the 1141 * Linux ping to work. 1142 */ 1143 if (PTRIN(linux_msg.msg_control) != NULL && linux_msg.msg_controllen == 0) 1144 linux_msg.msg_control = PTROUT(NULL); 1145 1146 error = linux_to_bsd_msghdr(&msg, &linux_msg); 1147 if (error) 1148 return (error); 1149 1150 #ifdef COMPAT_LINUX32 1151 error = linux32_copyiniov(PTRIN(msg.msg_iov), msg.msg_iovlen, 1152 &iov, EMSGSIZE); 1153 #else 1154 error = copyiniov(msg.msg_iov, msg.msg_iovlen, &iov, EMSGSIZE); 1155 #endif 1156 if (error) 1157 return (error); 1158 1159 control = NULL; 1160 cmsg = NULL; 1161 1162 if ((ptr_cmsg = LINUX_CMSG_FIRSTHDR(&linux_msg)) != NULL) { 1163 error = kern_getsockname(td, args->s, &sa, &datalen); 1164 if (error) 1165 goto bad; 1166 sa_family = sa->sa_family; 1167 free(sa, M_SONAME); 1168 1169 error = ENOBUFS; 1170 cmsg = malloc(CMSG_HDRSZ, M_TEMP, M_WAITOK | M_ZERO); 1171 control = m_get(M_WAIT, MT_CONTROL); 1172 if (control == NULL) 1173 goto bad; 1174 1175 do { 1176 error = copyin(ptr_cmsg, &linux_cmsg, 1177 sizeof(struct l_cmsghdr)); 1178 if (error) 1179 goto bad; 1180 1181 error = EINVAL; 1182 if (linux_cmsg.cmsg_len < sizeof(struct l_cmsghdr)) 1183 goto bad; 1184 1185 /* 1186 * Now we support only SCM_RIGHTS and SCM_CRED, 1187 * so return EINVAL in any other cmsg_type 1188 */ 1189 cmsg->cmsg_type = 1190 linux_to_bsd_cmsg_type(linux_cmsg.cmsg_type); 1191 cmsg->cmsg_level = 1192 linux_to_bsd_sockopt_level(linux_cmsg.cmsg_level); 1193 if (cmsg->cmsg_type == -1 1194 || cmsg->cmsg_level != SOL_SOCKET) 1195 goto bad; 1196 1197 /* 1198 * Some applications (e.g. pulseaudio) attempt to 1199 * send ancillary data even if the underlying protocol 1200 * doesn't support it which is not allowed in the 1201 * FreeBSD system call interface. 1202 */ 1203 if (sa_family != AF_UNIX) 1204 continue; 1205 1206 data = LINUX_CMSG_DATA(ptr_cmsg); 1207 datalen = linux_cmsg.cmsg_len - L_CMSG_HDRSZ; 1208 1209 switch (cmsg->cmsg_type) 1210 { 1211 case SCM_RIGHTS: 1212 break; 1213 1214 case SCM_CREDS: 1215 data = &cmcred; 1216 datalen = sizeof(cmcred); 1217 1218 /* 1219 * The lower levels will fill in the structure 1220 */ 1221 bzero(data, datalen); 1222 break; 1223 } 1224 1225 cmsg->cmsg_len = CMSG_LEN(datalen); 1226 1227 error = ENOBUFS; 1228 if (!m_append(control, CMSG_HDRSZ, (c_caddr_t) cmsg)) 1229 goto bad; 1230 if (!m_append(control, datalen, (c_caddr_t) data)) 1231 goto bad; 1232 } while ((ptr_cmsg = LINUX_CMSG_NXTHDR(&linux_msg, ptr_cmsg))); 1233 1234 if (m_length(control, NULL) == 0) { 1235 m_freem(control); 1236 control = NULL; 1237 } 1238 } 1239 1240 msg.msg_iov = iov; 1241 msg.msg_flags = 0; 1242 error = linux_sendit(td, args->s, &msg, args->flags, control, 1243 UIO_USERSPACE); 1244 1245 bad: 1246 free(iov, M_IOV); 1247 if (cmsg) 1248 free(cmsg, M_TEMP); 1249 return (error); 1250 } 1251 1252 struct linux_recvmsg_args { 1253 int s; 1254 l_uintptr_t msg; 1255 int flags; 1256 }; 1257 1258 static int 1259 linux_recvmsg(struct thread *td, struct linux_recvmsg_args *args) 1260 { 1261 struct cmsghdr *cm; 1262 struct cmsgcred *cmcred; 1263 struct msghdr msg; 1264 struct l_cmsghdr *linux_cmsg = NULL; 1265 struct l_ucred linux_ucred; 1266 socklen_t datalen, outlen; 1267 struct l_msghdr linux_msg; 1268 struct iovec *iov, *uiov; 1269 struct mbuf *control = NULL; 1270 struct mbuf **controlp; 1271 caddr_t outbuf; 1272 void *data; 1273 int error, i, fd, fds, *fdp; 1274 1275 error = copyin(PTRIN(args->msg), &linux_msg, sizeof(linux_msg)); 1276 if (error) 1277 return (error); 1278 1279 error = linux_to_bsd_msghdr(&msg, &linux_msg); 1280 if (error) 1281 return (error); 1282 1283 #ifdef COMPAT_LINUX32 1284 error = linux32_copyiniov(PTRIN(msg.msg_iov), msg.msg_iovlen, 1285 &iov, EMSGSIZE); 1286 #else 1287 error = copyiniov(msg.msg_iov, msg.msg_iovlen, &iov, EMSGSIZE); 1288 #endif 1289 if (error) 1290 return (error); 1291 1292 if (msg.msg_name) { 1293 error = linux_to_bsd_sockaddr((struct sockaddr *)msg.msg_name, 1294 msg.msg_namelen); 1295 if (error) 1296 goto bad; 1297 } 1298 1299 uiov = msg.msg_iov; 1300 msg.msg_iov = iov; 1301 controlp = (msg.msg_control != NULL) ? &control : NULL; 1302 error = kern_recvit(td, args->s, &msg, UIO_USERSPACE, controlp); 1303 msg.msg_iov = uiov; 1304 if (error) 1305 goto bad; 1306 1307 error = bsd_to_linux_msghdr(&msg, &linux_msg); 1308 if (error) 1309 goto bad; 1310 1311 if (linux_msg.msg_name) { 1312 error = bsd_to_linux_sockaddr((struct sockaddr *) 1313 PTRIN(linux_msg.msg_name)); 1314 if (error) 1315 goto bad; 1316 } 1317 if (linux_msg.msg_name && linux_msg.msg_namelen > 2) { 1318 error = linux_sa_put(PTRIN(linux_msg.msg_name)); 1319 if (error) 1320 goto bad; 1321 } 1322 1323 outbuf = PTRIN(linux_msg.msg_control); 1324 outlen = 0; 1325 1326 if (control) { 1327 linux_cmsg = malloc(L_CMSG_HDRSZ, M_TEMP, M_WAITOK | M_ZERO); 1328 1329 msg.msg_control = mtod(control, struct cmsghdr *); 1330 msg.msg_controllen = control->m_len; 1331 1332 cm = CMSG_FIRSTHDR(&msg); 1333 1334 while (cm != NULL) { 1335 linux_cmsg->cmsg_type = 1336 bsd_to_linux_cmsg_type(cm->cmsg_type); 1337 linux_cmsg->cmsg_level = 1338 bsd_to_linux_sockopt_level(cm->cmsg_level); 1339 if (linux_cmsg->cmsg_type == -1 1340 || cm->cmsg_level != SOL_SOCKET) 1341 { 1342 error = EINVAL; 1343 goto bad; 1344 } 1345 1346 data = CMSG_DATA(cm); 1347 datalen = (caddr_t)cm + cm->cmsg_len - (caddr_t)data; 1348 1349 switch (cm->cmsg_type) 1350 { 1351 case SCM_RIGHTS: 1352 if (args->flags & LINUX_MSG_CMSG_CLOEXEC) { 1353 fds = datalen / sizeof(int); 1354 fdp = data; 1355 for (i = 0; i < fds; i++) { 1356 fd = *fdp++; 1357 (void)kern_fcntl(td, fd, 1358 F_SETFD, FD_CLOEXEC); 1359 } 1360 } 1361 break; 1362 1363 case SCM_CREDS: 1364 /* 1365 * Currently LOCAL_CREDS is never in 1366 * effect for Linux so no need to worry 1367 * about sockcred 1368 */ 1369 if (datalen != sizeof (*cmcred)) { 1370 error = EMSGSIZE; 1371 goto bad; 1372 } 1373 cmcred = (struct cmsgcred *)data; 1374 bzero(&linux_ucred, sizeof(linux_ucred)); 1375 linux_ucred.pid = cmcred->cmcred_pid; 1376 linux_ucred.uid = cmcred->cmcred_uid; 1377 linux_ucred.gid = cmcred->cmcred_gid; 1378 data = &linux_ucred; 1379 datalen = sizeof(linux_ucred); 1380 break; 1381 } 1382 1383 if (outlen + LINUX_CMSG_LEN(datalen) > 1384 linux_msg.msg_controllen) { 1385 if (outlen == 0) { 1386 error = EMSGSIZE; 1387 goto bad; 1388 } else { 1389 linux_msg.msg_flags |= 1390 LINUX_MSG_CTRUNC; 1391 goto out; 1392 } 1393 } 1394 1395 linux_cmsg->cmsg_len = LINUX_CMSG_LEN(datalen); 1396 1397 error = copyout(linux_cmsg, outbuf, L_CMSG_HDRSZ); 1398 if (error) 1399 goto bad; 1400 outbuf += L_CMSG_HDRSZ; 1401 1402 error = copyout(data, outbuf, datalen); 1403 if (error) 1404 goto bad; 1405 1406 outbuf += LINUX_CMSG_ALIGN(datalen); 1407 outlen += LINUX_CMSG_LEN(datalen); 1408 1409 cm = CMSG_NXTHDR(&msg, cm); 1410 } 1411 } 1412 1413 out: 1414 linux_msg.msg_controllen = outlen; 1415 error = copyout(&linux_msg, PTRIN(args->msg), sizeof(linux_msg)); 1416 1417 bad: 1418 free(iov, M_IOV); 1419 if (control != NULL) 1420 m_freem(control); 1421 if (linux_cmsg != NULL) 1422 free(linux_cmsg, M_TEMP); 1423 1424 return (error); 1425 } 1426 1427 struct linux_shutdown_args { 1428 int s; 1429 int how; 1430 }; 1431 1432 static int 1433 linux_shutdown(struct thread *td, struct linux_shutdown_args *args) 1434 { 1435 struct shutdown_args /* { 1436 int s; 1437 int how; 1438 } */ bsd_args; 1439 1440 bsd_args.s = args->s; 1441 bsd_args.how = args->how; 1442 return (shutdown(td, &bsd_args)); 1443 } 1444 1445 struct linux_setsockopt_args { 1446 int s; 1447 int level; 1448 int optname; 1449 l_uintptr_t optval; 1450 int optlen; 1451 }; 1452 1453 static int 1454 linux_setsockopt(struct thread *td, struct linux_setsockopt_args *args) 1455 { 1456 struct setsockopt_args /* { 1457 int s; 1458 int level; 1459 int name; 1460 caddr_t val; 1461 int valsize; 1462 } */ bsd_args; 1463 l_timeval linux_tv; 1464 struct timeval tv; 1465 int error, name; 1466 1467 bsd_args.s = args->s; 1468 bsd_args.level = linux_to_bsd_sockopt_level(args->level); 1469 switch (bsd_args.level) { 1470 case SOL_SOCKET: 1471 name = linux_to_bsd_so_sockopt(args->optname); 1472 switch (args->optname) { 1473 case LINUX_SO_PASSCRED: 1474 /* FreeBSD bug? socket level opts at non socket level */ 1475 bsd_args.level = 0; 1476 break; 1477 } 1478 switch (name) { 1479 case SO_RCVTIMEO: 1480 /* FALLTHROUGH */ 1481 case SO_SNDTIMEO: 1482 error = copyin(PTRIN(args->optval), &linux_tv, 1483 sizeof(linux_tv)); 1484 if (error) 1485 return (error); 1486 tv.tv_sec = linux_tv.tv_sec; 1487 tv.tv_usec = linux_tv.tv_usec; 1488 return (kern_setsockopt(td, args->s, bsd_args.level, 1489 name, &tv, UIO_SYSSPACE, sizeof(tv))); 1490 /* NOTREACHED */ 1491 break; 1492 default: 1493 break; 1494 } 1495 break; 1496 case IPPROTO_IP: 1497 name = linux_to_bsd_ip_sockopt(args->optname); 1498 break; 1499 case IPPROTO_TCP: 1500 /* Linux TCP option values match BSD's */ 1501 name = args->optname; 1502 break; 1503 default: 1504 name = -1; 1505 break; 1506 } 1507 if (name == -1) 1508 return (ENOPROTOOPT); 1509 1510 bsd_args.name = name; 1511 bsd_args.val = PTRIN(args->optval); 1512 bsd_args.valsize = args->optlen; 1513 1514 if (name == IPV6_NEXTHOP) { 1515 linux_to_bsd_sockaddr((struct sockaddr *)bsd_args.val, 1516 bsd_args.valsize); 1517 error = setsockopt(td, &bsd_args); 1518 bsd_to_linux_sockaddr((struct sockaddr *)bsd_args.val); 1519 } else 1520 error = setsockopt(td, &bsd_args); 1521 1522 return (error); 1523 } 1524 1525 struct linux_getsockopt_args { 1526 int s; 1527 int level; 1528 int optname; 1529 l_uintptr_t optval; 1530 l_uintptr_t optlen; 1531 }; 1532 1533 static int 1534 linux_getsockopt(struct thread *td, struct linux_getsockopt_args *args) 1535 { 1536 struct getsockopt_args /* { 1537 int s; 1538 int level; 1539 int name; 1540 caddr_t val; 1541 int *avalsize; 1542 } */ bsd_args; 1543 l_timeval linux_tv; 1544 struct timeval tv; 1545 socklen_t tv_len, xulen; 1546 struct xucred xu; 1547 struct l_ucred lxu; 1548 int error, name; 1549 1550 bsd_args.s = args->s; 1551 bsd_args.level = linux_to_bsd_sockopt_level(args->level); 1552 switch (bsd_args.level) { 1553 case SOL_SOCKET: 1554 name = linux_to_bsd_so_sockopt(args->optname); 1555 switch (args->optname) { 1556 case LINUX_SO_PASSCRED: 1557 /* FreeBSD bug? socket level opts at non socket level */ 1558 bsd_args.level = 0; 1559 break; 1560 } 1561 switch (name) { 1562 case SO_RCVTIMEO: 1563 /* FALLTHROUGH */ 1564 case SO_SNDTIMEO: 1565 tv_len = sizeof(tv); 1566 error = kern_getsockopt(td, args->s, bsd_args.level, 1567 name, &tv, UIO_SYSSPACE, &tv_len); 1568 if (error) 1569 return (error); 1570 linux_tv.tv_sec = tv.tv_sec; 1571 linux_tv.tv_usec = tv.tv_usec; 1572 return (copyout(&linux_tv, PTRIN(args->optval), 1573 sizeof(linux_tv))); 1574 /* NOTREACHED */ 1575 break; 1576 case LOCAL_PEERCRED: 1577 if (args->optlen != sizeof(lxu)) 1578 return (EINVAL); 1579 xulen = sizeof(xu); 1580 error = kern_getsockopt(td, args->s, bsd_args.level, 1581 name, &xu, UIO_SYSSPACE, &xulen); 1582 if (error) 1583 return (error); 1584 /* 1585 * XXX Use 0 for pid as the FreeBSD does not cache peer pid. 1586 */ 1587 lxu.pid = 0; 1588 lxu.uid = xu.cr_uid; 1589 lxu.gid = xu.cr_gid; 1590 return (copyout(&lxu, PTRIN(args->optval), sizeof(lxu))); 1591 /* NOTREACHED */ 1592 break; 1593 default: 1594 break; 1595 } 1596 break; 1597 case IPPROTO_IP: 1598 name = linux_to_bsd_ip_sockopt(args->optname); 1599 break; 1600 case IPPROTO_TCP: 1601 /* Linux TCP option values match BSD's */ 1602 name = args->optname; 1603 break; 1604 default: 1605 name = -1; 1606 break; 1607 } 1608 if (name == -1) 1609 return (EINVAL); 1610 1611 bsd_args.name = name; 1612 bsd_args.val = PTRIN(args->optval); 1613 bsd_args.avalsize = PTRIN(args->optlen); 1614 1615 if (name == IPV6_NEXTHOP) { 1616 error = getsockopt(td, &bsd_args); 1617 bsd_to_linux_sockaddr((struct sockaddr *)bsd_args.val); 1618 } else 1619 error = getsockopt(td, &bsd_args); 1620 1621 return (error); 1622 } 1623 1624 /* Argument list sizes for linux_socketcall */ 1625 1626 #define LINUX_AL(x) ((x) * sizeof(l_ulong)) 1627 1628 static const unsigned char lxs_args[] = { 1629 LINUX_AL(0) /* unused*/, LINUX_AL(3) /* socket */, 1630 LINUX_AL(3) /* bind */, LINUX_AL(3) /* connect */, 1631 LINUX_AL(2) /* listen */, LINUX_AL(3) /* accept */, 1632 LINUX_AL(3) /* getsockname */, LINUX_AL(3) /* getpeername */, 1633 LINUX_AL(4) /* socketpair */, LINUX_AL(4) /* send */, 1634 LINUX_AL(4) /* recv */, LINUX_AL(6) /* sendto */, 1635 LINUX_AL(6) /* recvfrom */, LINUX_AL(2) /* shutdown */, 1636 LINUX_AL(5) /* setsockopt */, LINUX_AL(5) /* getsockopt */, 1637 LINUX_AL(3) /* sendmsg */, LINUX_AL(3) /* recvmsg */, 1638 LINUX_AL(4) /* accept4 */ 1639 }; 1640 1641 #define LINUX_AL_SIZE sizeof(lxs_args) / sizeof(lxs_args[0]) - 1 1642 1643 int 1644 linux_socketcall(struct thread *td, struct linux_socketcall_args *args) 1645 { 1646 l_ulong a[6]; 1647 void *arg; 1648 int error; 1649 1650 if (args->what < LINUX_SOCKET || args->what > LINUX_AL_SIZE) 1651 return (EINVAL); 1652 error = copyin(PTRIN(args->args), a, lxs_args[args->what]); 1653 if (error) 1654 return (error); 1655 1656 arg = a; 1657 switch (args->what) { 1658 case LINUX_SOCKET: 1659 return (linux_socket(td, arg)); 1660 case LINUX_BIND: 1661 return (linux_bind(td, arg)); 1662 case LINUX_CONNECT: 1663 return (linux_connect(td, arg)); 1664 case LINUX_LISTEN: 1665 return (linux_listen(td, arg)); 1666 case LINUX_ACCEPT: 1667 return (linux_accept(td, arg)); 1668 case LINUX_GETSOCKNAME: 1669 return (linux_getsockname(td, arg)); 1670 case LINUX_GETPEERNAME: 1671 return (linux_getpeername(td, arg)); 1672 case LINUX_SOCKETPAIR: 1673 return (linux_socketpair(td, arg)); 1674 case LINUX_SEND: 1675 return (linux_send(td, arg)); 1676 case LINUX_RECV: 1677 return (linux_recv(td, arg)); 1678 case LINUX_SENDTO: 1679 return (linux_sendto(td, arg)); 1680 case LINUX_RECVFROM: 1681 return (linux_recvfrom(td, arg)); 1682 case LINUX_SHUTDOWN: 1683 return (linux_shutdown(td, arg)); 1684 case LINUX_SETSOCKOPT: 1685 return (linux_setsockopt(td, arg)); 1686 case LINUX_GETSOCKOPT: 1687 return (linux_getsockopt(td, arg)); 1688 case LINUX_SENDMSG: 1689 return (linux_sendmsg(td, arg)); 1690 case LINUX_RECVMSG: 1691 return (linux_recvmsg(td, arg)); 1692 case LINUX_ACCEPT4: 1693 return (linux_accept4(td, arg)); 1694 } 1695 1696 uprintf("LINUX: 'socket' typ=%d not implemented\n", args->what); 1697 return (ENOSYS); 1698 } 1699