Annotation of src/sys/compat/linux/common/linux_socket.c, revision 1.24

1.24    ! thorpej     1: /*     $NetBSD: linux_socket.c,v 1.23 2000/03/30 11:27:18 augustss Exp $       */
1.16      erh         2: 
                      3: /*-
1.18      fvdl        4:  * Copyright (c) 1995, 1998 The NetBSD Foundation, Inc.
1.16      erh         5:  * All rights reserved.
                      6:  *
                      7:  * This code is derived from software contributed to The NetBSD Foundation
1.18      fvdl        8:  * by Frank van der Linden and Eric Haszlakiewicz.
1.16      erh         9:  *
                     10:  * Redistribution and use in source and binary forms, with or without
                     11:  * modification, are permitted provided that the following conditions
                     12:  * are met:
                     13:  * 1. Redistributions of source code must retain the above copyright
                     14:  *    notice, this list of conditions and the following disclaimer.
                     15:  * 2. Redistributions in binary form must reproduce the above copyright
                     16:  *    notice, this list of conditions and the following disclaimer in the
                     17:  *    documentation and/or other materials provided with the distribution.
                     18:  * 3. All advertising materials mentioning features or use of this software
                     19:  *    must display the following acknowledgement:
                     20:  *     This product includes software developed by the NetBSD
                     21:  *     Foundation, Inc. and its contributors.
                     22:  * 4. Neither the name of The NetBSD Foundation nor the names of its
                     23:  *    contributors may be used to endorse or promote products derived
                     24:  *    from this software without specific prior written permission.
                     25:  *
                     26:  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
                     27:  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
                     28:  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
                     29:  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
                     30:  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
                     31:  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
                     32:  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
                     33:  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
                     34:  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
                     35:  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
                     36:  * POSSIBILITY OF SUCH DAMAGE.
1.1       fvdl       37:  */
                     38: 
1.16      erh        39: /*
                     40:  * Functions in multiarch:
                     41:  *     linux_sys_socketcall            : linux_socketcall.c
                     42:  */
                     43: 
1.1       fvdl       44: #include <sys/param.h>
                     45: #include <sys/kernel.h>
                     46: #include <sys/systm.h>
                     47: #include <sys/buf.h>
                     48: #include <sys/malloc.h>
                     49: #include <sys/ioctl.h>
                     50: #include <sys/tty.h>
                     51: #include <sys/file.h>
                     52: #include <sys/filedesc.h>
                     53: #include <sys/select.h>
                     54: #include <sys/socket.h>
                     55: #include <sys/socketvar.h>
                     56: #include <net/if.h>
1.21      jtk        57: #include <net/if_dl.h>
                     58: #include <net/if_types.h>
1.1       fvdl       59: #include <netinet/in.h>
1.7       mycroft    60: #include <netinet/tcp.h>
1.1       fvdl       61: #include <sys/mount.h>
                     62: #include <sys/proc.h>
                     63: #include <sys/vnode.h>
                     64: #include <sys/device.h>
1.19      sommerfe   65: #include <sys/protosw.h> 
1.1       fvdl       66: 
                     67: #include <sys/syscallargs.h>
                     68: 
1.17      christos   69: #include <compat/linux/common/linux_types.h>
                     70: #include <compat/linux/common/linux_util.h>
                     71: #include <compat/linux/common/linux_signal.h>
                     72: #include <compat/linux/common/linux_ioctl.h>
                     73: #include <compat/linux/common/linux_socket.h>
                     74: #include <compat/linux/common/linux_socketcall.h>
                     75: #include <compat/linux/common/linux_sockio.h>
                     76: 
1.1       fvdl       77: #include <compat/linux/linux_syscallargs.h>
                     78: 
1.21      jtk        79: #ifndef MIN
                     80: #define        MIN(a,b) (((a)<(b))?(a):(b))
                     81: #endif
                     82: 
