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