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

1.14    ! christos    1: /*     $NetBSD: linux_socket.c,v 1.13 1996/03/08 04:56:05 mycroft Exp $        */
1.1       fvdl        2: 
                      3: /*
                      4:  * Copyright (c) 1995 Frank van der Linden
                      5:  * All rights reserved.
                      6:  *
                      7:  * Redistribution and use in source and binary forms, with or without
                      8:  * modification, are permitted provided that the following conditions
                      9:  * are met:
                     10:  * 1. Redistributions of source code must retain the above copyright
                     11:  *    notice, this list of conditions and the following disclaimer.
                     12:  * 2. Redistributions in binary form must reproduce the above copyright
                     13:  *    notice, this list of conditions and the following disclaimer in the
                     14:  *    documentation and/or other materials provided with the distribution.
                     15:  * 3. All advertising materials mentioning features or use of this software
                     16:  *    must display the following acknowledgement:
                     17:  *      This product includes software developed for the NetBSD Project
                     18:  *      by Frank van der Linden
                     19:  * 4. The name of the author may not be used to endorse or promote products
                     20:  *    derived from this software without specific prior written permission
                     21:  *
                     22:  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
                     23:  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
                     24:  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
                     25:  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
                     26:  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
                     27:  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
                     28:  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
                     29:  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
                     30:  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
                     31:  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
                     32:  */
                     33: 
                     34: #include <sys/param.h>
                     35: #include <sys/kernel.h>
                     36: #include <sys/systm.h>
                     37: #include <sys/buf.h>
                     38: #include <sys/malloc.h>
                     39: #include <sys/ioctl.h>
                     40: #include <sys/tty.h>
                     41: #include <sys/file.h>
                     42: #include <sys/filedesc.h>
                     43: #include <sys/select.h>
                     44: #include <sys/socket.h>
                     45: #include <sys/socketvar.h>
                     46: #include <net/if.h>
                     47: #include <netinet/in.h>
1.7       mycroft    48: #include <netinet/tcp.h>
1.1       fvdl       49: #include <sys/mount.h>
                     50: #include <sys/proc.h>
                     51: #include <sys/vnode.h>
                     52: #include <sys/device.h>
                     53: 
                     54: #include <sys/syscallargs.h>
                     55: 
                     56: #include <compat/linux/linux_types.h>
                     57: #include <compat/linux/linux_util.h>
1.10      mycroft    58: #include <compat/linux/linux_signal.h>
1.1       fvdl       59: #include <compat/linux/linux_syscallargs.h>
                     60: #include <compat/linux/linux_ioctl.h>
                     61: #include <compat/linux/linux_socket.h>
                     62: #include <compat/linux/linux_socketcall.h>
                     63: #include <compat/linux/linux_sockio.h>
                     64: 
                     65: /*
                     66:  * All the calls in this file are entered via one common system
                     67:  * call in Linux, represented here by linux_socketcall()
                     68:  * Arguments for the various calls are on the user stack. A pointer
                     69:  * to them is the only thing that is passed. It is up to the various
                     70:  * calls to copy them in themselves. To make it look better, they
                     71:  * are copied to structures.
                     72:  */
1.14    ! christos   73: 
        !            74: int linux_to_bsd_domain __P((int));
        !            75: int linux_socket __P((struct proc *, struct linux_socket_args *, register_t *));
        !            76: int linux_bind __P((struct proc *, struct linux_bind_args *, register_t *));
        !            77: int linux_connect __P((struct proc *, struct linux_connect_args *,
        !            78:     register_t *));
        !            79: int linux_listen __P((struct proc *, struct linux_listen_args *, register_t *));
        !            80: int linux_accept __P((struct proc *, struct linux_accept_args *, register_t *));
        !            81: int linux_getsockname __P((struct proc *, struct linux_getsockname_args *,
        !            82:     register_t *));
        !            83: int linux_getpeername __P((struct proc *, struct linux_getpeername_args *,
        !            84:     register_t *));
        !            85: int linux_socketpair __P((struct proc *, struct linux_socketpair_args *,
        !            86:     register_t *));
        !            87: int linux_send __P((struct proc *, struct linux_send_args *, register_t *));
        !            88: int linux_recv __P((struct proc *, struct linux_recv_args *, register_t *));
        !            89: int linux_sendto __P((struct proc *, struct linux_sendto_args *, register_t *));
        !            90: int linux_recvfrom __P((struct proc *, struct linux_recvfrom_args *,
        !            91:     register_t *));
        !            92: int linux_shutdown __P((struct proc *, struct linux_shutdown_args *,
        !            93:     register_t *));
        !            94: int linux_to_bsd_sopt_level __P((int));
        !            95: int linux_to_bsd_so_sockopt __P((int));
        !            96: int linux_to_bsd_ip_sockopt __P((int));
        !            97: int linux_to_bsd_tcp_sockopt __P((int));
        !            98: int linux_to_bsd_udp_sockopt __P((int));
        !            99: int linux_setsockopt __P((struct proc *, struct linux_setsockopt_args *,
        !           100:     register_t *));
        !           101: int linux_getsockopt __P((struct proc *, struct linux_getsockopt_args *,
        !           102:     register_t *));
