sys/compat/linux/linux_socket.c

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