1.1       fvdl       83: /*
1.16      erh        84:  * The calls in this file are entered either via the linux_socketcall()
                     85:  * interface or, on the Alpha, as individual syscalls.  The
                     86:  * linux_socketcall function does any massaging of arguments so that all
                     87:  * the calls in here need not think that they are anything other
                     88:  * than a normal syscall.
1.1       fvdl       89:  */
1.14      christos   90: 
                     91: int linux_to_bsd_domain __P((int));
                     92: int linux_to_bsd_sopt_level __P((int));
                     93: int linux_to_bsd_so_sockopt __P((int));
                     94: int linux_to_bsd_ip_sockopt __P((int));
                     95: int linux_to_bsd_tcp_sockopt __P((int));
                     96: int linux_to_bsd_udp_sockopt __P((int));
1.21      jtk        97: int linux_getifhwaddr __P((struct proc *, register_t *, u_int, void *));
1.1       fvdl       98: 
                     99: /*
                    100:  * Convert between Linux and BSD socket domain values
                    101:  */
1.2       mycroft   102: int
1.1       fvdl      103: linux_to_bsd_domain(ldom)
                    104:        int ldom;
                    105: {
1.12      mycroft   106: 
1.1       fvdl      107:        switch (ldom) {
                    108:        case LINUX_AF_UNSPEC:
                    109:                return AF_UNSPEC;
                    110:        case LINUX_AF_UNIX:
                    111:                return AF_LOCAL;
                    112:        case LINUX_AF_INET:
                    113:                return AF_INET;
                    114:        case LINUX_AF_AX25:
                    115:                return AF_CCITT;
                    116:        case LINUX_AF_IPX:
                    117:                return AF_IPX;
                    118:        case LINUX_AF_APPLETALK:
                    119:                return AF_APPLETALK;
1.16      erh       120:        case LINUX_AF_X25:
                    121:                return AF_CCITT;
                    122:        case LINUX_AF_INET6:
                    123:                return AF_INET6;
                    124:        case LINUX_AF_DECnet:
                    125:                return AF_DECnet;
                    126:        case LINUX_AF_NETLINK:
                    127:                return AF_ROUTE;
                    128:        /* NETROM, BRIDGE, ATMPVC, ROSE, NETBEUI, SECURITY, */
                    129:        /* pseudo_AF_KEY, PACKET, ASH, ECONET, ATMSVC, SNA */
1.1       fvdl      130:        default:
                    131:                return -1;
                    132:        }
                    133: }
                    134: 
1.2       mycroft   135: int
1.16      erh       136: linux_sys_socket(p, v, retval)
1.1       fvdl      137:        struct proc *p;
1.16      erh       138:        void *v;
                    139:        register_t *retval;
                    140: {
                    141:        struct linux_sys_socket_args /* {
1.1       fvdl      142:                syscallarg(int) domain;
                    143:                syscallarg(int) type;
                    144:                syscallarg(int) protocol;
1.16      erh       145:        } */ *uap = v;
1.12      mycroft   146:        struct sys_socket_args bsa;
1.1       fvdl      147: 
1.16      erh       148:        SCARG(&bsa, protocol) = SCARG(uap, protocol);
                    149:        SCARG(&bsa, type) = SCARG(uap, type);
                    150:        SCARG(&bsa, domain) = linux_to_bsd_domain(SCARG(uap, domain));
1.1       fvdl      151:        if (SCARG(&bsa, domain) == -1)
                    152:                return EINVAL;
1.12      mycroft   153:        return sys_socket(p, &bsa, retval);
1.1       fvdl      154: }
                    155: 