1.1       fvdl      103: 
                    104: /*
                    105:  * Convert between Linux and BSD socket domain values
                    106:  */
1.2       mycroft   107: int
1.1       fvdl      108: linux_to_bsd_domain(ldom)
                    109:        int ldom;
                    110: {
1.12      mycroft   111: 
1.1       fvdl      112:        switch (ldom) {
                    113:        case LINUX_AF_UNSPEC:
                    114:                return AF_UNSPEC;
                    115:        case LINUX_AF_UNIX:
                    116:                return AF_LOCAL;
                    117:        case LINUX_AF_INET:
                    118:                return AF_INET;
                    119:        case LINUX_AF_AX25:
                    120:                return AF_CCITT;
                    121:        case LINUX_AF_IPX:
                    122:                return AF_IPX;
                    123:        case LINUX_AF_APPLETALK:
                    124:                return AF_APPLETALK;
                    125:        default:
                    126:                return -1;
                    127:        }
                    128: }
                    129: 
1.2       mycroft   130: int
1.12      mycroft   131: linux_socket(p, uap, retval)
1.1       fvdl      132:        struct proc *p;
                    133:        struct linux_socket_args /* {
                    134:                syscallarg(int) domain;
                    135:                syscallarg(int) type;
                    136:                syscallarg(int) protocol;
1.12      mycroft   137:        } */ *uap;
1.1       fvdl      138:        register_t *retval;
                    139: {
                    140:        struct linux_socket_args lsa;
1.12      mycroft   141:        struct sys_socket_args bsa;
1.1       fvdl      142:        int error;
                    143: 
1.12      mycroft   144:        if ((error = copyin((caddr_t) uap, (caddr_t) &lsa, sizeof lsa)))
1.1       fvdl      145:                return error;
                    146: 
                    147:        SCARG(&bsa, protocol) = lsa.protocol;
                    148:        SCARG(&bsa, type) = lsa.type;
                    149:        SCARG(&bsa, domain) = linux_to_bsd_domain(lsa.domain);
                    150:        if (SCARG(&bsa, domain) == -1)
                    151:                return EINVAL;
1.12      mycroft   152:        return sys_socket(p, &bsa, retval);
1.1       fvdl      153: }
                    154: 
1.2       mycroft   155: int
1.12      mycroft   156: linux_bind(p, uap, retval)
1.1       fvdl      157:        struct proc *p;
                    158:        struct linux_bind_args /* {
                    159:                syscallarg(int) s;
                    160:                syscallarg(struct sockaddr *) name;
                    161:                syscallarg(int) namelen;
1.12      mycroft   162:        } */ *uap;
1.1       fvdl      163:        register_t *retval;
                    164: {
                    165:        struct linux_bind_args lba;
1.12      mycroft   166:        struct sys_bind_args bba;
1.1       fvdl      167:        int error;
                    168: 
1.12      mycroft   169:        if ((error = copyin((caddr_t) uap, (caddr_t) &lba, sizeof lba)))
1.1       fvdl      170:                return error;
                    171: 
                    172:        SCARG(&bba, s) = lba.s;
                    173:        SCARG(&bba, name) = (caddr_t) lba.name;
                    174:        SCARG(&bba, namelen) = lba.namelen;
                    175: 
1.12      mycroft   176:        return sys_bind(p, &bba, retval);
1.1       fvdl      177: }
                    178: 
1.2       mycroft   179: int
1.12      mycroft   180: linux_connect(p, uap, retval)
1.1       fvdl      181:        struct proc *p;
                    182:        struct linux_connect_args /* {
                    183:                syscallarg(int) s;
                    184:                syscallarg(struct sockaddr *) name;
                    185:                syscallarg(int) namelen;
1.12      mycroft   186:        } */ *uap;
1.1       fvdl      187:        register_t *retval;
                    188: {
                    189:        struct linux_connect_args lca;
1.12      mycroft   190:        struct sys_connect_args bca;
1.1       fvdl      191:        int error;
                    192: 
1.12      mycroft   193:        if ((error = copyin((caddr_t) uap, (caddr_t) &lca, sizeof lca)))
1.1       fvdl      194:                return error;
                    195: 
                    196:        SCARG(&bca, s) = lca.s;
                    197:        SCARG(&bca, name) = (caddr_t) lca.name;
                    198:        SCARG(&bca, namelen) = lca.namelen;
                    199: 
1.12      mycroft   200:        return sys_connect(p, &bca, retval);
1.1       fvdl      201: }
                    202: 
