sys/emulation/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 withough 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  * $FreeBSD: src/sys/compat/linux/linux_socket.c,v 1.19.2.8 2001/11/07 20:33:55 marcel Exp $
  29  * $DragonFly: src/sys/emulation/linux/linux_socket.c,v 1.28 2008/07/10 00:19:27 aggelos Exp $
  30  */
  31
  32 #include <sys/param.h>
  33 #include <sys/proc.h>
  34 #include <sys/systm.h>
  35 #include <sys/sysproto.h>
  36 #include <sys/fcntl.h>
  37 #include <sys/file.h>
  38 #include <sys/kern_syscall.h>
  39 #include <sys/socket.h>
  40 #include <sys/socketvar.h>
  41 #include <sys/uio.h>
  42 #include <sys/malloc.h>
  43 #include <sys/mbuf.h>
  44
  45 #include <netinet/in.h>
  46 #include <netinet/in_systm.h>
  47 #include <netinet/ip.h>
  48
  49 #include <arch_linux/linux.h>
  50 #include <arch_linux/linux_proto.h>
  51 #include "linux_socket.h"
  52 #include "linux_util.h"
  53
  54 /*
  55  * Copyin a sockaddr structure provided by a Linux binary.  Linux uses
  56  * the 4.3BSD sockaddr structure which has no sa_len field.  We must
  57  * pass 4.4BSD sockaddr structures when we call native functions in the
  58  * BSD kernel.  This function does the conversion for us.
  59  *
  60  * Also, our socket calls require the sockaddr structure length to agree
  61  * with the address family.  Linux does not, so we must force it.
  62  *
  63  * This function should only need to be called from linux_connect()
  64  * and linux_bind().
  65  */
  66 static int
  67 linux_getsockaddr(struct sockaddr **namp, struct sockaddr *uaddr, size_t len)
  68 {
  69         struct sockaddr *sa;
  70         uint16_t family;        /* XXX: must match Linux sockaddr */
  71         int error;
  72         int sa_len;
  73
  74         *namp = NULL;
  75
  76         if (len > SOCK_MAXADDRLEN)
  77                 return ENAMETOOLONG;
  78         error = copyin(uaddr, &family, sizeof(family));
  79         if (error)
  80                 return (error);
  81
  82         /*
  83          * Force the sa_len field to match the address family.
  84          */
  85         switch (family) {
  86         case AF_INET:
  87                 sa_len = sizeof(struct sockaddr_in);
  88                 break;
  89         case AF_INET6:
  90                 sa_len = sizeof(struct sockaddr_in6);
  91                 break;
  92         default:
  93                 /*
  94                  * This is the default behavior of the old
  95                  * linux_to_bsd_namelen() function.  NOTE!  The
  96                  * minimum length we allocate must cover sa->sa_len and
  97                  * sa->sa_family.
  98                  */
  99                 sa_len = offsetof(struct sockaddr, sa_data[0]);
 100                 if (sa_len < len)
 101                         sa_len = len;
 102                 break;
 103         }
 104
 105         MALLOC(sa, struct sockaddr *, sa_len, M_SONAME, M_WAITOK);
 106         error = copyin(uaddr, sa, sa_len);
 107         if (error) {
 108                 FREE(sa, M_SONAME);
 109         } else {
 110                 /*
 111                  * Convert to the 4.4BSD sockaddr structure.
 112                  */
 113                 sa->sa_family = *(sa_family_t *)sa;
 114                 sa->sa_len = sa_len;
 115                 *namp = sa;
 116         }
 117
 118         return (error);
 119 }
 120
 121 /*
 122  * Transform a 4.4BSD sockaddr structure into a Linux sockaddr structure
 123  * and copy it out to a user address.
 124  */
 125 static int
 126 linux_copyout_sockaddr(struct sockaddr *sa, struct sockaddr *uaddr, int sa_len)
 127 {
 128         int error;
 129
 130         if (sa_len < (int)sizeof(u_short))
 131                 return (EINVAL);
 132
 133         *(u_short *)sa = sa->sa_family;
 134         error = copyout(sa, uaddr, sa_len);
 135
 136         return (error);
 137 }
 138
 139 static int
 140 linux_to_bsd_domain(int domain)
 141 {
 142
 143         switch (domain) {
 144         case LINUX_AF_UNSPEC:
 145                 return (AF_UNSPEC);
 146         case LINUX_AF_UNIX:
 147                 return (AF_LOCAL);
 148         case LINUX_AF_INET:
 149                 return (AF_INET);
 150         case LINUX_AF_AX25:
 151                 return (AF_CCITT);
 152         case LINUX_AF_IPX:
 153                 return (AF_IPX);
 154         case LINUX_AF_APPLETALK:
 155                 return (AF_APPLETALK);
 156         }
 157         return (-1);
 158 }
 159
 160 static int
 161 linux_to_bsd_sockopt_level(int level)
 162 {
 163
 164         switch (level) {
 165         case LINUX_SOL_SOCKET:
 166                 return (SOL_SOCKET);
 167         }
 168         return (level);
 169 }
 170
 171 static int
 172 linux_to_bsd_ip_sockopt(int opt)
 173 {
 174
 175         switch (opt) {
 176         case LINUX_IP_TOS:
 177                 return (IP_TOS);
 178         case LINUX_IP_TTL:
 179                 return (IP_TTL);
 180         case LINUX_IP_OPTIONS:
 181                 return (IP_OPTIONS);
 182         case LINUX_IP_MULTICAST_IF:
 183                 return (IP_MULTICAST_IF);
 184         case LINUX_IP_MULTICAST_TTL:
 185                 return (IP_MULTICAST_TTL);
 186         case LINUX_IP_MULTICAST_LOOP:
 187                 return (IP_MULTICAST_LOOP);
 188         case LINUX_IP_ADD_MEMBERSHIP:
 189                 return (IP_ADD_MEMBERSHIP);
 190         case LINUX_IP_DROP_MEMBERSHIP:
 191                 return (IP_DROP_MEMBERSHIP);
 192         case LINUX_IP_HDRINCL:
 193                 return (IP_HDRINCL);
 194         }
 195         return (-1);
 196 }
 197
 198 static int
 199 linux_to_bsd_so_sockopt(int opt)
 200 {
 201
 202         switch (opt) {
 203         case LINUX_SO_DEBUG:
 204                 return (SO_DEBUG);
 205         case LINUX_SO_REUSEADDR:
 206                 return (SO_REUSEADDR);
 207         case LINUX_SO_TYPE:
 208                 return (SO_TYPE);
 209         case LINUX_SO_ERROR:
 210                 return (SO_ERROR);
 211         case LINUX_SO_DONTROUTE:
 212                 return (SO_DONTROUTE);
 213         case LINUX_SO_BROADCAST:
 214                 return (SO_BROADCAST);
 215         case LINUX_SO_SNDBUF:
 216                 return (SO_SNDBUF);
 217         case LINUX_SO_RCVBUF:
 218                 return (SO_RCVBUF);
 219         case LINUX_SO_KEEPALIVE:
 220                 return (SO_KEEPALIVE);
 221         case LINUX_SO_OOBINLINE:
 222                 return (SO_OOBINLINE);
 223         case LINUX_SO_LINGER:
 224                 return (SO_LINGER);
 225         }
 226         return (-1);
 227 }
 228
 229 static int
 230 linux_to_bsd_msg_flags(int flags)
 231 {
 232         int ret_flags = 0;
 233
 234         if (flags & LINUX_MSG_OOB)
 235                 ret_flags |= MSG_OOB;
 236         if (flags & LINUX_MSG_PEEK)
 237                 ret_flags |= MSG_PEEK;
 238         if (flags & LINUX_MSG_DONTROUTE)
 239                 ret_flags |= MSG_DONTROUTE;
 240         if (flags & LINUX_MSG_CTRUNC)
 241                 ret_flags |= MSG_CTRUNC;
 242         if (flags & LINUX_MSG_TRUNC)
 243                 ret_flags |= MSG_TRUNC;
 244         if (flags & LINUX_MSG_DONTWAIT)
 245                 ret_flags |= MSG_DONTWAIT;
 246         if (flags & LINUX_MSG_EOR)
 247                 ret_flags |= MSG_EOR;
 248         if (flags & LINUX_MSG_WAITALL)
 249                 ret_flags |= MSG_WAITALL;
 250 #if 0 /* not handled */
 251         if (flags & LINUX_MSG_PROXY)
 252                 ;
 253         if (flags & LINUX_MSG_FIN)
 254                 ;
 255         if (flags & LINUX_MSG_SYN)
 256                 ;
 257         if (flags & LINUX_MSG_CONFIRM)
 258                 ;
 259         if (flags & LINUX_MSG_RST)
 260                 ;
 261         if (flags & LINUX_MSG_ERRQUEUE)
 262                 ;
 263         if (flags & LINUX_MSG_NOSIGNAL)
 264                 ;
 265 #endif
 266         return ret_flags;
 267 }
 268
 269 struct linux_socket_args {
 270         int domain;
 271         int type;
 272         int protocol;
 273 };
 274
 275 static int
 276 linux_socket(struct linux_socket_args *args, int *res)
 277 {
 278         struct linux_socket_args linux_args;
 279         struct sockopt sopt;
 280         int error, domain, optval;
 281
 282         error = copyin(args, &linux_args, sizeof(linux_args));
 283         if (error)
 284                 return (error);
 285
 286         domain = linux_to_bsd_domain(linux_args.domain);
 287         if (domain == -1)
 288                 return (EINVAL);
 289
 290         error = kern_socket(domain, linux_args.type, linux_args.protocol, res);
 291
 292         /* Copy back the return value from socket() */
 293         if (error == 0 && linux_args.type == SOCK_RAW &&
 294             (linux_args.protocol == IPPROTO_RAW || linux_args.protocol == 0) &&
 295             linux_args.domain == AF_INET) {
 296                 /* It's a raw IP socket: set the IP_HDRINCL option. */
 297                 optval = 1;
 298                 sopt.sopt_dir = SOPT_SET;
 299                 sopt.sopt_level = IPPROTO_IP;
 300                 sopt.sopt_name = IP_HDRINCL;
 301                 sopt.sopt_val = &optval;
 302                 sopt.sopt_valsize = sizeof(optval);
 303                 sopt.sopt_td = NULL;
 304
 305                 /* We ignore any error returned by setsockopt() */
 306                 kern_setsockopt(*res, &sopt);
 307         }
 308
 309         return (error);
 310 }
 311
 312 struct linux_bind_args {
 313         int s;
 314         struct sockaddr *name;
 315         int namelen;
 316 };
 317
 318 static int
 319 linux_bind(struct linux_bind_args *args, int *res)
 320 {
 321         struct linux_bind_args linux_args;
 322         struct sockaddr *sa;
 323         int error;
 324
 325         error = copyin(args, &linux_args, sizeof(linux_args));
 326         if (error)
 327                 return (error);
 328         error = linux_getsockaddr(&sa, linux_args.name, linux_args.namelen);
 329         if (error)
 330                 return (error);
 331
 332         error = kern_bind(linux_args.s, sa);
 333         FREE(sa, M_SONAME);
 334
 335         return (error);
 336 }
 337
 338 struct linux_connect_args {
 339         int s;
 340         struct sockaddr * name;
 341         int namelen;
 342 };
 343
 344 static int
 345 linux_connect(struct linux_connect_args *args, int *res)
 346 {
 347         struct thread *td = curthread;  /* XXX */
 348         struct proc *p = td->td_proc;
 349         struct linux_connect_args linux_args;
 350         struct sockaddr *sa;
 351         struct socket *so;
 352         struct file *fp;
 353         int error;
 354
 355         KKASSERT(p);
 356
 357         error = copyin(args, &linux_args, sizeof(linux_args));
 358         if (error)
 359                 return (error);
 360         error = linux_getsockaddr(&sa, linux_args.name, linux_args.namelen);
 361         if (error)
 362                 return (error);
 363
 364         error = kern_connect(linux_args.s, 0, sa);
 365         FREE(sa, M_SONAME);
 366
 367         if (error != EISCONN)
 368                 return (error);
 369
 370         /*
 371          * Linux doesn't return EISCONN the first time it occurs,
 372          * when on a non-blocking socket. Instead it returns the
 373          * error getsockopt(SOL_SOCKET, SO_ERROR) would return on BSD.
 374          */
 375         error = holdsock(p->p_fd, linux_args.s, &fp);
 376         if (error)
 377                 return (error);
 378         error = EISCONN;
 379         if (fp->f_flag & FNONBLOCK) {
 380                 so = (struct socket *)fp->f_data;
 381                 if (so->so_emuldata == 0)
 382                         error = so->so_error;
 383                 so->so_emuldata = (void *)1;
 384         }
 385         fdrop(fp);
 386         return (error);
 387 }
 388
 389 struct linux_listen_args {
 390         int s;
 391         int backlog;
 392 };
 393
 394 static int
 395 linux_listen(struct linux_listen_args *args, int *res)
 396 {
 397         struct linux_listen_args linux_args;
 398         int error;
 399
 400         error = copyin(args, &linux_args, sizeof(linux_args));
 401         if (error)
 402                 return (error);
 403
 404         error = kern_listen(linux_args.s, linux_args.backlog);
 405
 406         return(error);
 407 }
 408
 409 struct linux_accept_args {
 410         int s;
 411         struct sockaddr *addr;
 412         int *namelen;
 413 };
 414
 415 static int
 416 linux_accept(struct linux_accept_args *args, int *res)
 417 {
 418         struct thread *td = curthread;
 419         struct linux_accept_args linux_args;
 420         struct sockaddr *sa = NULL;
 421         union fcntl_dat dat = { 0 };
 422         int error, sa_len;
 423
 424         error = copyin(args, &linux_args, sizeof(linux_args));
 425         if (error)
 426                 return (error);
 427
 428         if (linux_args.addr) {
 429                 error = copyin(linux_args.namelen, &sa_len, sizeof(sa_len));
 430                 if (error)
 431                         return (error);
 432
 433                 error = kern_accept(linux_args.s, 0, &sa, &sa_len, res);
 434
 435                 if (error) {
 436                         /*
 437                          * Return a namelen of zero for older code which
 438                          * might ignore the return value from accept().
 439                          */
 440                         sa_len = 0;
 441                         copyout(&sa_len, linux_args.namelen,
 442                             sizeof(*linux_args.namelen));
 443                 } else {
 444                         error = linux_copyout_sockaddr(sa, linux_args.addr,
 445                             sa_len);
 446                         if (error == 0) {
 447                                 error = copyout(&sa_len, linux_args.namelen,
 448                                     sizeof(*linux_args.namelen));
 449                         }
 450                 }
 451                 if (sa)
 452                         FREE(sa, M_SONAME);
 453         } else {
 454                 error = kern_accept(linux_args.s, 0, NULL, 0, res);
 455         }
 456
 457         if (error)
 458                 return (error);
 459
 460         /*
 461          * linux appears not to copy flags from the parent socket to the
 462          * accepted one, so we must clear the flags in the new descriptor.
 463          * Ignore any errors, because we already have an open fd.
 464          */
 465         kern_fcntl(*res, F_SETFL, &dat, td->td_ucred);
 466         return (0);
 467 }
 468
 469 struct linux_getsockname_args {
 470         int s;
 471         struct sockaddr *addr;
 472         int *namelen;
 473 };
 474
 475 static int
 476 linux_getsockname(struct linux_getsockname_args *args, int *res)
 477 {
 478         struct linux_getsockname_args linux_args;
 479         struct sockaddr *sa = NULL;
 480         int error, sa_len;
 481
 482
 483         error = copyin(args, &linux_args, sizeof(linux_args));
 484         if (error)
 485                 return (error);
 486         error = copyin(linux_args.namelen, &sa_len, sizeof(sa_len));
 487         if (error)
 488                 return (error);
 489
 490         error = kern_getsockname(linux_args.s, &sa, &sa_len);
 491
 492         if (error == 0)
 493                 error = linux_copyout_sockaddr(sa, linux_args.addr, sa_len);
 494         if (error == 0)
 495                 error = copyout(&sa_len, linux_args.namelen,
 496                     sizeof(*linux_args.namelen));
 497         if (sa)
 498                 FREE(sa, M_SONAME);
 499         return(error);
 500 }
 501
 502 struct linux_getpeername_args {
 503         int s;
 504         struct sockaddr *addr;
 505         int *namelen;
 506 };
 507
 508 static int
 509 linux_getpeername(struct linux_getpeername_args *args, int *res)
 510 {
 511         struct linux_getpeername_args linux_args;
 512         struct sockaddr *sa = NULL;
 513         int error, sa_len;
 514
 515         error = copyin(args, &linux_args, sizeof(linux_args));
 516         if (error)
 517                 return (error);
 518         error = copyin(linux_args.namelen, &sa_len, sizeof(sa_len));
 519         if (error)
 520                 return (error);
 521
 522         error = kern_getpeername(linux_args.s, &sa, &sa_len);
 523
 524         if (error == 0)
 525                 error = linux_copyout_sockaddr(sa, linux_args.addr, sa_len);
 526         if (error == 0)
 527                 error = copyout(&sa_len, linux_args.namelen,
 528                     sizeof(*linux_args.namelen));
 529         if (sa)
 530                 FREE(sa, M_SONAME);
 531         return(error);
 532 }
 533
 534 struct linux_socketpair_args {
 535         int domain;
 536         int type;
 537         int protocol;
 538         int *rsv;
 539 };
 540
 541 static int
 542 linux_socketpair(struct linux_socketpair_args *args, int *res)
 543 {
 544         struct linux_socketpair_args linux_args;
 545         int error, domain, sockv[2];
 546
 547         error = copyin(args, &linux_args, sizeof(linux_args));
 548         if (error)
 549                 return (error);
 550
 551         domain = linux_to_bsd_domain(linux_args.domain);
 552         if (domain == -1)
 553                 return (EINVAL);
 554         error = kern_socketpair(domain, linux_args.type, linux_args.protocol,
 555             sockv);
 556
 557         if (error == 0)
 558                 error = copyout(sockv, linux_args.rsv, sizeof(sockv));
 559         return(error);
 560 }
 561
 562 struct linux_send_args {
 563         int s;
 564         void *msg;
 565         int len;
 566         int flags;
 567 };
 568
 569 static int
 570 linux_send(struct linux_send_args *args, size_t *res)
 571 {
 572         struct linux_send_args linux_args;
 573         struct thread *td = curthread;
 574         struct uio auio;
 575         struct iovec aiov;
 576         int error;
 577
 578         error = copyin(args, &linux_args, sizeof(linux_args));
 579         if (error)
 580                 return (error);
 581
 582         aiov.iov_base = linux_args.msg;
 583         aiov.iov_len = linux_args.len;
 584         auio.uio_iov = &aiov;
 585         auio.uio_iovcnt = 1;
 586         auio.uio_offset = 0;
 587         auio.uio_resid = linux_args.len;
 588         auio.uio_segflg = UIO_USERSPACE;
 589         auio.uio_rw = UIO_WRITE;
 590         auio.uio_td = td;
 591
 592         error = kern_sendmsg(linux_args.s, NULL, &auio, NULL,
 593                              linux_args.flags, res);
 594
 595         return(error);
 596 }
 597
 598 struct linux_recv_args {
 599         int s;
 600         void *msg;
 601         int len;
 602         int flags;
 603 };
 604
 605 static int
 606 linux_recv(struct linux_recv_args *args, size_t *res)
 607 {
 608         struct linux_recv_args linux_args;
 609         struct thread *td = curthread;
 610         struct uio auio;
 611         struct iovec aiov;
 612         int error;
 613
 614         error = copyin(args, &linux_args, sizeof(linux_args));
 615         if (error)
 616                 return (error);
 617
 618         aiov.iov_base = linux_args.msg;
 619         aiov.iov_len = linux_args.len;
 620         auio.uio_iov = &aiov;
 621         auio.uio_iovcnt = 1;
 622         auio.uio_offset = 0;
 623         auio.uio_resid = linux_args.len;
 624         auio.uio_segflg = UIO_USERSPACE;
 625         auio.uio_rw = UIO_READ;
 626         auio.uio_td = td;
 627
 628         error = kern_recvmsg(linux_args.s, NULL, &auio, NULL,
 629                              &linux_args.flags, res);
 630
 631         return(error);
 632 }
 633
 634 struct linux_sendto_args {
 635         int s;
 636         void *msg;
 637         int len;
 638         int flags;
 639         struct sockaddr *to;
 640         int tolen;
 641 };
 642
 643 static int
 644 linux_sendto(struct linux_sendto_args *args, size_t *res)
 645 {
 646         struct linux_sendto_args linux_args;
 647         struct thread *td = curthread;
 648         struct uio auio;
 649         struct iovec aiov;
 650         struct sockopt sopt;
 651         struct sockaddr *sa = NULL;
 652         caddr_t msg = NULL;
 653         int error, optval;
 654
 655         error = copyin(args, &linux_args, sizeof(linux_args));
 656         if (error)
 657                 return (error);
 658
 659         if (linux_args.to) {
 660                 error = linux_getsockaddr(&sa, linux_args.to,
 661                     linux_args.tolen);
 662                 if (error)
 663                         return (error);
 664         }
 665
 666         /*
 667          * Check to see if the IP_HDRINCL option is set.
 668          */
 669         sopt.sopt_dir = SOPT_GET;
 670         sopt.sopt_level = IPPROTO_IP;
 671         sopt.sopt_name = IP_HDRINCL;
 672         sopt.sopt_val = &optval;
 673         sopt.sopt_valsize = sizeof(optval);
 674         sopt.sopt_td = NULL;
 675
 676         if (kern_getsockopt(linux_args.s, &sopt) != 0)
 677                 optval = 0;
 678
 679         if (optval == 0) {
 680                 /*
 681                  * IP_HDRINCL is not set.  Package the message as usual.
 682                  */
 683                 aiov.iov_base = linux_args.msg;
 684                 aiov.iov_len = linux_args.len;
 685                 auio.uio_iov = &aiov;
 686                 auio.uio_iovcnt = 1;
 687                 auio.uio_offset = 0;
 688                 auio.uio_resid = linux_args.len;
 689                 auio.uio_segflg = UIO_USERSPACE;
 690                 auio.uio_rw = UIO_WRITE;
 691                 auio.uio_td = td;
 692         } else {
 693                 /*
 694                  * IP_HDRINCL is set.  We must convert the beginning of
 695                  * the packet header so we can feed it to the BSD kernel.
 696                  */
 697
 698                 /*
 699                  * Check that the packet header is long enough to contain
 700                  * the fields of interest.  This relies on the fact that
 701                  * the fragment offset field comes after the length field.
 702                  */
 703                 if (linux_args.len < offsetof(struct ip, ip_off))
 704                         return (EINVAL);
 705
 706                 MALLOC(msg, caddr_t, linux_args.len, M_LINUX, M_WAITOK);
 707                 error = copyin(linux_args.msg, msg, linux_args.len);
 708                 if (error)
 709                         goto cleanup;
 710
 711                 /* Fix the ip_len and ip_off fields.  */
 712                 ((struct ip *)msg)->ip_len = linux_args.len;
 713                 ((struct ip *)msg)->ip_off = ntohs(((struct ip *)msg)->ip_off);
 714
 715                 aiov.iov_base = msg;
 716                 aiov.iov_len = linux_args.len;
 717                 auio.uio_iov = &aiov;
 718                 auio.uio_iovcnt = 1;
 719                 auio.uio_offset = 0;
 720                 auio.uio_resid = linux_args.len;
 721                 auio.uio_segflg = UIO_SYSSPACE;
 722                 auio.uio_rw = UIO_WRITE;
 723                 auio.uio_td = td;
 724         }
 725
 726         error = kern_sendmsg(linux_args.s, sa, &auio, NULL,
 727                              linux_args.flags, res);
 728
 729 cleanup:
 730         if (sa)
 731                 FREE(sa, M_SONAME);
 732         if (msg)
 733                 FREE(msg, M_LINUX);
 734         return(error);
 735 }
 736
 737 struct linux_recvfrom_args {
 738         int s;
 739         void *buf;
 740         int len;
 741         int flags;
 742         struct sockaddr *from;
 743         int *fromlen;
 744 };
 745
 746 static int
 747 linux_recvfrom(struct linux_recvfrom_args *args, size_t *res)
 748 {
 749         struct linux_recvfrom_args linux_args;
 750         struct thread *td = curthread;
 751         struct uio auio;
 752         struct iovec aiov;
 753         struct sockaddr *sa = NULL;
 754         int error, fromlen, flags;
 755
 756         error = copyin(args, &linux_args, sizeof(linux_args));
 757         if (error)
 758                 return (error);
 759
 760         if (linux_args.from && linux_args.fromlen) {
 761                 error = copyin(linux_args.fromlen, &fromlen, sizeof(fromlen));
 762                 if (error)
 763                         return (error);
 764                 if (fromlen < 0)
 765                         return (EINVAL);
 766         } else {
 767                 fromlen = 0;
 768         }
 769         aiov.iov_base = linux_args.buf;
 770         aiov.iov_len = linux_args.len;
 771         auio.uio_iov = &aiov;
 772         auio.uio_iovcnt = 1;
 773         auio.uio_offset = 0;
 774         auio.uio_resid = linux_args.len;
 775         auio.uio_segflg = UIO_USERSPACE;
 776         auio.uio_rw = UIO_READ;
 777         auio.uio_td = td;
 778
 779         flags = linux_to_bsd_msg_flags(linux_args.flags);
 780
 781         error = kern_recvmsg(linux_args.s, linux_args.from ? &sa : NULL, &auio,
 782                              NULL, &flags, res);
 783
 784         if (error == 0 && linux_args.from) {
 785                 if (sa != NULL) {
 786                         fromlen = MIN(fromlen, sa->sa_len);
 787                         error = linux_copyout_sockaddr(sa, linux_args.from,
 788                                                         fromlen);
 789                 } else
 790                         fromlen = 0;
 791                 if (error == 0)
 792                         copyout(&fromlen, linux_args.fromlen,
 793                             sizeof(fromlen));
 794         }
 795         if (sa)
 796                 FREE(sa, M_SONAME);
 797
 798         return(error);
 799 }
 800
 801 struct linux_sendmsg_args {
 802         int s;
 803         struct msghdr *msg;
 804         int flags;
 805 };
 806
 807 static int
 808 linux_sendmsg(struct linux_sendmsg_args *args, size_t *res)
 809 {
 810         struct linux_sendmsg_args linux_args;
 811         struct thread *td = curthread;
 812         struct msghdr msg;
 813         struct uio auio;
 814         struct iovec aiov[UIO_SMALLIOV], *iov = NULL;
 815         struct sockaddr *sa = NULL;
 816         struct mbuf *control = NULL;
 817         int error;
 818
 819         error = copyin(args, &linux_args, sizeof(linux_args));
 820         if (error)
 821                 return (error);
 822
 823         error = copyin(linux_args.msg, &msg, sizeof(msg));
 824         if (error)
 825                 return (error);
 826
 827         /*
 828          * Conditionally copyin msg.msg_name.
 829          */
 830         if (msg.msg_name) {
 831                 error = linux_getsockaddr(&sa, msg.msg_name, msg.msg_namelen);
 832                 if (error)
 833                         return (error);
 834         }
 835
 836         /*
 837          * Populate auio.
 838          */
 839         error = iovec_copyin(msg.msg_iov, &iov, aiov, msg.msg_iovlen,
 840                              &auio.uio_resid);
 841         if (error)
 842                 goto cleanup2;
 843         auio.uio_iov = iov;
 844         auio.uio_iovcnt = msg.msg_iovlen;
 845         auio.uio_offset = 0;
 846         auio.uio_segflg = UIO_USERSPACE;
 847         auio.uio_rw = UIO_WRITE;
 848         auio.uio_td = td;
 849
 850         /*
 851          * Conditionally copyin msg.msg_control.
 852          */
 853         if (msg.msg_control) {
 854                 if (msg.msg_controllen < sizeof(struct cmsghdr) ||
 855                     msg.msg_controllen > MLEN) {
 856                         error = EINVAL;
 857                         goto cleanup;
 858                 }
 859                 control = m_get(MB_WAIT, MT_CONTROL);
 860                 if (control == NULL) {
 861                         error = ENOBUFS;
 862                         goto cleanup;
 863                 }
 864                 control->m_len = msg.msg_controllen;
 865                 error = copyin(msg.msg_control, mtod(control, caddr_t),
 866                     msg.msg_controllen);
 867                 if (error) {
 868                         m_free(control);
 869                         goto cleanup;
 870                 }
 871                 /*
 872                  * Linux and BSD both support SCM_RIGHTS.  If a linux binary
 873                  * wants anything else with an option level of SOL_SOCKET,
 874                  * we don't support it.
 875                  */
 876                 if (mtod(control, struct cmsghdr *)->cmsg_level ==
 877                     SOL_SOCKET &&
 878                     mtod(control, struct cmsghdr *)->cmsg_type !=
 879                     SCM_RIGHTS) {
 880                         m_free(control);
 881                         error = EINVAL;
 882                         goto cleanup;
 883                 }
 884         }
 885
 886         error = kern_sendmsg(linux_args.s, sa, &auio, control,
 887                              linux_args.flags, res);
 888
 889 cleanup:
 890         iovec_free(&iov, aiov);
 891 cleanup2:
 892         if (sa)
 893                 FREE(sa, M_SONAME);
 894         return (error);
 895 }
 896
 897 struct linux_recvmsg_args {
 898         int s;
 899         struct msghdr *msg;
 900         int flags;
 901 };
 902
 903 static int
 904 linux_recvmsg(struct linux_recvmsg_args *args, size_t *res)
 905 {
 906         struct linux_recvmsg_args linux_args;
 907         struct thread *td = curthread;
 908         struct msghdr msg;
 909         struct uio auio;
 910         struct iovec aiov[UIO_SMALLIOV], *iov = NULL;
 911         struct mbuf *m, *control = NULL;
 912         struct sockaddr *sa = NULL;
 913         caddr_t ctlbuf;
 914         socklen_t *ufromlenp, *ucontrollenp;
 915         int error, fromlen, controllen, len, flags, *uflagsp;
 916
 917         error = copyin(args, &linux_args, sizeof(linux_args));
 918         if (error)
 919                 return (error);
 920
 921         error = copyin(linux_args.msg, &msg, sizeof(struct msghdr));
 922         if (error)
 923                 return (error);
 924
 925         if (msg.msg_name && msg.msg_namelen < 0)
 926                 return (EINVAL);
 927         if (msg.msg_control && msg.msg_controllen < 0)
 928                 return (EINVAL);
 929
 930         ufromlenp = (socklen_t *)((caddr_t)linux_args.msg +
 931             offsetof(struct msghdr, msg_namelen));
 932         ucontrollenp = (socklen_t *)((caddr_t)linux_args.msg +
 933             offsetof(struct msghdr, msg_controllen));
 934         uflagsp = (int *)((caddr_t)linux_args.msg +
 935             offsetof(struct msghdr, msg_flags));
 936
 937         /*
 938          * Populate auio.
 939          */
 940         error = iovec_copyin(msg.msg_iov, &iov, aiov, msg.msg_iovlen,
 941                              &auio.uio_resid);
 942         if (error)
 943                 return (error);
 944         auio.uio_iov = iov;
 945         auio.uio_iovcnt = msg.msg_iovlen;
 946         auio.uio_offset = 0;
 947         auio.uio_segflg = UIO_USERSPACE;
 948         auio.uio_rw = UIO_READ;
 949         auio.uio_td = td;
 950
 951         flags = linux_to_bsd_msg_flags(linux_args.flags);
 952
 953         error = kern_recvmsg(linux_args.s, msg.msg_name ? &sa : NULL, &auio,
 954                              msg.msg_control ? &control : NULL, &flags, res);
 955
 956         /*
 957          * Copyout msg.msg_name and msg.msg_namelen.
 958          */
 959         if (error == 0 && msg.msg_name) {
 960                 if (sa != NULL) {
 961                         fromlen = MIN(msg.msg_namelen, sa->sa_len);
 962                         error = linux_copyout_sockaddr(sa, msg.msg_name,
 963                                                         fromlen);
 964                 } else
 965                         fromlen = 0;
 966                 if (error == 0)
 967                         error = copyout(&fromlen, ufromlenp,
 968                             sizeof(*ufromlenp));
 969         }
 970
 971         /*
 972          * Copyout msg.msg_control and msg.msg_controllen.
 973          */
 974         if (error == 0 && msg.msg_control) {
 975                 /*
 976                  * Linux and BSD both support SCM_RIGHTS.  If a linux binary
 977                  * wants anything else with an option level of SOL_SOCKET,
 978                  * we don't support it.
 979                  */
 980                 if (mtod((struct mbuf *)msg.msg_control,
 981                     struct cmsghdr *)->cmsg_level == SOL_SOCKET &&
 982                     mtod((struct mbuf *)msg.msg_control,
 983                     struct cmsghdr *)->cmsg_type != SCM_RIGHTS) {
 984                         error = EINVAL;
 985                         goto cleanup;
 986                 }
 987
 988                 len = msg.msg_controllen;
 989                 m = control;
 990                 ctlbuf = (caddr_t)msg.msg_control;
 991
 992                 while (m && len > 0) {
 993                         unsigned int tocopy;
 994
 995                         if (len >= m->m_len) {
 996                                 tocopy = m->m_len;
 997                         } else {
 998                                 msg.msg_flags |= MSG_CTRUNC;
 999                                 tocopy = len;
1000                         }
1001
1002                         error = copyout(mtod(m, caddr_t), ctlbuf,
1003                             tocopy);
1004                         if (error)
1005                                 goto cleanup;
1006
1007                         ctlbuf += tocopy;
1008                         len -= tocopy;
1009                         m = m->m_next;
1010                 }
1011                 controllen = ctlbuf - (caddr_t)msg.msg_control;
1012                 error = copyout(&controllen, ucontrollenp,
1013                     sizeof(*ucontrollenp));
1014         }
1015
1016         if (error == 0)
1017                 error = copyout(&flags, uflagsp, sizeof(*uflagsp));
1018
1019 cleanup:
1020         if (sa)
1021                 FREE(sa, M_SONAME);
1022         iovec_free(&iov, aiov);
1023         if (control)
1024                 m_freem(control);
1025         return (error);
1026 }
1027
1028 struct linux_shutdown_args {
1029         int s;
1030         int how;
1031 };
1032
1033 static int
1034 linux_shutdown(struct linux_shutdown_args *args, int *res)
1035 {
1036         struct linux_shutdown_args linux_args;
1037         int error;
1038
1039         error = copyin(args, &linux_args, sizeof(linux_args));
1040         if (error)
1041                 return (error);
1042
1043         error = kern_shutdown(linux_args.s, linux_args.how);
1044
1045         return (error);
1046 }
1047
1048 struct linux_setsockopt_args {
1049         int s;
1050         int level;
1051         int optname;
1052         void *optval;
1053         int optlen;
1054 };
1055
1056 static int
1057 linux_setsockopt(struct linux_setsockopt_args *args, int *res)
1058 {
1059         struct linux_setsockopt_args linux_args;
1060         struct thread *td = curthread;
1061         struct sockopt sopt;
1062         int error, name, level;
1063
1064         error = copyin(args, &linux_args, sizeof(linux_args));
1065         if (error)
1066                 return (error);
1067
1068         level = linux_to_bsd_sockopt_level(linux_args.level);
1069         switch (level) {
1070         case SOL_SOCKET:
1071                 name = linux_to_bsd_so_sockopt(linux_args.optname);
1072                 break;
1073         case IPPROTO_IP:
1074                 name = linux_to_bsd_ip_sockopt(linux_args.optname);
1075                 break;
1076         case IPPROTO_TCP:
1077                 /* Linux TCP option values match BSD's */
1078                 name = linux_args.optname;
1079                 break;
1080         default:
1081                 name = -1;
1082                 break;
1083         }
1084         if (name == -1)
1085                 return (EINVAL);
1086
1087         sopt.sopt_dir = SOPT_SET;
1088         sopt.sopt_level = level;
1089         sopt.sopt_name = name;
1090         sopt.sopt_valsize = linux_args.optlen;
1091         sopt.sopt_td = td;
1092
1093         if (sopt.sopt_valsize < 0 || sopt.sopt_valsize > SOMAXOPT_SIZE)
1094                 return (EINVAL);
1095
1096         if (linux_args.optval) {
1097                 sopt.sopt_val = kmalloc(sopt.sopt_valsize, M_TEMP, M_WAITOK);
1098                 error = copyin(linux_args.optval, sopt.sopt_val, sopt.sopt_valsize);
1099                 if (error)
1100                         goto out;
1101         } else {
1102                 sopt.sopt_val = NULL;
1103         }
1104         error = kern_setsockopt(linux_args.s, &sopt);
1105         if (error)
1106                 goto out;
1107         if (linux_args.optval)
1108                 error = copyout(sopt.sopt_val, linux_args.optval,
1109                                 sopt.sopt_valsize);
1110 out:
1111         if (linux_args.optval)
1112                 kfree(sopt.sopt_val, M_TEMP);
1113         return(error);
1114 }
1115
1116 struct linux_getsockopt_args {
1117         int s;
1118         int level;
1119         int optname;
1120         void *optval;
1121         int *optlen;
1122 };
1123
1124 static int
1125 linux_getsockopt(struct linux_getsockopt_args *args, int *res)
1126 {
1127         struct linux_getsockopt_args linux_args;
1128         struct thread *td = curthread;
1129         struct sockopt sopt;
1130         int error, name, valsize, level;
1131
1132         error = copyin(args, &linux_args, sizeof(linux_args));
1133         if (error)
1134                 return (error);
1135
1136         if (linux_args.optval) {
1137                 error = copyin(linux_args.optlen, &valsize, sizeof(valsize));
1138                 if (error)
1139                         return (error);
1140                 if (valsize < 0 || valsize > SOMAXOPT_SIZE)
1141                         return (EINVAL);
1142         } else {
1143                 valsize = 0;
1144         }
1145
1146         level = linux_to_bsd_sockopt_level(linux_args.level);
1147         switch (level) {
1148         case SOL_SOCKET:
1149                 name = linux_to_bsd_so_sockopt(linux_args.optname);
1150                 break;
1151         case IPPROTO_IP:
1152                 name = linux_to_bsd_ip_sockopt(linux_args.optname);
1153                 break;
1154         case IPPROTO_TCP:
1155                 /* Linux TCP option values match BSD's */
1156                 name = linux_args.optname;
1157                 break;
1158         default:
1159                 name = -1;
1160                 break;
1161         }
1162         if (name == -1)
1163                 return (EINVAL);
1164
1165         sopt.sopt_dir = SOPT_GET;
1166         sopt.sopt_level = level;
1167         sopt.sopt_name = name;
1168         sopt.sopt_valsize = valsize;
1169         sopt.sopt_td = td;
1170
1171         if (linux_args.optval) {
1172                 sopt.sopt_val = kmalloc(sopt.sopt_valsize, M_TEMP, M_WAITOK);
1173                 error = copyin(linux_args.optval, sopt.sopt_val, sopt.sopt_valsize);
1174                 if (error)
1175                         goto out;
1176         } else {
1177                 sopt.sopt_val = NULL;
1178         }
1179         error = kern_getsockopt(linux_args.s, &sopt);
1180         if (error)
1181                 goto out;
1182         valsize = sopt.sopt_valsize;
1183         error = copyout(&valsize, linux_args.optlen, sizeof(valsize));
1184         if (error)
1185                 goto out;
1186         if (linux_args.optval)
1187                 error = copyout(sopt.sopt_val, linux_args.optval, sopt.sopt_valsize);
1188 out:
1189         if (linux_args.optval)
1190                 kfree(sopt.sopt_val, M_TEMP);
1191         return(error);
1192 }
1193
1194 /*
1195  * MPALMOSTSAFE
1196  */
1197 int
1198 sys_linux_socketcall(struct linux_socketcall_args *args)
1199 {
1200         void *arg = (void *)args->args;
1201
1202         get_mplock();
1203
1204         switch (args->what) {
1205         case LINUX_SOCKET:
1206                 return (linux_socket(arg, &args->sysmsg_result));
1207         case LINUX_BIND:
1208                 return (linux_bind(arg, &args->sysmsg_result));
1209         case LINUX_CONNECT:
1210                 return (linux_connect(arg, &args->sysmsg_result));
1211         case LINUX_LISTEN:
1212                 return (linux_listen(arg, &args->sysmsg_result));
1213         case LINUX_ACCEPT:
1214                 return (linux_accept(arg, &args->sysmsg_result));
1215         case LINUX_GETSOCKNAME:
1216                 return (linux_getsockname(arg, &args->sysmsg_result));
1217         case LINUX_GETPEERNAME:
1218                 return (linux_getpeername(arg, &args->sysmsg_result));
1219         case LINUX_SOCKETPAIR:
1220                 return (linux_socketpair(arg, &args->sysmsg_result));
1221         case LINUX_SEND:
1222                 return (linux_send(arg, &args->sysmsg_szresult));
1223         case LINUX_RECV:
1224                 return (linux_recv(arg, &args->sysmsg_szresult));
1225         case LINUX_SENDTO:
1226                 return (linux_sendto(arg, &args->sysmsg_szresult));
1227         case LINUX_RECVFROM:
1228                 return (linux_recvfrom(arg, &args->sysmsg_szresult));
1229         case LINUX_SHUTDOWN:
1230                 return (linux_shutdown(arg, &args->sysmsg_result));
1231         case LINUX_SETSOCKOPT:
1232                 return (linux_setsockopt(arg, &args->sysmsg_result));
1233         case LINUX_GETSOCKOPT:
1234                 return (linux_getsockopt(arg, &args->sysmsg_result));
1235         case LINUX_SENDMSG:
1236                 return (linux_sendmsg(arg, &args->sysmsg_szresult));
1237         case LINUX_RECVMSG:
1238                 return (linux_recvmsg(arg, &args->sysmsg_szresult));
1239         }
1240         rel_mplock();
1241
1242         uprintf("LINUX: 'socket' typ=%d not implemented\n", args->what);
1243         return (ENOSYS);
1244 }