1.2       mycroft   156: int
1.16      erh       157: linux_sys_socketpair(p, v, retval)
1.1       fvdl      158:        struct proc *p;
1.16      erh       159:        void *v;
1.1       fvdl      160:        register_t *retval;
                    161: {
1.16      erh       162:        struct linux_sys_socketpair_args /* {
1.1       fvdl      163:                syscallarg(int) domain;
                    164:                syscallarg(int) type;
                    165:                syscallarg(int) protocol;
                    166:                syscallarg(int *) rsv;
1.16      erh       167:        } */ *uap = v;
1.12      mycroft   168:        struct sys_socketpair_args bsa;
1.1       fvdl      169: 
1.16      erh       170:        SCARG(&bsa, domain) = linux_to_bsd_domain(SCARG(uap, domain));
1.1       fvdl      171:        if (SCARG(&bsa, domain) == -1)
                    172:                return EINVAL;
1.16      erh       173:        SCARG(&bsa, type) = SCARG(uap, type);
                    174:        SCARG(&bsa, protocol) = SCARG(uap, protocol);
                    175:        SCARG(&bsa, rsv) = SCARG(uap, rsv);
1.1       fvdl      176: 
1.12      mycroft   177:        return sys_socketpair(p, &bsa, retval);
1.1       fvdl      178: }
                    179: 
1.2       mycroft   180: int
1.16      erh       181: linux_sys_sendto(p, v, retval)
1.1       fvdl      182:        struct proc *p;
1.16      erh       183:        void *v;
1.1       fvdl      184:        register_t *retval;
                    185: {
1.16      erh       186:        struct linux_sys_sendto_args /* {
1.1       fvdl      187:                syscallarg(int) s;
                    188:                syscallarg(void *) msg;
                    189:                syscallarg(int) len;
                    190:                syscallarg(int) flags;
                    191:                syscallarg(sockaddr *) to;
                    192:                syscallarg(int) tolen;
1.16      erh       193:        } */ *uap = v;
1.12      mycroft   194:        struct sys_sendto_args bsa;
1.1       fvdl      195: 
1.16      erh       196:        SCARG(&bsa, s) = SCARG(uap, s);
                    197:        SCARG(&bsa, buf) = SCARG(uap, msg);
                    198:        SCARG(&bsa, len) = SCARG(uap, len);
                    199:        SCARG(&bsa, flags) = SCARG(uap, flags);
                    200:        SCARG(&bsa, to) = (void *) SCARG(uap, to);
                    201:        SCARG(&bsa, tolen) = SCARG(uap, tolen);
1.1       fvdl      202: 
1.12      mycroft   203:        return sys_sendto(p, &bsa, retval);
1.1       fvdl      204: }
                    205: 
1.2       mycroft   206: int
1.16      erh       207: linux_sys_recvfrom(p, v, retval)
1.1       fvdl      208:        struct proc *p;
1.16      erh       209:        void *v;
                    210:        register_t *retval;
                    211: {
                    212:        struct linux_sys_recvfrom_args /* {
1.1       fvdl      213:                syscallarg(int) s;
                    214:                syscallarg(void *) buf;
                    215:                syscallarg(int) len;
                    216:                syscallarg(int) flags;
                    217:                syscallarg(struct sockaddr *) from;
                    218:                syscallarg(int *) fromlen;
1.16      erh       219:        } */ *uap = v;
1.12      mycroft   220:        struct compat_43_sys_recvfrom_args bra;
1.1       fvdl      221: 
1.16      erh       222:        SCARG(&bra, s) = SCARG(uap, s);
                    223:        SCARG(&bra, buf) = SCARG(uap, buf);
                    224:        SCARG(&bra, len) = SCARG(uap, len);
                    225:        SCARG(&bra, flags) = SCARG(uap, flags);
                    226:        SCARG(&bra, from) = (caddr_t) SCARG(uap, from);
                    227:        SCARG(&bra, fromlenaddr) = SCARG(uap, fromlen);
1.1       fvdl      228: 
1.12      mycroft   229:        return compat_43_sys_recvfrom(p, &bra, retval);
1.1       fvdl      230: }
                    231: 
                    232: /*
                    233:  * Convert socket option level from Linux to NetBSD value. Only SOL_SOCKET
                    234:  * is different, the rest matches IPPROTO_* on both systems.
                    235:  */