1.2       mycroft   203: int
1.12      mycroft   204: linux_listen(p, uap, retval)
1.1       fvdl      205:        struct proc *p;
                    206:        struct linux_listen_args /* {
                    207:                syscallarg(int) s;
                    208:                syscallarg(int) backlog;
1.12      mycroft   209:        } */ *uap;
                    210:        register_t *retval;
1.1       fvdl      211: {
                    212:        struct linux_listen_args lla;
1.12      mycroft   213:        struct sys_listen_args bla;
1.1       fvdl      214:        int error;
                    215: 
1.12      mycroft   216:        if ((error = copyin((caddr_t) uap, (caddr_t) &lla, sizeof lla)))
1.1       fvdl      217:                return error;
                    218: 
                    219:        SCARG(&bla, s) = lla.s;
                    220:        SCARG(&bla, backlog) = lla.backlog;
                    221: 
1.12      mycroft   222:        return sys_listen(p, &bla, retval);
1.1       fvdl      223: }
                    224: 
1.2       mycroft   225: int
1.12      mycroft   226: linux_accept(p, uap, retval)
1.1       fvdl      227:        struct proc *p;
                    228:        struct linux_accept_args /* {
                    229:                syscallarg(int) s;
                    230:                syscallarg(struct sockaddr *) addr;
                    231:                syscallarg(int *) namelen;
1.12      mycroft   232:        } */ *uap;
1.1       fvdl      233:        register_t *retval;
                    234: {
                    235:        struct linux_accept_args laa;
1.12      mycroft   236:        struct compat_43_sys_accept_args baa;
1.1       fvdl      237:        int error;
                    238: 
1.12      mycroft   239:        if ((error = copyin((caddr_t) uap, (caddr_t) &laa, sizeof laa)))
1.1       fvdl      240:                return error;
                    241: 
                    242:        SCARG(&baa, s) = laa.s;
                    243:        SCARG(&baa, name) = (caddr_t) laa.addr;
                    244:        SCARG(&baa, anamelen) = laa.namelen;
                    245: 
1.12      mycroft   246:        return compat_43_sys_accept(p, &baa, retval);
1.1       fvdl      247: }
                    248: 
1.2       mycroft   249: int
1.12      mycroft   250: linux_getsockname(p, uap, retval)
1.1       fvdl      251:        struct proc *p;
                    252:        struct linux_getsockname_args /* {
                    253:                syscallarg(int) s;
                    254:                syscallarg(struct sockaddr *) addr;
                    255:                syscallarg(int *) namelen;
1.12      mycroft   256:        } */ *uap;
1.1       fvdl      257:        register_t *retval;
                    258: {
                    259:        struct linux_getsockname_args lga;
1.12      mycroft   260:        struct compat_43_sys_getsockname_args bga;
1.1       fvdl      261:        int error;
                    262: 
1.12      mycroft   263:        if ((error = copyin((caddr_t) uap, (caddr_t) &lga, sizeof lga)))
1.1       fvdl      264:                return error;
                    265: 
                    266:        SCARG(&bga, fdec) = lga.s;
                    267:        SCARG(&bga, asa) = (caddr_t) lga.addr;
                    268:        SCARG(&bga, alen) = lga.namelen;
                    269: 
1.12      mycroft   270:        return compat_43_sys_getsockname(p, &bga, retval);
1.1       fvdl      271: }
                    272: 
1.2       mycroft   273: int
1.12      mycroft   274: linux_getpeername(p, uap, retval)
1.1       fvdl      275:        struct proc *p;
                    276:        struct linux_getpeername_args /* {
                    277:                syscallarg(int) s;
                    278:                syscallarg(struct sockaddr *) addr;
                    279:                syscallarg(int *) namelen;
1.12      mycroft   280:        } */ *uap;
1.1       fvdl      281:        register_t *retval;
                    282: {
                    283:        struct linux_getpeername_args lga;
1.12      mycroft   284:        struct compat_43_sys_getpeername_args bga;
1.1       fvdl      285:        int error;
                    286: 
1.12      mycroft   287:        if ((error = copyin((caddr_t) uap, (caddr_t) &lga, sizeof lga)))
1.1       fvdl      288:                return error;
                    289: 
                    290:        SCARG(&bga, fdes) = lga.s;
                    291:        SCARG(&bga, asa) = (caddr_t) lga.addr;
                    292:        SCARG(&bga, alen) = lga.namelen;
                    293: 
1.12      mycroft   294:        return compat_43_sys_getpeername(p, &bga, retval);
1.1       fvdl      295: }
                    296: 
