Annotation of sys/compat/linux/linux_socket.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: linux_socket.c,v 1.36 2007/06/06 09:59:21 henning Exp $ */
2: /* $NetBSD: linux_socket.c,v 1.14 1996/04/05 00:01:50 christos Exp $ */
3:
4: /*
5: * Copyright (c) 1995 Frank van der Linden
6: * All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. All advertising materials mentioning features or use of this software
17: * must display the following acknowledgement:
18: * This product includes software developed for the NetBSD Project
19: * by Frank van der Linden
20: * 4. The name of the author may not be used to endorse or promote products
21: * derived from this software without specific prior written permission
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
27: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
28: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
32: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33: */
34:
35: #include <sys/param.h>
36: #include <sys/kernel.h>
37: #include <sys/systm.h>
38: #include <sys/buf.h>
39: #include <sys/malloc.h>
40: #include <sys/ioctl.h>
41: #include <sys/tty.h>
42: #include <sys/file.h>
43: #include <sys/filedesc.h>
44: #include <sys/selinfo.h>
45: #include <sys/socket.h>
46: #include <sys/socketvar.h>
47: #include <net/if.h>
48: #include <net/if_types.h>
49: #include <net/if_dl.h>
50: #include <netinet/in.h>
51: #include <netinet/in_systm.h>
52: #include <netinet/ip.h>
53: #include <netinet/tcp.h>
54: #include <sys/mount.h>
55: #include <sys/proc.h>
56: #include <sys/vnode.h>
57: #include <sys/device.h>
58:
59: #include <sys/syscallargs.h>
60:
61: #include <compat/linux/linux_types.h>
62: #include <compat/linux/linux_util.h>
63: #include <compat/linux/linux_signal.h>
64: #include <compat/linux/linux_syscallargs.h>
65: #include <compat/linux/linux_ioctl.h>
66: #include <compat/linux/linux_socket.h>
67: #include <compat/linux/linux_socketcall.h>
68: #include <compat/linux/linux_sockio.h>
69:
70: /*
71: * All the calls in this file are entered via one common system
72: * call in Linux, represented here by linux_socketcall()
73: * Arguments for the various calls are on the user stack. A pointer
74: * to them is the only thing that is passed. It is up to the various
75: * calls to copy them in themselves. To make it look better, they
76: * are copied to structures.
77: */
78:
79: static int linux_to_bsd_domain (int);
80: static int bsd_to_linux_domain(int);
81:
82: int linux_socket(struct proc *, void *, register_t *);
83: int linux_bind(struct proc *, void *, register_t *);
84: int linux_connect(struct proc *, void *, register_t *);
85: int linux_listen(struct proc *, void *, register_t *);
86: int linux_accept(struct proc *, void *, register_t *);
87: int linux_getsockname(struct proc *, void *, register_t *);
88: int linux_getpeername(struct proc *, void *, register_t *);
89: int linux_socketpair(struct proc *, void *, register_t *);
90: int linux_send(struct proc *, void *, register_t *);
91: int linux_recv(struct proc *, void *, register_t *);
92: int linux_sendto(struct proc *, void *, register_t *);
93: int linux_recvfrom(struct proc *, void *, register_t *);
94: int linux_shutdown(struct proc *, void *, register_t *);
95: int linux_to_bsd_sopt_level(int);
96: int linux_to_bsd_so_sockopt(int);
97: int linux_to_bsd_ip_sockopt(int);
98: int linux_to_bsd_tcp_sockopt(int);
99: int linux_to_bsd_udp_sockopt(int);
100: int linux_setsockopt(struct proc *, void *, register_t *);
101: int linux_getsockopt(struct proc *, void *, register_t *);
102: int linux_recvmsg(struct proc *, void *, register_t *);
103: int linux_sendmsg(struct proc *, void *, register_t *);
104:
105: int linux_check_hdrincl(struct proc *, int, register_t *, caddr_t *);
106: int linux_sendto_hdrincl(struct proc *, struct sys_sendto_args *,
107: register_t *, caddr_t *);
108:
109: int linux_sa_get(struct proc *, caddr_t *, struct sockaddr **,
110: const struct osockaddr *, int *);
111: int linux_sa_put(struct osockaddr *);
112:
113: static const int linux_to_bsd_domain_[LINUX_AF_MAX] = {
114: AF_UNSPEC,
115: AF_UNIX,
116: AF_INET,
117: -1, /* LINUX_AF_AX25 */
118: -1, /* IPX */
119: AF_APPLETALK,
120: -1, /* LINUX_AF_NETROM */
121: -1, /* LINUX_AF_BRIDGE */
122: -1, /* LINUX_AF_ATMPVC */
123: -1, /* LINUX_AF_X25 */
124: AF_INET6,
125: -1, /* LINUX_AF_ROSE */
126: AF_DECnet,
127: -1, /* LINUX_AF_NETBEUI */
128: -1, /* LINUX_AF_SECURITY */
129: -1, /* pseudo_AF_KEY */
130: AF_ROUTE, /* LINUX_AF_NETLINK */
131: -1, /* LINUX_AF_PACKET */
132: -1, /* LINUX_AF_ASH */
133: -1, /* LINUX_AF_ECONET */
134: -1, /* LINUX_AF_ATMSVC */
135: AF_SNA,
136: /* rest up to LINUX_AF_MAX-1 is not allocated */
137: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
138: };
139:
140: static const int bsd_to_linux_domain_[AF_MAX] = {
141: LINUX_AF_UNSPEC,
142: LINUX_AF_UNIX,
143: LINUX_AF_INET,
144: -1, /* AF_IMPLINK */
145: -1, /* AF_PUP */
146: -1, /* AF_CHAOS */
147: -1, /* AF_NS */
148: -1, /* AF_ISO */
149: -1, /* AF_ECMA */
150: -1, /* AF_DATAKIT */
151: -1, /* AF_CCITT */
152: -1, /* LINUX_AF_SNA */
153: -1, /* LINUX_AF_DECnet */
154: -1, /* AF_DLI */
155: -1, /* AF_LAT */
156: -1, /* AF_HYLINK */
157: LINUX_AF_APPLETALK,
158: -1, /* LINUX_AF_NETLINK */
159: -1, /* AF_LINK */
160: -1, /* AF_XTP */
161: -1, /* AF_COIP */
162: -1, /* AF_CNT */
163: -1, /* pseudo_AF_RTIP */
164: LINUX_AF_IPX,
165: LINUX_AF_INET6,
166: -1, /* pseudo_AF_PIP */
167: -1, /* AF_ISDN */
168: -1, /* AF_NATM */
169: -1, /* AF_ARP */
170: -1, /* LINUX_pseudo_AF_KEY */
171: -1, /* pseudo_AF_HDRCMPLT */
172: };
173:
174: /*
175: * Convert between Linux and BSD socket domain values
176: */
177: static int
178: linux_to_bsd_domain(ldom)
179: int ldom;
180: {
181: if (ldom < 0 || ldom >= LINUX_AF_MAX)
182: return (-1);
183:
184: return linux_to_bsd_domain_[ldom];
185: }
186:
187: /*
188: * Convert between BSD and Linux socket domain values
189: */
190: static int
191: bsd_to_linux_domain(bdom)
192: int bdom;
193: {
194: if (bdom < 0 || bdom >= AF_MAX)
195: return (-1);
196:
197: return bsd_to_linux_domain_[bdom];
198: }
199:
200: int
201: linux_socket(p, v, retval)
202: struct proc *p;
203: void *v;
204: register_t *retval;
205: {
206: struct linux_socket_args /* {
207: syscallarg(int) domain;
208: syscallarg(int) type;
209: syscallarg(int) protocol;
210: } */ *uap = v;
211: struct linux_socket_args lsa;
212: struct sys_socket_args bsa;
213: int error;
214:
215: if ((error = copyin((caddr_t) uap, (caddr_t) &lsa, sizeof lsa)))
216: return error;
217:
218: SCARG(&bsa, protocol) = lsa.protocol;
219: SCARG(&bsa, type) = lsa.type;
220: SCARG(&bsa, domain) = linux_to_bsd_domain(lsa.domain);
221: if (SCARG(&bsa, domain) == -1)
222: return EINVAL;
223: return sys_socket(p, &bsa, retval);
224: }
225:
226: int
227: linux_bind(p, v, retval)
228: struct proc *p;
229: void *v;
230: register_t *retval;
231: {
232: struct linux_bind_args /* {
233: syscallarg(int) s;
234: syscallarg(struct sockaddr *) name;
235: syscallarg(int) namelen;
236: } */ *uap = v;
237: struct linux_bind_args lba;
238: struct sys_bind_args bba;
239: int error;
240: int namlen;
241:
242: if ((error = copyin((caddr_t) uap, (caddr_t) &lba, sizeof lba)))
243: return error;
244:
245: SCARG(&bba, s) = lba.s;
246: namlen = lba.namelen;
247: if (lba.name) {
248: struct sockaddr *sa;
249: caddr_t sg = stackgap_init(p->p_emul);
250:
251: error = linux_sa_get(p, &sg, &sa, lba.name, &namlen);
252: if (error)
253: return (error);
254: SCARG(&bba, name) = sa;
255: } else
256: SCARG(&bba, name) = NULL;
257: SCARG(&bba, namelen) = namlen;
258:
259: return sys_bind(p, &bba, retval);
260: }
261:
262: int
263: linux_connect(p, v, retval)
264: struct proc *p;
265: void *v;
266: register_t *retval;
267: {
268: struct linux_connect_args /* {
269: syscallarg(int) s;
270: syscallarg(struct osockaddr *) name;
271: syscallarg(int) namelen;
272: } */ *uap = v;
273: struct linux_connect_args lca;
274: struct sys_connect_args bca;
275: struct sockaddr *sa;
276: caddr_t sg = stackgap_init(p->p_emul);
277: int namlen;
278: int error;
279:
280: if ((error = copyin((caddr_t) uap, (caddr_t) &lca, sizeof lca)))
281: return error;
282:
283: namlen = lca.namelen;
284: error = linux_sa_get(p, &sg, &sa, lca.name, &namlen);
285: if (error)
286: return (error);
287:
288: SCARG(&bca, s) = lca.s;
289: SCARG(&bca, name) = sa;
290: SCARG(&bca, namelen) = (unsigned int)namlen;
291:
292: error = sys_connect(p, &bca, retval);
293:
294: if (error == EISCONN) {
295: struct sys_getsockopt_args bga;
296: #if 0
297: struct sys_fcntl_args fca;
298: #endif
299: void *status, *statusl;
300: int stat, statl = sizeof stat;
301:
302: #if 0
303: SCARG(&fca, fd) = lca.s;
304: SCARG(&fca, cmd) = F_GETFL;
305: SCARG(&fca, arg) = 0;
306: if (sys_fcntl(p, &fca, retval) == -1 ||
307: (*retval & O_NONBLOCK) == 0)
308: return error;
309: #endif
310:
311: status = stackgap_alloc(&sg, sizeof stat);
312: statusl = stackgap_alloc(&sg, sizeof statusl);
313:
314: if ((error = copyout(&statl, statusl, sizeof statl)))
315: return error;
316:
317: SCARG(&bga, s) = lca.s;
318: SCARG(&bga, level) = SOL_SOCKET;
319: SCARG(&bga, name) = SO_ERROR;
320: SCARG(&bga, val) = status;
321: SCARG(&bga, avalsize) = statusl;
322:
323: error = sys_getsockopt(p, &bga, retval);
324: if (error)
325: return error;
326: if ((error = copyin(status, &stat, sizeof stat)))
327: return error;
328: return stat;
329: }
330: return error;
331: }
332:
333: int
334: linux_listen(p, v, retval)
335: struct proc *p;
336: void *v;
337: register_t *retval;
338: {
339: struct linux_listen_args /* {
340: syscallarg(int) s;
341: syscallarg(int) backlog;
342: } */ *uap = v;
343: struct linux_listen_args lla;
344: struct sys_listen_args bla;
345: int error;
346:
347: if ((error = copyin((caddr_t) uap, (caddr_t) &lla, sizeof lla)))
348: return error;
349:
350: SCARG(&bla, s) = lla.s;
351: SCARG(&bla, backlog) = lla.backlog;
352:
353: return sys_listen(p, &bla, retval);
354: }
355:
356: int
357: linux_accept(p, v, retval)
358: struct proc *p;
359: void *v;
360: register_t *retval;
361: {
362: struct linux_accept_args /* {
363: syscallarg(int) s;
364: syscallarg(struct sockaddr *) addr;
365: syscallarg(int *) namelen;
366: } */ *uap = v;
367: struct linux_accept_args laa;
368: struct compat_43_sys_accept_args baa;
369: struct sys_fcntl_args fca;
370: int error;
371:
372: if ((error = copyin((caddr_t) uap, (caddr_t) &laa, sizeof laa)))
373: return error;
374:
375: SCARG(&baa, s) = laa.s;
376: SCARG(&baa, name) = (caddr_t) laa.addr;
377: SCARG(&baa, anamelen) = laa.namelen;
378:
379: error = compat_43_sys_accept(p, &baa, retval);
380: if (error)
381: return (error);
382:
383: /*
384: * linux appears not to copy flags from the parent socket to the
385: * accepted one, so we must clear the flags in the new descriptor.
386: * Ignore any errors, because we already have an open fd.
387: */
388: SCARG(&fca, fd) = *retval;
389: SCARG(&fca, cmd) = F_SETFL;
390: SCARG(&fca, arg) = 0;
391: (void)sys_fcntl(p, &fca, retval);
392: *retval = SCARG(&fca, fd);
393: return (0);
394: }
395:
396: int
397: linux_getsockname(p, v, retval)
398: struct proc *p;
399: void *v;
400: register_t *retval;
401: {
402: struct linux_getsockname_args /* {
403: syscallarg(int) s;
404: syscallarg(caddr_t) addr;
405: syscallarg(int *) namelen;
406: } */ *uap = v;
407: struct linux_getsockname_args lga;
408: struct sys_getsockname_args bga;
409: int error;
410:
411: if ((error = copyin((caddr_t) uap, (caddr_t) &lga, sizeof lga)))
412: return error;
413:
414: SCARG(&bga, fdes) = lga.s;
415: SCARG(&bga, asa) = (struct sockaddr *) lga.addr;
416: SCARG(&bga, alen) = lga.namelen;
417:
418: error = sys_getsockname(p, &bga, retval);
419: if (error)
420: return (error);
421:
422: if ((error = linux_sa_put((struct osockaddr *)lga.addr)))
423: return (error);
424:
425: return (0);
426: }
427:
428: int
429: linux_getpeername(p, v, retval)
430: struct proc *p;
431: void *v;
432: register_t *retval;
433: {
434: struct linux_getpeername_args /* {
435: syscallarg(int) s;
436: syscallarg(struct sockaddr *) addr;
437: syscallarg(int *) namelen;
438: } */ *uap = v;
439: struct linux_getpeername_args lga;
440: struct sys_getpeername_args bga;
441: int error;
442:
443: if ((error = copyin((caddr_t) uap, (caddr_t) &lga, sizeof lga)))
444: return error;
445:
446: SCARG(&bga, fdes) = lga.s;
447: SCARG(&bga, asa) = (struct sockaddr *) lga.addr;
448: SCARG(&bga, alen) = lga.namelen;
449:
450: error = sys_getpeername(p, &bga, retval);
451: if (error)
452: return (error);
453:
454: if ((error = linux_sa_put((struct osockaddr *)lga.addr)))
455: return (error);
456:
457: return (0);
458: }
459:
460: int
461: linux_socketpair(p, v, retval)
462: struct proc *p;
463: void *v;
464: register_t *retval;
465: {
466: struct linux_socketpair_args /* {
467: syscallarg(int) domain;
468: syscallarg(int) type;
469: syscallarg(int) protocol;
470: syscallarg(int *) rsv;
471: } */ *uap = v;
472: struct linux_socketpair_args lsa;
473: struct sys_socketpair_args bsa;
474: int error;
475:
476: if ((error = copyin((caddr_t) uap, &lsa, sizeof lsa)))
477: return error;
478:
479: SCARG(&bsa, domain) = linux_to_bsd_domain(lsa.domain);
480: if (SCARG(&bsa, domain) == -1)
481: return EINVAL;
482: SCARG(&bsa, type) = lsa.type;
483: SCARG(&bsa, protocol) = lsa.protocol;
484: SCARG(&bsa, rsv) = lsa.rsv;
485:
486: return sys_socketpair(p, &bsa, retval);
487: }
488:
489: int
490: linux_send(p, v, retval)
491: struct proc *p;
492: void *v;
493: register_t *retval;
494: {
495: struct linux_send_args /* {
496: syscallarg(int) s;
497: syscallarg(void *) msg;
498: syscallarg(int) len;
499: syscallarg(int) flags;
500: } */ *uap = v;
501: struct linux_send_args lsa;
502: struct compat_43_sys_send_args bsa;
503: int error;
504:
505: if ((error = copyin((caddr_t) uap, (caddr_t) &lsa, sizeof lsa)))
506: return error;
507:
508: SCARG(&bsa, s) = lsa.s;
509: SCARG(&bsa, buf) = lsa.msg;
510: SCARG(&bsa, len) = lsa.len;
511: SCARG(&bsa, flags) = lsa.flags;
512:
513: return compat_43_sys_send(p, &bsa, retval);
514: }
515:
516: int
517: linux_recv(p, v, retval)
518: struct proc *p;
519: void *v;
520: register_t *retval;
521: {
522: struct linux_recv_args /* {
523: syscallarg(int) s;
524: syscallarg(void *) msg;
525: syscallarg(int) len;
526: syscallarg(int) flags;
527: } */ *uap = v;
528: struct linux_recv_args lra;
529: struct compat_43_sys_recv_args bra;
530: int error;
531:
532: if ((error = copyin((caddr_t) uap, (caddr_t) &lra, sizeof lra)))
533: return error;
534:
535: SCARG(&bra, s) = lra.s;
536: SCARG(&bra, buf) = lra.msg;
537: SCARG(&bra, len) = lra.len;
538: SCARG(&bra, flags) = lra.flags;
539:
540: return compat_43_sys_recv(p, &bra, retval);
541: }
542:
543: int
544: linux_check_hdrincl(p, fd, retval, sgp)
545: struct proc *p;
546: int fd;
547: register_t *retval;
548: caddr_t *sgp;
549: {
550: struct sys_getsockopt_args /* {
551: int s;
552: int level;
553: int name;
554: caddr_t val;
555: int *avalsize;
556: } */ gsa;
557: int error;
558: caddr_t val;
559: int *valsize;
560: int size_val = sizeof val;
561: int optval;
562:
563: val = stackgap_alloc(sgp, sizeof(optval));
564: valsize = stackgap_alloc(sgp, sizeof(size_val));
565:
566: if ((error = copyout(&size_val, valsize, sizeof(size_val))))
567: return (error);
568: SCARG(&gsa, s) = fd;
569: SCARG(&gsa, level) = IPPROTO_IP;
570: SCARG(&gsa, name) = IP_HDRINCL;
571: SCARG(&gsa, val) = val;
572: SCARG(&gsa, avalsize) = valsize;
573:
574: if ((error = sys_getsockopt(p, &gsa, retval)))
575: return (error);
576: if ((error = copyin(val, &optval, sizeof(optval))))
577: return (error);
578: return (optval == 0);
579: }
580:
581: /*
582: * linux_ip_copysize defines how many bytes we should copy
583: * from the beginning of the IP packet before we customize it for BSD.
584: * It should include all the fields we modify (ip_len and ip_off)
585: * and be as small as possible to minimize copying overhead.
586: */
587: #define linux_ip_copysize 8
588:
589: int
590: linux_sendto_hdrincl(p, bsa, retval, sgp)
591: struct proc *p;
592: struct sys_sendto_args *bsa;
593: register_t *retval;
594: caddr_t *sgp;
595: {
596: struct sys_sendmsg_args ssa;
597: struct ip *packet, rpacket;
598: struct msghdr *msg, rmsg;
599: struct iovec *iov, riov[2];
600: int error;
601:
602: /* Check the packet isn't too small before we mess with it */
603: if (SCARG(bsa, len) < linux_ip_copysize)
604: return EINVAL;
605:
606: /*
607: * Tweaking the user buffer in place would be bad manners.
608: * We create a corrected IP header with just the needed length,
609: * then use an iovec to glue it to the rest of the user packet
610: * when calling sendmsg().
611: */
612: packet = (struct ip *)stackgap_alloc(sgp, linux_ip_copysize);
613: msg = (struct msghdr *)stackgap_alloc(sgp, sizeof(*msg));
614: iov = (struct iovec *)stackgap_alloc(sgp, sizeof(*iov)*2);
615:
616: /* Make a copy of the beginning of the packet to be sent */
617: if ((error = copyin(SCARG(bsa, buf), (caddr_t)&rpacket,
618: linux_ip_copysize)))
619: return error;
620:
621: /* Convert fields from Linux to BSD raw IP socket format */
622: rpacket.ip_len = SCARG(bsa, len);
623: error = copyout(&rpacket, packet, linux_ip_copysize);
624: if (error)
625: return (error);
626:
627: riov[0].iov_base = (char *)packet;
628: riov[0].iov_len = linux_ip_copysize;
629: riov[1].iov_base = (caddr_t)SCARG(bsa, buf) + linux_ip_copysize;
630: riov[1].iov_len = SCARG(bsa, len) - linux_ip_copysize;
631:
632: error = copyout(&riov[0], iov, sizeof(riov));
633: if (error)
634: return (error);
635:
636: /* Prepare the msghdr and iovec structures describing the new packet */
637: rmsg.msg_name = (void *)SCARG(bsa, to);
638: rmsg.msg_namelen = SCARG(bsa, tolen);
639: rmsg.msg_iov = iov;
640: rmsg.msg_iovlen = 2;
641: rmsg.msg_control = NULL;
642: rmsg.msg_controllen = 0;
643: rmsg.msg_flags = 0;
644:
645: error = copyout(&riov[0], iov, sizeof(riov));
646: if (error)
647: return (error);
648:
649: SCARG(&ssa, s) = SCARG(bsa, s);
650: SCARG(&ssa, msg) = msg;
651: SCARG(&ssa, flags) = SCARG(bsa, flags);
652: return sys_sendmsg(p, &ssa, retval);
653: }
654:
655: int
656: linux_sendto(p, v, retval)
657: struct proc *p;
658: void *v;
659: register_t *retval;
660: {
661: struct linux_sendto_args /* {
662: syscallarg(int) s;
663: syscallarg(void *) msg;
664: syscallarg(int) len;
665: syscallarg(int) flags;
666: syscallarg(osockaddr *) to;
667: syscallarg(int) tolen;
668: } */ *uap = v;
669: struct linux_sendto_args lsa;
670: struct sys_sendto_args bsa;
671: int error;
672: int tolen;
673: caddr_t sg = stackgap_init(p->p_emul);
674:
675: if ((error = copyin((caddr_t) uap, (caddr_t) &lsa, sizeof lsa)))
676: return error;
677:
678: SCARG(&bsa, s) = lsa.s;
679: SCARG(&bsa, buf) = lsa.msg;
680: SCARG(&bsa, len) = lsa.len;
681: SCARG(&bsa, flags) = lsa.flags;
682: tolen = lsa.tolen;
683: if (lsa.to) {
684: struct sockaddr *sa;
685:
686: if ((error = linux_sa_get(p, &sg, &sa, lsa.to, &tolen)))
687: return (error);
688: SCARG(&bsa, to) = sa;
689: } else
690: SCARG(&bsa, to) = NULL;
691: SCARG(&bsa, tolen) = tolen;
692:
693: if (linux_check_hdrincl(p, lsa.s, retval, &sg) == 0)
694: return linux_sendto_hdrincl(p, &bsa, retval, &sg);
695: return sys_sendto(p, &bsa, retval);
696: }
697:
698: int
699: linux_recvfrom(p, v, retval)
700: struct proc *p;
701: void *v;
702: register_t *retval;
703: {
704: struct linux_recvfrom_args /* {
705: syscallarg(int) s;
706: syscallarg(void *) buf;
707: syscallarg(int) len;
708: syscallarg(int) flags;
709: syscallarg(struct osockaddr *) from;
710: syscallarg(int *) fromlen;
711: } */ *uap = v;
712: struct linux_recvfrom_args lra;
713: struct sys_recvfrom_args bra;
714: int error;
715:
716: if ((error = copyin((caddr_t) uap, (caddr_t) &lra, sizeof lra)))
717: return error;
718:
719: SCARG(&bra, s) = lra.s;
720: SCARG(&bra, buf) = lra.buf;
721: SCARG(&bra, len) = lra.len;
722: SCARG(&bra, flags) = lra.flags;
723: SCARG(&bra, from) = (struct sockaddr *) lra.from;
724: SCARG(&bra, fromlenaddr) = lra.fromlen;
725:
726: if ((error = sys_recvfrom(p, &bra, retval)))
727: return (error);
728:
729: if (lra.from && (error = linux_sa_put(lra.from)))
730: return (error);
731:
732: return (0);
733: }
734:
735: int
736: linux_shutdown(p, v, retval)
737: struct proc *p;
738: void *v;
739: register_t *retval;
740: {
741: struct linux_shutdown_args /* {
742: syscallarg(int) s;
743: syscallarg(int) how;
744: } */ *uap = v;
745: struct linux_shutdown_args lsa;
746: struct sys_shutdown_args bsa;
747: int error;
748:
749: if ((error = copyin((caddr_t) uap, (caddr_t) &lsa, sizeof lsa)))
750: return error;
751:
752: SCARG(&bsa, s) = lsa.s;
753: SCARG(&bsa, how) = lsa.how;
754:
755: return sys_shutdown(p, &bsa, retval);
756: }
757:
758: /*
759: * Convert socket option level from Linux to OpenBSD value. Only SOL_SOCKET
760: * is different, the rest matches IPPROTO_* on both systems.
761: */
762: int
763: linux_to_bsd_sopt_level(llevel)
764: int llevel;
765: {
766:
767: switch (llevel) {
768: case LINUX_SOL_SOCKET:
769: return SOL_SOCKET;
770: case LINUX_SOL_IP:
771: return IPPROTO_IP;
772: case LINUX_SOL_TCP:
773: return IPPROTO_TCP;
774: case LINUX_SOL_UDP:
775: return IPPROTO_UDP;
776: default:
777: return -1;
778: }
779: }
780:
781: /*
782: * Convert Linux socket level socket option numbers to OpenBSD values.
783: */
784: int
785: linux_to_bsd_so_sockopt(lopt)
786: int lopt;
787: {
788:
789: switch (lopt) {
790: case LINUX_SO_DEBUG:
791: return SO_DEBUG;
792: case LINUX_SO_REUSEADDR:
793: /*
794: * Linux does not implement SO_REUSEPORT, but allows reuse
795: * of a host:port pair through SO_REUSEADDR even if the
796: * address is not a multicast-address. Effectively, this
797: * means that we should use SO_REUSEPORT to allow Linux
798: * applications to not exit with EADDRINUSE.
799: */
800: return SO_REUSEPORT;
801: case LINUX_SO_TYPE:
802: return SO_TYPE;
803: case LINUX_SO_ERROR:
804: return SO_ERROR;
805: case LINUX_SO_DONTROUTE:
806: return SO_DONTROUTE;
807: case LINUX_SO_BROADCAST:
808: return SO_BROADCAST;
809: case LINUX_SO_SNDBUF:
810: return SO_SNDBUF;
811: case LINUX_SO_RCVBUF:
812: return SO_RCVBUF;
813: case LINUX_SO_KEEPALIVE:
814: return SO_KEEPALIVE;
815: case LINUX_SO_OOBINLINE:
816: return SO_OOBINLINE;
817: case LINUX_SO_LINGER:
818: return SO_LINGER;
819: case LINUX_SO_PRIORITY:
820: case LINUX_SO_NO_CHECK:
821: default:
822: return -1;
823: }
824: }
825:
826: /*
827: * Convert Linux IP level socket option number to OpenBSD values.
828: */
829: int
830: linux_to_bsd_ip_sockopt(lopt)
831: int lopt;
832: {
833:
834: switch (lopt) {
835: case LINUX_IP_TOS:
836: return IP_TOS;
837: case LINUX_IP_TTL:
838: return IP_TTL;
839: case LINUX_IP_MULTICAST_TTL:
840: return IP_MULTICAST_TTL;
841: case LINUX_IP_MULTICAST_LOOP:
842: return IP_MULTICAST_LOOP;
843: case LINUX_IP_MULTICAST_IF:
844: return IP_MULTICAST_IF;
845: case LINUX_IP_ADD_MEMBERSHIP:
846: return IP_ADD_MEMBERSHIP;
847: case LINUX_IP_DROP_MEMBERSHIP:
848: return IP_DROP_MEMBERSHIP;
849: case LINUX_IP_HDRINCL:
850: return IP_HDRINCL;
851: default:
852: return -1;
853: }
854: }
855:
856: /*
857: * Convert Linux TCP level socket option number to OpenBSD values.
858: */
859: int
860: linux_to_bsd_tcp_sockopt(lopt)
861: int lopt;
862: {
863:
864: switch (lopt) {
865: case LINUX_TCP_NODELAY:
866: return TCP_NODELAY;
867: case LINUX_TCP_MAXSEG:
868: return TCP_MAXSEG;
869: default:
870: return -1;
871: }
872: }
873:
874: /*
875: * Convert Linux UDP level socket option number to OpenBSD values.
876: */
877: int
878: linux_to_bsd_udp_sockopt(lopt)
879: int lopt;
880: {
881:
882: switch (lopt) {
883: default:
884: return -1;
885: }
886: }
887:
888: /*
889: * Another reasonably straightforward function: setsockopt(2).
890: * The level and option numbers are converted; the values passed
891: * are not (yet) converted, the ones currently implemented don't
892: * need conversion, as they are the same on both systems.
893: */
894: int
895: linux_setsockopt(p, v, retval)
896: struct proc *p;
897: void *v;
898: register_t *retval;
899: {
900: struct linux_setsockopt_args /* {
901: syscallarg(int) s;
902: syscallarg(int) level;
903: syscallarg(int) optname;
904: syscallarg(void *) optval;
905: syscallarg(int) optlen;
906: } */ *uap = v;
907: struct linux_setsockopt_args lsa;
908: struct sys_setsockopt_args bsa;
909: int error, name;
910:
911: if ((error = copyin((caddr_t) uap, (caddr_t) &lsa, sizeof lsa)))
912: return error;
913:
914: SCARG(&bsa, s) = lsa.s;
915: SCARG(&bsa, level) = linux_to_bsd_sopt_level(lsa.level);
916: SCARG(&bsa, val) = lsa.optval;
917: SCARG(&bsa, valsize) = lsa.optlen;
918:
919: switch (SCARG(&bsa, level)) {
920: case SOL_SOCKET:
921: name = linux_to_bsd_so_sockopt(lsa.optname);
922: break;
923: case IPPROTO_IP:
924: name = linux_to_bsd_ip_sockopt(lsa.optname);
925: break;
926: case IPPROTO_TCP:
927: name = linux_to_bsd_tcp_sockopt(lsa.optname);
928: break;
929: case IPPROTO_UDP:
930: name = linux_to_bsd_udp_sockopt(lsa.optname);
931: break;
932: default:
933: return EINVAL;
934: }
935:
936: if (name == -1)
937: return EINVAL;
938: SCARG(&bsa, name) = name;
939:
940: return sys_setsockopt(p, &bsa, retval);
941: }
942:
943: /*
944: * getsockopt(2) is very much the same as setsockopt(2) (see above)
945: */
946: int
947: linux_getsockopt(p, v, retval)
948: struct proc *p;
949: void *v;
950: register_t *retval;
951: {
952: struct linux_getsockopt_args /* {
953: syscallarg(int) s;
954: syscallarg(int) level;
955: syscallarg(int) optname;
956: syscallarg(void *) optval;
957: syscallarg(int) *optlen;
958: } */ *uap = v;
959: struct linux_getsockopt_args lga;
960: struct sys_getsockopt_args bga;
961: int error, name;
962:
963: if ((error = copyin((caddr_t) uap, (caddr_t) &lga, sizeof lga)))
964: return error;
965:
966: SCARG(&bga, s) = lga.s;
967: SCARG(&bga, level) = linux_to_bsd_sopt_level(lga.level);
968: SCARG(&bga, val) = lga.optval;
969: SCARG(&bga, avalsize) = lga.optlen;
970:
971: switch (SCARG(&bga, level)) {
972: case SOL_SOCKET:
973: name = linux_to_bsd_so_sockopt(lga.optname);
974: break;
975: case IPPROTO_IP:
976: name = linux_to_bsd_ip_sockopt(lga.optname);
977: break;
978: case IPPROTO_TCP:
979: name = linux_to_bsd_tcp_sockopt(lga.optname);
980: break;
981: case IPPROTO_UDP:
982: name = linux_to_bsd_udp_sockopt(lga.optname);
983: break;
984: default:
985: return EINVAL;
986: }
987:
988: if (name == -1)
989: return EINVAL;
990: SCARG(&bga, name) = name;
991:
992: return sys_getsockopt(p, &bga, retval);
993: }
994:
995: int
996: linux_recvmsg(p, v, retval)
997: struct proc *p;
998: void *v;
999: register_t *retval;
1000: {
1001: struct linux_recvmsg_args /* {
1002: syscallarg(int) s;
1003: syscallarg(caddr_t) msg;
1004: syscallarg(int) flags;
1005: } */ *uap = v;
1006: struct linux_recvmsg_args lla;
1007: struct sys_recvmsg_args bla;
1008: struct msghdr msg;
1009: int error;
1010:
1011: if ((error = copyin((caddr_t) uap, (caddr_t) &lla, sizeof lla)))
1012: return error;
1013:
1014: SCARG(&bla, s) = lla.s;
1015: SCARG(&bla, msg) = (struct msghdr *)lla.msg;
1016: SCARG(&bla, flags) = lla.flags;
1017:
1018: error = sys_recvmsg(p, &bla, retval);
1019: if (error)
1020: return (error);
1021:
1022: error = copyin(lla.msg, (caddr_t)&msg, sizeof(msg));
1023:
1024: if (!error && msg.msg_name && msg.msg_namelen > 2)
1025: error = linux_sa_put(msg.msg_name);
1026:
1027: return (error);
1028: }
1029:
1030: int
1031: linux_sendmsg(p, v, retval)
1032: struct proc *p;
1033: void *v;
1034: register_t *retval;
1035: {
1036: struct linux_sendmsg_args /* {
1037: syscallarg(int) s;
1038: syscallarg(struct msghdr *) msg;
1039: syscallarg(int) flags;
1040: } */ *uap = v;
1041: struct linux_sendmsg_args lla;
1042: struct sys_sendmsg_args bla;
1043: struct msghdr msg, *nmsg = NULL;
1044: int error;
1045: caddr_t control;
1046: int level;
1047:
1048: if ((error = copyin((caddr_t) uap, (caddr_t) &lla, sizeof lla)))
1049: return error;
1050:
1051: if ((error = copyin(lla.msg, (caddr_t) &msg, sizeof(msg))))
1052: return (error);
1053:
1054: if (msg.msg_name) {
1055: struct sockaddr *sa;
1056: caddr_t sg = stackgap_init(p->p_emul);
1057:
1058: nmsg = (struct msghdr *)stackgap_alloc(&sg,
1059: sizeof(struct msghdr));
1060: if (!nmsg)
1061: return (ENOMEM);
1062:
1063: error = linux_sa_get(p, &sg, &sa,
1064: (struct osockaddr *)msg.msg_name, &msg.msg_namelen);
1065: if (error)
1066: return (error);
1067:
1068: msg.msg_name = (struct sockaddr *)sa;
1069: if ((error = copyout(&msg, nmsg, sizeof(struct msghdr))))
1070: return (error);
1071: lla.msg = nmsg;
1072: }
1073:
1074: SCARG(&bla, s) = lla.s;
1075: SCARG(&bla, msg) = lla.msg;
1076: SCARG(&bla, flags) = lla.flags;
1077:
1078: error = copyin(lla.msg->msg_control, &control, sizeof(caddr_t));
1079: if (error)
1080: return error;
1081: if (control == NULL)
1082: goto done;
1083: error = copyin(&((struct cmsghdr *)control)->cmsg_level,
1084: &level, sizeof(int));
1085: if (error)
1086: return error;
1087: if (level == 1) {
1088: /*
1089: * Linux thinks that SOL_SOCKET is 1; we know that it's really
1090: * 0xffff, of course.
1091: */
1092: level = SOL_SOCKET;
1093: /*
1094: * XXX should use stack gap!
1095: * We don't because the control header is variable length
1096: * up to 2048 bytes, and there's only 512 bytes of gap.
1097: */
1098: error = copyout(&level, &((struct cmsghdr *)control)->
1099: cmsg_level, sizeof(int));
1100: if (error)
1101: return error;
1102: }
1103: done:
1104: error = sys_sendmsg(p, &bla, retval);
1105: /* replace level, just in case somebody cares. */
1106: if (level == SOL_SOCKET) {
1107: level = 1;
1108: /* don't worry about the error */
1109: copyout(&level, &((struct cmsghdr *)control)->cmsg_level,
1110: sizeof(int));
1111: }
1112: return (error);
1113: }
1114:
1115: /*
1116: * Copy the osockaddr structure pointed to by osa to kernel, adjust
1117: * family and convert to sockaddr, allocate stackgap and put the
1118: * the converted structure there, address on stackgap returned in sap.
1119: */
1120: int
1121: linux_sa_get(p, sgp, sap, osa, osalen)
1122: struct proc *p;
1123: caddr_t *sgp;
1124: struct sockaddr **sap;
1125: const struct osockaddr *osa;
1126: int *osalen;
1127: {
1128: int error=0, bdom;
1129: struct sockaddr *sa, *usa;
1130: struct osockaddr *kosa;
1131: int alloclen;
1132: #ifdef INET6
1133: int oldv6size;
1134: struct sockaddr_in6 *sin6;
1135: #endif
1136:
1137: if (*osalen < 2 || *osalen > UCHAR_MAX || !osa) {
1138: return (EINVAL);
1139: }
1140:
1141: alloclen = *osalen;
1142: #ifdef INET6
1143: oldv6size = 0;
1144: /*
1145: * Check for old (pre-RFC2553) sockaddr_in6. We may accept it
1146: * if it's a v4-mapped address, so reserve the proper space
1147: * for it.
1148: */
1149: if (alloclen == sizeof (struct sockaddr_in6) - sizeof (u_int32_t)) {
1150: alloclen = sizeof (struct sockaddr_in6);
1151: oldv6size = 1;
1152: }
1153: #endif
1154:
1155: kosa = (struct osockaddr *) malloc(alloclen, M_TEMP, M_WAITOK);
1156:
1157: if ((error = copyin(osa, (caddr_t) kosa, *osalen))) {
1158: goto out;
1159: }
1160:
1161: bdom = linux_to_bsd_domain(kosa->sa_family);
1162: if (bdom == -1) {
1163: error = EINVAL;
1164: goto out;
1165: }
1166:
1167: #ifdef INET6
1168: /*
1169: * Older Linux IPv6 code uses obsolete RFC2133 struct sockaddr_in6,
1170: * which lacks the scope id compared with RFC2553 one. If we detect
1171: * the situation, reject the address.
1172: *
1173: * Still accept addresses for which the scope id is not used.
1174: */
1175: if (oldv6size && bdom == AF_INET6) {
1176: sin6 = (struct sockaddr_in6 *)kosa;
1177: if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr) ||
1178: (!IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr) &&
1179: !IN6_IS_ADDR_SITELOCAL(&sin6->sin6_addr) &&
1180: !IN6_IS_ADDR_V4COMPAT(&sin6->sin6_addr) &&
1181: !IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr) &&
1182: !IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr))) {
1183: sin6->sin6_scope_id = 0;
1184: } else {
1185: error = EINVAL;
1186: goto out;
1187: }
1188: } else
1189: #endif
1190: if (bdom == AF_INET) {
1191: alloclen = sizeof(struct sockaddr_in);
1192: }
1193:
1194: sa = (struct sockaddr *) kosa;
1195: sa->sa_family = bdom;
1196: sa->sa_len = alloclen;
1197:
1198: usa = (struct sockaddr *) stackgap_alloc(sgp, alloclen);
1199: if (!usa) {
1200: error = ENOMEM;
1201: goto out;
1202: }
1203:
1204: if ((error = copyout(sa, usa, alloclen))) {
1205: goto out;
1206: }
1207:
1208: *sap = usa;
1209:
1210: out:
1211: *osalen = alloclen;
1212: free(kosa, M_TEMP);
1213: return (error);
1214: }
1215:
1216: int
1217: linux_sa_put(osa)
1218: struct osockaddr *osa;
1219: {
1220: struct sockaddr sa;
1221: struct osockaddr *kosa;
1222: int error, bdom, len;
1223:
1224: /*
1225: * Only read/write the sockaddr family and length part, the rest is
1226: * not changed.
1227: */
1228: len = sizeof(sa.sa_len) + sizeof(sa.sa_family);
1229:
1230: error = copyin((caddr_t) osa, (caddr_t) &sa, len);
1231: if (error)
1232: return (error);
1233:
1234: bdom = bsd_to_linux_domain(sa.sa_family);
1235: if (bdom == -1)
1236: return (EINVAL);
1237:
1238: /* Note: we convert from sockaddr to osockaddr here, too */
1239: kosa = (struct osockaddr *) &sa;
1240: kosa->sa_family = bdom;
1241: error = copyout(kosa, osa, len);
1242: if (error)
1243: return (error);
1244:
1245: return (0);
1246: }
1247:
1248: /*
1249: * Entry point to all Linux socket calls. Just check which call to
1250: * make and take appropriate action.
1251: */
1252: int
1253: linux_sys_socketcall(p, v, retval)
1254: struct proc *p;
1255: void *v;
1256: register_t *retval;
1257: {
1258: struct linux_sys_socketcall_args /* {
1259: syscallarg(int) what;
1260: syscallarg(void *) args;
1261: } */ *uap = v;
1262:
1263: switch (SCARG(uap, what)) {
1264: case LINUX_SYS_socket:
1265: return linux_socket(p, SCARG(uap, args), retval);
1266: case LINUX_SYS_bind:
1267: return linux_bind(p, SCARG(uap, args), retval);
1268: case LINUX_SYS_connect:
1269: return linux_connect(p, SCARG(uap, args), retval);
1270: case LINUX_SYS_listen:
1271: return linux_listen(p, SCARG(uap, args), retval);
1272: case LINUX_SYS_accept:
1273: return linux_accept(p, SCARG(uap, args), retval);
1274: case LINUX_SYS_getsockname:
1275: return linux_getsockname(p, SCARG(uap, args), retval);
1276: case LINUX_SYS_getpeername:
1277: return linux_getpeername(p, SCARG(uap, args), retval);
1278: case LINUX_SYS_socketpair:
1279: return linux_socketpair(p, SCARG(uap, args), retval);
1280: case LINUX_SYS_send:
1281: return linux_send(p, SCARG(uap, args), retval);
1282: case LINUX_SYS_recv:
1283: return linux_recv(p, SCARG(uap, args), retval);
1284: case LINUX_SYS_sendto:
1285: return linux_sendto(p, SCARG(uap, args), retval);
1286: case LINUX_SYS_recvfrom:
1287: return linux_recvfrom(p, SCARG(uap, args), retval);
1288: case LINUX_SYS_shutdown:
1289: return linux_shutdown(p, SCARG(uap, args), retval);
1290: case LINUX_SYS_setsockopt:
1291: return linux_setsockopt(p, SCARG(uap, args), retval);
1292: case LINUX_SYS_getsockopt:
1293: return linux_getsockopt(p, SCARG(uap, args), retval);
1294: case LINUX_SYS_sendmsg:
1295: return linux_sendmsg(p, SCARG(uap, args), retval);
1296: case LINUX_SYS_recvmsg:
1297: return linux_recvmsg(p, SCARG(uap, args), retval);
1298: default:
1299: return ENOSYS;
1300: }
1301: }
1302:
1303: int
1304: linux_ioctl_socket(p, v, retval)
1305: register struct proc *p;
1306: void *v;
1307: register_t *retval;
1308: {
1309: struct linux_sys_ioctl_args /* {
1310: syscallarg(int) fd;
1311: syscallarg(u_long) com;
1312: syscallarg(caddr_t) data;
1313: } */ *uap = v;
1314: u_long com;
1315: struct sys_ioctl_args ia;
1316: struct file *fp;
1317: struct filedesc *fdp;
1318: struct vnode *vp;
1319: int (*ioctlf)(struct file *, u_long, caddr_t, struct proc *);
1320: struct ioctl_pt pt;
1321: int error = 0, isdev = 0, dosys = 1;
1322:
1323: fdp = p->p_fd;
1324: if ((fp = fd_getfile(fdp, SCARG(uap, fd))) == NULL)
1325: return (EBADF);
1326: FREF(fp);
1327:
1328: if (fp->f_type == DTYPE_VNODE) {
1329: vp = (struct vnode *)fp->f_data;
1330: isdev = vp->v_type == VCHR;
1331: }
1332:
1333: /*
1334: * Don't try to interpret socket ioctl calls that are done
1335: * on a device filedescriptor, just pass them through, to
1336: * emulate Linux behaviour. Use PTIOCLINUX so that the
1337: * device will only handle these if it's prepared to do
1338: * so, to avoid unexpected things from happening.
1339: */
1340: if (isdev) {
1341: dosys = 0;
1342: ioctlf = fp->f_ops->fo_ioctl;
1343: pt.com = SCARG(uap, com);
1344: pt.data = SCARG(uap, data);
1345: error = ioctlf(fp, PTIOCLINUX, (caddr_t)&pt, p);
1346: /*
1347: * XXX hack: if the function returns EJUSTRETURN,
1348: * it has stuffed a sysctl return value in pt.data.
1349: */
1350: if (error == EJUSTRETURN) {
1351: retval[0] = (register_t)pt.data;
1352: error = 0;
1353: }
1354: goto out;
1355: }
1356:
1357: com = SCARG(uap, com);
1358: retval[0] = 0;
1359:
1360: switch (com) {
1361: case LINUX_FIOSETOWN:
1362: SCARG(&ia, com) = FIOSETOWN;
1363: break;
1364: case LINUX_SIOCSPGRP:
1365: SCARG(&ia, com) = SIOCSPGRP;
1366: break;
1367: case LINUX_FIOGETOWN:
1368: SCARG(&ia, com) = FIOGETOWN;
1369: break;
1370: case LINUX_SIOCGPGRP:
1371: SCARG(&ia, com) = SIOCGPGRP;
1372: break;
1373: case LINUX_SIOCATMARK:
1374: SCARG(&ia, com) = SIOCATMARK;
1375: break;
1376: #if 0
1377: case LINUX_SIOCGSTAMP:
1378: SCARG(&ia, com) = SIOCGSTAMP;
1379: break;
1380: #endif
1381: case LINUX_SIOCGIFCONF:
1382: SCARG(&ia, com) = OSIOCGIFCONF;
1383: break;
1384: case LINUX_SIOCGIFFLAGS:
1385: SCARG(&ia, com) = SIOCGIFFLAGS;
1386: break;
1387: case LINUX_SIOCGIFADDR:
1388: SCARG(&ia, com) = OSIOCGIFADDR;
1389: break;
1390: case LINUX_SIOCGIFDSTADDR:
1391: SCARG(&ia, com) = OSIOCGIFDSTADDR;
1392: break;
1393: case LINUX_SIOCGIFBRDADDR:
1394: SCARG(&ia, com) = OSIOCGIFBRDADDR;
1395: break;
1396: case LINUX_SIOCGIFNETMASK:
1397: SCARG(&ia, com) = OSIOCGIFNETMASK;
1398: break;
1399: case LINUX_SIOCGIFMETRIC:
1400: SCARG(&ia, com) = SIOCGIFMETRIC;
1401: break;
1402: case LINUX_SIOCGIFMTU:
1403: SCARG(&ia, com) = SIOCGIFMTU;
1404: break;
1405: case LINUX_SIOCADDMULTI:
1406: SCARG(&ia, com) = SIOCADDMULTI;
1407: break;
1408: case LINUX_SIOCDELMULTI:
1409: SCARG(&ia, com) = SIOCDELMULTI;
1410: break;
1411: case LINUX_SIOCGIFHWADDR: {
1412: struct linux_ifreq *ifr = (struct linux_ifreq *)SCARG(uap, data);
1413: struct sockaddr_dl *sdl;
1414: struct ifnet *ifp;
1415: struct ifaddr *ifa;
1416:
1417: /*
1418: * Note that we don't actually respect the name in the ifreq
1419: * structure, as Linux interface names are all different.
1420: */
1421: TAILQ_FOREACH(ifp, &ifnet, if_list) {
1422: if (ifp->if_type != IFT_ETHER)
1423: continue;
1424: TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) {
1425: if ((sdl = (struct sockaddr_dl *)ifa->ifa_addr) &&
1426: (sdl->sdl_family == AF_LINK) &&
1427: (sdl->sdl_type == IFT_ETHER)) {
1428: error = copyout(LLADDR(sdl),
1429: (caddr_t)&ifr->ifr_hwaddr.sa_data,
1430: LINUX_IFHWADDRLEN);
1431: dosys = 0;
1432: goto out;
1433: }
1434: }
1435: }
1436: error = ENOENT;
1437: break;
1438: }
1439: default:
1440: error = EINVAL;
1441: }
1442:
1443: out:
1444: if (error == 0 && dosys) {
1445: SCARG(&ia, fd) = SCARG(uap, fd);
1446: SCARG(&ia, data) = SCARG(uap, data);
1447: error = sys_ioctl(p, &ia, retval);
1448: }
1449:
1450: FRELE(fp);
1451: return (error);
1452: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to linux_socket.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / linux