/*      $NetBSD: linux32_socket.c,v 1.32 2022/12/24 15:23:02 andvar Exp $ */

/*-
* Copyright (c) 2006 Emmanuel Dreyfus, all rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
*    must display the following acknowledgement:
*      This product includes software developed by Emmanuel Dreyfus
* 4. The name of the author may not be used to endorse or promote
*    products derived from this software without specific prior written
*    permission.
*
* THIS SOFTWARE IS PROVIDED BY THE THE AUTHOR AND CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#include <sys/cdefs.h>

__KERNEL_RCSID(0, "$NetBSD: linux32_socket.c,v 1.32 2022/12/24 15:23:02 andvar Exp $");

#include <sys/types.h>
#include <sys/param.h>
#include <sys/fstypes.h>
#include <sys/signal.h>
#include <sys/dirent.h>
#include <sys/kernel.h>
#include <sys/fcntl.h>
#include <sys/select.h>
#include <sys/proc.h>
#include <sys/ucred.h>
#include <sys/swap.h>
#include <sys/file.h>
#include <sys/vnode.h>
#include <sys/filedesc.h>

#include <machine/types.h>

#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_types.h>
#include <net/route.h>

#include <netinet/in.h>
#include <netinet/ip_mroute.h>

#include <sys/syscallargs.h>

#include <compat/netbsd32/netbsd32.h>
#include <compat/netbsd32/netbsd32_ioctl.h>
#include <compat/netbsd32/netbsd32_conv.h>
#include <compat/netbsd32/netbsd32_syscallargs.h>

#include <compat/sys/socket.h>
#include <compat/sys/sockio.h>

#include <compat/linux/common/linux_types.h>
#include <compat/linux/common/linux_types.h>
#include <compat/linux/common/linux_signal.h>
#include <compat/linux/common/linux_machdep.h>
#include <compat/linux/common/linux_misc.h>
#include <compat/linux/common/linux_oldolduname.h>
#include <compat/linux/common/linux_ioctl.h>
#include <compat/linux/common/linux_sockio.h>
#include <compat/linux/common/linux_ipc.h>
#include <compat/linux/common/linux_sem.h>
#include <compat/linux/linux_syscallargs.h>

#include <compat/linux32/common/linux32_types.h>
#include <compat/linux32/common/linux32_signal.h>
#include <compat/linux32/common/linux32_machdep.h>
#include <compat/linux32/common/linux32_sysctl.h>
#include <compat/linux32/common/linux32_socketcall.h>
#include <compat/linux32/common/linux32_sockio.h>
#include <compat/linux32/common/linux32_ioctl.h>
#include <compat/linux32/linux32_syscallargs.h>

int linux32_getifname(struct lwp *, register_t *, void *);
int linux32_getifconf(struct lwp *, register_t *, void *);
int linux32_getifhwaddr(struct lwp *, register_t *, u_int, void *);

int
linux32_sys_socketpair(struct lwp *l, const struct linux32_sys_socketpair_args *uap, register_t *retval)
{
       /* {
               syscallarg(int) domain;
               syscallarg(int) type;
               syscallarg(int) protocol;
               syscallarg(netbsd32_intp) rsv;
       } */
       struct linux_sys_socketpair_args ua;

       NETBSD32TO64_UAP(domain);
       NETBSD32TO64_UAP(type);
       NETBSD32TO64_UAP(protocol);
       NETBSD32TOP_UAP(rsv, int);

       return linux_sys_socketpair(l, &ua, retval);
}

int
linux32_sys_sendto(struct lwp *l, const struct linux32_sys_sendto_args *uap, register_t *retval)
{
       /* {
               syscallarg(int) s;
               syscallarg(netbsd32_voidp) msg;
               syscallarg(int) len;
               syscallarg(int) flags;
               syscallarg(netbsd32_osockaddrp_t) to;
               syscallarg(int) tolen;
       } */
       struct linux_sys_sendto_args ua;

       NETBSD32TO64_UAP(s);
       NETBSD32TOP_UAP(msg, void);
       NETBSD32TO64_UAP(len);
       NETBSD32TO64_UAP(flags);
       NETBSD32TOP_UAP(to, struct osockaddr);
       NETBSD32TO64_UAP(tolen);

       return linux_sys_sendto(l, &ua, retval);
}