1.2       mycroft   297: int
1.12      mycroft   298: linux_socketpair(p, uap, retval)
1.1       fvdl      299:        struct proc *p;
                    300:        struct linux_socketpair_args /* {
                    301:                syscallarg(int) domain;
                    302:                syscallarg(int) type;
                    303:                syscallarg(int) protocol;
                    304:                syscallarg(int *) rsv;
1.12      mycroft   305:        } */ *uap;
1.1       fvdl      306:        register_t *retval;
                    307: {
                    308:        struct linux_socketpair_args lsa;
1.12      mycroft   309:        struct sys_socketpair_args bsa;
1.1       fvdl      310:        int error;
                    311: 
1.12      mycroft   312:        if ((error = copyin((caddr_t) uap, &lsa, sizeof lsa)))
1.1       fvdl      313:                return error;
                    314: 
                    315:        SCARG(&bsa, domain) = linux_to_bsd_domain(lsa.domain);
                    316:        if (SCARG(&bsa, domain) == -1)
                    317:                return EINVAL;
                    318:        SCARG(&bsa, type) = lsa.type;
                    319:        SCARG(&bsa, protocol) = lsa.protocol;
                    320:        SCARG(&bsa, rsv) = lsa.rsv;
                    321: 
1.12      mycroft   322:        return sys_socketpair(p, &bsa, retval);
1.1       fvdl      323: }
                    324: 
1.2       mycroft   325: int
1.12      mycroft   326: linux_send(p, uap, retval)
1.1       fvdl      327:        struct proc *p;
                    328:        struct linux_send_args /* {
                    329:                syscallarg(int) s;
                    330:                syscallarg(void *) msg;
                    331:                syscallarg(int) len;
                    332:                syscallarg(int) flags;
1.12      mycroft   333:        } */ *uap;
1.1       fvdl      334:        register_t *retval;
                    335: {
                    336:        struct linux_send_args lsa;
1.12      mycroft   337:        struct compat_43_sys_send_args bsa;
1.1       fvdl      338:        int error;
                    339: 
1.12      mycroft   340:        if ((error = copyin((caddr_t) uap, (caddr_t) &lsa, sizeof lsa)))
1.1       fvdl      341:                return error;
                    342: 
                    343:        SCARG(&bsa, s) = lsa.s;
                    344:        SCARG(&bsa, buf) = lsa.msg;
                    345:        SCARG(&bsa, len) = lsa.len;
                    346:        SCARG(&bsa, flags) = lsa.flags;
                    347: 
1.12      mycroft   348:        return compat_43_sys_send(p, &bsa, retval);
1.1       fvdl      349: }
                    350: 
1.2       mycroft   351: int
1.12      mycroft   352: linux_recv(p, uap, retval)
1.1       fvdl      353:        struct proc *p;
1.12      mycroft   354:        struct linux_recv_args /* {
                    355:                syscallarg(int) s;
                    356:                syscallarg(void *) msg;
                    357:                syscallarg(int) len;
                    358:                syscallarg(int) flags;
                    359:        } */ *uap;
1.1       fvdl      360:        register_t *retval;
                    361: {
                    362:        struct linux_recv_args lra;
1.12      mycroft   363:        struct compat_43_sys_recv_args bra;
1.1       fvdl      364:        int error;
                    365: 
1.12      mycroft   366:        if ((error = copyin((caddr_t) uap, (caddr_t) &lra, sizeof lra)))
1.1       fvdl      367:                return error;
                    368: 
                    369:        SCARG(&bra, s) = lra.s;
                    370:        SCARG(&bra, buf) = lra.msg;
                    371:        SCARG(&bra, len) = lra.len;
                    372:        SCARG(&bra, flags) = lra.flags;
                    373: 
1.12      mycroft   374:        return compat_43_sys_recv(p, &bra, retval);
1.1       fvdl      375: }
                    376: 