1.2       mycroft   236: int
1.1       fvdl      237: linux_to_bsd_sopt_level(llevel)
                    238:        int llevel;
                    239: {
1.12      mycroft   240: 
1.1       fvdl      241:        switch (llevel) {
                    242:        case LINUX_SOL_SOCKET:
                    243:                return SOL_SOCKET;
1.3       mycroft   244:        case LINUX_SOL_IP:
                    245:                return IPPROTO_IP;
                    246:        case LINUX_SOL_TCP:
                    247:                return IPPROTO_TCP;
                    248:        case LINUX_SOL_UDP:
                    249:                return IPPROTO_UDP;
1.1       fvdl      250:        default:
                    251:                return -1;
                    252:        }
                    253: }
                    254: 
                    255: /*
                    256:  * Convert Linux socket level socket option numbers to NetBSD values.
                    257:  */
1.2       mycroft   258: int
1.1       fvdl      259: linux_to_bsd_so_sockopt(lopt)
                    260:        int lopt;
                    261: {
1.12      mycroft   262: 
1.1       fvdl      263:        switch (lopt) {
                    264:        case LINUX_SO_DEBUG:
                    265:                return SO_DEBUG;
                    266:        case LINUX_SO_REUSEADDR:
                    267:                return SO_REUSEADDR;
                    268:        case LINUX_SO_TYPE:
                    269:                return SO_TYPE;
                    270:        case LINUX_SO_ERROR:
                    271:                return SO_ERROR;
                    272:        case LINUX_SO_DONTROUTE:
                    273:                return SO_DONTROUTE;
                    274:        case LINUX_SO_BROADCAST:
                    275:                return SO_BROADCAST;
                    276:        case LINUX_SO_SNDBUF:
                    277:                return SO_SNDBUF;
                    278:        case LINUX_SO_RCVBUF:
                    279:                return SO_RCVBUF;
                    280:        case LINUX_SO_KEEPALIVE:
                    281:                return SO_KEEPALIVE;
                    282:        case LINUX_SO_OOBINLINE:
                    283:                return SO_OOBINLINE;
                    284:        case LINUX_SO_LINGER:
                    285:                return SO_LINGER;
                    286:        case LINUX_SO_PRIORITY:
                    287:        case LINUX_SO_NO_CHECK:
                    288:        default:
                    289:                return -1;
                    290:        }
                    291: }
                    292: 
                    293: /*
1.3       mycroft   294:  * Convert Linux IP level socket option number to NetBSD values.
                    295:  */
                    296: int
                    297: linux_to_bsd_ip_sockopt(lopt)
                    298:        int lopt;
                    299: {
1.12      mycroft   300: 
1.3       mycroft   301:        switch (lopt) {
                    302:        case LINUX_IP_TOS:
                    303:                return IP_TOS;
                    304:        case LINUX_IP_TTL:
                    305:                return IP_TTL;
                    306:        case LINUX_IP_MULTICAST_TTL:
                    307:                return IP_MULTICAST_TTL;
                    308:        case LINUX_IP_MULTICAST_LOOP:
                    309:                return IP_MULTICAST_LOOP;
                    310:        case LINUX_IP_MULTICAST_IF:
                    311:                return IP_MULTICAST_IF;
                    312:        case LINUX_IP_ADD_MEMBERSHIP:
                    313:                return IP_ADD_MEMBERSHIP;
                    314:        case LINUX_IP_DROP_MEMBERSHIP:
                    315:                return IP_DROP_MEMBERSHIP;
                    316:        default:
                    317:                return -1;
                    318:        }
                    319: }
                    320: 
                    321: /*
                    322:  * Convert Linux TCP level socket option number to NetBSD values.
                    323:  */
                    324: int
                    325: linux_to_bsd_tcp_sockopt(lopt)
                    326:        int lopt;
                    327: {
1.12      mycroft   328: 
1.3       mycroft   329:        switch (lopt) {
1.6       mycroft   330:        case LINUX_TCP_NODELAY:
                    331:                return TCP_NODELAY;
                    332:        case LINUX_TCP_MAXSEG:
                    333:                return TCP_MAXSEG;
1.3       mycroft   334:        default:
1.6       mycroft   335:                return -1;
1.3       mycroft   336:        }
                    337: }
                    338: 
                    339: /*
                    340:  * Convert Linux UDP level socket option number to NetBSD values.
                    341:  */
                    342: int
                    343: linux_to_bsd_udp_sockopt(lopt)
                    344:        int lopt;
                    345: {
1.12      mycroft   346: 
1.3       mycroft   347:        switch (lopt) {
                    348:        default:
1.6       mycroft   349:                return -1;
1.3       mycroft   350:        }
                    351: }
                    352: 
                    353: /*
1.5       mycroft   354:  * Another reasonably straightforward function: setsockopt(2).
1.1       fvdl      355:  * The level and option numbers are converted; the values passed
                    356:  * are not (yet) converted, the ones currently implemented don't
                    357:  * need conversion, as they are the same on both systems.
                    358:  */