int
linux32_sys_recvfrom(struct lwp *l, const struct linux32_sys_recvfrom_args *uap, register_t *retval)
{
       /* {
               syscallarg(int) s;
               syscallarg(netbsd32_voidp) buf;
               syscallarg(netbsd32_size_t) len;
               syscallarg(int) flags;
               syscallarg(netbsd32_osockaddrp_t) from;
               syscallarg(netbsd32_intp) fromlenaddr;
       } */
       struct linux_sys_recvfrom_args ua;

       NETBSD32TO64_UAP(s);
       NETBSD32TOP_UAP(buf, void);
       NETBSD32TO64_UAP(len);
       NETBSD32TO64_UAP(flags);
       NETBSD32TOP_UAP(from, struct osockaddr);
       NETBSD32TOP_UAP(fromlenaddr, unsigned int);

       return linux_sys_recvfrom(l, &ua, retval);
}

int
linux32_sys_setsockopt(struct lwp *l, const struct linux32_sys_setsockopt_args *uap, register_t *retval)
{
       /* {
               syscallarg(int) s;
               syscallarg(int) level;
               syscallarg(int) optname;
               syscallarg(netbsd32_voidp) optval;
               syscallarg(int) optlen;
       } */
       struct linux_sys_setsockopt_args ua;

       NETBSD32TO64_UAP(s);
       NETBSD32TO64_UAP(level);
       NETBSD32TO64_UAP(optname);
       NETBSD32TOP_UAP(optval, void);
       NETBSD32TO64_UAP(optlen);

       return linux_sys_setsockopt(l, &ua, retval);
}


int
linux32_sys_getsockopt(struct lwp *l, const struct linux32_sys_getsockopt_args *uap, register_t *retval)
{
       /* {
               syscallarg(int) s;
               syscallarg(int) level;
               syscallarg(int) optname;
               syscallarg(netbsd32_voidp) optval;
               syscallarg(netbsd32_intp) optlen;
       } */
       struct linux_sys_getsockopt_args ua;

       NETBSD32TO64_UAP(s);
       NETBSD32TO64_UAP(level);
       NETBSD32TO64_UAP(optname);
       NETBSD32TOP_UAP(optval, void);
       NETBSD32TOP_UAP(optlen, int);

       return linux_sys_getsockopt(l, &ua, retval);
}

int
linux32_sys_socket(struct lwp *l, const struct linux32_sys_socket_args *uap, register_t *retval)
{
       /* {
               syscallarg(int) domain;
               syscallarg(int) type;
               syscallarg(int) protocol;
       } */
       struct linux_sys_socket_args ua;

       NETBSD32TO64_UAP(domain);
       NETBSD32TO64_UAP(type);
       NETBSD32TO64_UAP(protocol);

       return linux_sys_socket(l, &ua, retval);
}

int
linux32_sys_bind(struct lwp *l, const struct linux32_sys_bind_args *uap, register_t *retval)
{
       /* {
               syscallarg(int) s;
               syscallarg(netbsd32_osockaddrp_t) name;
               syscallarg(int) namelen;
       } */
       struct linux_sys_bind_args ua;

       NETBSD32TO64_UAP(s);
       NETBSD32TOP_UAP(name, struct osockaddr);
       NETBSD32TO64_UAP(namelen);

       return linux_sys_bind(l, &ua, retval);
}

int
linux32_sys_connect(struct lwp *l, const struct linux32_sys_connect_args *uap, register_t *retval)
{
       /* {
               syscallarg(int) s;
               syscallarg(netbsd32_osockaddrp_t) name;
               syscallarg(int) namelen;
       } */
       struct linux_sys_connect_args ua;

       NETBSD32TO64_UAP(s);
       NETBSD32TOP_UAP(name, struct osockaddr);
       NETBSD32TO64_UAP(namelen);

#ifdef DEBUG_LINUX
       printf("linux32_sys_connect: s = %d, name = %p, namelen = %d\n",
               SCARG(&ua, s), SCARG(&ua, name), SCARG(&ua, namelen));
#endif

       return linux_sys_connect(l, &ua, retval);
}