1.2       mycroft   377: int
1.12      mycroft   378: linux_sendto(p, uap, retval)
1.1       fvdl      379:        struct proc *p;
                    380:        struct linux_sendto_args /* {
                    381:                syscallarg(int) s;
                    382:                syscallarg(void *) msg;
                    383:                syscallarg(int) len;
                    384:                syscallarg(int) flags;
                    385:                syscallarg(sockaddr *) to;
                    386:                syscallarg(int) tolen;
1.12      mycroft   387:        } */ *uap;
1.1       fvdl      388:        register_t *retval;
                    389: {
                    390:        struct linux_sendto_args lsa;
1.12      mycroft   391:        struct sys_sendto_args bsa;
1.1       fvdl      392:        int error;
                    393: 
1.12      mycroft   394:        if ((error = copyin((caddr_t) uap, (caddr_t) &lsa, sizeof lsa)))
1.1       fvdl      395:                return error;
                    396: 
                    397:        SCARG(&bsa, s) = lsa.s;
                    398:        SCARG(&bsa, buf) = lsa.msg;
                    399:        SCARG(&bsa, len) = lsa.len;
                    400:        SCARG(&bsa, flags) = lsa.flags;
                    401:        SCARG(&bsa, to) = (caddr_t) lsa.to;
                    402:        SCARG(&bsa, tolen) = lsa.tolen;
                    403: 
1.12      mycroft   404:        return sys_sendto(p, &bsa, retval);
1.1       fvdl      405: }
                    406: 
1.2       mycroft   407: int
1.12      mycroft   408: linux_recvfrom(p, uap, retval)
1.1       fvdl      409:        struct proc *p;
                    410:        struct linux_recvfrom_args /* {
                    411:                syscallarg(int) s;
                    412:                syscallarg(void *) buf;
                    413:                syscallarg(int) len;
                    414:                syscallarg(int) flags;
                    415:                syscallarg(struct sockaddr *) from;
                    416:                syscallarg(int *) fromlen;
1.12      mycroft   417:        } */ *uap;
                    418:        register_t *retval;
                    419: {
1.1       fvdl      420:        struct linux_recvfrom_args lra;
1.12      mycroft   421:        struct compat_43_sys_recvfrom_args bra;
1.1       fvdl      422:        int error;
                    423: 
1.12      mycroft   424:        if ((error = copyin((caddr_t) uap, (caddr_t) &lra, sizeof lra)))
1.1       fvdl      425:                return error;
                    426: 
                    427:        SCARG(&bra, s) = lra.s;
                    428:        SCARG(&bra, buf) = lra.buf;
                    429:        SCARG(&bra, len) = lra.len;
                    430:        SCARG(&bra, flags) = lra.flags;
                    431:        SCARG(&bra, from) = (caddr_t) lra.from;
                    432:        SCARG(&bra, fromlenaddr) = lra.fromlen;
                    433: 
1.12      mycroft   434:        return compat_43_sys_recvfrom(p, &bra, retval);
1.1       fvdl      435: }
                    436: 
1.2       mycroft   437: int
1.12      mycroft   438: linux_shutdown(p, uap, retval)
1.1       fvdl      439:        struct proc *p;
                    440:        struct linux_shutdown_args /* {
                    441:                syscallarg(int) s;
                    442:                syscallarg(int) how;
1.12      mycroft   443:        } */ *uap;
1.1       fvdl      444:        register_t *retval;
                    445: {
                    446:        struct linux_shutdown_args lsa;
1.12      mycroft   447:        struct sys_shutdown_args bsa;
1.1       fvdl      448:        int error;
                    449: 
1.12      mycroft   450:        if ((error = copyin((caddr_t) uap, (caddr_t) &lsa, sizeof lsa)))
1.1       fvdl      451:                return error;
                    452: 
                    453:        SCARG(&bsa, s) = lsa.s;
                    454:        SCARG(&bsa, how) = lsa.how;
                    455: 
1.12      mycroft   456:        return sys_shutdown(p, &bsa, retval);
1.1       fvdl      457: }
                    458: 
                    459: /*
                    460:  * Convert socket option level from Linux to NetBSD value. Only SOL_SOCKET
                    461:  * is different, the rest matches IPPROTO_* on both systems.
                    462:  */
1.2       mycroft   463: int
1.1       fvdl      464: linux_to_bsd_sopt_level(llevel)
                    465:        int llevel;
                    466: {
1.12      mycroft   467: 
1.1       fvdl      468:        switch (llevel) {
                    469:        case LINUX_SOL_SOCKET:
                    470:                return SOL_SOCKET;
1.3       mycroft   471:        case LINUX_SOL_IP:
                    472:                return IPPROTO_IP;
                    473:        case LINUX_SOL_TCP:
                    474:                return IPPROTO_TCP;
                    475:        case LINUX_SOL_UDP:
                    476:                return IPPROTO_UDP;
1.1       fvdl      477:        default:
                    478:                return -1;
                    479:        }
                    480: }
                    481: 
                    482: /*
                    483:  * Convert Linux socket level socket option numbers to NetBSD values.
                    484:  */