1.2       mycroft   359: int
1.16      erh       360: linux_sys_setsockopt(p, v, retval)
1.1       fvdl      361:        struct proc *p;
1.16      erh       362:        void *v;
                    363:        register_t *retval;
                    364: {
                    365:        struct linux_sys_setsockopt_args /* {
1.1       fvdl      366:                syscallarg(int) s;
                    367:                syscallarg(int) level;
                    368:                syscallarg(int) optname;
                    369:                syscallarg(void *) optval;
                    370:                syscallarg(int) optlen;
1.16      erh       371:        } */ *uap = v;
1.12      mycroft   372:        struct sys_setsockopt_args bsa;
1.16      erh       373:        int name;
1.1       fvdl      374: 
1.16      erh       375:        SCARG(&bsa, s) = SCARG(uap, s);
                    376:        SCARG(&bsa, level) = linux_to_bsd_sopt_level(SCARG(uap, level));
                    377:        SCARG(&bsa, val) = SCARG(uap, optval);
                    378:        SCARG(&bsa, valsize) = SCARG(uap, optlen);
1.1       fvdl      379: 
                    380:        switch (SCARG(&bsa, level)) {
                    381:                case SOL_SOCKET:
1.16      erh       382:                        name = linux_to_bsd_so_sockopt(SCARG(uap, optname));
1.1       fvdl      383:                        break;
                    384:                case IPPROTO_IP:
1.16      erh       385:                        name = linux_to_bsd_ip_sockopt(SCARG(uap, optname));
1.1       fvdl      386:                        break;
1.3       mycroft   387:                case IPPROTO_TCP:
1.16      erh       388:                        name = linux_to_bsd_tcp_sockopt(SCARG(uap, optname));
1.3       mycroft   389:                        break;
                    390:                case IPPROTO_UDP:
1.16      erh       391:                        name = linux_to_bsd_udp_sockopt(SCARG(uap, optname));
1.3       mycroft   392:                        break;
1.1       fvdl      393:                default:
                    394:                        return EINVAL;
                    395:        }
                    396: 
                    397:        if (name == -1)
                    398:                return EINVAL;
                    399:        SCARG(&bsa, name) = name;
                    400: 
1.12      mycroft   401:        return sys_setsockopt(p, &bsa, retval);
1.1       fvdl      402: }
                    403: 
                    404: /*
                    405:  * getsockopt(2) is very much the same as setsockopt(2) (see above)
                    406:  */
