?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
No empty .Rs/.Re
[netbsd-mini2440.git] / sys / compat / svr4 / svr4_stream.c
blobeb3261c4ef2eee570a0f8aaf37f670571f61f777
1 /* $NetBSD: svr4_stream.c,v 1.76 2008/04/23 13:58:06 ad Exp $ */
2
3 /*-
4 * Copyright (c) 1994, 2008 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Christos Zoulas.
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.
30 */
31
32 /*
33 * Pretend that we have streams...
34 * Yes, this is gross.
35 *
36 * ToDo: The state machine for getmsg needs re-thinking
37 *
38 * The svr4_32 version is built from this file as well.
39 */
40
41 #include <sys/cdefs.h>
42 __KERNEL_RCSID(0, "$NetBSD: svr4_stream.c,v 1.76 2008/04/23 13:58:06 ad Exp $");
43
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/namei.h>
54 #include <sys/select.h>
55 #include <sys/socket.h>
56 #include <sys/socketvar.h>
57 #include <sys/protosw.h>
58 #include <sys/un.h>
59 #include <net/if.h>
60 #include <netinet/in.h>
61 #include <sys/mbuf.h>
62 #include <sys/mount.h>
63 #include <sys/proc.h>
64 #include <sys/vfs_syscalls.h>
65 #include <sys/vnode.h>
66 #include <sys/device.h>
67 #include <sys/stat.h>
68
69 #include <sys/syscallargs.h>
70
71 #ifndef SVR4_32
72 #define compat(name) <compat/svr4/svr4_##name>
73 #else
74 #define compat(name) <compat/svr4_32/svr4_32_##name>
75 #endif
76
77 #include compat(types.h)
78 #include compat(util.h)
79 #include compat(signal.h)
80 #include compat(lwp.h)
81 #include compat(ucontext.h)
82 #include compat(syscallargs.h)
83 #include compat(stropts.h)
84 #include compat(timod.h)
85 #include <compat/svr4/svr4_sockmod.h>
86 #include compat(ioctl.h)
87 #include compat(socket.h)
88
89 #undef compat
90
91 #ifndef SVR4_32
92
93 #define SCARG_PTR(uap, arg) SCARG(uap, arg)
94 #define NETBSD32PTR(ptr) (ptr)
95
96 #else
97
98 #define SCARG_PTR(uap, arg) SCARG_P32(uap, arg)
99 #define NETBSD32PTR(ptr) NETBSD32PTR64(ptr)
100
101 /* Rename stuff that is different for the svr4_32 build */
102 #define svr4_infocmd svr4_32_infocmd
103 #define svr4_ino_t svr4_32_ino_t
104 #define svr4_netaddr_in svr4_32_netaddr_in
105 #define svr4_netaddr_un svr4_32_netaddr_un
106 #define svr4_strbuf svr4_32_strbuf
107 #define svr4_stream_get svr4_32_stream_get
108 #define svr4_stream_ioctl svr4_32_stream_ioctl
109 #define svr4_stream_ti_ioctl svr4_32_stream_ti_ioctl
110 #define svr4_strfdinsert svr4_32_strfdinsert
111 #define svr4_strioctl svr4_32_strioctl
112 #define svr4_strmcmd svr4_32_strmcmd
113 #define svr4_sys_getmsg svr4_32_sys_getmsg
114 #define svr4_sys_getmsg_args svr4_32_sys_getmsg_args
115 #define svr4_sys_putmsg svr4_32_sys_putmsg
116 #define svr4_sys_putmsg_args svr4_32_sys_putmsg_args
117
118 #endif /* SVR4_32 */
119
120 /* Utils */
121 static int clean_pipe(struct lwp *, const char *);
122 static void getparm(file_t *, struct svr4_si_sockparms *);
123
124 /* Address Conversions */
125 static void sockaddr_to_netaddr_in(struct svr4_strmcmd *,
126 const struct sockaddr_in *);
127 static void sockaddr_to_netaddr_un(struct svr4_strmcmd *,
128 const struct sockaddr_un *);
129 static void netaddr_to_sockaddr_in(struct sockaddr_in *,
130 const struct svr4_strmcmd *);
131 static void netaddr_to_sockaddr_un(struct sockaddr_un *,
132 const struct svr4_strmcmd *);
133
134 /* stream ioctls */
135 static int i_nread(file_t *, struct lwp *, register_t *, int,
136 u_long, void *);
137 static int i_fdinsert(file_t *, struct lwp *, register_t *, int,
138 u_long, void *);
139 static int i_str(file_t *, struct lwp *, register_t *, int,
140 u_long, void *);
141 static int i_setsig(file_t *, struct lwp *, register_t *, int,
142 u_long, void *);
143 static int i_getsig(file_t *, struct lwp *, register_t *, int,
144 u_long, void *);
145 static int _i_bind_rsvd(file_t *, struct lwp *, register_t *, int,
146 u_long, void *);
147 static int _i_rele_rsvd(file_t *, struct lwp *, register_t *, int,
148 u_long, void *);
149
150 /* i_str sockmod calls */
151 static int sockmod(file_t *, int, struct svr4_strioctl *,
152 struct lwp *);
153 static int si_listen(file_t *, int, struct svr4_strioctl *,
154 struct lwp *);
155 static int si_ogetudata(file_t *, int, struct svr4_strioctl *,
156 struct lwp *);
157 static int si_sockparams(file_t *, int, struct svr4_strioctl *,
158 struct lwp *);
159 static int si_shutdown(file_t *, int, struct svr4_strioctl *,
160 struct lwp *);
161 static int si_getudata(file_t *, int, struct svr4_strioctl *,
162 struct lwp *);
163
164 /* i_str timod calls */
165 static int timod(file_t *, int, struct svr4_strioctl *,
166 struct lwp *);
167 static int ti_getinfo(file_t *, int, struct svr4_strioctl *,
168 struct lwp *);
169 static int ti_bind(file_t *, int, struct svr4_strioctl *,
170 struct lwp *);
171
172 #ifdef DEBUG_SVR4
173 static void bufprint(u_char *, size_t);
174 static int show_ioc(const char *, struct svr4_strioctl *);
175 static int show_strbuf(struct svr4_strbuf *);
176 static void show_msg(const char *, int, struct svr4_strbuf *,
177 struct svr4_strbuf *, int);
178
179 static void
180 bufprint(u_char *buf, size_t len)
181 {
182 size_t i;
183
184 uprintf("\n\t");
185 for (i = 0; i < len; i++) {
186 uprintf("%x ", buf[i]);
187 if (i && (i % 16) == 0)
188 uprintf("\n\t");
189 }
190 }
191
192 static int
193 show_ioc(const char *str, struct svr4_strioctl *ioc)
194 {
195 u_char *ptr;
196 int error, len;
197
198 len = ioc->len;
199 if (len > 1024)
200 len = 1024;
201
202 ptr = (u_char *) malloc(len, M_TEMP, M_WAITOK);
203 uprintf("%s cmd = %ld, timeout = %d, len = %d, buf = %p { ",
204 str, ioc->cmd, ioc->timeout, ioc->len, ioc->buf);
205
206 if ((error = copyin(ioc->buf, ptr, len)) != 0) {
207 free((char *) ptr, M_TEMP);
208 return error;
209 }
210
211 bufprint(ptr, len);
212
213 uprintf("}\n");
214
215 free((char *) ptr, M_TEMP);
216 return 0;
217 }
218
219
220 static int
221 show_strbuf(struct svr4_strbuf *str)
222 {
223 int error;
224 u_char *ptr = NULL;
225 int maxlen = str->maxlen;
226 int len = str->len;
227
228 if (maxlen > 8192)
229 maxlen = 8192;
230
231 if (maxlen < 0)
232 maxlen = 0;
233
234 if (len >= maxlen)
235 len = maxlen;
236
237 if (len > 0) {
238 ptr = (u_char *) malloc(len, M_TEMP, M_WAITOK);
239
240 if ((error = copyin(str->buf, ptr, len)) != 0) {
241 free((char *) ptr, M_TEMP);
242 return error;
243 }
244 }
245
246 uprintf(", { %d, %d, %p=[ ", str->maxlen, str->len, str->buf);
247
248 if (ptr)
249 bufprint(ptr, len);
250
251 uprintf("]}");
252
253 if (ptr)
254 free((char *) ptr, M_TEMP);
255
256 return 0;
257 }
258
259
260 static void
261 show_msg(const char *str, int fd, struct svr4_strbuf *ctl, struct svr4_strbuf *dat, int flags)
262 {
263 struct svr4_strbuf buf;
264 int error;
265
266 uprintf("%s(%d", str, fd);
267 if (ctl != NULL) {
268 if ((error = copyin(ctl, &buf, sizeof(buf))) != 0)
269 return;
270 show_strbuf(&buf);
271 }
272 else
273 uprintf(", NULL");
274
275 if (dat != NULL) {
276 if ((error = copyin(dat, &buf, sizeof(buf))) != 0)
277 return;
278 show_strbuf(&buf);
279 }
280 else
281 uprintf(", NULL");
282
283 uprintf(", %x);\n", flags);
284 }
285
286 #endif /* DEBUG_SVR4 */
287
288
289 /*
290 * We are faced with an interesting situation. On svr4 unix sockets
291 * are really pipes. But we really have sockets, and we might as
292 * well use them. At the point where svr4 calls TI_BIND, it has
293 * already created a named pipe for the socket using mknod(2).
294 * We need to create a socket with the same name when we bind,
295 * so we need to remove the pipe before, otherwise we'll get address
296 * already in use. So we *carefully* remove the pipe, to avoid
297 * using this as a random file removal tool.
298 */
299 static int
300 clean_pipe(struct lwp *l, const char *path)
301 {
302 struct nameidata nd;
303 struct vattr va;
304 int error;
305
306 NDINIT(&nd, DELETE, NOFOLLOW | LOCKPARENT | LOCKLEAF | TRYEMULROOT,
307 UIO_SYSSPACE, path);
308
309 error = namei(&nd);
310 if (error != 0)
311 return error;
312
313 /*
314 * Make sure we are dealing with a mode 0 named pipe.
315 */
316 if (nd.ni_vp->v_type != VFIFO)
317 goto bad;
318 error = VOP_GETATTR(nd.ni_vp, &va, l->l_cred);
319 if (error != 0)
320 goto bad;
321 if ((va.va_mode & ALLPERMS) != 0)
322 goto bad;
323
324 return VOP_REMOVE(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
325
326 bad:
327 if (nd.ni_dvp == nd.ni_vp)
328 vrele(nd.ni_dvp);
329 else
330 vput(nd.ni_dvp);
331 vput(nd.ni_vp);
332 return error;
333 }
334
335
336 static void
337 sockaddr_to_netaddr_in(struct svr4_strmcmd *sc, const struct sockaddr_in *sain)
338 {
339 struct svr4_netaddr_in *na;
340 na = SVR4_ADDROF(sc);
341
342 na->family = sain->sin_family;
343 na->port = sain->sin_port;
344 na->addr = sain->sin_addr.s_addr;
345 DPRINTF(("sockaddr_in -> netaddr %d %d %lx\n", na->family, na->port,
346 na->addr));
347 }
348
349
350 static void
351 sockaddr_to_netaddr_un(struct svr4_strmcmd *sc, const struct sockaddr_un *saun)
352 {
353 struct svr4_netaddr_un *na;
354 char *dst, *edst = ((char *) sc) + sc->offs + sizeof(na->family) + 1 -
355 sizeof(*sc);
356 const char *src;
357
358 na = SVR4_ADDROF(sc);
359 na->family = saun->sun_family;
360 for (src = saun->sun_path, dst = na->path; (*dst++ = *src++) != '\0'; )
361 if (dst == edst)
362 break;
363 DPRINTF(("sockaddr_un -> netaddr %d %s\n", na->family, na->path));
364 }
365
366
367 static void
368 netaddr_to_sockaddr_in(struct sockaddr_in *sain, const struct svr4_strmcmd *sc)
369 {
370 const struct svr4_netaddr_in *na;
371
372
373 na = SVR4_C_ADDROF(sc);
374 memset(sain, 0, sizeof(*sain));
375 sain->sin_len = sizeof(*sain);
376 sain->sin_family = na->family;
377 sain->sin_port = na->port;
378 sain->sin_addr.s_addr = na->addr;
379 DPRINTF(("netaddr -> sockaddr_in %d %d %x\n", sain->sin_family,
380 sain->sin_port, sain->sin_addr.s_addr));
381 }
382
383
384 static void
385 netaddr_to_sockaddr_un(struct sockaddr_un *saun, const struct svr4_strmcmd *sc)
386 {
387 const struct svr4_netaddr_un *na;
388 char *dst, *edst = &saun->sun_path[sizeof(saun->sun_path) - 1];
389 const char *src;
390
391 na = SVR4_C_ADDROF(sc);
392 memset(saun, 0, sizeof(*saun));
393 saun->sun_family = na->family;
394 for (src = na->path, dst = saun->sun_path; (*dst++ = *src++) != '\0'; )
395 if (dst == edst)
396 break;
397 saun->sun_len = dst - saun->sun_path;
398 DPRINTF(("netaddr -> sockaddr_un %d %s\n", saun->sun_family,
399 saun->sun_path));
400 }
401
402
403 static void
404 getparm(file_t *fp, struct svr4_si_sockparms *pa)
405 {
406 struct svr4_strm *st = svr4_stream_get(fp);
407 struct socket *so = (struct socket *) fp->f_data;
408
409 if (st == NULL)
410 return;
411
412 pa->family = st->s_family;
413
414 switch (so->so_type) {
415 case SOCK_DGRAM:
416 pa->type = SVR4_T_CLTS;
417 pa->protocol = IPPROTO_UDP;
418 DPRINTF(("getparm(dgram)\n"));
419 return;
420
421 case SOCK_STREAM:
422 pa->type = SVR4_T_COTS; /* What about T_COTS_ORD? XXX */
423 pa->protocol = IPPROTO_IP;
424 DPRINTF(("getparm(stream)\n"));
425 return;
426
427 case SOCK_RAW:
428 pa->type = SVR4_T_CLTS;
429 pa->protocol = IPPROTO_RAW;
430 DPRINTF(("getparm(raw)\n"));
431 return;
432
433 default:
434 pa->type = 0;
435 pa->protocol = 0;
436 DPRINTF(("getparm(type %d?)\n", so->so_type));
437 return;
438 }
439 }
440
441
442 static int
443 si_ogetudata(file_t *fp, int fd, struct svr4_strioctl *ioc,
444 struct lwp *l)
445 {
446 int error;
447 struct svr4_si_oudata ud;
448 struct svr4_si_sockparms pa;
449 (void)memset(&pa, 0, sizeof(pa)); /* XXX: GCC */
450
451 if (ioc->len != sizeof(ud) && ioc->len != sizeof(ud) - sizeof(int)) {
452 DPRINTF(("SI_OGETUDATA: Wrong size %ld != %d\n",
453 (unsigned long)sizeof(ud), ioc->len));
454 return EINVAL;
455 }
456
457 if ((error = copyin(NETBSD32PTR(ioc->buf), &ud, sizeof(ud))) != 0)
458 return error;
459
460 getparm(fp, &pa);
461
462 switch (pa.family) {
463 case AF_INET:
464 ud.tidusize = 16384;
465 ud.addrsize = sizeof(struct sockaddr_in);
466 if (pa.type == SVR4_SOCK_STREAM)
467 ud.etsdusize = 1;
468 else
469 ud.etsdusize = 0;
470 break;
471
472 case AF_LOCAL:
473 ud.tidusize = 65536;
474 ud.addrsize = 128;
475 ud.etsdusize = 128;
476 break;
477
478 default:
479 DPRINTF(("SI_OGETUDATA: Unsupported address family %d\n",
480 pa.family));
481 return ENOSYS;
482 }
483
484 /* I have no idea what these should be! */
485 ud.optsize = 128;
486 ud.tsdusize = 128;
487
488 ud.servtype = pa.type;
489
490 /* XXX: Fixme */
491 ud.so_state = 0;
492 ud.so_options = 0;
493 return copyout(&ud, NETBSD32PTR(ioc->buf), ioc->len);
494 }
495
496
497 static int
498 si_sockparams(file_t *fp, int fd, struct svr4_strioctl *ioc,
499 struct lwp *l)
500 {
501 struct svr4_si_sockparms pa;
502
503 getparm(fp, &pa);
504 return copyout(&pa, NETBSD32PTR(ioc->buf), sizeof(pa));
505 }
506
507
508 static int
509 si_listen(file_t *fp, int fd, struct svr4_strioctl *ioc, struct lwp *l)
510 {
511 int error;
512 struct svr4_strm *st = svr4_stream_get(fp);
513 register_t retval;
514 struct svr4_strmcmd lst;
515 struct sys_listen_args la;
516
517 if (st == NULL)
518 return EINVAL;
519
520 if (ioc->len > sizeof(lst))
521 return EINVAL;
522
523 if ((error = copyin(NETBSD32PTR(ioc->buf), &lst, ioc->len)) != 0)
524 return error;
525
526 if (lst.cmd != SVR4_TI_OLD_BIND_REQUEST) {
527 DPRINTF(("si_listen: bad request %ld\n", lst.cmd));
528 return EINVAL;
529 }
530
531 /*
532 * We are making assumptions again...
533 */
534 SCARG(&la, s) = fd;
535 DPRINTF(("SI_LISTEN: fileno %d backlog = %d\n", fd, 5));
536 SCARG(&la, backlog) = 5;
537
538 if ((error = sys_listen(l, &la, &retval)) != 0) {
539 DPRINTF(("SI_LISTEN: listen failed %d\n", error));
540 return error;
541 }
542
543 st->s_cmd = SVR4_TI__ACCEPT_WAIT;
544 lst.cmd = SVR4_TI_BIND_REPLY;
545
546 switch (st->s_family) {
547 case AF_INET:
548 /* XXX: Fill the length here */
549 break;
550
551 case AF_LOCAL:
552 lst.len = 140;
553 lst.pad[28] = 0x00000000; /* magic again */
554 lst.pad[29] = 0x00000800; /* magic again */
555 lst.pad[30] = 0x80001400; /* magic again */
556 break;
557
558 default:
559 DPRINTF(("SI_LISTEN: Unsupported address family %d\n",
560 st->s_family));
561 return ENOSYS;
562 }
563
564
565 if ((error = copyout(&lst, NETBSD32PTR(ioc->buf), ioc->len)) != 0)
566 return error;
567
568 return 0;
569 }
570
571
572 static int
573 si_getudata(file_t *fp, int fd, struct svr4_strioctl *ioc,
574 struct lwp *l)
575 {
576 int error;
577 struct svr4_si_udata ud;
578
579 if (sizeof(ud) != ioc->len) {
580 DPRINTF(("SI_GETUDATA: Wrong size %ld != %d\n",
581 (unsigned long)sizeof(ud), ioc->len));
582 return EINVAL;
583 }
584
585 if ((error = copyin(NETBSD32PTR(ioc->buf), &ud, sizeof(ud))) != 0)
586 return error;
587
588 getparm(fp, &ud.sockparms);
589
590 switch (ud.sockparms.family) {
591 case AF_INET:
592 ud.tidusize = 16384;
593 ud.tsdusize = 16384;
594 ud.addrsize = sizeof(struct sockaddr_in);
595 if (ud.sockparms.type == SVR4_SOCK_STREAM)
596 ud.etsdusize = 1;
597 else
598 ud.etsdusize = 0;
599 ud.optsize = 0;
600 break;
601
602 case AF_LOCAL:
603 ud.tidusize = 65536;
604 ud.tsdusize = 128;
605 ud.addrsize = 128;
606 ud.etsdusize = 128;
607 ud.optsize = 128;
608 break;
609
610 default:
611 DPRINTF(("SI_GETUDATA: Unsupported address family %d\n",
612 ud.sockparms.family));
613 return ENOSYS;
614 }
615
616
617 ud.servtype = ud.sockparms.type;
618
619 /* XXX: Fixme */
620 ud.so_state = 0;
621 ud.so_options = 0;
622 return copyout(&ud, NETBSD32PTR(ioc->buf), sizeof(ud));
623 }
624
625
626 static int
627 si_shutdown(file_t *fp, int fd, struct svr4_strioctl *ioc,
628 struct lwp *l)
629 {
630 int error;
631 struct sys_shutdown_args ap;
632 register_t retval;
633
634 if (ioc->len != sizeof(SCARG(&ap, how))) {
635 DPRINTF(("SI_SHUTDOWN: Wrong size %ld != %d\n",
636 (unsigned long)sizeof(SCARG(&ap, how)), ioc->len));
637 return EINVAL;
638 }
639
640 if ((error = copyin(NETBSD32PTR(ioc->buf), &SCARG(&ap, how), ioc->len)) != 0)
641 return error;
642
643 SCARG(&ap, s) = fd;
644
645 return sys_shutdown(l, &ap, &retval);
646 }
647
648
649 static int
650 sockmod(file_t *fp, int fd, struct svr4_strioctl *ioc, struct lwp *l)
651 {
652 switch (ioc->cmd) {
653 case SVR4_SI_OGETUDATA:
654 DPRINTF(("SI_OGETUDATA\n"));
655 return si_ogetudata(fp, fd, ioc, l);
656
657 case SVR4_SI_SHUTDOWN:
658 DPRINTF(("SI_SHUTDOWN\n"));
659 return si_shutdown(fp, fd, ioc, l);
660
661 case SVR4_SI_LISTEN:
662 DPRINTF(("SI_LISTEN\n"));
663 return si_listen(fp, fd, ioc, l);
664
665 case SVR4_SI_SETMYNAME:
666 DPRINTF(("SI_SETMYNAME\n"));
667 return 0;
668
669 case SVR4_SI_SETPEERNAME:
670 DPRINTF(("SI_SETPEERNAME\n"));
671 return 0;
672
673 case SVR4_SI_GETINTRANSIT:
674 DPRINTF(("SI_GETINTRANSIT\n"));
675 return 0;
676
677 case SVR4_SI_TCL_LINK:
678 DPRINTF(("SI_TCL_LINK\n"));
679 return 0;
680
681 case SVR4_SI_TCL_UNLINK:
682 DPRINTF(("SI_TCL_UNLINK\n"));
683 return 0;
684
685 case SVR4_SI_SOCKPARAMS:
686 DPRINTF(("SI_SOCKPARAMS\n"));
687 return si_sockparams(fp, fd, ioc, l);
688
689 case SVR4_SI_GETUDATA:
690 DPRINTF(("SI_GETUDATA\n"));
691 return si_getudata(fp, fd, ioc, l);
692
693 default:
694 DPRINTF(("Unknown sockmod ioctl %lx\n", ioc->cmd));
695 return 0;
696
697 }
698 }
699
700
701 static int
702 ti_getinfo(file_t *fp, int fd, struct svr4_strioctl *ioc,
703 struct lwp *l)
704 {
705 int error;
706 struct svr4_infocmd info;
707
708 memset(&info, 0, sizeof(info));
709
710 if (ioc->len > sizeof(info))
711 return EINVAL;
712
713 if ((error = copyin(NETBSD32PTR(ioc->buf), &info, ioc->len)) != 0)
714 return error;
715
716 if (info.cmd != SVR4_TI_INFO_REQUEST)
717 return EINVAL;
718
719 info.cmd = SVR4_TI_INFO_REPLY;
720 info.tsdu = 0;
721 info.etsdu = 1;
722 info.cdata = -2;
723 info.ddata = -2;
724 info.addr = 16;
725 info.opt = -1;
726 info.tidu = 16384;
727 info.serv = 2;
728 info.current = 0;
729 info.provider = 2;
730
731 ioc->len = sizeof(info);
732 if ((error = copyout(&info, NETBSD32PTR(ioc->buf), ioc->len)) != 0)
733 return error;
734
735 return 0;
736 }
737
738
739 static int
740 ti_bind(file_t *fp, int fd, struct svr4_strioctl *ioc, struct lwp *l)
741 {
742 int error;
743 struct svr4_strm *st = svr4_stream_get(fp);
744 struct sockaddr_in sain;
745 struct sockaddr_un saun;
746 void *skp, *sup = NULL;
747 int sasize;
748 struct svr4_strmcmd bnd;
749 struct mbuf *name;
750
751 if (st == NULL) {
752 DPRINTF(("ti_bind: bad file descriptor\n"));
753 return EINVAL;
754 }
755
756 if (ioc->len > sizeof(bnd))
757 return EINVAL;
758
759 if ((error = copyin(NETBSD32PTR(ioc->buf), &bnd, ioc->len)) != 0)
760 return error;
761
762 if (bnd.cmd != SVR4_TI_OLD_BIND_REQUEST) {
763 DPRINTF(("ti_bind: bad request %ld\n", bnd.cmd));
764 return EINVAL;
765 }
766
767 switch (st->s_family) {
768 case AF_INET:
769 skp = &sain;
770 sasize = sizeof(sain);
771
772 if (bnd.offs == 0)
773 goto reply;
774
775 netaddr_to_sockaddr_in(&sain, &bnd);
776
777 DPRINTF(("TI_BIND: fam %d, port %d, addr %x\n",
778 sain.sin_family, sain.sin_port,
779 sain.sin_addr.s_addr));
780 break;
781
782 case AF_LOCAL:
783 skp = &saun;
784 sasize = sizeof(saun);
785 if (bnd.offs == 0)
786 goto reply;
787
788 netaddr_to_sockaddr_un(&saun, &bnd);
789
790 if (saun.sun_path[0] == '\0')
791 goto reply;
792
793 DPRINTF(("TI_BIND: fam %d, path %s\n",
794 saun.sun_family, saun.sun_path));
795
796 if ((error = clean_pipe(l, saun.sun_path)) != 0)
797 return error;
798
799 bnd.pad[28] = 0x00001000; /* magic again */
800 break;
801
802 default:
803 DPRINTF(("TI_BIND: Unsupported address family %d\n",
804 st->s_family));
805 return ENOSYS;
806 }
807
808 name = m_get(M_WAIT, MT_SONAME);
809 if (sasize > MLEN)
810 MEXTMALLOC(name, sasize, M_WAITOK);
811
812 memcpy(mtod(name, void *), skp, sasize);
813
814 DPRINTF(("TI_BIND: fileno %d\n", fd));
815
816 error = do_sys_bind(l, fd, name);
817 if (error != 0) {
818 DPRINTF(("TI_BIND: bind failed %d\n", error));
819 return error;
820 }
821
822 reply:
823 if (sup == NULL) {
824 memset(&bnd, 0, sizeof(bnd));
825 bnd.len = sasize + 4;
826 bnd.offs = 0x10; /* XXX */
827 }
828
829 bnd.cmd = SVR4_TI_BIND_REPLY;
830
831 if ((error = copyout(&bnd, NETBSD32PTR(ioc->buf), ioc->len)) != 0)
832 return error;
833
834 return 0;
835 }
836
837
838 static int
839 timod(file_t *fp, int fd, struct svr4_strioctl *ioc, struct lwp *l)
840 {
841 switch (ioc->cmd) {
842 case SVR4_TI_GETINFO:
843 DPRINTF(("TI_GETINFO\n"));
844 return ti_getinfo(fp, fd, ioc, l);
845
846 case SVR4_TI_OPTMGMT:
847 DPRINTF(("TI_OPTMGMT\n"));
848 return 0;
849
850 case SVR4_TI_BIND:
851 DPRINTF(("TI_BIND\n"));
852 return ti_bind(fp, fd, ioc, l);
853
854 case SVR4_TI_UNBIND:
855 DPRINTF(("TI_UNBIND\n"));
856 return 0;
857
858 default:
859 DPRINTF(("Unknown timod ioctl %lx\n", ioc->cmd));
860 return 0;
861 }
862 }
863
864
865 int
866 svr4_stream_ti_ioctl(file_t *fp, struct lwp *l, register_t *retval, int fd, u_long cmd, void *dat)
867 {
868 struct svr4_strbuf skb, *sub = (struct svr4_strbuf *) dat;
869 struct svr4_strm *st = svr4_stream_get(fp);
870 int error;
871 struct svr4_strmcmd sc;
872 struct mbuf *name;
873
874 if (st == NULL)
875 return EINVAL;
876
877 sc.offs = 0x10;
878
879 if ((error = copyin(sub, &skb, sizeof(skb))) != 0) {
880 DPRINTF(("ti_ioctl: error copying in strbuf\n"));
881 return error;
882 }
883
884 switch (cmd) {
885 case SVR4_TI_GETMYNAME:
886 DPRINTF(("TI_GETMYNAME\n"));
887 cmd = PRU_SOCKADDR;
888 break;
889
890 case SVR4_TI_GETPEERNAME:
891 DPRINTF(("TI_GETPEERNAME\n"));
892 cmd = PRU_PEERADDR;
893 break;
894
895 case SVR4_TI_SETMYNAME:
896 DPRINTF(("TI_SETMYNAME\n"));
897 return 0;
898
899 case SVR4_TI_SETPEERNAME:
900 DPRINTF(("TI_SETPEERNAME\n"));
901 return 0;
902 default:
903 DPRINTF(("ti_ioctl: Unknown ioctl %lx\n", cmd));
904 return ENOSYS;
905 }
906
907 error = do_sys_getsockname(l, fd, cmd, &name);
908 if (error != 0)
909 return error;
910
911 switch (st->s_family) {
912 case AF_INET:
913 sockaddr_to_netaddr_in(&sc, mtod(name, void *));
914 skb.len = sizeof (struct sockaddr_in);
915 break;
916
917 case AF_LOCAL:
918 sockaddr_to_netaddr_un(&sc, mtod(name, void *));
919 /* XXX: the length gets adjusted but the copyout doesn't */
920 skb.len = sizeof (struct sockaddr_un) + 4;
921 break;
922
923 default:
924 DPRINTF(("ti_ioctl: Unsupported address family %d\n",
925 st->s_family));
926 m_free(name);
927 return ENOSYS;
928 }
929
930 error = copyout(SVR4_ADDROF(&sc), NETBSD32PTR(skb.buf), name->m_len);
931 m_free(name);
932 if (error != 0) {
933 DPRINTF(("ti_ioctl: error copying out socket data\n"));
934 return error;
935 }
936
937
938 if ((error = copyout(&skb, sub, sizeof(skb))) != 0) {
939 DPRINTF(("ti_ioctl: error copying out strbuf\n"));
940 return error;
941 }
942
943 return error;
944 }
945
946
947
948
949 static int
950 i_nread(file_t *fp, struct lwp *l, register_t *retval, int fd,
951 u_long cmd, void *dat)
952 {
953 int error;
954 int nread = 0;
955
956 /*
957 * We are supposed to return the message length in nread, and the
958 * number of messages in retval. We don't have the notion of number
959 * of stream messages, so we just find out if we have any bytes waiting
960 * for us, and if we do, then we assume that we have at least one
961 * message waiting for us.
962 */
963 if ((error = (*fp->f_ops->fo_ioctl)(fp, FIONREAD, &nread)) != 0)
964 return error;
965
966 if (nread != 0)
967 *retval = 1;
968 else
969 *retval = 0;
970
971 return copyout(&nread, dat, sizeof(nread));
972 }
973
974 static int
975 i_fdinsert(file_t *fp, struct lwp *l, register_t *retval, int fd,
976 u_long cmd, void *dat)
977 {
978 /*
979 * Major hack again here. We assume that we are using this to
980 * implement accept(2). If that is the case, we have already
981 * called accept, and we have stored the file descriptor in
982 * afd. We find the file descriptor that the code wants to use
983 * in fd insert, and then we dup2() our accepted file descriptor
984 * to it.
985 */
986 int error;
987 struct svr4_strm *st = svr4_stream_get(fp);
988 struct svr4_strfdinsert fdi;
989 struct sys_dup2_args d2p;
990 struct sys_close_args clp;
991
992 if (st == NULL) {
993 DPRINTF(("fdinsert: bad file type\n"));
994 return EINVAL;
995 }
996
997 if (st->s_afd == -1) {
998 DPRINTF(("fdinsert: accept fd not found\n"));
999 return ENOENT;
1000 }
1001
1002 if ((error = copyin(dat, &fdi, sizeof(fdi))) != 0) {
1003 DPRINTF(("fdinsert: copyin failed %d\n", error));
1004 return error;
1005 }
1006
1007 SCARG(&d2p, from) = st->s_afd;
1008 SCARG(&d2p, to) = fdi.fd;
1009
1010 if ((error = sys_dup2(l, &d2p, retval)) != 0) {
1011 DPRINTF(("fdinsert: dup2(%d, %d) failed %d\n",
1012 st->s_afd, fdi.fd, error));
1013 return error;
1014 }
1015
1016 SCARG(&clp, fd) = st->s_afd;
1017
1018 if ((error = sys_close(l, &clp, retval)) != 0) {
1019 DPRINTF(("fdinsert: close(%d) failed %d\n",
1020 st->s_afd, error));
1021 return error;
1022 }
1023
1024 st->s_afd = -1;
1025
1026 *retval = 0;
1027 return 0;
1028 }
1029
1030
1031 static int
1032 _i_bind_rsvd(file_t *fp, struct lwp *l, register_t *retval,
1033 int fd, u_long cmd, void *dat)
1034 {
1035 struct sys_mkfifo_args ap;
1036
1037 /*
1038 * This is a supposed to be a kernel and library only ioctl.
1039 * It gets called before ti_bind, when we have a unix
1040 * socket, to physically create the socket transport and
1041 * ``reserve'' it. I don't know how this get reserved inside
1042 * the kernel, but we are going to create it nevertheless.
1043 */
1044 SCARG(&ap, path) = dat;
1045 SCARG(&ap, mode) = S_IFIFO;
1046
1047 return sys_mkfifo(l, &ap, retval);
1048 }
1049
1050 static int
1051 _i_rele_rsvd(file_t *fp, struct lwp *l, register_t *retval,
1052 int fd, u_long cmd, void *dat)
1053 {
1054 struct sys_unlink_args ap;
1055
1056 /*
1057 * This is a supposed to be a kernel and library only ioctl.
1058 * I guess it is supposed to release the socket.
1059 */
1060 SCARG(&ap, path) = dat;
1061
1062 return sys_unlink(l, &ap, retval);
1063 }
1064
1065 static int
1066 i_str(file_t *fp, struct lwp *l, register_t *retval, int fd,
1067 u_long cmd, void *dat)
1068 {
1069 int error;
1070 struct svr4_strioctl ioc;
1071
1072 /*
1073 * Noop on non sockets
1074 */
1075 if (fp->f_type != DTYPE_SOCKET)
1076 return 0;
1077
1078 if ((error = copyin(dat, &ioc, sizeof(ioc))) != 0)
1079 return error;
1080
1081 #ifdef DEBUG_SVR4
1082 if ((error = show_ioc(">", &ioc)) != 0)
1083 return error;
1084 #endif /* DEBUG_SVR4 */
1085
1086 switch (ioc.cmd & 0xff00) {
1087 case SVR4_SIMOD:
1088 if ((error = sockmod(fp, fd, &ioc, l)) != 0)
1089 return error;
1090 break;
1091
1092 case SVR4_TIMOD:
1093 if ((error = timod(fp, fd, &ioc, l)) != 0)
1094 return error;
1095 break;
1096
1097 default:
1098 DPRINTF(("Unimplemented module %c %ld\n",
1099 (char) (cmd >> 8), cmd & 0xff));
1100 return 0;
1101 }
1102
1103 #ifdef DEBUG_SVR4
1104 if ((error = show_ioc("<", &ioc)) != 0)
1105 return error;
1106 #endif /* DEBUG_SVR4 */
1107 return copyout(&ioc, dat, sizeof(ioc));
1108 }
1109
1110 static int
1111 i_setsig(file_t *fp, struct lwp *l, register_t *retval, int fd,
1112 u_long cmd, void *dat)
1113 {
1114 /*
1115 * This is the best we can do for now; we cannot generate
1116 * signals only for specific events so the signal mask gets
1117 * ignored; we save it just to pass it to a possible I_GETSIG...
1118 *
1119 * We alse have to fix the O_ASYNC fcntl bit, so the
1120 * process will get SIGPOLLs.
1121 */
1122 struct sys_fcntl_args fa;
1123 int error;
1124 register_t oflags, flags;
1125 struct svr4_strm *st = svr4_stream_get(fp);
1126
1127 if (st == NULL) {
1128 DPRINTF(("i_setsig: bad file descriptor\n"));
1129 return EINVAL;
1130 }
1131 /* get old status flags */
1132 SCARG(&fa, fd) = fd;
1133 SCARG(&fa, cmd) = F_GETFL;
1134
1135 if ((error = sys_fcntl(l, &fa, &oflags)) != 0)
1136 return error;
1137
1138 /* update the flags */
1139 if (dat != NULL) {
1140 int mask;
1141
1142 flags = oflags | O_ASYNC;
1143 mask = (int)(u_long)dat;
1144 if (mask & ~SVR4_S_ALLMASK) {
1145 DPRINTF(("i_setsig: bad eventmask data %x\n", mask));
1146 return EINVAL;
1147 }
1148 st->s_eventmask = mask;
1149 }
1150 else {
1151 flags = oflags & ~O_ASYNC;
1152 st->s_eventmask = 0;
1153 }
1154
1155 /* set the new flags, if changed */
1156 if (flags != oflags) {
1157 SCARG(&fa, cmd) = F_SETFL;
1158 SCARG(&fa, arg) = (void *) flags;
1159 if ((error = sys_fcntl(l, &fa, &flags)) != 0)
1160 return error;
1161 }
1162
1163 /* set up SIGIO receiver if needed */
1164 if (dat != NULL) {
1165 SCARG(&fa, cmd) = F_SETOWN;
1166 SCARG(&fa, arg) = (void *)(u_long)l->l_proc->p_pid;
1167 return sys_fcntl(l, &fa, &flags);
1168 }
1169 return 0;
1170 }
1171
1172 static int
1173 i_getsig(file_t *fp, struct lwp *l, register_t *retval,
1174 int fd, u_long cmd, void *dat)
1175 {
1176 int error;
1177
1178 if (dat != NULL) {
1179 struct svr4_strm *st = svr4_stream_get(fp);
1180
1181 if (st == NULL) {
1182 DPRINTF(("i_getsig: bad file descriptor\n"));
1183 return EINVAL;
1184 }
1185 if ((error = copyout(&st->s_eventmask, dat,
1186 sizeof(st->s_eventmask))) != 0) {
1187 DPRINTF(("i_getsig: bad eventmask pointer\n"));
1188 return error;
1189 }
1190 }
1191 return 0;
1192 }
1193
1194 int
1195 svr4_stream_ioctl(file_t *fp, struct lwp *l, register_t *retval, int fd, u_long cmd, void *dat)
1196 {
1197 *retval = 0;
1198
1199 /*
1200 * All the following stuff assumes "sockmod" is pushed...
1201 */
1202 switch (cmd) {
1203 case SVR4_I_NREAD:
1204 DPRINTF(("I_NREAD\n"));
1205 return i_nread(fp, l, retval, fd, cmd, dat);
1206
1207 case SVR4_I_PUSH:
1208 DPRINTF(("I_PUSH\n"));
1209 return 0;
1210
1211 case SVR4_I_POP:
1212 DPRINTF(("I_POP\n"));
1213 return 0;
1214
1215 case SVR4_I_LOOK:
1216 DPRINTF(("I_LOOK\n"));
1217 return 0;
1218
1219 case SVR4_I_FLUSH:
1220 DPRINTF(("I_FLUSH\n"));
1221 return 0;
1222
1223 case SVR4_I_SRDOPT:
1224 DPRINTF(("I_SRDOPT\n"));
1225 return 0;
1226
1227 case SVR4_I_GRDOPT:
1228 DPRINTF(("I_GRDOPT\n"));
1229 return 0;
1230
1231 case SVR4_I_STR:
1232 DPRINTF(("I_STR\n"));
1233 return i_str(fp, l, retval, fd, cmd, dat);
1234
1235 case SVR4_I_SETSIG:
1236 DPRINTF(("I_SETSIG\n"));
1237 return i_setsig(fp, l, retval, fd, cmd, dat);
1238
1239 case SVR4_I_GETSIG:
1240 DPRINTF(("I_GETSIG\n"));
1241 return i_getsig(fp, l, retval, fd, cmd, dat);
1242
1243 case SVR4_I_FIND:
1244 DPRINTF(("I_FIND\n"));
1245 /*
1246 * Here we are not pushing modules really, we just
1247 * pretend all are present
1248 */
1249 *retval = 1;
1250 return 0;
1251
1252 case SVR4_I_LINK:
1253 DPRINTF(("I_LINK\n"));
1254 return 0;
1255
1256 case SVR4_I_UNLINK:
1257 DPRINTF(("I_UNLINK\n"));
1258 return 0;
1259
1260 case SVR4_I_ERECVFD:
1261 DPRINTF(("I_ERECVFD\n"));
1262 return 0;
1263
1264 case SVR4_I_PEEK:
1265 DPRINTF(("I_PEEK\n"));
1266 return 0;
1267
1268 case SVR4_I_FDINSERT:
1269 DPRINTF(("I_FDINSERT\n"));
1270 return i_fdinsert(fp, l, retval, fd, cmd, dat);
1271
1272 case SVR4_I_SENDFD:
1273 DPRINTF(("I_SENDFD\n"));
1274 return 0;
1275
1276 case SVR4_I_RECVFD:
1277 DPRINTF(("I_RECVFD\n"));
1278 return 0;
1279
1280 case SVR4_I_SWROPT:
1281 DPRINTF(("I_SWROPT\n"));
1282 return 0;
1283
1284 case SVR4_I_GWROPT:
1285 DPRINTF(("I_GWROPT\n"));
1286 return 0;
1287
1288 case SVR4_I_LIST:
1289 DPRINTF(("I_LIST\n"));
1290 return 0;
1291
1292 case SVR4_I_PLINK:
1293 DPRINTF(("I_PLINK\n"));
1294 return 0;
1295
1296 case SVR4_I_PUNLINK:
1297 DPRINTF(("I_PUNLINK\n"));
1298 return 0;
1299
1300 case SVR4_I_SETEV:
1301 DPRINTF(("I_SETEV\n"));
1302 return 0;
1303
1304 case SVR4_I_GETEV:
1305 DPRINTF(("I_GETEV\n"));
1306 return 0;
1307
1308 case SVR4_I_STREV:
1309 DPRINTF(("I_STREV\n"));
1310 return 0;
1311
1312 case SVR4_I_UNSTREV:
1313 DPRINTF(("I_UNSTREV\n"));
1314 return 0;
1315
1316 case SVR4_I_FLUSHBAND:
1317 DPRINTF(("I_FLUSHBAND\n"));
1318 return 0;
1319
1320 case SVR4_I_CKBAND:
1321 DPRINTF(("I_CKBAND\n"));
1322 return 0;
1323
1324 case SVR4_I_GETBAND:
1325 DPRINTF(("I_GETBANK\n"));
1326 return 0;
1327
1328 case SVR4_I_ATMARK:
1329 DPRINTF(("I_ATMARK\n"));
1330 return 0;
1331
1332 case SVR4_I_SETCLTIME:
1333 DPRINTF(("I_SETCLTIME\n"));
1334 return 0;
1335
1336 case SVR4_I_GETCLTIME:
1337 DPRINTF(("I_GETCLTIME\n"));
1338 return 0;
1339
1340 case SVR4_I_CANPUT:
1341 DPRINTF(("I_CANPUT\n"));
1342 return 0;
1343
1344 case SVR4__I_BIND_RSVD:
1345 DPRINTF(("_I_BIND_RSVD\n"));
1346 return _i_bind_rsvd(fp, l, retval, fd, cmd, dat);
1347
1348 case SVR4__I_RELE_RSVD:
1349 DPRINTF(("_I_RELE_RSVD\n"));
1350 return _i_rele_rsvd(fp, l, retval, fd, cmd, dat);
1351
1352 default:
1353 DPRINTF(("unimpl cmd = %lx\n", cmd));
1354 break;
1355 }
1356
1357 return 0;
1358 }
1359
1360
1361
1362
1363 int
1364 svr4_sys_putmsg(struct lwp *l, const struct svr4_sys_putmsg_args *uap, register_t *retval)
1365 {
1366 struct proc *p = l->l_proc;
1367 file_t *fp;
1368 struct svr4_strbuf dat, ctl;
1369 struct svr4_strmcmd sc;
1370 struct sockaddr_in sain;
1371 struct sockaddr_un saun;
1372 void *skp;
1373 int sasize;
1374 struct svr4_strm *st;
1375 int error;
1376 struct mbuf *nam;
1377 struct msghdr msg;
1378 struct iovec aiov;
1379
1380
1381 #ifdef DEBUG_SVR4
1382 show_msg(">putmsg", SCARG(uap, fd), SCARG(uap, ctl),
1383 SCARG(uap, dat), SCARG(uap, flags));
1384 #endif /* DEBUG_SVR4 */
1385
1386 if ((fp = fd_getfile(SCARG(uap, fd))) == NULL)
1387 return EBADF;
1388
1389 KERNEL_LOCK(1, NULL); /* svr4_find_socket */
1390
1391 if (SCARG_PTR(uap, ctl) != NULL) {
1392 if ((error = copyin(SCARG_PTR(uap, ctl),
1393 &ctl, sizeof(ctl))) != 0)
1394 goto out;
1395 } else
1396 ctl.len = -1;
1397
1398 if (SCARG_PTR(uap, dat) != NULL) {
1399 if ((error = copyin(SCARG_PTR(uap, dat),
1400 &dat, sizeof(dat))) != 0)
1401 goto out;
1402 } else
1403 dat.len = -1;
1404
1405 /*
1406 * Only for sockets for now.
1407 */
1408 if ((st = svr4_stream_get(fp)) == NULL) {
1409 DPRINTF(("putmsg: bad file type\n"));
1410 error = EINVAL;
1411 goto out;
1412 }
1413
1414 if (ctl.len > sizeof(sc)) {
1415 DPRINTF(("putmsg: Bad control size %ld != %d\n",
1416 (unsigned long)sizeof(struct svr4_strmcmd), ctl.len));
1417 error = EINVAL;
1418 goto out;
1419 }
1420
1421 if ((error = copyin(NETBSD32PTR(ctl.buf), &sc, ctl.len)) != 0)
1422 goto out;
1423
1424 switch (st->s_family) {
1425 case AF_INET:
1426 if (sc.len != sizeof(sain)) {
1427 #ifdef notyet
1428 if (sc.cmd == SVR4_TI_DATA_REQUEST) {
1429 struct sys_write_args wa;
1430
1431 /* Solaris seems to use sc.cmd = 3 to
1432 * send "expedited" data. telnet uses
1433 * this for options processing, sending EOF,
1434 * etc. I'm sure other things use it too.
1435 * I don't have any documentation
1436 * on it, so I'm making a guess that this
1437 * is how it works. newton@atdot.dotat.org XXX
1438 *
1439 * Hmm, expedited data seems to be sc.cmd = 4.
1440 * I think 3 is normal data. (christos)
1441 */
1442 DPRINTF(("sending expedited data (?)\n"));
1443 SCARG(&wa, fd) = SCARG(uap, fd);
1444 SCARG(&wa, buf) = dat.buf;
1445 SCARG(&wa, nbyte) = dat.len;
1446 error = sys_write(l, &wa, retval);
1447 goto out;
1448 }
1449 #endif
1450 DPRINTF(("putmsg: Invalid inet length %ld\n", sc.len));
1451 error = EINVAL;
1452 goto out;
1453 }
1454 netaddr_to_sockaddr_in(&sain, &sc);
1455 skp = &sain;
1456 sasize = sizeof(sain);
1457 error = sain.sin_family != st->s_family;
1458 break;
1459
1460 case AF_LOCAL:
1461 if (ctl.len == 8) {
1462 /* We are doing an accept; succeed */
1463 DPRINTF(("putmsg: Do nothing\n"));
1464 *retval = 0;
1465 error = 0;
1466 goto out;
1467 }
1468 else {
1469 /* Maybe we've been given a device/inode pair */
1470 dev_t *dev = SVR4_ADDROF(&sc);
1471 svr4_ino_t *ino = (svr4_ino_t *) &dev[1];
1472 skp = svr4_find_socket(p, fp, *dev, *ino);
1473 if (skp == NULL) {
1474 skp = &saun;
1475 /* I guess we have it by name */
1476 netaddr_to_sockaddr_un(skp, &sc);
1477 }
1478 sasize = sizeof(saun);
1479 }
1480 break;
1481
1482 default:
1483 DPRINTF(("putmsg: Unsupported address family %d\n",
1484 st->s_family));
1485 error = ENOSYS;
1486 goto out;
1487 }
1488
1489 nam = m_get(M_WAIT, MT_SONAME);
1490 nam->m_len = sasize;
1491 memcpy(mtod(nam, void *), skp, sasize);
1492
1493 switch (st->s_cmd = sc.cmd) {
1494 case SVR4_TI_CONNECT_REQUEST: /* connect */
1495 KERNEL_UNLOCK_ONE(NULL);
1496 return do_sys_connect(l, SCARG(uap, fd), nam);
1497
1498 case SVR4_TI_SENDTO_REQUEST: /* sendto */
1499 KERNEL_UNLOCK_ONE(NULL);
1500 msg.msg_name = nam;
1501 msg.msg_namelen = sasize;
1502 msg.msg_iov = &aiov;
1503 msg.msg_iovlen = 1;
1504 msg.msg_control = NULL;
1505 msg.msg_flags = MSG_NAMEMBUF;
1506 aiov.iov_base = NETBSD32PTR(dat.buf);
1507 aiov.iov_len = dat.len;
1508 error = do_sys_sendmsg(l, SCARG(uap, fd), &msg,
1509 SCARG(uap, flags), retval);
1510
1511 *retval = 0;
1512 return error;
1513
1514 default:
1515 m_free(nam);
1516 DPRINTF(("putmsg: Unimplemented command %lx\n", sc.cmd));
1517 error = ENOSYS;
1518 goto out;
1519 }
1520
1521 out:
1522 KERNEL_UNLOCK_ONE(NULL);
1523 fd_putfile(SCARG(uap, fd));
1524 return error;
1525 }
1526
1527
1528 int
1529 svr4_sys_getmsg(struct lwp *l, const struct svr4_sys_getmsg_args *uap, register_t *retval)
1530 {
1531 file_t *fp;
1532 struct svr4_strbuf dat, ctl;
1533 struct svr4_strmcmd sc;
1534 int error = 0;
1535 struct msghdr msg;
1536 struct iovec aiov;
1537 struct svr4_strm *st;
1538 int fl;
1539 struct mbuf *name;
1540
1541 memset(&sc, 0, sizeof(sc));
1542
1543 #ifdef DEBUG_SVR4
1544 show_msg(">getmsg", SCARG(uap, fd), SCARG(uap, ctl),
1545 SCARG(uap, dat), 0);
1546 #endif /* DEBUG_SVR4 */
1547
1548 if ((fp = fd_getfile(SCARG(uap, fd))) == NULL)
1549 return EBADF;
1550
1551 if (SCARG_PTR(uap, ctl) != NULL) {
1552 if ((error = copyin(SCARG_PTR(uap, ctl), &ctl,
1553 sizeof(ctl))) != 0)
1554 goto out;
1555 } else {
1556 ctl.len = -1;
1557 ctl.maxlen = 0;
1558 }
1559
1560 if (SCARG_PTR(uap, dat) != NULL) {
1561 if ((error = copyin(SCARG_PTR(uap, dat), &dat,
1562 sizeof(dat))) != 0)
1563 goto out;
1564 } else {
1565 dat.len = -1;
1566 dat.maxlen = 0;
1567 }
1568
1569 /*
1570 * Only for sockets for now.
1571 */
1572 if ((st = svr4_stream_get(fp)) == NULL) {
1573 DPRINTF(("getmsg: bad file type\n"));
1574 error = EINVAL;
1575 goto out;
1576 }
1577
1578 if (ctl.maxlen == -1 || dat.maxlen == -1) {
1579 DPRINTF(("getmsg: Cannot handle -1 maxlen (yet)\n"));
1580 error = ENOSYS;
1581 goto out;
1582 }
1583
1584 switch (st->s_family) {
1585 case AF_INET:
1586 case AF_LOCAL:
1587 break;
1588
1589 default:
1590 DPRINTF(("getmsg: Unsupported address family %d\n",
1591 st->s_family));
1592 goto out;
1593 }
1594
1595 switch (st->s_cmd) {
1596 case SVR4_TI_CONNECT_REQUEST:
1597 DPRINTF(("getmsg: TI_CONNECT_REQUEST\n"));
1598 /*
1599 * We do the connect in one step, so the putmsg should
1600 * have gotten the error.
1601 */
1602 sc.cmd = SVR4_TI_OK_REPLY;
1603 sc.len = 0;
1604
1605 ctl.len = 8;
1606 dat.len = -1;
1607 fl = 1;
1608 st->s_cmd = sc.cmd;
1609 break;
1610
1611 case SVR4_TI_OK_REPLY:
1612 DPRINTF(("getmsg: TI_OK_REPLY\n"));
1613 /*
1614 * We are immediately after a connect reply, so we send
1615 * a connect verification.
1616 */
1617
1618 error = do_sys_getsockname(l, SCARG(uap, fd), PRU_SOCKADDR,
1619 &name);
1620 if (error != 0) {
1621 DPRINTF(("getmsg: getpeername failed %d\n", error));
1622 goto out;
1623 }
1624
1625 sc.cmd = SVR4_TI_CONNECT_REPLY;
1626 sc.pad[0] = 0x4;
1627 sc.offs = 0x18;
1628 sc.pad[1] = 0x14;
1629 sc.pad[2] = 0x04000402;
1630
1631 switch (st->s_family) {
1632 case AF_INET:
1633 sc.len = sizeof (struct sockaddr_in) + 4;
1634 sockaddr_to_netaddr_in(&sc, mtod(name, void *));
1635 break;
1636
1637 case AF_LOCAL:
1638 sc.len = sizeof (struct sockaddr_un) + 4;
1639 sockaddr_to_netaddr_un(&sc, mtod(name, void *));
1640 break;
1641
1642 default:
1643 m_free(name);
1644 error = ENOSYS;
1645 goto out;
1646 }
1647 m_free(name);
1648
1649 ctl.len = 40;
1650 dat.len = -1;
1651 fl = 0;
1652 st->s_cmd = sc.cmd;
1653 break;
1654
1655 case SVR4_TI__ACCEPT_OK:
1656 DPRINTF(("getmsg: TI__ACCEPT_OK\n"));
1657 /*
1658 * We do the connect in one step, so the putmsg should
1659 * have gotten the error.
1660 */
1661 sc.cmd = SVR4_TI_OK_REPLY;
1662 sc.len = 1;
1663
1664 ctl.len = 8;
1665 dat.len = -1;
1666 fl = 1;
1667 st->s_cmd = SVR4_TI__ACCEPT_WAIT;
1668 break;
1669
1670 case SVR4_TI__ACCEPT_WAIT:
1671 DPRINTF(("getmsg: TI__ACCEPT_WAIT\n"));
1672 /*
1673 * We are after a listen, so we try to accept...
1674 */
1675
1676 error = do_sys_accept(l, SCARG(uap, fd), &name, retval);
1677 if (error != 0) {
1678 DPRINTF(("getmsg: accept failed %d\n", error));
1679 goto out;
1680 }
1681
1682 st->s_afd = *retval;
1683
1684 DPRINTF(("getmsg: Accept fd = %d\n", st->s_afd));
1685
1686 sc.cmd = SVR4_TI_ACCEPT_REPLY;
1687 sc.offs = 0x18;
1688 sc.pad[0] = 0x0;
1689
1690 switch (st->s_family) {
1691 case AF_INET:
1692 sc.pad[1] = 0x28;
1693 sockaddr_to_netaddr_in(&sc, mtod(name, void *));
1694 ctl.len = 40;
1695 sc.len = sizeof (struct sockaddr_in);
1696 break;
1697
1698 case AF_LOCAL:
1699 sc.pad[1] = 0x00010000;
1700 sc.pad[2] = 0xf6bcdaa0; /* I don't know what that is */
1701 sc.pad[3] = 0x00010000;
1702 ctl.len = 134;
1703 sc.len = sizeof (struct sockaddr_un) + 4;
1704 break;
1705
1706 default:
1707 m_free(name);
1708 error = ENOSYS;
1709 goto out;
1710 }
1711 m_free(name);
1712
1713 dat.len = -1;
1714 fl = 0;
1715 st->s_cmd = SVR4_TI__ACCEPT_OK;
1716 break;
1717
1718 case SVR4_TI_SENDTO_REQUEST:
1719 /*
1720 * XXX: dsl - I think this means that because we last did a
1721 * 'sendto' we'd better do a recvfrom now.
1722 */
1723 DPRINTF(("getmsg: TI_SENDTO_REQUEST\n"));
1724 if (ctl.maxlen > 36 && ctl.len < 36)
1725 ctl.len = 36;
1726 if (ctl.len > sizeof(sc))
1727 ctl.len = sizeof(sc);
1728
1729 if ((error = copyin(NETBSD32PTR(ctl.buf), &sc, ctl.len)) != 0)
1730 goto out;
1731
1732 msg.msg_name = NULL;
1733 msg.msg_namelen = 0;
1734 msg.msg_iov = &aiov;
1735 msg.msg_iovlen = 1;
1736 msg.msg_control = 0;
1737 aiov.iov_base = NETBSD32PTR(dat.buf);
1738 aiov.iov_len = dat.maxlen;
1739 msg.msg_flags = 0;
1740
1741 error = do_sys_recvmsg(l, SCARG(uap, fd), &msg, &name, NULL,
1742 retval);
1743
1744 if (error) {
1745 DPRINTF(("getmsg: do_sys_recvmsg failed %d\n", error));
1746 goto out;
1747 }
1748
1749 sc.cmd = SVR4_TI_RECVFROM_IND;
1750
1751 switch (st->s_family) {
1752 case AF_INET:
1753 sc.len = sizeof (struct sockaddr_in);
1754 sockaddr_to_netaddr_in(&sc, mtod(name, void *));
1755 break;
1756
1757 case AF_LOCAL:
1758 sc.len = sizeof (struct sockaddr_un) + 4;
1759 sockaddr_to_netaddr_un(&sc, mtod(name, void *));
1760 break;
1761
1762 default:
1763 m_free(name);
1764 error = ENOSYS;
1765 goto out;
1766 }
1767 m_free(name);
1768
1769 dat.len = *retval;
1770 fl = 0;
1771 st->s_cmd = sc.cmd;
1772 break;
1773
1774 default:
1775 st->s_cmd = sc.cmd;
1776 #ifdef notyet
1777 if (st->s_cmd == SVR4_TI_CONNECT_REQUEST) {
1778 struct sys_read_args ra;
1779
1780 /* More weirdness: Again, I can't find documentation
1781 * to back this up, but when a process does a generic
1782 * "getmsg()" call it seems that the command field is
1783 * zero and the length of the data area is zero. I
1784 * think processes expect getmsg() to fill in dat.len
1785 * after reading at most dat.maxlen octets from the
1786 * stream. Since we're using sockets I can let
1787 * read() look after it and frob return values
1788 * appropriately (or inappropriately :-)
1789 * -- newton@atdot.dotat.org XXX
1790 */
1791 SCARG(&ra, fd) = SCARG(uap, fd);
1792 SCARG(&ra, buf) = dat.buf;
1793 SCARG(&ra, nbyte) = dat.maxlen;
1794 if ((error = sys_read(p, &ra, retval)) != 0)
1795 goto out;
1796 dat.len = *retval;
1797 *retval = 0;
1798 st->s_cmd = SVR4_TI_SENDTO_REQUEST;
1799 break;
1800
1801 }
1802 #endif
1803 DPRINTF(("getmsg: Unknown state %x\n", st->s_cmd));
1804 error = EINVAL;
1805 goto out;
1806 }
1807
1808 if (SCARG_PTR(uap, ctl)) {
1809 if (ctl.len != -1)
1810 if ((error = copyout(&sc, NETBSD32PTR(ctl.buf),
1811 ctl.len)) != 0)
1812 goto out;
1813
1814 if ((error = copyout(&ctl, SCARG_PTR(uap, ctl),
1815 sizeof(ctl))) != 0)
1816 goto out;
1817 }
1818
1819 if (SCARG_PTR(uap, dat)) {
1820 if ((error = copyout(&dat, SCARG_PTR(uap, dat),
1821 sizeof(dat))) != 0)
1822 goto out;
1823 }
1824
1825 if (SCARG_PTR(uap, flags)) { /* XXX: Need translation */
1826 if ((error = copyout(&fl, SCARG_PTR(uap, flags),
1827 sizeof(fl))) != 0)
1828 goto out;
1829 }
1830
1831 *retval = 0;
1832
1833 #ifdef DEBUG_SVR4
1834 show_msg("<getmsg", SCARG(uap, fd), SCARG(uap, ctl),
1835 SCARG(uap, dat), fl);
1836 #endif /* DEBUG_SVR4 */
1837
1838 out:
1839 fd_putfile(SCARG(uap, fd));
1840 return error;
1841 }
NetBSD on the FriendlyARM MINI2440