1.2       mycroft   485: int
1.1       fvdl      486: linux_to_bsd_so_sockopt(lopt)
                    487:        int lopt;
                    488: {
1.12      mycroft   489: 
1.1       fvdl      490:        switch (lopt) {
                    491:        case LINUX_SO_DEBUG:
                    492:                return SO_DEBUG;
                    493:        case LINUX_SO_REUSEADDR:
                    494:                return SO_REUSEADDR;
                    495:        case LINUX_SO_TYPE:
                    496:                return SO_TYPE;
                    497:        case LINUX_SO_ERROR:
                    498:                return SO_ERROR;
                    499:        case LINUX_SO_DONTROUTE:
                    500:                return SO_DONTROUTE;
                    501:        case LINUX_SO_BROADCAST:
                    502:                return SO_BROADCAST;
                    503:        case LINUX_SO_SNDBUF:
                    504:                return SO_SNDBUF;
                    505:        case LINUX_SO_RCVBUF:
                    506:                return SO_RCVBUF;
                    507:        case LINUX_SO_KEEPALIVE:
                    508:                return SO_KEEPALIVE;
                    509:        case LINUX_SO_OOBINLINE:
                    510:                return SO_OOBINLINE;
                    511:        case LINUX_SO_LINGER:
                    512:                return SO_LINGER;
                    513:        case LINUX_SO_PRIORITY:
                    514:        case LINUX_SO_NO_CHECK:
                    515:        default:
                    516:                return -1;
                    517:        }
                    518: }
                    519: 
                    520: /*
1.3       mycroft   521:  * Convert Linux IP level socket option number to NetBSD values.
                    522:  */
                    523: int
                    524: linux_to_bsd_ip_sockopt(lopt)
                    525:        int lopt;
                    526: {
1.12      mycroft   527: 
1.3       mycroft   528:        switch (lopt) {
                    529:        case LINUX_IP_TOS:
                    530:                return IP_TOS;
                    531:        case LINUX_IP_TTL:
                    532:                return IP_TTL;
                    533:        case LINUX_IP_MULTICAST_TTL:
                    534:                return IP_MULTICAST_TTL;
                    535:        case LINUX_IP_MULTICAST_LOOP:
                    536:                return IP_MULTICAST_LOOP;
                    537:        case LINUX_IP_MULTICAST_IF:
                    538:                return IP_MULTICAST_IF;
                    539:        case LINUX_IP_ADD_MEMBERSHIP:
                    540:                return IP_ADD_MEMBERSHIP;
                    541:        case LINUX_IP_DROP_MEMBERSHIP:
                    542:                return IP_DROP_MEMBERSHIP;
                    543:        default:
                    544:                return -1;
                    545:        }
                    546: }
                    547: 
                    548: /*
                    549:  * Convert Linux TCP level socket option number to NetBSD values.
                    550:  */
                    551: int
                    552: linux_to_bsd_tcp_sockopt(lopt)
                    553:        int lopt;
                    554: {
1.12      mycroft   555: 
1.3       mycroft   556:        switch (lopt) {
1.6       mycroft   557:        case LINUX_TCP_NODELAY:
                    558:                return TCP_NODELAY;
                    559:        case LINUX_TCP_MAXSEG:
                    560:                return TCP_MAXSEG;
1.3       mycroft   561:        default:
1.6       mycroft   562:                return -1;
1.3       mycroft   563:        }
                    564: }
                    565: 
                    566: /*
                    567:  * Convert Linux UDP level socket option number to NetBSD values.
                    568:  */
                    569: int
                    570: linux_to_bsd_udp_sockopt(lopt)
                    571:        int lopt;
                    572: {
1.12      mycroft   573: 
1.3       mycroft   574:        switch (lopt) {
                    575:        default:
1.6       mycroft   576:                return -1;
1.3       mycroft   577:        }
                    578: }
                    579: 
                    580: /*
1.5       mycroft   581:  * Another reasonably straightforward function: setsockopt(2).
1.1       fvdl      582:  * The level and option numbers are converted; the values passed
                    583:  * are not (yet) converted, the ones currently implemented don't
                    584:  * need conversion, as they are the same on both systems.
                    585:  */