int
linux32_sys_accept(struct lwp *l, const struct linux32_sys_accept_args *uap, register_t *retval)
{
       /* {
               syscallarg(int) s;
               syscallarg(netbsd32_osockaddrp_t) name;
               syscallarg(netbsd32_intp) anamelen;
       } */
       struct linux_sys_accept_args ua;

       NETBSD32TO64_UAP(s);
       NETBSD32TOP_UAP(name, struct osockaddr);
       NETBSD32TOP_UAP(anamelen, int);

       return linux_sys_accept(l, &ua, retval);
}

int
linux32_sys_getpeername(struct lwp *l, const struct linux32_sys_getpeername_args *uap, register_t *retval)
{
       /* {
               syscallarg(int) fdes;
               syscallarg(netbsd32_sockaddrp_t) asa;
               syscallarg(netbsd32_intp) alen;
       } */
       struct linux_sys_getpeername_args ua;

       NETBSD32TO64_UAP(fdes);
       NETBSD32TOP_UAP(asa, struct sockaddr);
       NETBSD32TOP_UAP(alen, int);

       return linux_sys_getpeername(l, &ua, retval);
}

int
linux32_sys_getsockname(struct lwp *l, const struct linux32_sys_getsockname_args *uap, register_t *retval)
{
       /* {
               syscallarg(int) fdec;
               syscallarg(netbsd32_charp) asa;
               syscallarg(netbsd32_intp) alen;
       } */
       struct linux_sys_getsockname_args ua;

       NETBSD32TO64_UAP(fdec);
       NETBSD32TOP_UAP(asa, char);
       NETBSD32TOP_UAP(alen, int);

       return linux_sys_getsockname(l, &ua, retval);
}

int
linux32_sys_sendmsg(struct lwp *l, const struct linux32_sys_sendmsg_args *uap, register_t *retval)
{
       /* {
               syscallarg(int) s;
               syscallarg(netbsd32_msghdrp_t) msg;
               syscallarg(int) flags;
       } */
       struct linux_sys_sendmsg_args ua;

       NETBSD32TO64_UAP(s);
       NETBSD32TOP_UAP(msg, struct msghdr);
       NETBSD32TO64_UAP(flags);

       return linux_sys_sendmsg(l, &ua, retval);
}

int
linux32_sys_recvmsg(struct lwp *l, const struct linux32_sys_recvmsg_args *uap, register_t *retval)
{
       /* {
               syscallarg(int) s;
               syscallarg(netbsd32_msghdrp_t) msg;
               syscallarg(int) flags;
       } */
       struct linux_sys_recvmsg_args ua;

       NETBSD32TO64_UAP(s);
       NETBSD32TOP_UAP(msg, struct msghdr);
       NETBSD32TO64_UAP(flags);

       return linux_sys_recvmsg(l, &ua, retval);
}

int
linux32_sys_send(struct lwp *l, const struct linux32_sys_send_args *uap, register_t *retval)
{
       /* {
               syscallarg(int) s;
               syscallarg(netbsd32_voidp) buf;
               syscallarg(int) len;
               syscallarg(int) flags;
       } */
       struct sys_sendto_args ua;

       NETBSD32TO64_UAP(s);
       NETBSD32TOP_UAP(buf, void);
       NETBSD32TO64_UAP(len);
       NETBSD32TO64_UAP(flags);
       SCARG(&ua, to) = NULL;
       SCARG(&ua, tolen) = 0;

       return sys_sendto(l, &ua, retval);
}

