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