1.2       mycroft   586: int
1.12      mycroft   587: linux_setsockopt(p, uap, retval)
1.1       fvdl      588:        struct proc *p;
                    589:        struct linux_setsockopt_args /* {
                    590:                syscallarg(int) s;
                    591:                syscallarg(int) level;
                    592:                syscallarg(int) optname;
                    593:                syscallarg(void *) optval;
                    594:                syscallarg(int) optlen;
1.12      mycroft   595:        } */ *uap;
1.1       fvdl      596:        register_t *retval;
                    597: {
                    598:        struct linux_setsockopt_args lsa;
1.12      mycroft   599:        struct sys_setsockopt_args bsa;
1.1       fvdl      600:        int error, name;
                    601: 
1.12      mycroft   602:        if ((error = copyin((caddr_t) uap, (caddr_t) &lsa, sizeof lsa)))
1.1       fvdl      603:                return error;
                    604: 
                    605:        SCARG(&bsa, s) = lsa.s;
                    606:        SCARG(&bsa, level) = linux_to_bsd_sopt_level(lsa.level);
1.6       mycroft   607:        SCARG(&bsa, val) = lsa.optval;
                    608:        SCARG(&bsa, valsize) = lsa.optlen;
1.1       fvdl      609: 
                    610:        switch (SCARG(&bsa, level)) {
                    611:                case SOL_SOCKET:
                    612:                        name = linux_to_bsd_so_sockopt(lsa.optname);
                    613:                        break;
                    614:                case IPPROTO_IP:
                    615:                        name = linux_to_bsd_ip_sockopt(lsa.optname);
                    616:                        break;
1.3       mycroft   617:                case IPPROTO_TCP:
                    618:                        name = linux_to_bsd_tcp_sockopt(lsa.optname);
                    619:                        break;
                    620:                case IPPROTO_UDP:
                    621:                        name = linux_to_bsd_udp_sockopt(lsa.optname);
                    622:                        break;
1.1       fvdl      623:                default:
                    624:                        return EINVAL;
                    625:        }
                    626: 
                    627:        if (name == -1)
                    628:                return EINVAL;
                    629:        SCARG(&bsa, name) = name;
                    630: 
1.12      mycroft   631:        return sys_setsockopt(p, &bsa, retval);
1.1       fvdl      632: }
                    633: 
                    634: /*
                    635:  * getsockopt(2) is very much the same as setsockopt(2) (see above)
                    636:  */
1.2       mycroft   637: int
1.12      mycroft   638: linux_getsockopt(p, uap, retval)
1.1       fvdl      639:        struct proc *p;
                    640:        struct linux_getsockopt_args /* {
                    641:                syscallarg(int) s;
                    642:                syscallarg(int) level;
                    643:                syscallarg(int) optname;
                    644:                syscallarg(void *) optval;
                    645:                syscallarg(int) *optlen;
1.12      mycroft   646:        } */ *uap;
1.1       fvdl      647:        register_t *retval;
                    648: {
                    649:        struct linux_getsockopt_args lga;
1.12      mycroft   650:        struct sys_getsockopt_args bga;
1.1       fvdl      651:        int error, name;
                    652: 
1.12      mycroft   653:        if ((error = copyin((caddr_t) uap, (caddr_t) &lga, sizeof lga)))
1.1       fvdl      654:                return error;
                    655: 
                    656:        SCARG(&bga, s) = lga.s;
                    657:        SCARG(&bga, level) = linux_to_bsd_sopt_level(lga.level);
1.6       mycroft   658:        SCARG(&bga, val) = lga.optval;
                    659:        SCARG(&bga, avalsize) = lga.optlen;
1.1       fvdl      660: 
                    661:        switch (SCARG(&bga, level)) {
                    662:                case SOL_SOCKET:
                    663:                        name = linux_to_bsd_so_sockopt(lga.optname);
                    664:                        break;
                    665:                case IPPROTO_IP:
                    666:                        name = linux_to_bsd_ip_sockopt(lga.optname);
1.3       mycroft   667:                        break;
                    668:                case IPPROTO_TCP:
1.4       mycroft   669:                        name = linux_to_bsd_tcp_sockopt(lga.optname);
1.3       mycroft   670:                        break;
                    671:                case IPPROTO_UDP:
1.4       mycroft   672:                        name = linux_to_bsd_udp_sockopt(lga.optname);
1.1       fvdl      673:                        break;
                    674:                default:
                    675:                        return EINVAL;
                    676:        }
                    677: 
                    678:        if (name == -1)
                    679:                return EINVAL;
1.5       mycroft   680:        SCARG(&bga, name) = name;
1.1       fvdl      681: 
1.12      mycroft   682:        return sys_getsockopt(p, &bga, retval);
1.1       fvdl      683: }
                    684: 
                    685: /*
                    686:  * Entry point to all Linux socket calls. Just check which call to
                    687:  * make and take appropriate action.
                    688:  */
                    689: int