int
linux32_sys_recv(struct lwp *l, const struct linux32_sys_recv_args *uap, register_t *retval)
{
       /* {
               syscallarg(int) s;
               syscallarg(netbsd32_voidp) buf;
               syscallarg(int) len;
               syscallarg(int) flags;
       } */
       struct sys_recvfrom_args ua;

       NETBSD32TO64_UAP(s);
       NETBSD32TOP_UAP(buf, void);
       NETBSD32TO64_UAP(len);
       NETBSD32TO64_UAP(flags);
       SCARG(&ua, from) = NULL;
       SCARG(&ua, fromlenaddr) = NULL;

       return sys_recvfrom(l, &ua, retval);
}

int
linux32_getifname(struct lwp *l, register_t *retval, void *data)
{
       struct ifnet *ifp;
       struct linux32_ifreq ifr;
       int error;
       int s;

       error = copyin(data, &ifr, sizeof(ifr));
       if (error)
               return error;

       s = pserialize_read_enter();
       ifp = if_byindex(ifr.ifr_ifru.ifru_ifindex);
       if (ifp == NULL) {
               pserialize_read_exit(s);
               return ENODEV;
       }

       strncpy(ifr.ifr_name, ifp->if_xname, sizeof(ifr.ifr_name));
       pserialize_read_exit(s);

       return copyout(&ifr, data, sizeof(ifr));
}

int
linux32_getifconf(struct lwp *l, register_t *retval, void *data)
{
       struct linux32_ifreq ifr, *ifrp = NULL;
       struct linux32_ifconf ifc;
       struct ifnet *ifp;
       struct sockaddr *sa;
       struct osockaddr *osa;
       int space = 0, error;
       const int sz = (int)sizeof(ifr);
       bool docopy;
       int s;
       int bound;
       struct psref psref;

       error = copyin(data, &ifc, sizeof(ifc));
       if (error)
               return error;

       docopy = NETBSD32PTR64(ifc.ifc_req) != NULL;
       if (docopy) {
               if (ifc.ifc_len < 0)
                       return EINVAL;

               space = ifc.ifc_len;
               ifrp = NETBSD32PTR64(ifc.ifc_req);
       }
       memset(&ifr, 0, sizeof(ifr));

       bound = curlwp_bind();
       s = pserialize_read_enter();
       IFNET_READER_FOREACH(ifp) {
               struct ifaddr *ifa;
               if_acquire(ifp, &psref);
               pserialize_read_exit(s);

               (void)strncpy(ifr.ifr_name, ifp->if_xname,
                   sizeof(ifr.ifr_name));
               if (ifr.ifr_name[sizeof(ifr.ifr_name) - 1] != '\0') {
                       error = ENAMETOOLONG;
                       goto release_exit;
               }

               s = pserialize_read_enter();
               IFADDR_READER_FOREACH(ifa, ifp) {
                       struct psref psref_ifa;
                       ifa_acquire(ifa, &psref_ifa);
                       pserialize_read_exit(s);

                       sa = ifa->ifa_addr;
                       if (sa->sa_family != AF_INET ||
                           sa->sa_len > sizeof(*osa))
                               goto next;
                       memcpy(&ifr.ifr_addr, sa, sa->sa_len);
                       osa = (struct osockaddr *)&ifr.ifr_addr;
                       osa->sa_family = sa->sa_family;
                       if (space >= sz) {
                               error = copyout(&ifr, ifrp, sz);
                               if (error != 0) {
                                       ifa_release(ifa, &psref_ifa);
                                       goto release_exit;
                               }
                               ifrp++;
                       }
                       space -= sz;
               next:
                       s = pserialize_read_enter();
                       ifa_release(ifa, &psref_ifa);
               }

               KASSERT(pserialize_in_read_section());
               if_release(ifp, &psref);
       }
       pserialize_read_exit(s);
       curlwp_bindx(bound);

       if (docopy)
               ifc.ifc_len -= space;
       else
               ifc.ifc_len = -space;

       return copyout(&ifc, data, sizeof(ifc));

release_exit:
       if_release(ifp, &psref);
       curlwp_bindx(bound);
       return error;
}