1.2       mycroft   407: int
1.16      erh       408: linux_sys_getsockopt(p, v, retval)
1.1       fvdl      409:        struct proc *p;
1.16      erh       410:        void *v;
                    411:        register_t *retval;
                    412: {
                    413:        struct linux_sys_getsockopt_args /* {
1.1       fvdl      414:                syscallarg(int) s;
                    415:                syscallarg(int) level;
                    416:                syscallarg(int) optname;
                    417:                syscallarg(void *) optval;
1.16      erh       418:                syscallarg(int *) optlen;
                    419:        } */ *uap = v;
1.12      mycroft   420:        struct sys_getsockopt_args bga;
1.16      erh       421:        int name;
1.1       fvdl      422: 
1.16      erh       423:        SCARG(&bga, s) = SCARG(uap, s);
                    424:        SCARG(&bga, level) = linux_to_bsd_sopt_level(SCARG(uap, level));
                    425:        SCARG(&bga, val) = SCARG(uap, optval);
                    426:        SCARG(&bga, avalsize) = SCARG(uap, optlen);
1.1       fvdl      427: 
                    428:        switch (SCARG(&bga, level)) {
                    429:                case SOL_SOCKET:
1.16      erh       430:                        name = linux_to_bsd_so_sockopt(SCARG(uap, optname));
1.1       fvdl      431:                        break;
                    432:                case IPPROTO_IP:
1.16      erh       433:                        name = linux_to_bsd_ip_sockopt(SCARG(uap, optname));
1.3       mycroft   434:                        break;
                    435:                case IPPROTO_TCP:
1.16      erh       436:                        name = linux_to_bsd_tcp_sockopt(SCARG(uap, optname));
1.3       mycroft   437:                        break;
                    438:                case IPPROTO_UDP:
1.16      erh       439:                        name = linux_to_bsd_udp_sockopt(SCARG(uap, optname));
1.1       fvdl      440:                        break;
                    441:                default:
                    442:                        return EINVAL;
                    443:        }
                    444: 
                    445:        if (name == -1)
                    446:                return EINVAL;
1.5       mycroft   447:        SCARG(&bga, name) = name;
1.1       fvdl      448: 
1.12      mycroft   449:        return sys_getsockopt(p, &bga, retval);
1.13      mycroft   450: }
                    451: 