1.12      mycroft   690: linux_sys_socketcall(p, v, retval)
1.1       fvdl      691:        struct proc *p;
1.11      thorpej   692:        void *v;
                    693:        register_t *retval;
                    694: {
1.12      mycroft   695:        struct linux_sys_socketcall_args /* {
1.1       fvdl      696:                syscallarg(int) what;
                    697:                syscallarg(void *) args;
1.11      thorpej   698:        } */ *uap = v;
                    699: 
1.1       fvdl      700:        switch (SCARG(uap, what)) {
                    701:        case LINUX_SYS_socket:
                    702:                return linux_socket(p, SCARG(uap, args), retval);
                    703:        case LINUX_SYS_bind:
                    704:                return linux_bind(p, SCARG(uap, args), retval);
                    705:        case LINUX_SYS_connect:
                    706:                return linux_connect(p, SCARG(uap, args), retval);
                    707:        case LINUX_SYS_listen:
                    708:                return linux_listen(p, SCARG(uap, args), retval);
                    709:        case LINUX_SYS_accept:
                    710:                return linux_accept(p, SCARG(uap, args), retval);
                    711:        case LINUX_SYS_getsockname:
                    712:                return linux_getsockname(p, SCARG(uap, args), retval);
                    713:        case LINUX_SYS_getpeername:
                    714:                return linux_getpeername(p, SCARG(uap, args), retval);
                    715:        case LINUX_SYS_socketpair:
                    716:                return linux_socketpair(p, SCARG(uap, args), retval);
                    717:        case LINUX_SYS_send:
                    718:                return linux_send(p, SCARG(uap, args), retval);
                    719:        case LINUX_SYS_recv:
                    720:                return linux_recv(p, SCARG(uap, args), retval);
                    721:        case LINUX_SYS_sendto:
                    722:                return linux_sendto(p, SCARG(uap, args), retval);
                    723:        case LINUX_SYS_recvfrom:
                    724:                return linux_recvfrom(p, SCARG(uap, args), retval);
                    725:        case LINUX_SYS_shutdown:
                    726:                return linux_shutdown(p, SCARG(uap, args), retval);
                    727:        case LINUX_SYS_setsockopt:
                    728:                return linux_setsockopt(p, SCARG(uap, args), retval);
                    729:        case LINUX_SYS_getsockopt:
                    730:                return linux_getsockopt(p, SCARG(uap, args), retval);
                    731:        default:
                    732:                return ENOSYS;
                    733:        }
1.13      mycroft   734: }
                    735: 
                    736: int
                    737: linux_ioctl_socket(p, uap, retval)
                    738:        register struct proc *p;
                    739:        register struct linux_sys_ioctl_args /* {
                    740:                syscallarg(int) fd;
                    741:                syscallarg(u_long) com;
                    742:                syscallarg(caddr_t) data;
                    743:        } */ *uap;
                    744:        register_t *retval;
                    745: {
                    746:        u_long com;
                    747:        struct sys_ioctl_args ia;
                    748: 
                    749:        com = SCARG(uap, com);
                    750:        retval[0] = 0;
                    751: 
                    752:        switch (com) {
                    753:        case LINUX_SIOCGIFCONF:
                    754:                SCARG(&ia, com) = OSIOCGIFCONF;
                    755:                break;
                    756:        case LINUX_SIOCGIFFLAGS:
                    757:                SCARG(&ia, com) = SIOCGIFFLAGS;
                    758:                break;
                    759:        case LINUX_SIOCGIFADDR:
                    760:                SCARG(&ia, com) = OSIOCGIFADDR;
                    761:                break;
                    762:        case LINUX_SIOCGIFDSTADDR:
                    763:                SCARG(&ia, com) = OSIOCGIFDSTADDR;
                    764:                break;
                    765:        case LINUX_SIOCGIFBRDADDR:
                    766:                SCARG(&ia, com) = OSIOCGIFBRDADDR;
                    767:                break;
                    768:        case LINUX_SIOCGIFNETMASK:
                    769:                SCARG(&ia, com) = OSIOCGIFNETMASK;
                    770:                break;
                    771:        case LINUX_SIOCADDMULTI:
                    772:                SCARG(&ia, com) = SIOCADDMULTI;
                    773:                break;
                    774:        case LINUX_SIOCDELMULTI:
                    775:                SCARG(&ia, com) = SIOCDELMULTI;
                    776:                break;
                    777:        default:
                    778:                return EINVAL;
                    779:        }
                    780: 
                    781:        SCARG(&ia, fd) = SCARG(uap, fd);
                    782:        SCARG(&ia, data) = SCARG(uap, data);
                    783:        return sys_ioctl(p, &ia, retval);
1.1       fvdl      784: }

CVSweb <webmaster@jp.NetBSD.org>