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.2 2003/06/17 04:28:19 dillon Exp $
  30  */
  31
  32 /* XXX we use functions that might not exist. */
  33 #include "opt_compat.h"
  34
  35 #ifndef COMPAT_43
  36 #error "Unable to compile Linux-emulator due to missing COMPAT_43 option!"
  37 #endif
  38
  39 #include <sys/param.h>
  40 #include <sys/proc.h>
  41 #include <sys/systm.h>
  42 #include <sys/sysproto.h>
  43 #include <sys/fcntl.h>
  44 #include <sys/file.h>
  45 #include <sys/socket.h>
  46 #include <sys/socketvar.h>
  47 #include <sys/uio.h>
  48
  49 #include <netinet/in.h>
  50 #include <netinet/in_systm.h>
  51 #include <netinet/ip.h>
  52
  53 #include <machine/../linux/linux.h>
  54 #include <machine/../linux/linux_proto.h>
  55 #include <compat/linux/linux_socket.h>
  56 #include <compat/linux/linux_util.h>
  57
  58 /*
  59  * FreeBSD's socket calls require the sockaddr struct length to agree
  60  * with the address family.  Linux does not, so we must force it.
  61  */
  62 static int
  63 linux_to_bsd_namelen(caddr_t name, int namelen)
  64 {
  65         uint16_t        family; /* XXX must match Linux sockaddr */
  66
  67         if (copyin(name, &family, sizeof(family)))
  68                 return namelen;
  69
  70         switch (family) {
  71                 case AF_INET:
  72                         return sizeof(struct sockaddr_in);
  73                 case AF_INET6:
  74                         return sizeof(struct sockaddr_in6);
  75         }
  76         return namelen;
  77 }
  78
  79 #ifndef __alpha__
  80 static int
  81 linux_to_bsd_domain(int domain)
  82 {
  83
  84         switch (domain) {
  85         case LINUX_AF_UNSPEC:
  86                 return (AF_UNSPEC);
  87         case LINUX_AF_UNIX:
  88                 return (AF_LOCAL);
  89         case LINUX_AF_INET:
  90                 return (AF_INET);
  91         case LINUX_AF_AX25:
  92                 return (AF_CCITT);
  93         case LINUX_AF_IPX:
  94                 return (AF_IPX);
  95         case LINUX_AF_APPLETALK:
  96                 return (AF_APPLETALK);
  97         }
  98         return (-1);
  99 }
 100
 101 static int
 102 linux_to_bsd_sockopt_level(int level)
 103 {
 104
 105         switch (level) {
 106         case LINUX_SOL_SOCKET:
 107                 return (SOL_SOCKET);
 108         }
 109         return (level);
 110 }
 111
 112 static int
 113 linux_to_bsd_ip_sockopt(int opt)
 114 {
 115
 116         switch (opt) {
 117         case LINUX_IP_TOS:
 118                 return (IP_TOS);
 119         case LINUX_IP_TTL:
 120                 return (IP_TTL);
 121         case LINUX_IP_OPTIONS:
 122                 return (IP_OPTIONS);
 123         case LINUX_IP_MULTICAST_IF:
 124                 return (IP_MULTICAST_IF);
 125         case LINUX_IP_MULTICAST_TTL:
 126                 return (IP_MULTICAST_TTL);
 127         case LINUX_IP_MULTICAST_LOOP:
 128                 return (IP_MULTICAST_LOOP);
 129         case LINUX_IP_ADD_MEMBERSHIP:
 130                 return (IP_ADD_MEMBERSHIP);
 131         case LINUX_IP_DROP_MEMBERSHIP:
 132                 return (IP_DROP_MEMBERSHIP);
 133         case LINUX_IP_HDRINCL:
 134                 return (IP_HDRINCL);
 135         }
 136         return (-1);
 137 }
 138
 139 static int
 140 linux_to_bsd_so_sockopt(int opt)
 141 {
 142
 143         switch (opt) {
 144         case LINUX_SO_DEBUG:
 145                 return (SO_DEBUG);
 146         case LINUX_SO_REUSEADDR:
 147                 return (SO_REUSEADDR);
 148         case LINUX_SO_TYPE:
 149                 return (SO_TYPE);
 150         case LINUX_SO_ERROR:
 151                 return (SO_ERROR);
 152         case LINUX_SO_DONTROUTE:
 153                 return (SO_DONTROUTE);
 154         case LINUX_SO_BROADCAST:
 155                 return (SO_BROADCAST);
 156         case LINUX_SO_SNDBUF:
 157                 return (SO_SNDBUF);
 158         case LINUX_SO_RCVBUF:
 159                 return (SO_RCVBUF);
 160         case LINUX_SO_KEEPALIVE:
 161                 return (SO_KEEPALIVE);
 162         case LINUX_SO_OOBINLINE:
 163                 return (SO_OOBINLINE);
 164         case LINUX_SO_LINGER:
 165                 return (SO_LINGER);
 166         }
 167         return (-1);
 168 }
 169
 170 static int
 171 linux_to_bsd_msg_flags(int flags)
 172 {
 173         int ret_flags = 0;
 174
 175         if (flags & LINUX_MSG_OOB)
 176                 ret_flags |= MSG_OOB;
 177         if (flags & LINUX_MSG_PEEK)
 178                 ret_flags |= MSG_PEEK;
 179         if (flags & LINUX_MSG_DONTROUTE)
 180                 ret_flags |= MSG_DONTROUTE;
 181         if (flags & LINUX_MSG_CTRUNC)
 182                 ret_flags |= MSG_CTRUNC;
 183         if (flags & LINUX_MSG_TRUNC)
 184                 ret_flags |= MSG_TRUNC;
 185         if (flags & LINUX_MSG_DONTWAIT)
 186                 ret_flags |= MSG_DONTWAIT;
 187         if (flags & LINUX_MSG_EOR)
 188                 ret_flags |= MSG_EOR;
 189         if (flags & LINUX_MSG_WAITALL)
 190                 ret_flags |= MSG_WAITALL;
 191 #if 0 /* not handled */
 192         if (flags & LINUX_MSG_PROXY)
 193                 ;
 194         if (flags & LINUX_MSG_FIN)
 195                 ;
 196         if (flags & LINUX_MSG_SYN)
 197                 ;
 198         if (flags & LINUX_MSG_CONFIRM)
 199                 ;
 200         if (flags & LINUX_MSG_RST)
 201                 ;
 202         if (flags & LINUX_MSG_ERRQUEUE)
 203                 ;
 204         if (flags & LINUX_MSG_NOSIGNAL)
 205                 ;
 206 #endif
 207         return ret_flags;
 208 }
 209
 210 /* Return 0 if IP_HDRINCL is set for the given socket. */
 211 static int
 212 linux_check_hdrincl(struct proc *p, int s)
 213 {
 214         struct getsockopt_args /* {
 215                 int s;
 216                 int level;
 217                 int name;
 218                 caddr_t val;
 219                 int *avalsize;
 220         } */ bsd_args;
 221         int error;
 222         caddr_t sg, val, valsize;
 223         int size_val = sizeof val;
 224         int optval;
 225
 226         sg = stackgap_init();
 227         val = stackgap_alloc(&sg, sizeof(int));
 228         valsize = stackgap_alloc(&sg, sizeof(int));
 229
 230         if ((error = copyout(&size_val, valsize, sizeof(size_val))))
 231                 return (error);
 232
 233         bsd_args.s = s;
 234         bsd_args.level = IPPROTO_IP;
 235         bsd_args.name = IP_HDRINCL;
 236         bsd_args.val = val;
 237         bsd_args.avalsize = (int *)valsize;
 238         if ((error = getsockopt(p, &bsd_args)))
 239                 return (error);
 240
 241         if ((error = copyin(val, &optval, sizeof(optval))))
 242                 return (error);
 243
 244         return (optval == 0);
 245 }
 246
 247 /*
 248  * Updated sendto() when IP_HDRINCL is set:
 249  * tweak endian-dependent fields in the IP packet.
 250  */
 251 static int
 252 linux_sendto_hdrincl(struct proc *p, struct sendto_args *bsd_args)
 253 {
 254 /*
 255  * linux_ip_copysize defines how many bytes we should copy
 256  * from the beginning of the IP packet before we customize it for BSD.
 257  * It should include all the fields we modify (ip_len and ip_off)
 258  * and be as small as possible to minimize copying overhead.
 259  */
 260 #define linux_ip_copysize       8
 261
 262         caddr_t sg;
 263         struct ip *packet;
 264         struct msghdr *msg;
 265         struct iovec *iov;
 266
 267         int error;
 268         struct  sendmsg_args /* {
 269                 int s;
 270                 caddr_t msg;
 271                 int flags;
 272         } */ sendmsg_args;
 273
 274         /* Check the packet isn't too small before we mess with it */
 275         if (bsd_args->len < linux_ip_copysize)
 276                 return (EINVAL);
 277
 278         /*
 279          * Tweaking the user buffer in place would be bad manners.
 280          * We create a corrected IP header with just the needed length,
 281          * then use an iovec to glue it to the rest of the user packet
 282          * when calling sendmsg().
 283          */
 284         sg = stackgap_init();
 285         packet = (struct ip *)stackgap_alloc(&sg, linux_ip_copysize);
 286         msg = (struct msghdr *)stackgap_alloc(&sg, sizeof(*msg));
 287         iov = (struct iovec *)stackgap_alloc(&sg, sizeof(*iov)*2);
 288
 289         /* Make a copy of the beginning of the packet to be sent */
 290         if ((error = copyin(bsd_args->buf, packet, linux_ip_copysize)))
 291                 return (error);
 292
 293         /* Convert fields from Linux to BSD raw IP socket format */
 294         packet->ip_len = bsd_args->len;
 295         packet->ip_off = ntohs(packet->ip_off);
 296
 297         /* Prepare the msghdr and iovec structures describing the new packet */
 298         msg->msg_name = bsd_args->to;
 299         msg->msg_namelen = bsd_args->tolen;
 300         msg->msg_iov = iov;
 301         msg->msg_iovlen = 2;
 302         msg->msg_control = NULL;
 303         msg->msg_controllen = 0;
 304         msg->msg_flags = 0;
 305         iov[0].iov_base = (char *)packet;
 306         iov[0].iov_len = linux_ip_copysize;
 307         iov[1].iov_base = (char *)(bsd_args->buf) + linux_ip_copysize;
 308         iov[1].iov_len = bsd_args->len - linux_ip_copysize;
 309
 310         sendmsg_args.s = bsd_args->s;
 311         sendmsg_args.msg = (caddr_t)msg;
 312         sendmsg_args.flags = bsd_args->flags;
 313         return (sendmsg(p, &sendmsg_args));
 314 }
 315
 316 struct linux_socket_args {
 317         int domain;
 318         int type;
 319         int protocol;
 320 };
 321
 322 static int
 323 linux_socket(struct proc *p, struct linux_socket_args *args)
 324 {
 325         struct linux_socket_args linux_args;
 326         struct socket_args /* {
 327                 int domain;
 328                 int type;
 329                 int protocol;
 330         } */ bsd_args;
 331         int error;
 332         int retval_socket;
 333
 334         if ((error = copyin(args, &linux_args, sizeof(linux_args))))
 335                 return (error);
 336
 337         bsd_args.protocol = linux_args.protocol;
 338         bsd_args.type = linux_args.type;
 339         bsd_args.domain = linux_to_bsd_domain(linux_args.domain);
 340         if (bsd_args.domain == -1)
 341                 return (EINVAL);
 342
 343         retval_socket = socket(p, &bsd_args);
 344         if (bsd_args.type == SOCK_RAW
 345             && (bsd_args.protocol == IPPROTO_RAW || bsd_args.protocol == 0)
 346             && bsd_args.domain == AF_INET
 347             && retval_socket >= 0) {
 348                 /* It's a raw IP socket: set the IP_HDRINCL option. */
 349                 struct setsockopt_args /* {
 350                         int s;
 351                         int level;
 352                         int name;
 353                         caddr_t val;
 354                         int valsize;
 355                 } */ bsd_setsockopt_args;
 356                 caddr_t sg;
 357                 int *hdrincl;
 358
 359                 sg = stackgap_init();
 360                 hdrincl = (int *)stackgap_alloc(&sg, sizeof(*hdrincl));
 361                 *hdrincl = 1;
 362                 bsd_setsockopt_args.s = p->p_retval[0];
 363                 bsd_setsockopt_args.level = IPPROTO_IP;
 364                 bsd_setsockopt_args.name = IP_HDRINCL;
 365                 bsd_setsockopt_args.val = (caddr_t)hdrincl;
 366                 bsd_setsockopt_args.valsize = sizeof(*hdrincl);
 367                 /* We ignore any error returned by setsockopt() */
 368                 setsockopt(p, &bsd_setsockopt_args);
 369                 /* Copy back the return value from socket() */
 370                 p->p_retval[0] = bsd_setsockopt_args.s;
 371         }
 372
 373         return (retval_socket);
 374 }
 375
 376 struct linux_bind_args {
 377         int s;
 378         struct sockaddr *name;
 379         int namelen;
 380 };
 381
 382 static int
 383 linux_bind(struct proc *p, struct linux_bind_args *args)
 384 {
 385         struct linux_bind_args linux_args;
 386         struct bind_args /* {
 387                 int s;
 388                 caddr_t name;
 389                 int namelen;
 390         } */ bsd_args;
 391         int error;
 392
 393         if ((error = copyin(args, &linux_args, sizeof(linux_args))))
 394                 return (error);
 395
 396         bsd_args.s = linux_args.s;
 397         bsd_args.name = (caddr_t)linux_args.name;
 398         bsd_args.namelen = linux_to_bsd_namelen(bsd_args.name,
 399             linux_args.namelen);
 400         return (bind(p, &bsd_args));
 401 }
 402
 403 struct linux_connect_args {
 404         int s;
 405         struct sockaddr * name;
 406         int namelen;
 407 };
 408 int linux_connect(struct proc *, struct linux_connect_args *);
 409 #endif /* !__alpha__*/
 410
 411 int
 412 linux_connect(struct proc *p, struct linux_connect_args *args)
 413 {
 414         struct linux_connect_args linux_args;
 415         struct connect_args /* {
 416                 int s;
 417                 caddr_t name;
 418                 int namelen;
 419         } */ bsd_args;
 420         struct socket *so;
 421         struct file *fp;
 422         int error;
 423
 424 #ifdef __alpha__
 425         bcopy(args, &linux_args, sizeof(linux_args));
 426 #else
 427         if ((error = copyin(args, &linux_args, sizeof(linux_args))))
 428                 return (error);
 429 #endif /* __alpha__ */
 430
 431         bsd_args.s = linux_args.s;
 432         bsd_args.name = (caddr_t)linux_args.name;
 433         bsd_args.namelen = linux_to_bsd_namelen(bsd_args.name,
 434             linux_args.namelen);
 435         error = connect(p, &bsd_args);
 436         if (error != EISCONN)
 437                 return (error);
 438
 439         /*
 440          * Linux doesn't return EISCONN the first time it occurs,
 441          * when on a non-blocking socket. Instead it returns the
 442          * error getsockopt(SOL_SOCKET, SO_ERROR) would return on BSD.
 443          */
 444         error = holdsock(p->p_fd, linux_args.s, &fp);
 445         if (error)
 446                 return (error);
 447         error = EISCONN;
 448         if (fp->f_flag & FNONBLOCK) {
 449                 so = (struct socket *)fp->f_data;
 450                 if (so->so_emuldata == 0)
 451                         error = so->so_error;
 452                 so->so_emuldata = (void *)1;
 453         }
 454         fdrop(fp, p);
 455         return (error);
 456 }
 457
 458 #ifndef __alpha__
 459
 460 struct linux_listen_args {
 461         int s;
 462         int backlog;
 463 };
 464
 465 static int
 466 linux_listen(struct proc *p, struct linux_listen_args *args)
 467 {
 468         struct linux_listen_args linux_args;
 469         struct listen_args /* {
 470                 int s;
 471                 int backlog;
 472         } */ bsd_args;
 473         int error;
 474
 475         if ((error = copyin(args, &linux_args, sizeof(linux_args))))
 476                 return (error);
 477
 478         bsd_args.s = linux_args.s;
 479         bsd_args.backlog = linux_args.backlog;
 480         return (listen(p, &bsd_args));
 481 }
 482
 483 struct linux_accept_args {
 484         int s;
 485         struct sockaddr *addr;
 486         int *namelen;
 487 };
 488
 489 static int
 490 linux_accept(struct proc *p, struct linux_accept_args *args)
 491 {
 492         struct linux_accept_args linux_args;
 493         struct accept_args /* {
 494                 int s;
 495                 caddr_t name;
 496                 int *anamelen;
 497         } */ bsd_args;
 498         struct fcntl_args /* {
 499                 int fd;
 500                 int cmd;
 501                 long arg;
 502         } */ f_args;
 503         int error;
 504
 505         if ((error = copyin(args, &linux_args, sizeof(linux_args))))
 506                 return (error);
 507
 508         bsd_args.s = linux_args.s;
 509         bsd_args.name = (caddr_t)linux_args.addr;
 510         bsd_args.anamelen = linux_args.namelen;
 511         error = oaccept(p, &bsd_args);
 512         if (error)
 513                 return (error);
 514
 515         /*
 516          * linux appears not to copy flags from the parent socket to the
 517          * accepted one, so we must clear the flags in the new descriptor.
 518          * Ignore any errors, because we already have an open fd.
 519          */
 520         f_args.fd = p->p_retval[0];
 521         f_args.cmd = F_SETFL;
 522         f_args.arg = 0;
 523         (void)fcntl(p, &f_args);
 524         p->p_retval[0] = f_args.fd;
 525         return (0);
 526 }
 527
 528 struct linux_getsockname_args {
 529         int s;
 530         struct sockaddr *addr;
 531         int *namelen;
 532 };
 533
 534 static int
 535 linux_getsockname(struct proc *p, struct linux_getsockname_args *args)
 536 {
 537         struct linux_getsockname_args linux_args;
 538         struct getsockname_args /* {
 539                 int fdes;
 540                 caddr_t asa;
 541                 int *alen;
 542         } */ bsd_args;
 543         int error;
 544
 545         if ((error = copyin(args, &linux_args, sizeof(linux_args))))
 546                 return (error);
 547
 548         bsd_args.fdes = linux_args.s;
 549         bsd_args.asa = (caddr_t) linux_args.addr;
 550         bsd_args.alen = linux_args.namelen;
 551         return (ogetsockname(p, &bsd_args));
 552 }
 553
 554 struct linux_getpeername_args {
 555         int s;
 556         struct sockaddr *addr;
 557         int *namelen;
 558 };
 559
 560 static int
 561 linux_getpeername(struct proc *p, struct linux_getpeername_args *args)
 562 {
 563         struct linux_getpeername_args linux_args;
 564         struct ogetpeername_args /* {
 565                 int fdes;
 566                 caddr_t asa;
 567                 int *alen;
 568         } */ bsd_args;
 569         int error;
 570
 571         if ((error = copyin(args, &linux_args, sizeof(linux_args))))
 572                 return (error);
 573
 574         bsd_args.fdes = linux_args.s;
 575         bsd_args.asa = (caddr_t) linux_args.addr;
 576         bsd_args.alen = linux_args.namelen;
 577         return (ogetpeername(p, &bsd_args));
 578 }
 579
 580 struct linux_socketpair_args {
 581         int domain;
 582         int type;
 583         int protocol;
 584         int *rsv;
 585 };
 586
 587 static int
 588 linux_socketpair(struct proc *p, struct linux_socketpair_args *args)
 589 {
 590         struct linux_socketpair_args linux_args;
 591         struct socketpair_args /* {
 592                 int domain;
 593                 int type;
 594                 int protocol;
 595                 int *rsv;
 596         } */ bsd_args;
 597         int error;
 598
 599         if ((error = copyin(args, &linux_args, sizeof(linux_args))))
 600                 return (error);
 601
 602         bsd_args.domain = linux_to_bsd_domain(linux_args.domain);
 603         if (bsd_args.domain == -1)
 604                 return (EINVAL);
 605
 606         bsd_args.type = linux_args.type;
 607         bsd_args.protocol = linux_args.protocol;
 608         bsd_args.rsv = linux_args.rsv;
 609         return (socketpair(p, &bsd_args));
 610 }
 611
 612 struct linux_send_args {
 613         int s;
 614         void *msg;
 615         int len;
 616         int flags;
 617 };
 618
 619 static int
 620 linux_send(struct proc *p, struct linux_send_args *args)
 621 {
 622         struct linux_send_args linux_args;
 623         struct osend_args /* {
 624                 int s;
 625                 caddr_t buf;
 626                 int len;
 627                 int flags;
 628         } */ bsd_args;
 629         int error;
 630
 631         if ((error = copyin(args, &linux_args, sizeof(linux_args))))
 632                 return (error);
 633
 634         bsd_args.s = linux_args.s;
 635         bsd_args.buf = linux_args.msg;
 636         bsd_args.len = linux_args.len;
 637         bsd_args.flags = linux_args.flags;
 638         return (osend(p, &bsd_args));
 639 }
 640
 641 struct linux_recv_args {
 642         int s;
 643         void *msg;
 644         int len;
 645         int flags;
 646 };
 647
 648 static int
 649 linux_recv(struct proc *p, struct linux_recv_args *args)
 650 {
 651         struct linux_recv_args linux_args;
 652         struct orecv_args /* {
 653                 int s;
 654                 caddr_t buf;
 655                 int len;
 656                 int flags;
 657         } */ bsd_args;
 658         int error;
 659
 660         if ((error = copyin(args, &linux_args, sizeof(linux_args))))
 661                 return (error);
 662
 663         bsd_args.s = linux_args.s;
 664         bsd_args.buf = linux_args.msg;
 665         bsd_args.len = linux_args.len;
 666         bsd_args.flags = linux_args.flags;
 667         return (orecv(p, &bsd_args));
 668 }
 669
 670 struct linux_sendto_args {
 671         int s;
 672         void *msg;
 673         int len;
 674         int flags;
 675         caddr_t to;
 676         int tolen;
 677 };
 678
 679 static int
 680 linux_sendto(struct proc *p, struct linux_sendto_args *args)
 681 {
 682         struct linux_sendto_args linux_args;
 683         struct sendto_args /* {
 684                 int s;
 685                 caddr_t buf;
 686                 size_t len;
 687                 int flags;
 688                 caddr_t to;
 689                 int tolen;
 690         } */ bsd_args;
 691         int error;
 692
 693         if ((error = copyin(args, &linux_args, sizeof(linux_args))))
 694                 return (error);
 695
 696         bsd_args.s = linux_args.s;
 697         bsd_args.buf = linux_args.msg;
 698         bsd_args.len = linux_args.len;
 699         bsd_args.flags = linux_args.flags;
 700         bsd_args.to = linux_args.to;
 701         bsd_args.tolen = linux_args.tolen;
 702
 703         if (linux_check_hdrincl(p, linux_args.s) == 0)
 704                 /* IP_HDRINCL set, tweak the packet before sending */
 705                 return (linux_sendto_hdrincl(p, &bsd_args));
 706
 707         return (sendto(p, &bsd_args));
 708 }
 709
 710 struct linux_recvfrom_args {
 711         int s;
 712         void *buf;
 713         int len;
 714         int flags;
 715         caddr_t from;
 716         int *fromlen;
 717 };
 718
 719 static int
 720 linux_recvfrom(struct proc *p, struct linux_recvfrom_args *args)
 721 {
 722         struct linux_recvfrom_args linux_args;
 723         struct recvfrom_args /* {
 724                 int s;
 725                 caddr_t buf;
 726                 size_t len;
 727                 int flags;
 728                 caddr_t from;
 729                 int *fromlenaddr;
 730         } */ bsd_args;
 731         int error;
 732
 733         if ((error = copyin(args, &linux_args, sizeof(linux_args))))
 734                 return (error);
 735
 736         bsd_args.s = linux_args.s;
 737         bsd_args.buf = linux_args.buf;
 738         bsd_args.len = linux_args.len;
 739         bsd_args.flags = linux_to_bsd_msg_flags(linux_args.flags);
 740         bsd_args.from = linux_args.from;
 741         bsd_args.fromlenaddr = linux_args.fromlen;
 742         return (orecvfrom(p, &bsd_args));
 743 }
 744
 745 struct linux_recvmsg_args {
 746         int s;
 747         struct msghdr *msg;
 748         int flags;
 749 };
 750
 751 static int
 752 linux_recvmsg(struct proc *p, struct linux_recvmsg_args *args)
 753 {
 754         struct linux_recvmsg_args linux_args;
 755         struct recvmsg_args /* {
 756                 int     s;
 757                 struct  msghdr *msg;
 758                 int     flags;
 759         } */ bsd_args;
 760         int error;
 761
 762         if ((error = copyin(args, &linux_args, sizeof(linux_args))))
 763                 return (error);
 764
 765         bsd_args.s = linux_args.s;
 766         bsd_args.msg = linux_args.msg;
 767         bsd_args.flags = linux_to_bsd_msg_flags(linux_args.flags);
 768         return (recvmsg(p, &bsd_args));
 769 }
 770
 771 struct linux_shutdown_args {
 772         int s;
 773         int how;
 774 };
 775
 776 static int
 777 linux_shutdown(struct proc *p, struct linux_shutdown_args *args)
 778 {
 779         struct linux_shutdown_args linux_args;
 780         struct shutdown_args /* {
 781                 int s;
 782                 int how;
 783         } */ bsd_args;
 784         int error;
 785
 786         if ((error = copyin(args, &linux_args, sizeof(linux_args))))
 787                 return (error);
 788
 789         bsd_args.s = linux_args.s;
 790         bsd_args.how = linux_args.how;
 791         return (shutdown(p, &bsd_args));
 792 }
 793
 794 struct linux_setsockopt_args {
 795         int s;
 796         int level;
 797         int optname;
 798         void *optval;
 799         int optlen;
 800 };
 801
 802 static int
 803 linux_setsockopt(struct proc *p, struct linux_setsockopt_args *args)
 804 {
 805         struct linux_setsockopt_args linux_args;
 806         struct setsockopt_args /* {
 807                 int s;
 808                 int level;
 809                 int name;
 810                 caddr_t val;
 811                 int valsize;
 812         } */ bsd_args;
 813         int error, name;
 814
 815         if ((error = copyin(args, &linux_args, sizeof(linux_args))))
 816                 return (error);
 817
 818         bsd_args.s = linux_args.s;
 819         bsd_args.level = linux_to_bsd_sockopt_level(linux_args.level);
 820         switch (bsd_args.level) {
 821         case SOL_SOCKET:
 822                 name = linux_to_bsd_so_sockopt(linux_args.optname);
 823                 break;
 824         case IPPROTO_IP:
 825                 name = linux_to_bsd_ip_sockopt(linux_args.optname);
 826                 break;
 827         case IPPROTO_TCP:
 828                 /* Linux TCP option values match BSD's */
 829                 name = linux_args.optname;
 830                 break;
 831         default:
 832                 name = -1;
 833                 break;
 834         }
 835         if (name == -1)
 836                 return (EINVAL);
 837
 838         bsd_args.name = name;
 839         bsd_args.val = linux_args.optval;
 840         bsd_args.valsize = linux_args.optlen;
 841         return (setsockopt(p, &bsd_args));
 842 }
 843
 844 struct linux_getsockopt_args {
 845         int s;
 846         int level;
 847         int optname;
 848         void *optval;
 849         int *optlen;
 850 };
 851
 852 static int
 853 linux_getsockopt(struct proc *p, struct linux_getsockopt_args *args)
 854 {
 855         struct linux_getsockopt_args linux_args;
 856         struct getsockopt_args /* {
 857                 int s;
 858                 int level;
 859                 int name;
 860                 caddr_t val;
 861                 int *avalsize;
 862         } */ bsd_args;
 863         int error, name;
 864
 865         if ((error = copyin(args, &linux_args, sizeof(linux_args))))
 866                 return (error);
 867
 868         bsd_args.s = linux_args.s;
 869         bsd_args.level = linux_to_bsd_sockopt_level(linux_args.level);
 870         switch (bsd_args.level) {
 871         case SOL_SOCKET:
 872                 name = linux_to_bsd_so_sockopt(linux_args.optname);
 873                 break;
 874         case IPPROTO_IP:
 875                 name = linux_to_bsd_ip_sockopt(linux_args.optname);
 876                 break;
 877         case IPPROTO_TCP:
 878                 /* Linux TCP option values match BSD's */
 879                 name = linux_args.optname;
 880                 break;
 881         default:
 882                 name = -1;
 883                 break;
 884         }
 885         if (name == -1)
 886                 return (EINVAL);
 887
 888         bsd_args.name = name;
 889         bsd_args.val = linux_args.optval;
 890         bsd_args.avalsize = linux_args.optlen;
 891         return (getsockopt(p, &bsd_args));
 892 }
 893
 894 int
 895 linux_socketcall(struct proc *p, struct linux_socketcall_args *args)
 896 {
 897         void *arg = (void *)args->args;
 898
 899         switch (args->what) {
 900         case LINUX_SOCKET:
 901                 return (linux_socket(p, arg));
 902         case LINUX_BIND:
 903                 return (linux_bind(p, arg));
 904         case LINUX_CONNECT:
 905                 return (linux_connect(p, arg));
 906         case LINUX_LISTEN:
 907                 return (linux_listen(p, arg));
 908         case LINUX_ACCEPT:
 909                 return (linux_accept(p, arg));
 910         case LINUX_GETSOCKNAME:
 911                 return (linux_getsockname(p, arg));
 912         case LINUX_GETPEERNAME:
 913                 return (linux_getpeername(p, arg));
 914         case LINUX_SOCKETPAIR:
 915                 return (linux_socketpair(p, arg));
 916         case LINUX_SEND:
 917                 return (linux_send(p, arg));
 918         case LINUX_RECV:
 919                 return (linux_recv(p, arg));
 920         case LINUX_SENDTO:
 921                 return (linux_sendto(p, arg));
 922         case LINUX_RECVFROM:
 923                 return (linux_recvfrom(p, arg));
 924         case LINUX_SHUTDOWN:
 925                 return (linux_shutdown(p, arg));
 926         case LINUX_SETSOCKOPT:
 927                 return (linux_setsockopt(p, arg));
 928         case LINUX_GETSOCKOPT:
 929                 return (linux_getsockopt(p, arg));
 930         case LINUX_SENDMSG:
 931                 do {
 932                         int error;
 933                         int level;
 934                         caddr_t control;
 935                         struct {
 936                                 int s;
 937                                 const struct msghdr *msg;
 938                                 int flags;
 939                         } *uap = arg;
 940
 941                         error = copyin(&uap->msg->msg_control, &control,
 942                             sizeof(caddr_t));
 943                         if (error)
 944                                 return (error);
 945
 946                         if (control == NULL)
 947                                 goto done;
 948
 949                         error = copyin(&((struct cmsghdr*)control)->cmsg_level,
 950                             &level, sizeof(int));
 951                         if (error)
 952                                 return (error);
 953
 954                         if (level == 1) {
 955                                 /*
 956                                  * Linux thinks that SOL_SOCKET is 1; we know
 957                                  * that it's really 0xffff, of course.
 958                                  */
 959                                 level = SOL_SOCKET;
 960                                 error = copyout(&level,
 961                                     &((struct cmsghdr *)control)->cmsg_level,
 962                                     sizeof(int));
 963                                 if (error)
 964                                         return (error);
 965                         }
 966                 done:
 967                         return (sendmsg(p, arg));
 968                 } while (0);
 969         case LINUX_RECVMSG:
 970                 return (linux_recvmsg(p, arg));
 971         }
 972
 973         uprintf("LINUX: 'socket' typ=%d not implemented\n", args->what);
 974         return (ENOSYS);
 975 }
 976 #endif  /*!__alpha__*/