1.21      jtk       452: #define IF_NAME_LEN 16
                    453: 
                    454: int
                    455: linux_getifhwaddr(p, retval, fd, data)
                    456:        struct proc *p;
                    457:        register_t *retval;
                    458:        u_int fd;
                    459:        void *data;
                    460: {
                    461:        /* Not the full structure, just enough to map what we do here */
                    462:        struct linux_ifreq {
                    463:                char if_name[IF_NAME_LEN];
                    464:                struct osockaddr hwaddr;
                    465:        } lreq;
                    466:        struct filedesc *fdp;
                    467:        struct file *fp;
                    468:        struct ifaddr *ifa;
                    469:        struct ifnet *ifp;
                    470:        struct sockaddr_dl *sadl;
                    471:        int error, found;
                    472:        int index, ifnum;
                    473: 
                    474:        /*
                    475:         * We can't emulate this ioctl by calling sys_ioctl() to run
                    476:         * SIOCGIFCONF, because the user buffer is not of the right
                    477:         * type to take those results.  We can't use kernel buffers to
                    478:         * receive the results, as the implementation of sys_ioctl()
                    479:         * and ifconf() [which implements SIOCGIFCONF] use
                    480:         * copyin()/copyout() which will fail on kernel addresses.
                    481:         *
                    482:         * So, we must duplicate code from sys_ioctl() and ifconf().  Ugh.
                    483:         */
                    484: 
                    485:        fdp = p->p_fd;
                    486:        if (fd >= fdp->fd_nfiles ||
                    487:            (fp = fdp->fd_ofiles[fd]) == NULL ||
                    488:            (fp->f_iflags & FIF_WANTCLOSE) != 0)
                    489:                return (EBADF);
                    490: 
                    491:        FILE_USE(fp);
                    492:        if ((fp->f_flag & (FREAD | FWRITE)) == 0) {
                    493:                error = EBADF;
                    494:                goto out;
                    495:        }
                    496: 
                    497:        error = copyin(data, (caddr_t)&lreq, sizeof(lreq));
                    498:        if (error)
                    499:                goto out;
                    500:        lreq.if_name[IF_NAME_LEN-1] = '\0';             /* just in case */
                    501: 
                    502:        /*
1.22      jdolecek  503:         * Try real interface name first, then fake "ethX"
1.21      jtk       504:         */
1.22      jdolecek  505:        for (ifp = ifnet.tqh_first, found = 0;
                    506:             ifp != 0 && !found;
                    507:             ifp = ifp->if_list.tqe_next) {
                    508:                if (strcmp(lreq.if_name, ifp->if_xname))
                    509:                        /* not this interface */
                    510:                        continue;
                    511:                found=1;           
                    512:                if ((ifa = ifp->if_addrlist.tqh_first) != 0) {
                    513:                        for (; ifa != 0; ifa = ifa->ifa_list.tqe_next) {
                    514:                                sadl = (struct sockaddr_dl *)ifa->ifa_addr;
                    515:                                /* only return ethernet addresses */
                    516:                                /* XXX what about FDDI, etc. ? */
                    517:                                if (sadl->sdl_family != AF_LINK ||
                    518:                                    sadl->sdl_type != IFT_ETHER)
                    519:                                        continue;
                    520:                                memcpy((caddr_t)&lreq.hwaddr.sa_data,
                    521:                                       LLADDR(sadl),
                    522:                                       MIN(sadl->sdl_alen,
                    523:                                           sizeof(lreq.hwaddr.sa_data)));
                    524:                                lreq.hwaddr.sa_family =
                    525:                                        sadl->sdl_family;
                    526:                                error = copyout((caddr_t)&lreq, data,
                    527:                                                sizeof(lreq));
                    528:                                goto out; 
                    529:                        }
                    530:                } else {
                    531:                        error = ENODEV;
                    532:                        goto out;
                    533:                }
                    534:        }
                    535: 
1.21      jtk       536:        if (lreq.if_name[0] == 'e' &&
                    537:            lreq.if_name[1] == 't' &&
                    538:            lreq.if_name[2] == 'h') {
                    539:                for (ifnum = 0, index = 3;
                    540:                     lreq.if_name[index] != '\0' && index < IF_NAME_LEN;
                    541:                     index++) {
                    542:                        ifnum *= 10;
                    543:                        ifnum += lreq.if_name[index] - '0';
                    544:                }
                    545: 
                    546:                error = EINVAL;                 /* in case we don't find one */
                    547:                for (ifp = ifnet.tqh_first, found = 0;
                    548:                     ifp != 0 && !found;
                    549:                     ifp = ifp->if_list.tqe_next) {
                    550:                        memcpy(lreq.if_name, ifp->if_xname,
                    551:                               MIN(IF_NAME_LEN, IFNAMSIZ));
                    552:                        if ((ifa = ifp->if_addrlist.tqh_first) == 0)
                    553:                                /* no addresses on this interface */
                    554:                                continue;
                    555:                        else 
                    556:                                for (; ifa != 0; ifa = ifa->ifa_list.tqe_next) {
                    557:                                        sadl = (struct sockaddr_dl *)ifa->ifa_addr;
                    558:                                        /* only return ethernet addresses */
                    559:                                        /* XXX what about FDDI, etc. ? */
                    560:                                        if (sadl->sdl_family != AF_LINK ||
                    561:                                            sadl->sdl_type != IFT_ETHER)
                    562:                                                continue;
                    563:                                        if (ifnum--)
                    564:                                                /* not the reqested iface */
                    565:                                                continue;
                    566:                                        memcpy((caddr_t)&lreq.hwaddr.sa_data,
                    567:                                               LLADDR(sadl),
                    568:                                               MIN(sadl->sdl_alen,
                    569:                                                   sizeof(lreq.hwaddr.sa_data)));
                    570:                                        lreq.hwaddr.sa_family =
                    571:                                                sadl->sdl_family;
                    572:                                        error = copyout((caddr_t)&lreq, data,
                    573:                                                        sizeof(lreq));
                    574:                                        found = 1;
                    575:                                        break;
                    576:                                }
                    577:                }
1.22      jdolecek  578:        } else {
                    579:                /* unknown interface, not even an "eth*" name */
                    580:                error = ENODEV;
                    581:        }
1.21      jtk       582:     
                    583: out:
                    584:        FILE_UNUSE(fp, p);
                    585:        return error;
                    586: }
1.24    ! thorpej   587: #undef IF_NAME_LEN
1.21      jtk       588: 
1.13      mycroft   589: int
                    590: linux_ioctl_socket(p, uap, retval)
