sys/compat/linux32/common/linux32_socket.c

   1 /*      $NetBSD: linux32_socket.c,v 1.14 2009/12/10 17:07:26 njoly Exp $ */
   2
   3 /*-
   4  * Copyright (c) 2006 Emmanuel Dreyfus, all rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. All advertising materials mentioning features or use of this software
  15  *    must display the following acknowledgement:
  16  *      This product includes software developed by Emmanuel Dreyfus
  17  * 4. The name of the author may not be used to endorse or promote
  18  *    products derived from this software without specific prior written
  19  *    permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE THE AUTHOR AND CONTRIBUTORS ``AS IS''
  22  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  23  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  24  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
  25  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  26  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  28  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  29  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  31  * POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include <sys/cdefs.h>
  35
  36 __KERNEL_RCSID(0, "$NetBSD: linux32_socket.c,v 1.14 2009/12/10 17:07:26 njoly Exp $");
  37
  38 #include <sys/types.h>
  39 #include <sys/param.h>
  40 #include <sys/fstypes.h>
  41 #include <sys/signal.h>
  42 #include <sys/dirent.h>
  43 #include <sys/kernel.h>
  44 #include <sys/fcntl.h>
  45 #include <sys/select.h>
  46 #include <sys/proc.h>
  47 #include <sys/ucred.h>
  48 #include <sys/swap.h>
  49 #include <sys/file.h>
  50 #include <sys/vnode.h>
  51 #include <sys/filedesc.h>
  52
  53 #include <machine/types.h>
  54
  55 #include <net/if.h>
  56 #include <net/if_dl.h>
  57 #include <net/if_types.h>
  58 #include <net/route.h>
  59
  60 #include <netinet/in.h>
  61 #include <netinet/ip_mroute.h>
  62
  63 #include <sys/syscallargs.h>
  64
  65 #include <compat/netbsd32/netbsd32.h>
  66 #include <compat/netbsd32/netbsd32_ioctl.h>
  67 #include <compat/netbsd32/netbsd32_conv.h>
  68 #include <compat/netbsd32/netbsd32_syscallargs.h>
  69
  70 #include <compat/sys/socket.h>
  71 #include <compat/sys/sockio.h>
  72
  73 #include <compat/linux/common/linux_types.h>
  74 #include <compat/linux/common/linux_types.h>
  75 #include <compat/linux/common/linux_signal.h>
  76 #include <compat/linux/common/linux_machdep.h>
  77 #include <compat/linux/common/linux_misc.h>
  78 #include <compat/linux/common/linux_oldolduname.h>
  79 #include <compat/linux/common/linux_ioctl.h>
  80 #include <compat/linux/common/linux_sockio.h>
  81 #include <compat/linux/common/linux_ipc.h>
  82 #include <compat/linux/common/linux_sem.h>
  83 #include <compat/linux/linux_syscallargs.h>
  84
  85 #include <compat/linux32/common/linux32_types.h>
  86 #include <compat/linux32/common/linux32_signal.h>
  87 #include <compat/linux32/common/linux32_machdep.h>
  88 #include <compat/linux32/common/linux32_sysctl.h>
  89 #include <compat/linux32/common/linux32_socketcall.h>
  90 #include <compat/linux32/common/linux32_sockio.h>
  91 #include <compat/linux32/common/linux32_ioctl.h>
  92 #include <compat/linux32/linux32_syscallargs.h>
  93
  94 int linux32_getifname(struct lwp *, register_t *, void *);
  95 int linux32_getifconf(struct lwp *, register_t *, void *);
  96 int linux32_getifhwaddr(struct lwp *, register_t *, u_int, void *);
  97
  98 int
  99 linux32_sys_socketpair(struct lwp *l, const struct linux32_sys_socketpair_args *uap, register_t *retval)
 100 {
 101         /* {
 102                 syscallarg(int) domain;
 103                 syscallarg(int) type;
 104                 syscallarg(int) protocol;
 105                 syscallarg(netbsd32_intp) rsv;
 106         } */
 107         struct linux_sys_socketpair_args ua;
 108
 109         NETBSD32TO64_UAP(domain);
 110         NETBSD32TO64_UAP(type);
 111         NETBSD32TO64_UAP(protocol);
 112         NETBSD32TOP_UAP(rsv, int);
 113
 114         return linux_sys_socketpair(l, &ua, retval);
 115 }
 116
 117 int
 118 linux32_sys_sendto(struct lwp *l, const struct linux32_sys_sendto_args *uap, register_t *retval)
 119 {
 120         /* {
 121                 syscallarg(int) s;
 122                 syscallarg(netbsd32_voidp) msg;
 123                 syscallarg(int) len;
 124                 syscallarg(int) flags;
 125                 syscallarg(netbsd32_osockaddrp_t) to;
 126                 syscallarg(int) tolen;
 127         } */
 128         struct linux_sys_sendto_args ua;
 129
 130         NETBSD32TO64_UAP(s);
 131         NETBSD32TOP_UAP(msg, void);
 132         NETBSD32TO64_UAP(len);
 133         NETBSD32TO64_UAP(flags);
 134         NETBSD32TOP_UAP(to, struct osockaddr);
 135         NETBSD32TO64_UAP(tolen);
 136
 137         return linux_sys_sendto(l, &ua, retval);
 138 }
 139
 140
 141 int
 142 linux32_sys_recvfrom(struct lwp *l, const struct linux32_sys_recvfrom_args *uap, register_t *retval)
 143 {
 144         /* {
 145                 syscallarg(int) s;
 146                 syscallarg(netbsd32_voidp) buf;
 147                 syscallarg(netbsd32_size_t) len;
 148                 syscallarg(int) flags;
 149                 syscallarg(netbsd32_osockaddrp_t) from;
 150                 syscallarg(netbsd32_intp) fromlenaddr;
 151         } */
 152         struct linux_sys_recvfrom_args ua;
 153
 154         NETBSD32TO64_UAP(s);
 155         NETBSD32TOP_UAP(buf, void);
 156         NETBSD32TO64_UAP(len);
 157         NETBSD32TO64_UAP(flags);
 158         NETBSD32TOP_UAP(from, struct osockaddr);
 159         NETBSD32TOP_UAP(fromlenaddr, unsigned int);
 160
 161         return linux_sys_recvfrom(l, &ua, retval);
 162 }
 163
 164 int
 165 linux32_sys_setsockopt(struct lwp *l, const struct linux32_sys_setsockopt_args *uap, register_t *retval)
 166 {
 167         /* {
 168                 syscallarg(int) s;
 169                 syscallarg(int) level;
 170                 syscallarg(int) optname;
 171                 syscallarg(netbsd32_voidp) optval;
 172                 syscallarg(int) optlen;
 173         } */
 174         struct linux_sys_setsockopt_args ua;
 175
 176         NETBSD32TO64_UAP(s);
 177         NETBSD32TO64_UAP(level);
 178         NETBSD32TO64_UAP(optname);
 179         NETBSD32TOP_UAP(optval, void);
 180         NETBSD32TO64_UAP(optlen);
 181
 182         return linux_sys_setsockopt(l, &ua, retval);
 183 }
 184
 185
 186 int
 187 linux32_sys_getsockopt(struct lwp *l, const struct linux32_sys_getsockopt_args *uap, register_t *retval)
 188 {
 189         /* {
 190                 syscallarg(int) s;
 191                 syscallarg(int) level;
 192                 syscallarg(int) optname;
 193                 syscallarg(netbsd32_voidp) optval;
 194                 syscallarg(netbsd32_intp) optlen;
 195         } */
 196         struct linux_sys_getsockopt_args ua;
 197
 198         NETBSD32TO64_UAP(s);
 199         NETBSD32TO64_UAP(level);
 200         NETBSD32TO64_UAP(optname);
 201         NETBSD32TOP_UAP(optval, void);
 202         NETBSD32TOP_UAP(optlen, int);
 203
 204         return linux_sys_getsockopt(l, &ua, retval);
 205 }
 206
 207 int
 208 linux32_sys_socket(struct lwp *l, const struct linux32_sys_socket_args *uap, register_t *retval)
 209 {
 210         /* {
 211                 syscallarg(int) domain;
 212                 syscallarg(int) type;
 213                 syscallarg(int) protocol;
 214         } */
 215         struct linux_sys_socket_args ua;
 216
 217         NETBSD32TO64_UAP(domain);
 218         NETBSD32TO64_UAP(type);
 219         NETBSD32TO64_UAP(protocol);
 220
 221         return linux_sys_socket(l, &ua, retval);
 222 }
 223
 224 int
 225 linux32_sys_bind(struct lwp *l, const struct linux32_sys_bind_args *uap, register_t *retval)
 226 {
 227         /* {
 228                 syscallarg(int) s;
 229                 syscallarg(netbsd32_osockaddrp_t) name;
 230                 syscallarg(int) namelen;
 231         } */
 232         struct linux_sys_bind_args ua;
 233
 234         NETBSD32TO64_UAP(s);
 235         NETBSD32TOP_UAP(name, struct osockaddr);
 236         NETBSD32TO64_UAP(namelen);
 237
 238         return linux_sys_bind(l, &ua, retval);
 239 }
 240
 241 int
 242 linux32_sys_connect(struct lwp *l, const struct linux32_sys_connect_args *uap, register_t *retval)
 243 {
 244         /* {
 245                 syscallarg(int) s;
 246                 syscallarg(netbsd32_osockaddrp_t) name;
 247                 syscallarg(int) namelen;
 248         } */
 249         struct linux_sys_connect_args ua;
 250
 251         NETBSD32TO64_UAP(s);
 252         NETBSD32TOP_UAP(name, struct osockaddr);
 253         NETBSD32TO64_UAP(namelen);
 254
 255 #ifdef DEBUG_LINUX
 256         printf("linux32_sys_connect: s = %d, name = %p, namelen = %d\n",
 257                 SCARG(&ua, s), SCARG(&ua, name), SCARG(&ua, namelen));
 258 #endif
 259
 260         return linux_sys_connect(l, &ua, retval);
 261 }
 262
 263 int
 264 linux32_sys_accept(struct lwp *l, const struct linux32_sys_accept_args *uap, register_t *retval)
 265 {
 266         /* {
 267                 syscallarg(int) s;
 268                 syscallarg(netbsd32_osockaddrp_t) name;
 269                 syscallarg(netbsd32_intp) anamelen;
 270         } */
 271         struct linux_sys_accept_args ua;
 272
 273         NETBSD32TO64_UAP(s);
 274         NETBSD32TOP_UAP(name, struct osockaddr);
 275         NETBSD32TOP_UAP(anamelen, int);
 276
 277         return linux_sys_accept(l, &ua, retval);
 278 }
 279
 280 int
 281 linux32_sys_getpeername(struct lwp *l, const struct linux32_sys_getpeername_args *uap, register_t *retval)
 282 {
 283         /* {
 284                 syscallarg(int) fdes;
 285                 syscallarg(netbsd32_sockaddrp_t) asa;
 286                 syscallarg(netbsd32_intp) alen;
 287         } */
 288         struct linux_sys_getpeername_args ua;
 289
 290         NETBSD32TO64_UAP(fdes);
 291         NETBSD32TOP_UAP(asa, struct sockaddr);
 292         NETBSD32TOP_UAP(alen, int);
 293
 294         return linux_sys_getpeername(l, &ua, retval);
 295 }
 296
 297 int
 298 linux32_sys_getsockname(struct lwp *l, const struct linux32_sys_getsockname_args *uap, register_t *retval)
 299 {
 300         /* {
 301                 syscallarg(int) fdec;
 302                 syscallarg(netbsd32_charp) asa;
 303                 syscallarg(netbsd32_intp) alen;
 304         } */
 305         struct linux_sys_getsockname_args ua;
 306
 307         NETBSD32TO64_UAP(fdec);
 308         NETBSD32TOP_UAP(asa, char);
 309         NETBSD32TOP_UAP(alen, int);
 310
 311         return linux_sys_getsockname(l, &ua, retval);
 312 }
 313
 314 int
 315 linux32_sys_sendmsg(struct lwp *l, const struct linux32_sys_sendmsg_args *uap, register_t *retval)
 316 {
 317         /* {
 318                 syscallarg(int) s;
 319                 syscallarg(netbsd32_msghdrp_t) msg;
 320                 syscallarg(int) flags;
 321         } */
 322         struct linux_sys_sendmsg_args ua;
 323
 324         NETBSD32TO64_UAP(s);
 325         NETBSD32TOP_UAP(msg, struct msghdr);
 326         NETBSD32TO64_UAP(flags);
 327
 328         return linux_sys_sendmsg(l, &ua, retval);
 329 }
 330
 331 int
 332 linux32_sys_recvmsg(struct lwp *l, const struct linux32_sys_recvmsg_args *uap, register_t *retval)
 333 {
 334         /* {
 335                 syscallarg(int) s;
 336                 syscallarg(netbsd32_msghdrp_t) msg;
 337                 syscallarg(int) flags;
 338         } */
 339         struct linux_sys_recvmsg_args ua;
 340
 341         NETBSD32TO64_UAP(s);
 342         NETBSD32TOP_UAP(msg, struct msghdr);
 343         NETBSD32TO64_UAP(flags);
 344
 345         return linux_sys_recvmsg(l, &ua, retval);
 346 }
 347
 348 int
 349 linux32_sys_send(struct lwp *l, const struct linux32_sys_send_args *uap, register_t *retval)
 350 {
 351         /* {
 352                 syscallarg(int) s;
 353                 syscallarg(netbsd32_voidp) buf;
 354                 syscallarg(int) len;
 355                 syscallarg(int) flags;
 356         } */
 357         struct sys_sendto_args ua;
 358
 359         NETBSD32TO64_UAP(s);
 360         NETBSD32TOP_UAP(buf, void);
 361         NETBSD32TO64_UAP(len);
 362         NETBSD32TO64_UAP(flags);
 363         SCARG(&ua, to) = NULL;
 364         SCARG(&ua, tolen) = 0;
 365
 366         return sys_sendto(l, &ua, retval);
 367 }
 368
 369 int
 370 linux32_sys_recv(struct lwp *l, const struct linux32_sys_recv_args *uap, register_t *retval)
 371 {
 372         /* {
 373                 syscallarg(int) s;
 374                 syscallarg(netbsd32_voidp) buf;
 375                 syscallarg(int) len;
 376                 syscallarg(int) flags;
 377         } */
 378         struct sys_recvfrom_args ua;
 379
 380         NETBSD32TO64_UAP(s);
 381         NETBSD32TOP_UAP(buf, void);
 382         NETBSD32TO64_UAP(len);
 383         NETBSD32TO64_UAP(flags);
 384         SCARG(&ua, from) = NULL;
 385         SCARG(&ua, fromlenaddr) = NULL;
 386
 387         return sys_recvfrom(l, &ua, retval);
 388 }
 389
 390 int
 391 linux32_getifname(struct lwp *l, register_t *retval, void *data)
 392 {
 393         struct ifnet *ifp;
 394         struct linux32_ifreq ifr;
 395         int error;
 396
 397         error = copyin(data, &ifr, sizeof(ifr));
 398         if (error)
 399                 return error;
 400
 401         if (ifr.ifr_ifru.ifru_ifindex >= if_indexlim)
 402                 return ENODEV;
 403
 404         ifp = ifindex2ifnet[ifr.ifr_ifru.ifru_ifindex];
 405         if (ifp == NULL)
 406                 return ENODEV;
 407
 408         strncpy(ifr.ifr_name, ifp->if_xname, sizeof(ifr.ifr_name));
 409
 410         return copyout(&ifr, data, sizeof(ifr));
 411 }
 412
 413 int
 414 linux32_getifconf(struct lwp *l, register_t *retval, void *data)
 415 {
 416         struct linux32_ifreq ifr, *ifrp;
 417         struct netbsd32_ifconf *ifc = data;
 418         struct ifnet *ifp;
 419         struct ifaddr *ifa;
 420         struct sockaddr *sa;
 421         struct osockaddr *osa;
 422         int space, error = 0;
 423         const int sz = (int)sizeof(ifr);
 424
 425         ifrp = (struct linux32_ifreq *)NETBSD32PTR64(ifc->ifc_req);
 426         if (ifrp == NULL)
 427                 space = 0;
 428         else
 429                 space = ifc->ifc_len;
 430
 431         IFNET_FOREACH(ifp) {
 432                 (void)strncpy(ifr.ifr_name, ifp->if_xname,
 433                     sizeof(ifr.ifr_name));
 434                 if (ifr.ifr_name[sizeof(ifr.ifr_name) - 1] != '\0')
 435                         return ENAMETOOLONG;
 436                 if (IFADDR_EMPTY(ifp))
 437                         continue;
 438                 IFADDR_FOREACH(ifa, ifp) {
 439                         sa = ifa->ifa_addr;
 440                         if (sa->sa_family != AF_INET ||
 441                             sa->sa_len > sizeof(*osa))
 442                                 continue;
 443                         memcpy(&ifr.ifr_addr, sa, sa->sa_len);
 444                         osa = (struct osockaddr *)&ifr.ifr_addr;
 445                         osa->sa_family = sa->sa_family;
 446                         if (space >= sz) {
 447                                 error = copyout(&ifr, ifrp, sz);
 448                                 if (error != 0)
 449                                         return error;
 450                                 ifrp++;
 451                         }
 452                         space -= sz;
 453                 }
 454         }
 455
 456         if (ifrp != NULL)
 457                 ifc->ifc_len -= space;
 458         else
 459                 ifc->ifc_len = -space;
 460
 461         return 0;
 462 }
 463
 464 int
 465 linux32_getifhwaddr(struct lwp *l, register_t *retval, u_int fd,
 466     void *data)
 467 {
 468         struct linux32_ifreq lreq;
 469         file_t *fp;
 470         struct ifaddr *ifa;
 471         struct ifnet *ifp;
 472         struct sockaddr_dl *sadl;
 473         int error, found;
 474         int index, ifnum;
 475
 476         /*
 477          * We can't emulate this ioctl by calling sys_ioctl() to run
 478          * SIOCGIFCONF, because the user buffer is not of the right
 479          * type to take those results.  We can't use kernel buffers to
 480          * receive the results, as the implementation of sys_ioctl()
 481          * and ifconf() [which implements SIOCGIFCONF] use
 482          * copyin()/copyout() which will fail on kernel addresses.
 483          *
 484          * So, we must duplicate code from sys_ioctl() and ifconf().  Ugh.
 485          */
 486
 487         if ((fp = fd_getfile(fd)) == NULL)
 488                 return (EBADF);
 489
 490         KERNEL_LOCK(1, NULL);
 491
 492         if ((fp->f_flag & (FREAD | FWRITE)) == 0) {
 493                 error = EBADF;
 494                 goto out;
 495         }
 496
 497         error = copyin(data, &lreq, sizeof(lreq));
 498         if (error)
 499                 goto out;
 500         lreq.ifr_name[LINUX32_IFNAMSIZ-1] = '\0';               /* just in case */
 501
 502         /*
 503          * Try real interface name first, then fake "ethX"
 504          */
 505         found = 0;
 506         IFNET_FOREACH(ifp) {
 507                 if (found)
 508                         break;
 509                 if (strcmp(lreq.ifr_name, ifp->if_xname))
 510                         /* not this interface */
 511                         continue;
 512                 found=1;
 513                 if (IFADDR_EMPTY(ifp)) {
 514                         error = ENODEV;
 515                         goto out;
 516                 }
 517                 IFADDR_FOREACH(ifa, ifp) {
 518                         sadl = satosdl(ifa->ifa_addr);
 519                         /* only return ethernet addresses */
 520                         /* XXX what about FDDI, etc. ? */
 521                         if (sadl->sdl_family != AF_LINK ||
 522                             sadl->sdl_type != IFT_ETHER)
 523                                 continue;
 524                         memcpy(&lreq.ifr_hwaddr.sa_data, CLLADDR(sadl),
 525                                MIN(sadl->sdl_alen,
 526                                    sizeof(lreq.ifr_hwaddr.sa_data)));
 527                         lreq.ifr_hwaddr.sa_family =
 528                                 sadl->sdl_family;
 529                         error = copyout(&lreq, data, sizeof(lreq));
 530                         goto out;
 531                 }
 532         }
 533
 534         if (strncmp(lreq.ifr_name, "eth", 3) == 0) {
 535                 for (ifnum = 0, index = 3;
 536                      lreq.ifr_name[index] != '\0' && index < LINUX32_IFNAMSIZ;
 537                      index++) {
 538                         ifnum *= 10;
 539                         ifnum += lreq.ifr_name[index] - '0';
 540                 }
 541
 542                 error = EINVAL;                 /* in case we don't find one */
 543                 found = 0;
 544                 IFNET_FOREACH(ifp) {
 545                         if (found)
 546                                 break;
 547                         memcpy(lreq.ifr_name, ifp->if_xname,
 548                                MIN(LINUX32_IFNAMSIZ, IFNAMSIZ));
 549                         IFADDR_FOREACH(ifa, ifp) {
 550                                 sadl = satosdl(ifa->ifa_addr);
 551                                 /* only return ethernet addresses */
 552                                 /* XXX what about FDDI, etc. ? */
 553                                 if (sadl->sdl_family != AF_LINK ||
 554                                     sadl->sdl_type != IFT_ETHER)
 555                                         continue;
 556                                 if (ifnum--)
 557                                         /* not the reqested iface */
 558                                         continue;
 559                                 memcpy(&lreq.ifr_hwaddr.sa_data,
 560                                        CLLADDR(sadl),
 561                                        MIN(sadl->sdl_alen,
 562                                            sizeof(lreq.ifr_hwaddr.sa_data)));
 563                                 lreq.ifr_hwaddr.sa_family =
 564                                         sadl->sdl_family;
 565                                 error = copyout(&lreq, data, sizeof(lreq));
 566                                 found = 1;
 567                                 break;
 568                         }
 569                 }
 570         } else {
 571                 /* unknown interface, not even an "eth*" name */
 572                 error = ENODEV;
 573         }
 574
 575 out:
 576         KERNEL_UNLOCK_ONE(NULL);
 577         fd_putfile(fd);
 578         return error;
 579 }
 580
 581 int
 582 linux32_ioctl_socket(struct lwp *l, const struct linux32_sys_ioctl_args *uap, register_t *retval)
 583 {
 584         /* {
 585                 syscallarg(int) fd;
 586                 syscallarg(u_long) com;
 587                 syscallarg(void *) data;
 588         } */
 589         u_long com;
 590         int error = 0, isdev = 0, dosys = 1;
 591         struct netbsd32_ioctl_args ia;
 592         file_t *fp;
 593         struct vnode *vp;
 594         int (*ioctlf)(file_t *, u_long, void *);
 595         struct ioctl_pt pt;
 596
 597         if ((fp = fd_getfile(SCARG(uap, fd))) == NULL)
 598                 return (EBADF);
 599
 600         if (fp->f_type == DTYPE_VNODE) {
 601                 vp = (struct vnode *)fp->f_data;
 602                 isdev = vp->v_type == VCHR;
 603         }
 604
 605         /*
 606          * Don't try to interpret socket ioctl calls that are done
 607          * on a device filedescriptor, just pass them through, to
 608          * emulate Linux behaviour. Use PTIOCLINUX so that the
 609          * device will only handle these if it's prepared to do
 610          * so, to avoid unexpected things from happening.
 611          */
 612         if (isdev) {
 613                 dosys = 0;
 614                 ioctlf = fp->f_ops->fo_ioctl;
 615                 pt.com = SCARG(uap, com);
 616                 pt.data = (void *)NETBSD32PTR64(SCARG(uap, data));
 617                 error = ioctlf(fp, PTIOCLINUX, &pt);
 618                 /*
 619                  * XXX hack: if the function returns EJUSTRETURN,
 620                  * it has stuffed a sysctl return value in pt.data.
 621                  */
 622                 if (error == EJUSTRETURN) {
 623                         retval[0] = (register_t)pt.data;
 624                         error = 0;
 625                 }
 626                 goto out;
 627         }
 628
 629         com = SCARG(uap, com);
 630         retval[0] = 0;
 631
 632         switch (com) {
 633         case LINUX_SIOCGIFNAME:
 634                 error = linux32_getifname(l, retval, SCARG_P32(uap, data));
 635                 dosys = 0;
 636                 break;
 637         case LINUX_SIOCGIFCONF:
 638                 error = linux32_getifconf(l, retval, SCARG_P32(uap, data));
 639                 dosys = 0;
 640                 break;
 641         case LINUX_SIOCGIFFLAGS:
 642                 SCARG(&ia, com) = OSIOCGIFFLAGS32;
 643                 break;
 644         case LINUX_SIOCSIFFLAGS:
 645                 SCARG(&ia, com) = OSIOCSIFFLAGS32;
 646                 break;
 647         case LINUX_SIOCGIFADDR:
 648                 SCARG(&ia, com) = OOSIOCGIFADDR32;
 649                 break;
 650         case LINUX_SIOCGIFDSTADDR:
 651                 SCARG(&ia, com) = OOSIOCGIFDSTADDR32;
 652                 break;
 653         case LINUX_SIOCGIFBRDADDR:
 654                 SCARG(&ia, com) = OOSIOCGIFBRDADDR32;
 655                 break;
 656         case LINUX_SIOCGIFNETMASK:
 657                 SCARG(&ia, com) = OOSIOCGIFNETMASK32;
 658                 break;
 659         case LINUX_SIOCGIFMTU:
 660                 SCARG(&ia, com) = OSIOCGIFMTU32;
 661                 break;
 662         case LINUX_SIOCADDMULTI:
 663                 SCARG(&ia, com) = OSIOCADDMULTI32;
 664                 break;
 665         case LINUX_SIOCDELMULTI:
 666                 SCARG(&ia, com) = OSIOCDELMULTI32;
 667                 break;
 668         case LINUX_SIOCGIFHWADDR:
 669                 error = linux32_getifhwaddr(l, retval, SCARG(uap, fd),
 670                     SCARG_P32(uap, data));
 671                 dosys = 0;
 672                 break;
 673         default:
 674                 error = EINVAL;
 675         }
 676
 677  out:
 678         fd_putfile(SCARG(uap, fd));
 679
 680         if (error == 0 && dosys) {
 681                 SCARG(&ia, fd) = SCARG(uap, fd);
 682                 SCARG(&ia, data) = SCARG(uap, data);
 683                 error = netbsd32_ioctl(curlwp, &ia, retval);
 684         }
 685
 686         return error;
 687 }