int
linux32_getifhwaddr(struct lwp *l, register_t *retval, u_int fd,
   void *data)
{
       struct linux32_ifreq lreq;
       file_t *fp;
       struct ifaddr *ifa;
       struct ifnet *ifp;
       struct sockaddr_dl *sadl;
       int error, found;
       int index, ifnum;
       int s;

       /*
        * We can't emulate this ioctl by calling sys_ioctl() to run
        * SIOCGIFCONF, because the user buffer is not of the right
        * type to take those results.  We can't use kernel buffers to
        * receive the results, as the implementation of sys_ioctl()
        * and ifconf() [which implements SIOCGIFCONF] use
        * copyin()/copyout() which will fail on kernel addresses.
        *
        * So, we must duplicate code from sys_ioctl() and ifconf().  Ugh.
        */

       if ((fp = fd_getfile(fd)) == NULL)
               return (EBADF);

       KERNEL_LOCK(1, NULL);

       if ((fp->f_flag & (FREAD | FWRITE)) == 0) {
               error = EBADF;
               goto out;
       }

       error = copyin(data, &lreq, sizeof(lreq));
       if (error)
               goto out;
       lreq.ifr_name[LINUX32_IFNAMSIZ-1] = '\0';               /* just in case */

       /*
        * Try real interface name first, then fake "ethX"
        */
       found = 0;
       s = pserialize_read_enter();
       IFNET_READER_FOREACH(ifp) {
               if (found)
                       break;
               if (strcmp(lreq.ifr_name, ifp->if_xname))
                       /* not this interface */
                       continue;
               found=1;
               if (IFADDR_READER_EMPTY(ifp)) {
                       error = ENODEV;
                       goto out;
               }
               IFADDR_READER_FOREACH(ifa, ifp) {
                       sadl = satosdl(ifa->ifa_addr);
                       /* only return ethernet addresses */
                       /* XXX what about FDDI, etc. ? */
                       if (sadl->sdl_family != AF_LINK ||
                           sadl->sdl_type != IFT_ETHER)
                               continue;
                       memcpy(&lreq.ifr_hwaddr.sa_data, CLLADDR(sadl),
                              MIN(sadl->sdl_alen,
                                  sizeof(lreq.ifr_hwaddr.sa_data)));
                       lreq.ifr_hwaddr.sa_family =
                               sadl->sdl_family;
                       pserialize_read_exit(s);

                       error = copyout(&lreq, data, sizeof(lreq));
                       goto out;
               }
       }
       pserialize_read_exit(s);

       if (strncmp(lreq.ifr_name, "eth", 3) == 0) {
               for (ifnum = 0, index = 3;
                    index < LINUX32_IFNAMSIZ && lreq.ifr_name[index] != '\0';
                    index++) {
                       ifnum *= 10;
                       ifnum += lreq.ifr_name[index] - '0';
               }

               error = EINVAL;                 /* in case we don't find one */
               s = pserialize_read_enter();
               IFNET_READER_FOREACH(ifp) {
                       memcpy(lreq.ifr_name, ifp->if_xname,
                              MIN(LINUX32_IFNAMSIZ, IFNAMSIZ));
                       IFADDR_READER_FOREACH(ifa, ifp) {
                               sadl = satosdl(ifa->ifa_addr);
                               /* only return ethernet addresses */
                               /* XXX what about FDDI, etc. ? */
                               if (sadl->sdl_family != AF_LINK ||
                                   sadl->sdl_type != IFT_ETHER)
                                       continue;
                               if (ifnum--)
                                       /* not the requested iface */
                                       continue;
                               memcpy(&lreq.ifr_hwaddr.sa_data,
                                      CLLADDR(sadl),
                                      MIN(sadl->sdl_alen,
                                          sizeof(lreq.ifr_hwaddr.sa_data)));
                               lreq.ifr_hwaddr.sa_family =
                                       sadl->sdl_family;
                               pserialize_read_exit(s);

                               error = copyout(&lreq, data, sizeof(lreq));
                               goto out;
                       }
               }
               pserialize_read_exit(s);
       } else {
               /* unknown interface, not even an "eth*" name */
               error = ENODEV;
       }

out:
       KERNEL_UNLOCK_ONE(NULL);
       fd_putfile(fd);
       return error;
}