1.23      augustss  591:        struct proc *p;
                    592:        struct linux_sys_ioctl_args /* {
1.13      mycroft   593:                syscallarg(int) fd;
                    594:                syscallarg(u_long) com;
                    595:                syscallarg(caddr_t) data;
                    596:        } */ *uap;
                    597:        register_t *retval;
                    598: {
                    599:        u_long com;
                    600:        struct sys_ioctl_args ia;
                    601: 
                    602:        com = SCARG(uap, com);
                    603:        retval[0] = 0;
                    604: 
                    605:        switch (com) {
                    606:        case LINUX_SIOCGIFCONF:
                    607:                SCARG(&ia, com) = OSIOCGIFCONF;
                    608:                break;
                    609:        case LINUX_SIOCGIFFLAGS:
                    610:                SCARG(&ia, com) = SIOCGIFFLAGS;
                    611:                break;
                    612:        case LINUX_SIOCGIFADDR:
                    613:                SCARG(&ia, com) = OSIOCGIFADDR;
                    614:                break;
                    615:        case LINUX_SIOCGIFDSTADDR:
                    616:                SCARG(&ia, com) = OSIOCGIFDSTADDR;
                    617:                break;
                    618:        case LINUX_SIOCGIFBRDADDR:
                    619:                SCARG(&ia, com) = OSIOCGIFBRDADDR;
                    620:                break;
                    621:        case LINUX_SIOCGIFNETMASK:
                    622:                SCARG(&ia, com) = OSIOCGIFNETMASK;
                    623:                break;
                    624:        case LINUX_SIOCADDMULTI:
                    625:                SCARG(&ia, com) = SIOCADDMULTI;
                    626:                break;
                    627:        case LINUX_SIOCDELMULTI:
                    628:                SCARG(&ia, com) = SIOCDELMULTI;
                    629:                break;
1.21      jtk       630:        case LINUX_SIOCGIFHWADDR:
                    631:                return linux_getifhwaddr(p, retval, SCARG(uap, fd),
                    632:                                         SCARG(uap, data));
1.13      mycroft   633:        default:
                    634:                return EINVAL;
                    635:        }
                    636: 
                    637:        SCARG(&ia, fd) = SCARG(uap, fd);
                    638:        SCARG(&ia, data) = SCARG(uap, data);
                    639:        return sys_ioctl(p, &ia, retval);
1.1       fvdl      640: }
1.19      sommerfe  641: 
                    642: int
                    643: linux_sys_connect(p, v, retval)
1.23      augustss  644:        struct proc *p;
1.19      sommerfe  645:        void *v;
                    646:        register_t *retval;
                    647: {
                    648:        int error;
                    649: 
1.23      augustss  650:        struct sys_connect_args /* {
1.19      sommerfe  651:                syscallarg(int) s;
                    652:                syscallarg(const struct sockaddr *) name;
                    653:                syscallarg(unsigned int) namelen;
                    654:        } */ *uap = v;
                    655:        
                    656:        error = sys_connect (p, v, retval);
                    657: 
                    658:        if (error == EISCONN) {
                    659:                struct file *fp;
1.23      augustss  660:                struct socket *so;
1.19      sommerfe  661:                int s, state, prflags;
                    662:                
1.20      thorpej   663:                /* getsock() will use the descriptor for us */
                    664:                if (getsock(p->p_fd, SCARG(uap, s), &fp) != 0)
1.19      sommerfe  665:                        return EISCONN;
                    666: 
                    667:                s = splsoftnet();
                    668:                so = (struct socket *)fp->f_data;
                    669:                state = so->so_state;
                    670:                prflags = so->so_proto->pr_flags;
                    671:                splx(s);
1.20      thorpej   672:                FILE_UNUSE(fp, p);
1.19      sommerfe  673:                /*
                    674:                 * We should only let this call succeed once per
                    675:                 * non-blocking connect; however we don't have
                    676:                 * a convenient place to keep that state..
                    677:                 */
                    678:                if ((state & SS_NBIO) && (state & SS_ISCONNECTED) &&
                    679:                    (prflags & PR_CONNREQUIRED))
                    680:                        return 0;
                    681:        }
                    682: 
                    683:        return error;
                    684: }

CVSweb <webmaster@jp.NetBSD.org>