Annotation of src/sys/compat/linux/common/linux_socket.c, revision 1.115
1.115 ! christos 1: /* $NetBSD: linux_socket.c,v 1.114 2012/06/20 15:03:18 christos Exp $ */
1.16 erh 2:
3: /*-
1.87 ad 4: * Copyright (c) 1995, 1998, 2008 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: *
19: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29: * POSSIBILITY OF SUCH DAMAGE.
1.1 fvdl 30: */
31:
1.16 erh 32: /*
33: * Functions in multiarch:
34: * linux_sys_socketcall : linux_socketcall.c
35: */
1.35 lukem 36:
37: #include <sys/cdefs.h>
1.115 ! christos 38: __KERNEL_RCSID(0, "$NetBSD: linux_socket.c,v 1.114 2012/06/20 15:03:18 christos Exp $");
1.16 erh 39:
1.74 yamt 40: #if defined(_KERNEL_OPT)
1.32 jdolecek 41: #include "opt_inet.h"
1.74 yamt 42: #endif /* defined(_KERNEL_OPT) */
1.32 jdolecek 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>
1.53 jdolecek 56: #include <sys/domain.h>
1.1 fvdl 57: #include <net/if.h>
1.21 jtk 58: #include <net/if_dl.h>
59: #include <net/if_types.h>
1.1 fvdl 60: #include <netinet/in.h>
1.7 mycroft 61: #include <netinet/tcp.h>
1.1 fvdl 62: #include <sys/mount.h>
63: #include <sys/proc.h>
64: #include <sys/vnode.h>
65: #include <sys/device.h>
1.55 perry 66: #include <sys/protosw.h>
1.32 jdolecek 67: #include <sys/mbuf.h>
68: #include <sys/syslog.h>
1.49 jdolecek 69: #include <sys/exec.h>
1.62 elad 70: #include <sys/kauth.h>
1.1 fvdl 71: #include <sys/syscallargs.h>
1.73 dsl 72: #include <sys/ktrace.h>
1.108 chs 73: #include <sys/fcntl.h>
1.1 fvdl 74:
1.60 dyoung 75: #include <lib/libkern/libkern.h>
76:
1.42 fvdl 77: #include <netinet/ip6.h>
78: #include <netinet6/ip6_var.h>
79:
1.57 christos 80: #include <compat/sys/socket.h>
1.72 christos 81: #include <compat/sys/sockio.h>
1.57 christos 82:
1.17 christos 83: #include <compat/linux/common/linux_types.h>
84: #include <compat/linux/common/linux_util.h>
85: #include <compat/linux/common/linux_signal.h>
86: #include <compat/linux/common/linux_ioctl.h>
87: #include <compat/linux/common/linux_socket.h>
1.108 chs 88: #include <compat/linux/common/linux_fcntl.h>
1.59 manu 89: #if !defined(__alpha__) && !defined(__amd64__)
1.17 christos 90: #include <compat/linux/common/linux_socketcall.h>
1.59 manu 91: #endif
1.17 christos 92: #include <compat/linux/common/linux_sockio.h>
1.80 njoly 93: #include <compat/linux/common/linux_ipc.h>
94: #include <compat/linux/common/linux_sem.h>
1.17 christos 95:
1.1 fvdl 96: #include <compat/linux/linux_syscallargs.h>
1.21 jtk 97:
1.37 christos 98: #ifdef DEBUG_LINUX
99: #define DPRINTF(a) uprintf a
100: #else
101: #define DPRINTF(a)
102: #endif
103:
1.1 fvdl 104: /*
1.16 erh 105: * The calls in this file are entered either via the linux_socketcall()
106: * interface or, on the Alpha, as individual syscalls. The
107: * linux_socketcall function does any massaging of arguments so that all
108: * the calls in here need not think that they are anything other
109: * than a normal syscall.
1.1 fvdl 110: */
1.14 christos 111:
1.81 dsl 112: static int linux_to_bsd_domain(int);
113: static int bsd_to_linux_domain(int);
114: int linux_to_bsd_sopt_level(int);
115: int linux_to_bsd_so_sockopt(int);
116: int linux_to_bsd_ip_sockopt(int);
117: int linux_to_bsd_tcp_sockopt(int);
118: int linux_to_bsd_udp_sockopt(int);
1.105 joerg 119: int linux_getifname(struct lwp *, register_t *, void *);
1.97 njoly 120: int linux_getifconf(struct lwp *, register_t *, void *);
1.81 dsl 121: int linux_getifhwaddr(struct lwp *, register_t *, u_int, void *);
1.73 dsl 122: static int linux_get_sa(struct lwp *, int, struct mbuf **,
1.93 njoly 123: const struct osockaddr *, unsigned int);
1.81 dsl 124: static int linux_sa_put(struct osockaddr *osa);
125: static int linux_to_bsd_msg_flags(int);
126: static int bsd_to_linux_msg_flags(int);
1.104 njoly 127: static void linux_to_bsd_msghdr(struct linux_msghdr *, struct msghdr *);
128: static void bsd_to_linux_msghdr(struct msghdr *, struct linux_msghdr *);
1.32 jdolecek 129:
130: static const int linux_to_bsd_domain_[LINUX_AF_MAX] = {
131: AF_UNSPEC,
132: AF_UNIX,
133: AF_INET,
134: AF_CCITT, /* LINUX_AF_AX25 */
135: AF_IPX,
136: AF_APPLETALK,
137: -1, /* LINUX_AF_NETROM */
138: -1, /* LINUX_AF_BRIDGE */
139: -1, /* LINUX_AF_ATMPVC */
140: AF_CCITT, /* LINUX_AF_X25 */
141: AF_INET6,
142: -1, /* LINUX_AF_ROSE */
143: AF_DECnet,
144: -1, /* LINUX_AF_NETBEUI */
145: -1, /* LINUX_AF_SECURITY */
146: pseudo_AF_KEY,
147: AF_ROUTE, /* LINUX_AF_NETLINK */
148: -1, /* LINUX_AF_PACKET */
149: -1, /* LINUX_AF_ASH */
150: -1, /* LINUX_AF_ECONET */
151: -1, /* LINUX_AF_ATMSVC */
152: AF_SNA,
153: /* rest up to LINUX_AF_MAX-1 is not allocated */
154: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
155: };
1.55 perry 156:
1.32 jdolecek 157: static const int bsd_to_linux_domain_[AF_MAX] = {
158: LINUX_AF_UNSPEC,
159: LINUX_AF_UNIX,
160: LINUX_AF_INET,
161: -1, /* AF_IMPLINK */
162: -1, /* AF_PUP */
163: -1, /* AF_CHAOS */
164: -1, /* AF_NS */
165: -1, /* AF_ISO */
166: -1, /* AF_ECMA */
167: -1, /* AF_DATAKIT */
168: LINUX_AF_AX25, /* AF_CCITT */
169: LINUX_AF_SNA,
170: LINUX_AF_DECnet,
171: -1, /* AF_DLI */
172: -1, /* AF_LAT */
173: -1, /* AF_HYLINK */
174: LINUX_AF_APPLETALK,
175: LINUX_AF_NETLINK,
176: -1, /* AF_LINK */
177: -1, /* AF_XTP */
178: -1, /* AF_COIP */
179: -1, /* AF_CNT */
180: -1, /* pseudo_AF_RTIP */
181: LINUX_AF_IPX,
182: LINUX_AF_INET6,
183: -1, /* pseudo_AF_PIP */
184: -1, /* AF_ISDN */
185: -1, /* AF_NATM */
186: -1, /* AF_ARP */
187: LINUX_pseudo_AF_KEY,
188: -1, /* pseudo_AF_HDRCMPLT */
189: };
1.1 fvdl 190:
1.60 dyoung 191: static const struct {
192: int bfl;
193: int lfl;
194: } bsd_to_linux_msg_flags_[] = {
195: {MSG_OOB, LINUX_MSG_OOB},
196: {MSG_PEEK, LINUX_MSG_PEEK},
197: {MSG_DONTROUTE, LINUX_MSG_DONTROUTE},
198: {MSG_EOR, LINUX_MSG_EOR},
199: {MSG_TRUNC, LINUX_MSG_TRUNC},
200: {MSG_CTRUNC, LINUX_MSG_CTRUNC},
201: {MSG_WAITALL, LINUX_MSG_WAITALL},
202: {MSG_DONTWAIT, LINUX_MSG_DONTWAIT},
203: {MSG_BCAST, 0}, /* not supported, clear */
204: {MSG_MCAST, 0}, /* not supported, clear */
1.108 chs 205: {MSG_NOSIGNAL, LINUX_MSG_NOSIGNAL},
1.60 dyoung 206: {-1, /* not supp */ LINUX_MSG_PROBE},
207: {-1, /* not supp */ LINUX_MSG_FIN},
208: {-1, /* not supp */ LINUX_MSG_SYN},
209: {-1, /* not supp */ LINUX_MSG_CONFIRM},
210: {-1, /* not supp */ LINUX_MSG_RST},
211: {-1, /* not supp */ LINUX_MSG_ERRQUEUE},
212: {-1, /* not supp */ LINUX_MSG_MORE},
1.49 jdolecek 213: };
214:
1.1 fvdl 215: /*
216: * Convert between Linux and BSD socket domain values
217: */
1.32 jdolecek 218: static int
1.84 dsl 219: linux_to_bsd_domain(int ldom)
1.1 fvdl 220: {
1.32 jdolecek 221: if (ldom < 0 || ldom >= LINUX_AF_MAX)
222: return (-1);
223:
224: return linux_to_bsd_domain_[ldom];
225: }
226:
227: /*
228: * Convert between BSD and Linux socket domain values
229: */
230: static int
1.84 dsl 231: bsd_to_linux_domain(int bdom)
1.32 jdolecek 232: {
233: if (bdom < 0 || bdom >= AF_MAX)
234: return (-1);
1.12 mycroft 235:
1.32 jdolecek 236: return bsd_to_linux_domain_[bdom];
1.1 fvdl 237: }
238:
1.49 jdolecek 239: static int
1.84 dsl 240: linux_to_bsd_msg_flags(int lflag)
1.49 jdolecek 241: {
242: int i, lfl, bfl;
243: int bflag = 0;
244:
245: if (lflag == 0)
246: return (0);
247:
1.60 dyoung 248: for(i = 0; i < __arraycount(bsd_to_linux_msg_flags_); i++) {
249: bfl = bsd_to_linux_msg_flags_[i].bfl;
250: lfl = bsd_to_linux_msg_flags_[i].lfl;
1.49 jdolecek 251:
252: if (lfl == 0)
253: continue;
254:
255: if (lflag & lfl) {
256: if (bfl < 0)
257: return (-1);
258:
259: bflag |= bfl;
260: }
261: }
262:
263: return (bflag);
264: }
265:
266: static int
1.84 dsl 267: bsd_to_linux_msg_flags(int bflag)
1.49 jdolecek 268: {
269: int i, lfl, bfl;
270: int lflag = 0;
271:
272: if (bflag == 0)
273: return (0);
274:
1.60 dyoung 275: for(i = 0; i < __arraycount(bsd_to_linux_msg_flags_); i++) {
276: bfl = bsd_to_linux_msg_flags_[i].bfl;
277: lfl = bsd_to_linux_msg_flags_[i].lfl;
1.49 jdolecek 278:
279: if (bfl <= 0)
280: continue;
281:
282: if (bflag & bfl) {
283: if (lfl < 0)
284: return (-1);
285:
286: lflag |= lfl;
287: }
288: }
289:
290: return (lflag);
291: }
292:
1.2 mycroft 293: int
1.85 dsl 294: linux_sys_socket(struct lwp *l, const struct linux_sys_socket_args *uap, register_t *retval)
1.16 erh 295: {
1.85 dsl 296: /* {
1.1 fvdl 297: syscallarg(int) domain;
298: syscallarg(int) type;
299: syscallarg(int) protocol;
1.85 dsl 300: } */
301: struct sys___socket30_args bsa;
1.108 chs 302: struct sys_fcntl_args fsa;
303: register_t fretval[2];
304: int error, flags;
305:
1.1 fvdl 306:
1.16 erh 307: SCARG(&bsa, protocol) = SCARG(uap, protocol);
1.108 chs 308: SCARG(&bsa, type) = SCARG(uap, type) & LINUX_SOCK_TYPE_MASK;
1.16 erh 309: SCARG(&bsa, domain) = linux_to_bsd_domain(SCARG(uap, domain));
1.1 fvdl 310: if (SCARG(&bsa, domain) == -1)
311: return EINVAL;
1.110 christos 312: /*
313: * Apparently linux uses this to talk to ISDN sockets. If we fail
314: * now programs seems to handle it, but if we don't we are going
315: * to fail when we bind and programs don't handle this well.
316: */
317: if (SCARG(&bsa, domain) == AF_ROUTE && SCARG(&bsa, type) == SOCK_RAW)
318: return ENOTSUP;
1.108 chs 319: flags = SCARG(uap, type) & ~LINUX_SOCK_TYPE_MASK;
320: if (flags & ~(LINUX_SOCK_CLOEXEC | LINUX_SOCK_NONBLOCK))
321: return EINVAL;
1.64 pavel 322: error = sys___socket30(l, &bsa, retval);
1.41 itojun 323:
1.108 chs 324: /*
325: * Linux overloads the "type" parameter to include some
326: * fcntl flags to be set on the file descriptor.
327: * Process those if creating the socket succeeded.
328: */
329:
330: if (!error && flags & LINUX_SOCK_CLOEXEC) {
331: SCARG(&fsa, fd) = *retval;
332: SCARG(&fsa, cmd) = F_SETFD;
333: SCARG(&fsa, arg) = (void *)(uintptr_t)FD_CLOEXEC;
334: (void) sys_fcntl(l, &fsa, fretval);
335: }
336: if (!error && flags & LINUX_SOCK_NONBLOCK) {
337: SCARG(&fsa, fd) = *retval;
338: SCARG(&fsa, cmd) = F_SETFL;
339: SCARG(&fsa, arg) = (void *)(uintptr_t)O_NONBLOCK;
340: error = sys_fcntl(l, &fsa, fretval);
341: if (error) {
342: struct sys_close_args csa;
343:
344: SCARG(&csa, fd) = *retval;
345: (void) sys_close(l, &csa, fretval);
346: }
347: }
348:
1.41 itojun 349: #ifdef INET6
350: /*
1.42 fvdl 351: * Linux AF_INET6 socket has IPV6_V6ONLY setsockopt set to 0 by
352: * default and some apps depend on this. So, set V6ONLY to 0
353: * for Linux apps if the sysctl value is set to 1.
1.41 itojun 354: */
1.42 fvdl 355: if (!error && ip6_v6only && SCARG(&bsa, domain) == PF_INET6) {
1.89 ad 356: struct socket *so;
1.42 fvdl 357:
1.89 ad 358: if (fd_getsock(*retval, &so) == 0) {
1.98 plunky 359: int val = 0;
1.42 fvdl 360:
361: /* ignore error */
1.98 plunky 362: (void)so_setsockopt(l, so, IPPROTO_IPV6, IPV6_V6ONLY,
363: &val, sizeof(val));
1.42 fvdl 364:
1.87 ad 365: fd_putfile(*retval);
1.41 itojun 366: }
367: }
368: #endif
369:
1.42 fvdl 370: return (error);
1.1 fvdl 371: }
372:
1.2 mycroft 373: int
1.85 dsl 374: linux_sys_socketpair(struct lwp *l, const struct linux_sys_socketpair_args *uap, register_t *retval)
1.1 fvdl 375: {
1.85 dsl 376: /* {
1.1 fvdl 377: syscallarg(int) domain;
378: syscallarg(int) type;
379: syscallarg(int) protocol;
380: syscallarg(int *) rsv;
1.85 dsl 381: } */
1.12 mycroft 382: struct sys_socketpair_args bsa;
1.1 fvdl 383:
1.16 erh 384: SCARG(&bsa, domain) = linux_to_bsd_domain(SCARG(uap, domain));
1.1 fvdl 385: if (SCARG(&bsa, domain) == -1)
386: return EINVAL;
1.16 erh 387: SCARG(&bsa, type) = SCARG(uap, type);
388: SCARG(&bsa, protocol) = SCARG(uap, protocol);
389: SCARG(&bsa, rsv) = SCARG(uap, rsv);
1.1 fvdl 390:
1.43 thorpej 391: return sys_socketpair(l, &bsa, retval);
1.1 fvdl 392: }
393:
1.2 mycroft 394: int
1.85 dsl 395: linux_sys_sendto(struct lwp *l, const struct linux_sys_sendto_args *uap, register_t *retval)
1.1 fvdl 396: {
1.85 dsl 397: /* {
1.32 jdolecek 398: syscallarg(int) s;
399: syscallarg(void *) msg;
400: syscallarg(int) len;
401: syscallarg(int) flags;
402: syscallarg(struct osockaddr *) to;
403: syscallarg(int) tolen;
1.85 dsl 404: } */
1.73 dsl 405: struct msghdr msg;
406: struct iovec aiov;
407: struct mbuf *nam;
408: int bflags;
409: int error;
1.1 fvdl 410:
1.73 dsl 411: /* Translate message flags. */
412: bflags = linux_to_bsd_msg_flags(SCARG(uap, flags));
413: if (bflags < 0)
414: /* Some supported flag */
415: return EINVAL;
1.32 jdolecek 416:
1.95 njoly 417: msg.msg_flags = 0;
418: msg.msg_name = NULL;
419: msg.msg_control = NULL;
420:
421: if (SCARG(uap, tolen)) {
422: /* Read in and convert the sockaddr */
423: error = linux_get_sa(l, SCARG(uap, s), &nam, SCARG(uap, to),
424: SCARG(uap, tolen));
425: if (error)
426: return (error);
427: msg.msg_flags |= MSG_NAMEMBUF;
428: msg.msg_name = nam;
429: msg.msg_namelen = SCARG(uap, tolen);
430: }
1.32 jdolecek 431:
1.73 dsl 432: msg.msg_iov = &aiov;
433: msg.msg_iovlen = 1;
434: aiov.iov_base = __UNCONST(SCARG(uap, msg));
435: aiov.iov_len = SCARG(uap, len);
1.1 fvdl 436:
1.73 dsl 437: return do_sys_sendmsg(l, SCARG(uap, s), &msg, bflags, retval);
1.32 jdolecek 438: }
439:
1.104 njoly 440: static void
441: linux_to_bsd_msghdr(struct linux_msghdr *lmsg, struct msghdr *bmsg)
442: {
443: bmsg->msg_name = lmsg->msg_name;
444: bmsg->msg_namelen = lmsg->msg_namelen;
445: bmsg->msg_iov = lmsg->msg_iov;
446: bmsg->msg_iovlen = lmsg->msg_iovlen;
447: bmsg->msg_control = lmsg->msg_control;
448: bmsg->msg_controllen = lmsg->msg_controllen;
449: bmsg->msg_flags = lmsg->msg_flags;
450: }
451:
452: static void
453: bsd_to_linux_msghdr(struct msghdr *bmsg, struct linux_msghdr *lmsg)
454: {
455: lmsg->msg_name = bmsg->msg_name;
456: lmsg->msg_namelen = bmsg->msg_namelen;
457: lmsg->msg_iov = bmsg->msg_iov;
458: lmsg->msg_iovlen = bmsg->msg_iovlen;
459: lmsg->msg_control = bmsg->msg_control;
460: lmsg->msg_controllen = bmsg->msg_controllen;
461: lmsg->msg_flags = bmsg->msg_flags;
462: }
463:
1.32 jdolecek 464: int
1.85 dsl 465: linux_sys_sendmsg(struct lwp *l, const struct linux_sys_sendmsg_args *uap, register_t *retval)
1.32 jdolecek 466: {
1.85 dsl 467: /* {
1.32 jdolecek 468: syscallarg(int) s;
1.104 njoly 469: syscallarg(struct linux_msghdr *) msg;
1.32 jdolecek 470: syscallarg(u_int) flags;
1.85 dsl 471: } */
1.32 jdolecek 472: struct msghdr msg;
1.104 njoly 473: struct linux_msghdr lmsg;
1.32 jdolecek 474: int error;
1.49 jdolecek 475: int bflags;
1.73 dsl 476: struct mbuf *nam;
477: u_int8_t *control;
478: struct mbuf *ctl_mbuf = NULL;
1.32 jdolecek 479:
1.104 njoly 480: error = copyin(SCARG(uap, msg), &lmsg, sizeof(lmsg));
1.100 njoly 481: if (error)
482: return error;
1.104 njoly 483: linux_to_bsd_msghdr(&lmsg, &msg);
1.100 njoly 484:
1.73 dsl 485: msg.msg_flags = MSG_IOVUSRSPACE;
1.32 jdolecek 486:
1.49 jdolecek 487: /*
488: * Translate message flags.
489: */
490: bflags = linux_to_bsd_msg_flags(SCARG(uap, flags));
1.73 dsl 491: if (bflags < 0)
1.49 jdolecek 492: /* Some supported flag */
1.73 dsl 493: return EINVAL;
494:
1.104 njoly 495: if (lmsg.msg_name) {
1.73 dsl 496: /* Read in and convert the sockaddr */
497: error = linux_get_sa(l, SCARG(uap, s), &nam, msg.msg_name,
498: msg.msg_namelen);
499: if (error)
500: return (error);
501: msg.msg_flags |= MSG_NAMEMBUF;
502: msg.msg_name = nam;
1.32 jdolecek 503: }
504:
505: /*
1.49 jdolecek 506: * Handle cmsg if there is any.
1.32 jdolecek 507: */
1.104 njoly 508: if (LINUX_CMSG_FIRSTHDR(&lmsg)) {
1.76 dsl 509: struct linux_cmsghdr l_cmsg, *l_cc;
510: struct cmsghdr *cmsg;
1.49 jdolecek 511: ssize_t resid = msg.msg_controllen;
512: size_t clen, cidx = 0, cspace;
513:
1.73 dsl 514: ctl_mbuf = m_get(M_WAIT, MT_CONTROL);
515: clen = MLEN;
516: control = mtod(ctl_mbuf, void *);
1.49 jdolecek 517:
1.104 njoly 518: l_cc = LINUX_CMSG_FIRSTHDR(&lmsg);
1.49 jdolecek 519: do {
1.76 dsl 520: error = copyin(l_cc, &l_cmsg, sizeof(l_cmsg));
1.49 jdolecek 521: if (error)
522: goto done;
523:
524: /*
525: * Sanity check the control message length.
526: */
1.76 dsl 527: if (l_cmsg.cmsg_len > resid
528: || l_cmsg.cmsg_len < sizeof l_cmsg) {
1.49 jdolecek 529: error = EINVAL;
530: goto done;
531: }
532:
533: /*
534: * Refuse unsupported control messages, and
535: * translate fields as appropriate.
536: */
1.76 dsl 537: switch (l_cmsg.cmsg_level) {
1.49 jdolecek 538: case LINUX_SOL_SOCKET:
539: /* It only differs on some archs */
1.73 dsl 540: if (LINUX_SOL_SOCKET != SOL_SOCKET)
1.76 dsl 541: l_cmsg.cmsg_level = SOL_SOCKET;
1.49 jdolecek 542:
1.76 dsl 543: switch(l_cmsg.cmsg_type) {
1.49 jdolecek 544: case LINUX_SCM_RIGHTS:
545: /* Linux SCM_RIGHTS is same as NetBSD */
546: break;
547:
1.108 chs 548: case LINUX_SCM_CREDENTIALS:
549: /* no native equivalent, just drop it */
550: m_free(ctl_mbuf);
551: ctl_mbuf = NULL;
552: msg.msg_control = NULL;
553: msg.msg_controllen = 0;
554: goto skipcmsg;
555:
1.49 jdolecek 556: default:
557: /* other types not supported */
558: error = EINVAL;
559: goto done;
560: }
561: break;
562: default:
563: /* pray and leave intact */
564: break;
565: }
566:
1.76 dsl 567: cspace = CMSG_SPACE(l_cmsg.cmsg_len - sizeof(l_cmsg));
1.49 jdolecek 568:
569: /* Check the buffer is big enough */
570: if (__predict_false(cidx + cspace > clen)) {
571: u_int8_t *nc;
572:
573: clen = cidx + cspace;
1.73 dsl 574: if (clen >= PAGE_SIZE) {
575: error = EINVAL;
576: goto done;
577: }
578: nc = realloc(clen <= MLEN ? NULL : control,
579: clen, M_TEMP, M_WAITOK);
1.49 jdolecek 580: if (!nc) {
581: error = ENOMEM;
582: goto done;
583: }
1.73 dsl 584: if (cidx <= MLEN)
585: /* Old buffer was in mbuf... */
586: memcpy(nc, control, cidx);
1.49 jdolecek 587: control = nc;
588: }
589:
590: /* Copy header */
1.76 dsl 591: cmsg = (void *)&control[cidx];
592: cmsg->cmsg_len = l_cmsg.cmsg_len + LINUX_CMSG_ALIGN_DELTA;
593: cmsg->cmsg_level = l_cmsg.cmsg_level;
594: cmsg->cmsg_type = l_cmsg.cmsg_type;
1.49 jdolecek 595:
1.108 chs 596: /* Zero area between header and data */
1.76 dsl 597: memset(cmsg + 1, 0,
1.112 joerg 598: CMSG_ALIGN(sizeof(*cmsg)) - sizeof(*cmsg));
1.49 jdolecek 599:
600: /* Copyin the data */
1.76 dsl 601: error = copyin(LINUX_CMSG_DATA(l_cc),
1.112 joerg 602: CMSG_DATA(cmsg),
1.76 dsl 603: l_cmsg.cmsg_len - sizeof(l_cmsg));
1.49 jdolecek 604: if (error)
605: goto done;
606:
1.76 dsl 607: resid -= LINUX_CMSG_ALIGN(l_cmsg.cmsg_len);
1.49 jdolecek 608: cidx += cspace;
1.76 dsl 609: } while ((l_cc = LINUX_CMSG_NXTHDR(&msg, l_cc)) && resid > 0);
1.49 jdolecek 610:
1.73 dsl 611: /* If we allocated a buffer, attach to mbuf */
612: if (cidx > MLEN) {
613: MEXTADD(ctl_mbuf, control, clen, M_MBUF, NULL, NULL);
614: ctl_mbuf->m_flags |= M_EXT_RW;
1.49 jdolecek 615: }
1.73 dsl 616: control = NULL;
617: ctl_mbuf->m_len = cidx;
1.49 jdolecek 618:
1.73 dsl 619: msg.msg_control = ctl_mbuf;
620: msg.msg_flags |= MSG_CONTROLMBUF;
1.101 njoly 621:
1.114 christos 622: ktrkuser("mbcontrol", mtod(ctl_mbuf, void *),
1.101 njoly 623: msg.msg_controllen);
1.49 jdolecek 624: }
1.32 jdolecek 625:
1.108 chs 626: skipcmsg:
1.73 dsl 627: error = do_sys_sendmsg(l, SCARG(uap, s), &msg, bflags, retval);
628: /* Freed internally */
629: ctl_mbuf = NULL;
1.32 jdolecek 630:
1.49 jdolecek 631: done:
1.73 dsl 632: if (ctl_mbuf != NULL) {
633: if (control != NULL && control != mtod(ctl_mbuf, void *))
634: free(control, M_MBUF);
635: m_free(ctl_mbuf);
636: }
1.49 jdolecek 637: return (error);
1.1 fvdl 638: }
639:
1.2 mycroft 640: int
1.85 dsl 641: linux_sys_recvfrom(struct lwp *l, const struct linux_sys_recvfrom_args *uap, register_t *retval)
1.16 erh 642: {
1.85 dsl 643: /* {
1.1 fvdl 644: syscallarg(int) s;
645: syscallarg(void *) buf;
646: syscallarg(int) len;
647: syscallarg(int) flags;
1.32 jdolecek 648: syscallarg(struct osockaddr *) from;
649: syscallarg(int *) fromlenaddr;
1.85 dsl 650: } */
1.32 jdolecek 651: int error;
652: struct sys_recvfrom_args bra;
1.1 fvdl 653:
1.16 erh 654: SCARG(&bra, s) = SCARG(uap, s);
655: SCARG(&bra, buf) = SCARG(uap, buf);
656: SCARG(&bra, len) = SCARG(uap, len);
657: SCARG(&bra, flags) = SCARG(uap, flags);
1.32 jdolecek 658: SCARG(&bra, from) = (struct sockaddr *) SCARG(uap, from);
1.61 mrg 659: SCARG(&bra, fromlenaddr) = (socklen_t *)SCARG(uap, fromlenaddr);
1.1 fvdl 660:
1.43 thorpej 661: if ((error = sys_recvfrom(l, &bra, retval)))
1.32 jdolecek 662: return (error);
663:
664: if (SCARG(uap, from) && (error = linux_sa_put(SCARG(uap, from))))
665: return (error);
666:
667: return (0);
668: }
669:
1.76 dsl 670: static int
671: linux_copyout_msg_control(struct lwp *l, struct msghdr *mp, struct mbuf *control)
672: {
673: int dlen, error = 0;
674: struct cmsghdr *cmsg;
675: struct linux_cmsghdr linux_cmsg;
676: struct mbuf *m;
677: char *q, *q_end;
678:
679: if (mp->msg_controllen <= 0 || control == 0) {
680: mp->msg_controllen = 0;
681: free_control_mbuf(l, control, control);
682: return 0;
683: }
684:
1.101 njoly 685: ktrkuser("msgcontrol", mtod(control, void *), mp->msg_controllen);
686:
1.76 dsl 687: q = (char *)mp->msg_control;
688: q_end = q + mp->msg_controllen;
689:
690: for (m = control; m != NULL; ) {
691: cmsg = mtod(m, struct cmsghdr *);
692:
693: /*
694: * Fixup cmsg. We handle two things:
695: * 0. different sizeof cmsg_len.
696: * 1. different values for level/type on some archs
697: * 2. different alignment of CMSG_DATA on some archs
698: */
699: linux_cmsg.cmsg_len = cmsg->cmsg_len - LINUX_CMSG_ALIGN_DELTA;
700: linux_cmsg.cmsg_level = cmsg->cmsg_level;
701: linux_cmsg.cmsg_type = cmsg->cmsg_type;
702:
703: dlen = q_end - q;
704: if (linux_cmsg.cmsg_len > dlen) {
705: /* Not enough room for the parameter */
706: dlen -= sizeof linux_cmsg;
707: if (dlen <= 0)
708: /* Discard if header wont fit */
709: break;
710: mp->msg_flags |= MSG_CTRUNC;
711: if (linux_cmsg.cmsg_level == SOL_SOCKET
712: && linux_cmsg.cmsg_type == SCM_RIGHTS)
713: /* Do not truncate me ... */
714: break;
715: } else
716: dlen = linux_cmsg.cmsg_len - sizeof linux_cmsg;
717:
718: switch (linux_cmsg.cmsg_level) {
719: case SOL_SOCKET:
720: linux_cmsg.cmsg_level = LINUX_SOL_SOCKET;
721: switch (linux_cmsg.cmsg_type) {
722: case SCM_RIGHTS:
723: /* Linux SCM_RIGHTS is same as NetBSD */
724: break;
725:
726: default:
727: /* other types not supported */
728: error = EINVAL;
729: goto done;
730: }
1.109 wiz 731: /* machine dependent ! */
1.76 dsl 732: break;
733: default:
734: /* pray and leave intact */
735: break;
736: }
737:
738: /* There can be padding between the header and data... */
1.102 njoly 739: error = copyout(&linux_cmsg, q, sizeof linux_cmsg);
1.76 dsl 740: if (error != 0) {
741: error = copyout(CCMSG_DATA(cmsg), q + sizeof linux_cmsg,
742: dlen);
743: }
744: if (error != 0) {
745: /* We must free all the SCM_RIGHTS */
746: m = control;
747: break;
748: }
749: m = m->m_next;
1.103 njoly 750: if (m == NULL || q + LINUX_CMSG_SPACE(dlen) > q_end) {
751: q += LINUX_CMSG_LEN(dlen);
1.76 dsl 752: break;
753: }
1.103 njoly 754: q += LINUX_CMSG_SPACE(dlen);
1.76 dsl 755: }
756:
757: done:
758: free_control_mbuf(l, control, m);
759:
760: mp->msg_controllen = q - (char *)mp->msg_control;
761: return error;
762: }
763:
1.32 jdolecek 764: int
1.85 dsl 765: linux_sys_recvmsg(struct lwp *l, const struct linux_sys_recvmsg_args *uap, register_t *retval)
1.32 jdolecek 766: {
1.85 dsl 767: /* {
1.32 jdolecek 768: syscallarg(int) s;
1.104 njoly 769: syscallarg(struct linux_msghdr *) msg;
1.32 jdolecek 770: syscallarg(u_int) flags;
1.85 dsl 771: } */
1.32 jdolecek 772: struct msghdr msg;
1.104 njoly 773: struct linux_msghdr lmsg;
1.32 jdolecek 774: int error;
1.76 dsl 775: struct mbuf *from, *control;
1.32 jdolecek 776:
1.104 njoly 777: error = copyin(SCARG(uap, msg), &lmsg, sizeof(lmsg));
1.76 dsl 778: if (error)
779: return (error);
1.104 njoly 780: linux_to_bsd_msghdr(&lmsg, &msg);
1.49 jdolecek 781:
1.76 dsl 782: msg.msg_flags = linux_to_bsd_msg_flags(SCARG(uap, flags));
783: if (msg.msg_flags < 0) {
1.49 jdolecek 784: /* Some unsupported flag */
785: return (EINVAL);
786: }
1.76 dsl 787: msg.msg_flags |= MSG_IOVUSRSPACE;
1.49 jdolecek 788:
1.76 dsl 789: error = do_sys_recvmsg(l, SCARG(uap, s), &msg, &from,
790: msg.msg_control != NULL ? &control : NULL, retval);
791: if (error != 0)
792: return error;
793:
794: if (msg.msg_control != NULL)
795: error = linux_copyout_msg_control(l, &msg, control);
796:
797: if (error == 0 && from != 0) {
798: mtod(from, struct osockaddr *)->sa_family =
799: bsd_to_linux_domain(mtod(from, struct sockaddr *)->sa_family);
800: error = copyout_sockname(msg.msg_name, &msg.msg_namelen, 0,
801: from);
802: } else
803: msg.msg_namelen = 0;
804:
805: if (from != NULL)
806: m_free(from);
807:
808: if (error == 0) {
809: msg.msg_flags = bsd_to_linux_msg_flags(msg.msg_flags);
810: if (msg.msg_flags < 0)
811: /* Some flag unsupported by Linux */
812: error = EINVAL;
1.101 njoly 813: else {
814: ktrkuser("msghdr", &msg, sizeof(msg));
1.104 njoly 815: bsd_to_linux_msghdr(&msg, &lmsg);
816: error = copyout(&lmsg, SCARG(uap, msg), sizeof(lmsg));
1.101 njoly 817: }
1.49 jdolecek 818: }
819:
1.32 jdolecek 820: return (error);
1.1 fvdl 821: }
822:
823: /*
824: * Convert socket option level from Linux to NetBSD value. Only SOL_SOCKET
825: * is different, the rest matches IPPROTO_* on both systems.
826: */
1.2 mycroft 827: int
1.84 dsl 828: linux_to_bsd_sopt_level(int llevel)
1.1 fvdl 829: {
1.12 mycroft 830:
1.1 fvdl 831: switch (llevel) {
832: case LINUX_SOL_SOCKET:
833: return SOL_SOCKET;
1.3 mycroft 834: case LINUX_SOL_IP:
835: return IPPROTO_IP;
836: case LINUX_SOL_TCP:
837: return IPPROTO_TCP;
838: case LINUX_SOL_UDP:
839: return IPPROTO_UDP;
1.1 fvdl 840: default:
841: return -1;
842: }
843: }
844:
845: /*
846: * Convert Linux socket level socket option numbers to NetBSD values.
847: */
1.2 mycroft 848: int
1.84 dsl 849: linux_to_bsd_so_sockopt(int lopt)
1.1 fvdl 850: {
1.12 mycroft 851:
1.1 fvdl 852: switch (lopt) {
853: case LINUX_SO_DEBUG:
854: return SO_DEBUG;
855: case LINUX_SO_REUSEADDR:
1.55 perry 856: /*
1.39 jschauma 857: * Linux does not implement SO_REUSEPORT, but allows reuse of a
858: * host:port pair through SO_REUSEADDR even if the address is not a
859: * multicast-address. Effectively, this means that we should use
860: * SO_REUSEPORT to allow Linux applications to not exit with
861: * EADDRINUSE
862: */
863: return SO_REUSEPORT;
1.1 fvdl 864: case LINUX_SO_TYPE:
865: return SO_TYPE;
866: case LINUX_SO_ERROR:
867: return SO_ERROR;
868: case LINUX_SO_DONTROUTE:
869: return SO_DONTROUTE;
870: case LINUX_SO_BROADCAST:
871: return SO_BROADCAST;
872: case LINUX_SO_SNDBUF:
873: return SO_SNDBUF;
874: case LINUX_SO_RCVBUF:
875: return SO_RCVBUF;
876: case LINUX_SO_KEEPALIVE:
877: return SO_KEEPALIVE;
878: case LINUX_SO_OOBINLINE:
879: return SO_OOBINLINE;
880: case LINUX_SO_LINGER:
881: return SO_LINGER;
882: case LINUX_SO_PRIORITY:
883: case LINUX_SO_NO_CHECK:
884: default:
885: return -1;
886: }
887: }
888:
889: /*
1.3 mycroft 890: * Convert Linux IP level socket option number to NetBSD values.
891: */
892: int
1.84 dsl 893: linux_to_bsd_ip_sockopt(int lopt)
1.3 mycroft 894: {
1.12 mycroft 895:
1.3 mycroft 896: switch (lopt) {
897: case LINUX_IP_TOS:
898: return IP_TOS;
899: case LINUX_IP_TTL:
900: return IP_TTL;
1.107 dsl 901: case LINUX_IP_HDRINCL:
902: return IP_HDRINCL;
1.3 mycroft 903: case LINUX_IP_MULTICAST_TTL:
904: return IP_MULTICAST_TTL;
905: case LINUX_IP_MULTICAST_LOOP:
906: return IP_MULTICAST_LOOP;
907: case LINUX_IP_MULTICAST_IF:
908: return IP_MULTICAST_IF;
909: case LINUX_IP_ADD_MEMBERSHIP:
910: return IP_ADD_MEMBERSHIP;
911: case LINUX_IP_DROP_MEMBERSHIP:
912: return IP_DROP_MEMBERSHIP;
913: default:
914: return -1;
915: }
916: }
917:
918: /*
919: * Convert Linux TCP level socket option number to NetBSD values.
920: */
921: int
1.84 dsl 922: linux_to_bsd_tcp_sockopt(int lopt)
1.3 mycroft 923: {
1.12 mycroft 924:
1.3 mycroft 925: switch (lopt) {
1.6 mycroft 926: case LINUX_TCP_NODELAY:
927: return TCP_NODELAY;
928: case LINUX_TCP_MAXSEG:
929: return TCP_MAXSEG;
1.3 mycroft 930: default:
1.6 mycroft 931: return -1;
1.3 mycroft 932: }
933: }
934:
935: /*
936: * Convert Linux UDP level socket option number to NetBSD values.
937: */
938: int
1.84 dsl 939: linux_to_bsd_udp_sockopt(int lopt)
1.3 mycroft 940: {
1.12 mycroft 941:
1.3 mycroft 942: switch (lopt) {
943: default:
1.6 mycroft 944: return -1;
1.3 mycroft 945: }
946: }
947:
948: /*
1.5 mycroft 949: * Another reasonably straightforward function: setsockopt(2).
1.1 fvdl 950: * The level and option numbers are converted; the values passed
951: * are not (yet) converted, the ones currently implemented don't
952: * need conversion, as they are the same on both systems.
953: */
1.2 mycroft 954: int
1.85 dsl 955: linux_sys_setsockopt(struct lwp *l, const struct linux_sys_setsockopt_args *uap, register_t *retval)
1.16 erh 956: {
1.85 dsl 957: /* {
1.1 fvdl 958: syscallarg(int) s;
959: syscallarg(int) level;
960: syscallarg(int) optname;
961: syscallarg(void *) optval;
962: syscallarg(int) optlen;
1.85 dsl 963: } */
1.12 mycroft 964: struct sys_setsockopt_args bsa;
1.16 erh 965: int name;
1.1 fvdl 966:
1.16 erh 967: SCARG(&bsa, s) = SCARG(uap, s);
968: SCARG(&bsa, level) = linux_to_bsd_sopt_level(SCARG(uap, level));
969: SCARG(&bsa, val) = SCARG(uap, optval);
970: SCARG(&bsa, valsize) = SCARG(uap, optlen);
1.1 fvdl 971:
1.70 mlelstv 972: /*
973: * Linux supports only SOL_SOCKET for AF_LOCAL domain sockets
974: * and returns EOPNOTSUPP for other levels
975: */
976: if (SCARG(&bsa, level) != SOL_SOCKET) {
977: struct socket *so;
1.89 ad 978: int error, family;
1.70 mlelstv 979:
1.96 ad 980: /* fd_getsock() will use the descriptor for us */
1.89 ad 981: if ((error = fd_getsock(SCARG(&bsa, s), &so)) != 0)
1.70 mlelstv 982: return error;
983: family = so->so_proto->pr_domain->dom_family;
1.87 ad 984: fd_putfile(SCARG(&bsa, s));
1.70 mlelstv 985:
986: if (family == AF_LOCAL)
987: return EOPNOTSUPP;
988: }
989:
1.1 fvdl 990: switch (SCARG(&bsa, level)) {
1.40 itojun 991: case SOL_SOCKET:
992: name = linux_to_bsd_so_sockopt(SCARG(uap, optname));
993: break;
994: case IPPROTO_IP:
995: name = linux_to_bsd_ip_sockopt(SCARG(uap, optname));
996: break;
997: case IPPROTO_TCP:
998: name = linux_to_bsd_tcp_sockopt(SCARG(uap, optname));
999: break;
1000: case IPPROTO_UDP:
1001: name = linux_to_bsd_udp_sockopt(SCARG(uap, optname));
1002: break;
1003: default:
1004: return EINVAL;
1.1 fvdl 1005: }
1006:
1007: if (name == -1)
1008: return EINVAL;
1009: SCARG(&bsa, name) = name;
1010:
1.43 thorpej 1011: return sys_setsockopt(l, &bsa, retval);
1.1 fvdl 1012: }
1013:
1014: /*
1015: * getsockopt(2) is very much the same as setsockopt(2) (see above)
1016: */
1.2 mycroft 1017: int
1.85 dsl 1018: linux_sys_getsockopt(struct lwp *l, const struct linux_sys_getsockopt_args *uap, register_t *retval)
1.16 erh 1019: {
1.85 dsl 1020: /* {
1.1 fvdl 1021: syscallarg(int) s;
1022: syscallarg(int) level;
1023: syscallarg(int) optname;
1024: syscallarg(void *) optval;
1.16 erh 1025: syscallarg(int *) optlen;
1.85 dsl 1026: } */
1.12 mycroft 1027: struct sys_getsockopt_args bga;
1.16 erh 1028: int name;
1.1 fvdl 1029:
1.16 erh 1030: SCARG(&bga, s) = SCARG(uap, s);
1031: SCARG(&bga, level) = linux_to_bsd_sopt_level(SCARG(uap, level));
1032: SCARG(&bga, val) = SCARG(uap, optval);
1.61 mrg 1033: SCARG(&bga, avalsize) = (socklen_t *)SCARG(uap, optlen);
1.1 fvdl 1034:
1035: switch (SCARG(&bga, level)) {
1.40 itojun 1036: case SOL_SOCKET:
1037: name = linux_to_bsd_so_sockopt(SCARG(uap, optname));
1038: break;
1039: case IPPROTO_IP:
1040: name = linux_to_bsd_ip_sockopt(SCARG(uap, optname));
1041: break;
1042: case IPPROTO_TCP:
1043: name = linux_to_bsd_tcp_sockopt(SCARG(uap, optname));
1044: break;
1045: case IPPROTO_UDP:
1046: name = linux_to_bsd_udp_sockopt(SCARG(uap, optname));
1047: break;
1048: default:
1049: return EINVAL;
1.1 fvdl 1050: }
1051:
1052: if (name == -1)
1053: return EINVAL;
1.5 mycroft 1054: SCARG(&bga, name) = name;
1.1 fvdl 1055:
1.43 thorpej 1056: return sys_getsockopt(l, &bga, retval);
1.13 mycroft 1057: }
1058:
1.97 njoly 1059: int
1.105 joerg 1060: linux_getifname(struct lwp *l, register_t *retval, void *data)
1061: {
1062: struct ifnet *ifp;
1063: struct linux_ifreq ifr;
1064: int error;
1065:
1066: error = copyin(data, &ifr, sizeof(ifr));
1067: if (error)
1068: return error;
1069:
1070: if (ifr.ifr_ifru.ifru_ifindex >= if_indexlim)
1071: return ENODEV;
1072:
1073: ifp = ifindex2ifnet[ifr.ifr_ifru.ifru_ifindex];
1074: if (ifp == NULL)
1075: return ENODEV;
1076:
1077: strncpy(ifr.ifr_name, ifp->if_xname, sizeof(ifr.ifr_name));
1078:
1.106 joerg 1079: return copyout(&ifr, data, sizeof(ifr));
1.105 joerg 1080: }
1081:
1082: int
1.97 njoly 1083: linux_getifconf(struct lwp *l, register_t *retval, void *data)
1084: {
1085: struct linux_ifreq ifr, *ifrp;
1.115 ! christos 1086: struct linux_ifconf ifc;
1.97 njoly 1087: struct ifnet *ifp;
1088: struct ifaddr *ifa;
1089: struct sockaddr *sa;
1090: struct osockaddr *osa;
1091: int space, error = 0;
1092: const int sz = (int)sizeof(ifr);
1093:
1.115 ! christos 1094: error = copyin(data, &ifc, sizeof(ifc));
! 1095: if (error)
! 1096: return error;
! 1097:
! 1098: ifrp = ifc.ifc_req;
1.97 njoly 1099: if (ifrp == NULL)
1100: space = 0;
1101: else
1.115 ! christos 1102: space = ifc.ifc_len;
1.97 njoly 1103:
1104: IFNET_FOREACH(ifp) {
1105: (void)strncpy(ifr.ifr_name, ifp->if_xname,
1106: sizeof(ifr.ifr_name));
1107: if (ifr.ifr_name[sizeof(ifr.ifr_name) - 1] != '\0')
1108: return ENAMETOOLONG;
1109: if (IFADDR_EMPTY(ifp))
1110: continue;
1111: IFADDR_FOREACH(ifa, ifp) {
1112: sa = ifa->ifa_addr;
1113: if (sa->sa_family != AF_INET ||
1114: sa->sa_len > sizeof(*osa))
1115: continue;
1116: memcpy(&ifr.ifr_addr, sa, sa->sa_len);
1117: osa = (struct osockaddr *)&ifr.ifr_addr;
1118: osa->sa_family = sa->sa_family;
1119: if (space >= sz) {
1120: error = copyout(&ifr, ifrp, sz);
1121: if (error != 0)
1122: return error;
1123: ifrp++;
1124: }
1125: space -= sz;
1126: }
1127: }
1128:
1129: if (ifrp != NULL)
1.115 ! christos 1130: ifc.ifc_len -= space;
1.97 njoly 1131: else
1.115 ! christos 1132: ifc.ifc_len = -space;
1.97 njoly 1133:
1.115 ! christos 1134: return copyout(&ifc, data, sizeof(ifc));
1.97 njoly 1135: }
1.21 jtk 1136:
1137: int
1.68 christos 1138: linux_getifhwaddr(struct lwp *l, register_t *retval, u_int fd,
1.67 christos 1139: void *data)
1.21 jtk 1140: {
1141: /* Not the full structure, just enough to map what we do here */
1.97 njoly 1142: struct linux_ifreq lreq;
1.87 ad 1143: file_t *fp;
1.21 jtk 1144: struct ifaddr *ifa;
1145: struct ifnet *ifp;
1146: struct sockaddr_dl *sadl;
1147: int error, found;
1148: int index, ifnum;
1149:
1150: /*
1151: * We can't emulate this ioctl by calling sys_ioctl() to run
1152: * SIOCGIFCONF, because the user buffer is not of the right
1153: * type to take those results. We can't use kernel buffers to
1154: * receive the results, as the implementation of sys_ioctl()
1155: * and ifconf() [which implements SIOCGIFCONF] use
1156: * copyin()/copyout() which will fail on kernel addresses.
1157: *
1158: * So, we must duplicate code from sys_ioctl() and ifconf(). Ugh.
1159: */
1160:
1.87 ad 1161: if ((fp = fd_getfile(fd)) == NULL)
1.21 jtk 1162: return (EBADF);
1163:
1.90 ad 1164: KERNEL_LOCK(1, NULL);
1165:
1.21 jtk 1166: if ((fp->f_flag & (FREAD | FWRITE)) == 0) {
1167: error = EBADF;
1168: goto out;
1169: }
1170:
1.73 dsl 1171: error = copyin(data, &lreq, sizeof(lreq));
1.21 jtk 1172: if (error)
1173: goto out;
1.97 njoly 1174: lreq.ifr_name[LINUX_IFNAMSIZ-1] = '\0'; /* just in case */
1.21 jtk 1175:
1176: /*
1.22 jdolecek 1177: * Try real interface name first, then fake "ethX"
1.21 jtk 1178: */
1.82 dyoung 1179: found = 0;
1180: IFNET_FOREACH(ifp) {
1181: if (found)
1182: break;
1.97 njoly 1183: if (strcmp(lreq.ifr_name, ifp->if_xname))
1.22 jdolecek 1184: /* not this interface */
1185: continue;
1.55 perry 1186: found=1;
1.83 dyoung 1187: if (IFADDR_EMPTY(ifp)) {
1.22 jdolecek 1188: error = ENODEV;
1189: goto out;
1190: }
1.82 dyoung 1191: IFADDR_FOREACH(ifa, ifp) {
1192: sadl = satosdl(ifa->ifa_addr);
1193: /* only return ethernet addresses */
1194: /* XXX what about FDDI, etc. ? */
1195: if (sadl->sdl_family != AF_LINK ||
1196: sadl->sdl_type != IFT_ETHER)
1197: continue;
1.97 njoly 1198: memcpy(&lreq.ifr_hwaddr.sa_data, CLLADDR(sadl),
1.82 dyoung 1199: MIN(sadl->sdl_alen,
1.97 njoly 1200: sizeof(lreq.ifr_hwaddr.sa_data)));
1201: lreq.ifr_hwaddr.sa_family =
1.82 dyoung 1202: sadl->sdl_family;
1203: error = copyout(&lreq, data, sizeof(lreq));
1204: goto out;
1205: }
1.22 jdolecek 1206: }
1207:
1.97 njoly 1208: if (strncmp(lreq.ifr_name, "eth", 3) == 0) {
1.21 jtk 1209: for (ifnum = 0, index = 3;
1.113 bouyer 1210: index < LINUX_IFNAMSIZ && lreq.ifr_name[index] != '\0';
1.21 jtk 1211: index++) {
1212: ifnum *= 10;
1.97 njoly 1213: ifnum += lreq.ifr_name[index] - '0';
1.21 jtk 1214: }
1215:
1216: error = EINVAL; /* in case we don't find one */
1.82 dyoung 1217: found = 0;
1218: IFNET_FOREACH(ifp) {
1219: if (found)
1220: break;
1.97 njoly 1221: memcpy(lreq.ifr_name, ifp->if_xname,
1222: MIN(LINUX_IFNAMSIZ, IFNAMSIZ));
1.82 dyoung 1223: IFADDR_FOREACH(ifa, ifp) {
1224: sadl = satosdl(ifa->ifa_addr);
1225: /* only return ethernet addresses */
1226: /* XXX what about FDDI, etc. ? */
1227: if (sadl->sdl_family != AF_LINK ||
1228: sadl->sdl_type != IFT_ETHER)
1229: continue;
1230: if (ifnum--)
1231: /* not the reqested iface */
1232: continue;
1.97 njoly 1233: memcpy(&lreq.ifr_hwaddr.sa_data,
1.82 dyoung 1234: CLLADDR(sadl),
1235: MIN(sadl->sdl_alen,
1.97 njoly 1236: sizeof(lreq.ifr_hwaddr.sa_data)));
1237: lreq.ifr_hwaddr.sa_family =
1.82 dyoung 1238: sadl->sdl_family;
1239: error = copyout(&lreq, data, sizeof(lreq));
1240: found = 1;
1241: break;
1242: }
1.21 jtk 1243: }
1.22 jdolecek 1244: } else {
1245: /* unknown interface, not even an "eth*" name */
1246: error = ENODEV;
1247: }
1.55 perry 1248:
1.21 jtk 1249: out:
1.90 ad 1250: KERNEL_UNLOCK_ONE(NULL);
1.87 ad 1251: fd_putfile(fd);
1.21 jtk 1252: return error;
1253: }
1254:
1.13 mycroft 1255: int
1.85 dsl 1256: linux_ioctl_socket(struct lwp *l, const struct linux_sys_ioctl_args *uap, register_t *retval)
1257: {
1258: /* {
1.13 mycroft 1259: syscallarg(int) fd;
1260: syscallarg(u_long) com;
1.71 christos 1261: syscallarg(void *) data;
1.85 dsl 1262: } */
1.13 mycroft 1263: u_long com;
1.25 fvdl 1264: int error = 0, isdev = 0, dosys = 1;
1.13 mycroft 1265: struct sys_ioctl_args ia;
1.87 ad 1266: file_t *fp;
1.25 fvdl 1267: struct vnode *vp;
1.87 ad 1268: int (*ioctlf)(file_t *, u_long, void *);
1.25 fvdl 1269: struct ioctl_pt pt;
1270:
1.87 ad 1271: if ((fp = fd_getfile(SCARG(uap, fd))) == NULL)
1.25 fvdl 1272: return (EBADF);
1273:
1274: if (fp->f_type == DTYPE_VNODE) {
1275: vp = (struct vnode *)fp->f_data;
1276: isdev = vp->v_type == VCHR;
1277: }
1278:
1279: /*
1280: * Don't try to interpret socket ioctl calls that are done
1281: * on a device filedescriptor, just pass them through, to
1282: * emulate Linux behaviour. Use PTIOCLINUX so that the
1283: * device will only handle these if it's prepared to do
1284: * so, to avoid unexpected things from happening.
1285: */
1286: if (isdev) {
1.26 fvdl 1287: dosys = 0;
1.25 fvdl 1288: ioctlf = fp->f_ops->fo_ioctl;
1289: pt.com = SCARG(uap, com);
1290: pt.data = SCARG(uap, data);
1.87 ad 1291: error = ioctlf(fp, PTIOCLINUX, &pt);
1.27 fvdl 1292: /*
1.55 perry 1293: * XXX hack: if the function returns EJUSTRETURN,
1.27 fvdl 1294: * it has stuffed a sysctl return value in pt.data.
1295: */
1296: if (error == EJUSTRETURN) {
1297: retval[0] = (register_t)pt.data;
1298: error = 0;
1299: }
1.25 fvdl 1300: goto out;
1301: }
1.13 mycroft 1302:
1303: com = SCARG(uap, com);
1304: retval[0] = 0;
1305:
1306: switch (com) {
1.105 joerg 1307: case LINUX_SIOCGIFNAME:
1308: error = linux_getifname(l, retval, SCARG(uap, data));
1309: dosys = 0;
1310: break;
1.13 mycroft 1311: case LINUX_SIOCGIFCONF:
1.97 njoly 1312: error = linux_getifconf(l, retval, SCARG(uap, data));
1313: dosys = 0;
1.13 mycroft 1314: break;
1315: case LINUX_SIOCGIFFLAGS:
1.72 christos 1316: SCARG(&ia, com) = OSIOCGIFFLAGS;
1.13 mycroft 1317: break;
1.25 fvdl 1318: case LINUX_SIOCSIFFLAGS:
1.72 christos 1319: SCARG(&ia, com) = OSIOCSIFFLAGS;
1.25 fvdl 1320: break;
1.13 mycroft 1321: case LINUX_SIOCGIFADDR:
1.72 christos 1322: SCARG(&ia, com) = OOSIOCGIFADDR;
1.13 mycroft 1323: break;
1324: case LINUX_SIOCGIFDSTADDR:
1.72 christos 1325: SCARG(&ia, com) = OOSIOCGIFDSTADDR;
1.13 mycroft 1326: break;
1327: case LINUX_SIOCGIFBRDADDR:
1.72 christos 1328: SCARG(&ia, com) = OOSIOCGIFBRDADDR;
1.13 mycroft 1329: break;
1330: case LINUX_SIOCGIFNETMASK:
1.72 christos 1331: SCARG(&ia, com) = OOSIOCGIFNETMASK;
1.13 mycroft 1332: break;
1.107 dsl 1333: case LINUX_SIOCGIFMTU:
1334: SCARG(&ia, com) = OSIOCGIFMTU;
1335: break;
1.13 mycroft 1336: case LINUX_SIOCADDMULTI:
1.72 christos 1337: SCARG(&ia, com) = OSIOCADDMULTI;
1.13 mycroft 1338: break;
1339: case LINUX_SIOCDELMULTI:
1.72 christos 1340: SCARG(&ia, com) = OSIOCDELMULTI;
1.13 mycroft 1341: break;
1.21 jtk 1342: case LINUX_SIOCGIFHWADDR:
1.73 dsl 1343: error = linux_getifhwaddr(l, retval, SCARG(uap, fd),
1.87 ad 1344: SCARG(uap, data));
1.29 fvdl 1345: dosys = 0;
1.25 fvdl 1346: break;
1.13 mycroft 1347: default:
1.25 fvdl 1348: error = EINVAL;
1349: }
1350:
1.87 ad 1351: out:
1352: fd_putfile(SCARG(uap, fd));
1.25 fvdl 1353:
1354: if (error ==0 && dosys) {
1355: SCARG(&ia, fd) = SCARG(uap, fd);
1356: SCARG(&ia, data) = SCARG(uap, data);
1.43 thorpej 1357: error = sys_ioctl(curlwp, &ia, retval);
1.13 mycroft 1358: }
1359:
1.25 fvdl 1360: return error;
1.1 fvdl 1361: }
1.19 sommerfe 1362:
1363: int
1.85 dsl 1364: linux_sys_connect(struct lwp *l, const struct linux_sys_connect_args *uap, register_t *retval)
1.19 sommerfe 1365: {
1.85 dsl 1366: /* {
1.19 sommerfe 1367: syscallarg(int) s;
1368: syscallarg(const struct sockaddr *) name;
1.32 jdolecek 1369: syscallarg(int) namelen;
1.85 dsl 1370: } */
1.32 jdolecek 1371: int error;
1.73 dsl 1372: struct mbuf *nam;
1373:
1374: error = linux_get_sa(l, SCARG(uap, s), &nam, SCARG(uap, name),
1375: SCARG(uap, namelen));
1.32 jdolecek 1376: if (error)
1377: return (error);
1.55 perry 1378:
1.73 dsl 1379: error = do_sys_connect(l, SCARG(uap, s), nam);
1.19 sommerfe 1380:
1381: if (error == EISCONN) {
1.23 augustss 1382: struct socket *so;
1.111 christos 1383: int state, prflags;
1.55 perry 1384:
1.96 ad 1385: /* fd_getsock() will use the descriptor for us */
1.89 ad 1386: if (fd_getsock(SCARG(uap, s), &so) != 0)
1.19 sommerfe 1387: return EISCONN;
1388:
1.91 ad 1389: solock(so);
1.19 sommerfe 1390: state = so->so_state;
1391: prflags = so->so_proto->pr_flags;
1.91 ad 1392: sounlock(so);
1.87 ad 1393: fd_putfile(SCARG(uap, s));
1.19 sommerfe 1394: /*
1395: * We should only let this call succeed once per
1396: * non-blocking connect; however we don't have
1397: * a convenient place to keep that state..
1398: */
1.111 christos 1399: if ((state & (SS_ISCONNECTED|SS_NBIO)) ==
1400: (SS_ISCONNECTED|SS_NBIO) &&
1.19 sommerfe 1401: (prflags & PR_CONNREQUIRED))
1402: return 0;
1403: }
1404:
1.32 jdolecek 1405: return (error);
1406: }
1407:
1408: int
1.85 dsl 1409: linux_sys_bind(struct lwp *l, const struct linux_sys_bind_args *uap, register_t *retval)
1.32 jdolecek 1410: {
1.85 dsl 1411: /* {
1.32 jdolecek 1412: syscallarg(int) s;
1413: syscallarg(const struct osockaddr *) name;
1414: syscallarg(int) namelen;
1.85 dsl 1415: } */
1.61 mrg 1416: int error;
1.73 dsl 1417: struct mbuf *nam;
1.32 jdolecek 1418:
1.73 dsl 1419: error = linux_get_sa(l, SCARG(uap, s), &nam, SCARG(uap, name),
1420: SCARG(uap, namelen));
1421: if (error)
1422: return (error);
1.32 jdolecek 1423:
1.73 dsl 1424: return do_sys_bind(l, SCARG(uap, s), nam);
1.32 jdolecek 1425: }
1426:
1427: int
1.85 dsl 1428: linux_sys_getsockname(struct lwp *l, const struct linux_sys_getsockname_args *uap, register_t *retval)
1.32 jdolecek 1429: {
1.85 dsl 1430: /* {
1.32 jdolecek 1431: syscallarg(int) fdes;
1.71 christos 1432: syscallarg(void *) asa;
1.32 jdolecek 1433: syscallarg(int *) alen;
1.85 dsl 1434: } */
1.32 jdolecek 1435: int error;
1436:
1.85 dsl 1437: if ((error = sys_getsockname(l, (const void *)uap, retval)) != 0)
1.32 jdolecek 1438: return (error);
1439:
1440: if ((error = linux_sa_put((struct osockaddr *)SCARG(uap, asa))))
1441: return (error);
1442:
1443: return (0);
1444: }
1445:
1446: int
1.85 dsl 1447: linux_sys_getpeername(struct lwp *l, const struct linux_sys_getpeername_args *uap, register_t *retval)
1.32 jdolecek 1448: {
1.85 dsl 1449: /* {
1.32 jdolecek 1450: syscallarg(int) fdes;
1.71 christos 1451: syscallarg(void *) asa;
1.32 jdolecek 1452: syscallarg(int *) alen;
1.85 dsl 1453: } */
1.32 jdolecek 1454: int error;
1455:
1.85 dsl 1456: if ((error = sys_getpeername(l, (const void *)uap, retval)) != 0)
1.32 jdolecek 1457: return (error);
1458:
1459: if ((error = linux_sa_put((struct osockaddr *)SCARG(uap, asa))))
1460: return (error);
1461:
1462: return (0);
1463: }
1464:
1465: /*
1.73 dsl 1466: * Copy the osockaddr structure pointed to by osa to mbuf, adjust
1467: * family and convert to sockaddr.
1.32 jdolecek 1468: */
1469: static int
1.93 njoly 1470: linux_get_sa(struct lwp *l, int s, struct mbuf **mp,
1471: const struct osockaddr *osa, unsigned int salen)
1.73 dsl 1472: {
1473: int error, bdom;
1474: struct sockaddr *sa;
1475: struct osockaddr *kosa;
1476: struct mbuf *m;
1.32 jdolecek 1477:
1.73 dsl 1478: if (salen == 1 || salen > UCHAR_MAX) {
1479: DPRINTF(("bad osa=%p salen=%d\n", osa, salen));
1480: return EINVAL;
1.34 fvdl 1481: }
1.32 jdolecek 1482:
1.73 dsl 1483: /* We'll need the address in an mbuf later, so copy into one here */
1484: m = m_get(M_WAIT, MT_SONAME);
1485: if (salen > MLEN)
1486: MEXTMALLOC(m, salen, M_WAITOK);
1487:
1488: m->m_len = salen;
1489:
1.94 njoly 1490: if (salen == 0) {
1491: *mp = m;
1.73 dsl 1492: return 0;
1.94 njoly 1493: }
1.73 dsl 1494:
1495: kosa = mtod(m, void *);
1496: if ((error = copyin(osa, kosa, salen))) {
1497: DPRINTF(("error %d copying osa %p len %d\n",
1498: error, osa, salen));
1499: goto bad;
1.37 christos 1500: }
1.77 ad 1501:
1.114 christos 1502: ktrkuser("linux/sockaddr", kosa, salen);
1.32 jdolecek 1503:
1504: bdom = linux_to_bsd_domain(kosa->sa_family);
1505: if (bdom == -1) {
1.37 christos 1506: DPRINTF(("bad linux family=%d\n", kosa->sa_family));
1.32 jdolecek 1507: error = EINVAL;
1.73 dsl 1508: goto bad;
1509: }
1510:
1511: /*
1512: * If the family is unspecified, use address family of the socket.
1513: * This avoid triggering strict family checks in netinet/in_pcb.c et.al.
1514: */
1515: if (bdom == AF_UNSPEC) {
1516: struct socket *so;
1517:
1.96 ad 1518: /* fd_getsock() will use the descriptor for us */
1.88 ad 1519: if ((error = fd_getsock(s, &so)) != 0)
1.73 dsl 1520: goto bad;
1521:
1522: bdom = so->so_proto->pr_domain->dom_family;
1.88 ad 1523: fd_putfile(s);
1.73 dsl 1524:
1525: DPRINTF(("AF_UNSPEC family adjusted to %d\n", bdom));
1.32 jdolecek 1526: }
1527:
1528: /*
1529: * Older Linux IPv6 code uses obsolete RFC2133 struct sockaddr_in6,
1530: * which lacks the scope id compared with RFC2553 one. If we detect
1531: * the situation, reject the address and write a message to system log.
1.34 fvdl 1532: *
1533: * Still accept addresses for which the scope id is not used.
1.32 jdolecek 1534: */
1.73 dsl 1535: if (bdom == AF_INET6 && salen == sizeof (struct sockaddr_in6) - sizeof (u_int32_t)) {
1536: struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)kosa;
1537: if (!IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr) &&
1538: (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr) ||
1539: IN6_IS_ADDR_SITELOCAL(&sin6->sin6_addr) ||
1540: IN6_IS_ADDR_V4COMPAT(&sin6->sin6_addr) ||
1541: IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr) ||
1542: IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr))) {
1543: struct proc *p = l->l_proc;
1.65 ad 1544: int uid = l->l_cred ? kauth_cred_geteuid(l->l_cred) : -1;
1.34 fvdl 1545:
1546: log(LOG_DEBUG,
1547: "pid %d (%s), uid %d: obsolete pre-RFC2553 "
1548: "sockaddr_in6 rejected",
1549: p->p_pid, p->p_comm, uid);
1550: error = EINVAL;
1.73 dsl 1551: goto bad;
1.34 fvdl 1552: }
1.73 dsl 1553: salen = sizeof (struct sockaddr_in6);
1554: sin6->sin6_scope_id = 0;
1.53 jdolecek 1555: }
1556:
1.73 dsl 1557: if (bdom == AF_INET)
1558: salen = sizeof(struct sockaddr_in);
1.32 jdolecek 1559:
1560: sa = (struct sockaddr *) kosa;
1561: sa->sa_family = bdom;
1.73 dsl 1562: sa->sa_len = salen;
1563: m->m_len = salen;
1.114 christos 1564: ktrkuser("mbsoname", kosa, salen);
1.73 dsl 1565:
1.37 christos 1566: #ifdef DEBUG_LINUX
1567: DPRINTF(("family %d, len = %d [ ", sa->sa_family, sa->sa_len));
1568: for (bdom = 0; bdom < sizeof(sa->sa_data); bdom++)
1.51 jdolecek 1569: DPRINTF(("%02x ", (unsigned char) sa->sa_data[bdom]));
1.37 christos 1570: DPRINTF(("\n"));
1571: #endif
1.32 jdolecek 1572:
1.73 dsl 1573: *mp = m;
1574: return 0;
1.32 jdolecek 1575:
1.73 dsl 1576: bad:
1577: m_free(m);
1578: return error;
1.32 jdolecek 1579: }
1580:
1581: static int
1.84 dsl 1582: linux_sa_put(struct osockaddr *osa)
1.32 jdolecek 1583: {
1584: struct sockaddr sa;
1585: struct osockaddr *kosa;
1586: int error, bdom, len;
1587:
1588: /*
1589: * Only read/write the sockaddr family and length part, the rest is
1590: * not changed.
1591: */
1592: len = sizeof(sa.sa_len) + sizeof(sa.sa_family);
1593:
1.73 dsl 1594: error = copyin(osa, &sa, len);
1.32 jdolecek 1595: if (error)
1596: return (error);
1597:
1598: bdom = bsd_to_linux_domain(sa.sa_family);
1599: if (bdom == -1)
1600: return (EINVAL);
1601:
1602: /* Note: we convert from sockaddr to osockaddr here, too */
1603: kosa = (struct osockaddr *) &sa;
1604: kosa->sa_family = bdom;
1605: error = copyout(kosa, osa, len);
1606: if (error)
1607: return (error);
1608:
1609: return (0);
1610: }
1611:
1.56 manu 1612: #ifndef __amd64__
1.32 jdolecek 1613: int
1.85 dsl 1614: linux_sys_recv(struct lwp *l, const struct linux_sys_recv_args *uap, register_t *retval)
1.32 jdolecek 1615: {
1.85 dsl 1616: /* {
1.32 jdolecek 1617: syscallarg(int) s;
1618: syscallarg(void *) buf;
1619: syscallarg(int) len;
1620: syscallarg(int) flags;
1.85 dsl 1621: } */
1.32 jdolecek 1622: struct sys_recvfrom_args bra;
1623:
1624:
1625: SCARG(&bra, s) = SCARG(uap, s);
1626: SCARG(&bra, buf) = SCARG(uap, buf);
1627: SCARG(&bra, len) = (size_t) SCARG(uap, len);
1628: SCARG(&bra, flags) = SCARG(uap, flags);
1629: SCARG(&bra, from) = NULL;
1630: SCARG(&bra, fromlenaddr) = NULL;
1631:
1.43 thorpej 1632: return (sys_recvfrom(l, &bra, retval));
1.32 jdolecek 1633: }
1634:
1635: int
1.85 dsl 1636: linux_sys_send(struct lwp *l, const struct linux_sys_send_args *uap, register_t *retval)
1.32 jdolecek 1637: {
1.85 dsl 1638: /* {
1.32 jdolecek 1639: syscallarg(int) s;
1.71 christos 1640: syscallarg(void *) buf;
1.32 jdolecek 1641: syscallarg(int) len;
1642: syscallarg(int) flags;
1.85 dsl 1643: } */
1.32 jdolecek 1644: struct sys_sendto_args bsa;
1645:
1646: SCARG(&bsa, s) = SCARG(uap, s);
1647: SCARG(&bsa, buf) = SCARG(uap, buf);
1648: SCARG(&bsa, len) = SCARG(uap, len);
1649: SCARG(&bsa, flags) = SCARG(uap, flags);
1650: SCARG(&bsa, to) = NULL;
1651: SCARG(&bsa, tolen) = 0;
1652:
1.43 thorpej 1653: return (sys_sendto(l, &bsa, retval));
1.32 jdolecek 1654: }
1.59 manu 1655: #endif
1.32 jdolecek 1656:
1657: int
1.85 dsl 1658: linux_sys_accept(struct lwp *l, const struct linux_sys_accept_args *uap, register_t *retval)
1.32 jdolecek 1659: {
1.85 dsl 1660: /* {
1.32 jdolecek 1661: syscallarg(int) s;
1662: syscallarg(struct osockaddr *) name;
1663: syscallarg(int *) anamelen;
1.85 dsl 1664: } */
1.32 jdolecek 1665: int error;
1666: struct sys_accept_args baa;
1667:
1668: SCARG(&baa, s) = SCARG(uap, s);
1669: SCARG(&baa, name) = (struct sockaddr *) SCARG(uap, name);
1670: SCARG(&baa, anamelen) = (unsigned int *) SCARG(uap, anamelen);
1671:
1.43 thorpej 1672: if ((error = sys_accept(l, &baa, retval)))
1.32 jdolecek 1673: return (error);
1674:
1675: if (SCARG(uap, name) && (error = linux_sa_put(SCARG(uap, name))))
1676: return (error);
1677:
1678: return (0);
1.19 sommerfe 1679: }
CVSweb <webmaster@jp.NetBSD.org>