int
linux32_ioctl_socket(struct lwp *l, const struct linux32_sys_ioctl_args *uap, register_t *retval)
{
       /* {
               syscallarg(int) fd;
               syscallarg(u_long) com;
               syscallarg(void *) data;
       } */
       u_long com;
       int error = 0, isdev = 0, dosys = 1;
       struct netbsd32_ioctl_args ia;
       file_t *fp;
       struct vnode *vp;
       int (*ioctlf)(file_t *, u_long, void *);
       struct ioctl_pt pt;

       if ((fp = fd_getfile(SCARG(uap, fd))) == NULL)
               return (EBADF);

       if (fp->f_type == DTYPE_VNODE) {
               vp = (struct vnode *)fp->f_data;
               isdev = vp->v_type == VCHR;
       }

       /*
        * Don't try to interpret socket ioctl calls that are done
        * on a device filedescriptor, just pass them through, to
        * emulate Linux behaviour. Use PTIOCLINUX so that the
        * device will only handle these if it's prepared to do
        * so, to avoid unexpected things from happening.
        */
       if (isdev) {
               dosys = 0;
               ioctlf = fp->f_ops->fo_ioctl;
               pt.com = SCARG(uap, com);
               pt.data = (void *)NETBSD32PTR64(SCARG(uap, data));
               error = ioctlf(fp, PTIOCLINUX, &pt);
               /*
                * XXX hack: if the function returns EJUSTRETURN,
                * it has stuffed a sysctl return value in pt.data.
                */
               if (error == EJUSTRETURN) {
                       retval[0] = (register_t)pt.data;
                       error = 0;
               }
               goto out;
       }

       com = SCARG(uap, com);
       retval[0] = 0;

       switch (com) {
       case LINUX_SIOCGIFNAME:
               error = linux32_getifname(l, retval, SCARG_P32(uap, data));
               dosys = 0;
               break;
       case LINUX_SIOCGIFCONF:
               error = linux32_getifconf(l, retval, SCARG_P32(uap, data));
               dosys = 0;
               break;
       case LINUX_SIOCGIFFLAGS:
               SCARG(&ia, com) = OSIOCGIFFLAGS32;
               break;
       case LINUX_SIOCSIFFLAGS:
               SCARG(&ia, com) = OSIOCSIFFLAGS32;
               break;
       case LINUX_SIOCGIFADDR:
               SCARG(&ia, com) = OOSIOCGIFADDR32;
               break;
       case LINUX_SIOCGIFDSTADDR:
               SCARG(&ia, com) = OOSIOCGIFDSTADDR32;
               break;
       case LINUX_SIOCGIFBRDADDR:
               SCARG(&ia, com) = OOSIOCGIFBRDADDR32;
               break;
       case LINUX_SIOCGIFNETMASK:
               SCARG(&ia, com) = OOSIOCGIFNETMASK32;
               break;
       case LINUX_SIOCGIFMTU:
               SCARG(&ia, com) = OSIOCGIFMTU32;
               break;
       case LINUX_SIOCADDMULTI:
               SCARG(&ia, com) = OSIOCADDMULTI32;
               break;
       case LINUX_SIOCDELMULTI:
               SCARG(&ia, com) = OSIOCDELMULTI32;
               break;
       case LINUX_SIOCGIFHWADDR:
               error = linux32_getifhwaddr(l, retval, SCARG(uap, fd),
                   SCARG_P32(uap, data));
               dosys = 0;
               break;
       default:
               error = EINVAL;
       }

out:
       fd_putfile(SCARG(uap, fd));

       if (error == 0 && dosys) {
               SCARG(&ia, fd) = SCARG(uap, fd);
               SCARG(&ia, data) = SCARG(uap, data);
               error = netbsd32_ioctl(curlwp, &ia, retval);
       }

       return error;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.