2 * Copyright (c) 1998 Mark Newton. All rights reserved.
3 * Copyright (c) 1994, 1996 Christos Zoulas. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by Christos Zoulas.
16 * 4. The name of the author may not be used to endorse or promote products
17 * derived from this software without specific prior written permission.
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 * Pretend that we have streams...
35 * ToDo: The state machine for getmsg needs re-thinking
38 #include <sys/cdefs.h>
39 __FBSDID("$FreeBSD$");
41 #include "opt_compat.h"
42 #include "opt_ktrace.h"
44 #include <sys/param.h>
45 #include <sys/systm.h>
46 #include <sys/capability.h>
47 #include <sys/fcntl.h>
48 #include <sys/filedesc.h>
49 #include <sys/filio.h>
51 #include <sys/malloc.h>
52 #include <sys/file.h> /* Must come after sys/malloc.h */
54 #include <sys/mutex.h>
56 #include <sys/protosw.h>
57 #include <sys/signal.h>
58 #include <sys/signalvar.h>
59 #include <sys/socket.h>
60 #include <sys/socketvar.h>
62 #include <sys/syscallsubr.h>
63 #include <sys/sysproto.h>
65 #include <sys/ktrace.h> /* Must come after sys/uio.h */
68 #include <netinet/in.h>
70 #include <compat/svr4/svr4.h>
71 #include <compat/svr4/svr4_types.h>
72 #include <compat/svr4/svr4_util.h>
73 #include <compat/svr4/svr4_signal.h>
74 #include <compat/svr4/svr4_proto.h>
75 #include <compat/svr4/svr4_stropts.h>
76 #include <compat/svr4/svr4_timod.h>
77 #include <compat/svr4/svr4_sockmod.h>
78 #include <compat/svr4/svr4_ioctl.h>
79 #include <compat/svr4/svr4_socket.h>
82 static int clean_pipe(struct thread *, char *);
83 static void getparm(struct file *, struct svr4_si_sockparms *);
84 static int svr4_do_putmsg(struct thread *, struct svr4_sys_putmsg_args *,
86 static int svr4_do_getmsg(struct thread *, struct svr4_sys_getmsg_args *,
89 /* Address Conversions */
90 static void sockaddr_to_netaddr_in(struct svr4_strmcmd *,
91 const struct sockaddr_in *);
92 static void sockaddr_to_netaddr_un(struct svr4_strmcmd *,
93 const struct sockaddr_un *);
94 static void netaddr_to_sockaddr_in(struct sockaddr_in *,
95 const struct svr4_strmcmd *);
96 static void netaddr_to_sockaddr_un(struct sockaddr_un *,
97 const struct svr4_strmcmd *);
100 static int i_nread(struct file *, struct thread *, register_t *, int,
102 static int i_fdinsert(struct file *, struct thread *, register_t *, int,
104 static int i_str(struct file *, struct thread *, register_t *, int,
106 static int i_setsig(struct file *, struct thread *, register_t *, int,
108 static int i_getsig(struct file *, struct thread *, register_t *, int,
110 static int _i_bind_rsvd(struct file *, struct thread *, register_t *, int,
112 static int _i_rele_rsvd(struct file *, struct thread *, register_t *, int,
115 /* i_str sockmod calls */
116 static int sockmod(struct file *, int, struct svr4_strioctl *,
118 static int si_listen(struct file *, int, struct svr4_strioctl *,
120 static int si_ogetudata(struct file *, int, struct svr4_strioctl *,
122 static int si_sockparams(struct file *, int, struct svr4_strioctl *,
124 static int si_shutdown (struct file *, int, struct svr4_strioctl *,
126 static int si_getudata(struct file *, int, struct svr4_strioctl *,
129 /* i_str timod calls */
130 static int timod(struct file *, int, struct svr4_strioctl *, struct thread *);
131 static int ti_getinfo(struct file *, int, struct svr4_strioctl *,
133 static int ti_bind(struct file *, int, struct svr4_strioctl *, struct thread *);
136 static void bufprint(u_char *, size_t);
137 static int show_ioc(const char *, struct svr4_strioctl *);
138 static int show_strbuf(struct svr4_strbuf *);
139 static void show_msg(const char *, int, struct svr4_strbuf *,
140 struct svr4_strbuf *, int);
150 for (i = 0; i < len; i++) {
151 uprintf("%x ", buf[i]);
152 if (i && (i % 16) == 0)
160 struct svr4_strioctl *ioc;
171 ptr = (u_char *) malloc(len, M_TEMP, M_WAITOK);
172 if ((error = copyin(ioc->buf, ptr, len)) != 0) {
173 free((char *) ptr, M_TEMP);
178 uprintf("%s cmd = %ld, timeout = %d, len = %d, buf = %p { ",
179 str, ioc->cmd, ioc->timeout, ioc->len, ioc->buf);
187 free((char *) ptr, M_TEMP);
194 struct svr4_strbuf *str;
198 int maxlen = str->maxlen;
211 ptr = (u_char *) malloc(len, M_TEMP, M_WAITOK);
213 if ((error = copyin(str->buf, ptr, len)) != 0) {
214 free((char *) ptr, M_TEMP);
219 uprintf(", { %d, %d, %p=[ ", str->maxlen, str->len, str->buf);
227 free((char *) ptr, M_TEMP);
234 show_msg(str, fd, ctl, dat, flags)
237 struct svr4_strbuf *ctl;
238 struct svr4_strbuf *dat;
241 struct svr4_strbuf buf;
244 uprintf("%s(%d", str, fd);
246 if ((error = copyin(ctl, &buf, sizeof(buf))) != 0)
254 if ((error = copyin(dat, &buf, sizeof(buf))) != 0)
261 uprintf(", %x);\n", flags);
264 #endif /* DEBUG_SVR4 */
267 * We are faced with an interesting situation. On svr4 unix sockets
268 * are really pipes. But we really have sockets, and we might as
269 * well use them. At the point where svr4 calls TI_BIND, it has
270 * already created a named pipe for the socket using mknod(2).
271 * We need to create a socket with the same name when we bind,
272 * so we need to remove the pipe before, otherwise we'll get address
273 * already in use. So we *carefully* remove the pipe, to avoid
274 * using this as a random file removal tool. We use system calls
275 * to avoid code duplication.
285 error = kern_lstat(td, path, UIO_SYSSPACE, &st);
288 * Make sure we are dealing with a mode 0 named pipe.
290 if ((st.st_mode & S_IFMT) != S_IFIFO)
293 if ((st.st_mode & ALLPERMS) != 0)
296 error = kern_unlink(td, path, UIO_SYSSPACE);
298 DPRINTF(("clean_pipe: unlink failed %d\n", error));
304 sockaddr_to_netaddr_in(sc, sain)
305 struct svr4_strmcmd *sc;
306 const struct sockaddr_in *sain;
308 struct svr4_netaddr_in *na;
309 na = SVR4_ADDROF(sc);
311 na->family = sain->sin_family;
312 na->port = sain->sin_port;
313 na->addr = sain->sin_addr.s_addr;
314 DPRINTF(("sockaddr_in -> netaddr %d %d %lx\n", na->family, na->port,
320 sockaddr_to_netaddr_un(sc, saun)
321 struct svr4_strmcmd *sc;
322 const struct sockaddr_un *saun;
324 struct svr4_netaddr_un *na;
325 char *dst, *edst = ((char *) sc) + sc->offs + sizeof(na->family) + 1 -
329 na = SVR4_ADDROF(sc);
330 na->family = saun->sun_family;
331 for (src = saun->sun_path, dst = na->path; (*dst++ = *src++) != '\0'; )
334 DPRINTF(("sockaddr_un -> netaddr %d %s\n", na->family, na->path));
339 netaddr_to_sockaddr_in(sain, sc)
340 struct sockaddr_in *sain;
341 const struct svr4_strmcmd *sc;
343 const struct svr4_netaddr_in *na;
346 na = SVR4_C_ADDROF(sc);
347 memset(sain, 0, sizeof(*sain));
348 sain->sin_len = sizeof(*sain);
349 sain->sin_family = na->family;
350 sain->sin_port = na->port;
351 sain->sin_addr.s_addr = na->addr;
352 DPRINTF(("netaddr -> sockaddr_in %d %d %x\n", sain->sin_family,
353 sain->sin_port, sain->sin_addr.s_addr));
358 netaddr_to_sockaddr_un(saun, sc)
359 struct sockaddr_un *saun;
360 const struct svr4_strmcmd *sc;
362 const struct svr4_netaddr_un *na;
363 char *dst, *edst = &saun->sun_path[sizeof(saun->sun_path) - 1];
366 na = SVR4_C_ADDROF(sc);
367 memset(saun, 0, sizeof(*saun));
368 saun->sun_family = na->family;
369 for (src = na->path, dst = saun->sun_path; (*dst++ = *src++) != '\0'; )
372 saun->sun_len = dst - saun->sun_path;
373 DPRINTF(("netaddr -> sockaddr_un %d %s\n", saun->sun_family,
381 struct svr4_si_sockparms *pa;
383 struct svr4_strm *st;
386 st = svr4_stream_get(fp);
392 pa->family = st->s_family;
394 switch (so->so_type) {
396 pa->type = SVR4_T_CLTS;
397 pa->protocol = IPPROTO_UDP;
398 DPRINTF(("getparm(dgram)\n"));
402 pa->type = SVR4_T_COTS; /* What about T_COTS_ORD? XXX */
403 pa->protocol = IPPROTO_IP;
404 DPRINTF(("getparm(stream)\n"));
408 pa->type = SVR4_T_CLTS;
409 pa->protocol = IPPROTO_RAW;
410 DPRINTF(("getparm(raw)\n"));
416 DPRINTF(("getparm(type %d?)\n", so->so_type));
423 si_ogetudata(fp, fd, ioc, td)
426 struct svr4_strioctl *ioc;
430 struct svr4_si_oudata ud;
431 struct svr4_si_sockparms pa;
433 if (ioc->len != sizeof(ud) && ioc->len != sizeof(ud) - sizeof(int)) {
434 DPRINTF(("SI_OGETUDATA: Wrong size %d != %d\n",
435 sizeof(ud), ioc->len));
439 if ((error = copyin(ioc->buf, &ud, sizeof(ud))) != 0)
447 ud.addrsize = sizeof(struct svr4_sockaddr_in);
448 if (pa.type == SVR4_SOCK_STREAM)
461 DPRINTF(("SI_OGETUDATA: Unsupported address family %d\n",
466 /* I have no idea what these should be! */
470 ud.servtype = pa.type;
475 return copyout(&ud, ioc->buf, ioc->len);
480 si_sockparams(fp, fd, ioc, td)
483 struct svr4_strioctl *ioc;
486 struct svr4_si_sockparms pa;
489 return copyout(&pa, ioc->buf, sizeof(pa));
494 si_listen(fp, fd, ioc, td)
497 struct svr4_strioctl *ioc;
501 struct svr4_strm *st = svr4_stream_get(fp);
502 struct svr4_strmcmd lst;
503 struct listen_args la;
508 if (ioc->len < 0 || ioc->len > sizeof(lst))
511 if ((error = copyin(ioc->buf, &lst, ioc->len)) != 0)
514 if (lst.cmd != SVR4_TI_OLD_BIND_REQUEST) {
515 DPRINTF(("si_listen: bad request %ld\n", lst.cmd));
520 * We are making assumptions again...
523 DPRINTF(("SI_LISTEN: fileno %d backlog = %d\n", fd, 5));
526 if ((error = sys_listen(td, &la)) != 0) {
527 DPRINTF(("SI_LISTEN: listen failed %d\n", error));
531 st->s_cmd = SVR4_TI__ACCEPT_WAIT;
532 lst.cmd = SVR4_TI_BIND_REPLY;
534 switch (st->s_family) {
536 /* XXX: Fill the length here */
541 lst.pad[28] = 0x00000000; /* magic again */
542 lst.pad[29] = 0x00000800; /* magic again */
543 lst.pad[30] = 0x80001400; /* magic again */
547 DPRINTF(("SI_LISTEN: Unsupported address family %d\n",
553 if ((error = copyout(&lst, ioc->buf, ioc->len)) != 0)
561 si_getudata(fp, fd, ioc, td)
564 struct svr4_strioctl *ioc;
568 struct svr4_si_udata ud;
570 if (sizeof(ud) != ioc->len) {
571 DPRINTF(("SI_GETUDATA: Wrong size %d != %d\n",
572 sizeof(ud), ioc->len));
576 if ((error = copyin(ioc->buf, &ud, sizeof(ud))) != 0)
579 getparm(fp, &ud.sockparms);
581 switch (ud.sockparms.family) {
583 DPRINTF(("getudata_inet\n"));
586 ud.addrsize = sizeof(struct svr4_sockaddr_in);
587 if (ud.sockparms.type == SVR4_SOCK_STREAM)
595 DPRINTF(("getudata_local\n"));
604 DPRINTF(("SI_GETUDATA: Unsupported address family %d\n",
605 ud.sockparms.family));
610 ud.servtype = ud.sockparms.type;
611 DPRINTF(("ud.servtype = %d\n", ud.servtype));
615 return copyout(&ud, ioc->buf, sizeof(ud));
620 si_shutdown(fp, fd, ioc, td)
623 struct svr4_strioctl *ioc;
627 struct shutdown_args ap;
629 if (ioc->len != sizeof(ap.how)) {
630 DPRINTF(("SI_SHUTDOWN: Wrong size %d != %d\n",
631 sizeof(ap.how), ioc->len));
635 if ((error = copyin(ioc->buf, &ap.how, ioc->len)) != 0)
640 return sys_shutdown(td, &ap);
645 sockmod(fp, fd, ioc, td)
648 struct svr4_strioctl *ioc;
652 case SVR4_SI_OGETUDATA:
653 DPRINTF(("SI_OGETUDATA\n"));
654 return si_ogetudata(fp, fd, ioc, td);
656 case SVR4_SI_SHUTDOWN:
657 DPRINTF(("SI_SHUTDOWN\n"));
658 return si_shutdown(fp, fd, ioc, td);
661 DPRINTF(("SI_LISTEN\n"));
662 return si_listen(fp, fd, ioc, td);
664 case SVR4_SI_SETMYNAME:
665 DPRINTF(("SI_SETMYNAME\n"));
668 case SVR4_SI_SETPEERNAME:
669 DPRINTF(("SI_SETPEERNAME\n"));
672 case SVR4_SI_GETINTRANSIT:
673 DPRINTF(("SI_GETINTRANSIT\n"));
676 case SVR4_SI_TCL_LINK:
677 DPRINTF(("SI_TCL_LINK\n"));
680 case SVR4_SI_TCL_UNLINK:
681 DPRINTF(("SI_TCL_UNLINK\n"));
684 case SVR4_SI_SOCKPARAMS:
685 DPRINTF(("SI_SOCKPARAMS\n"));
686 return si_sockparams(fp, fd, ioc, td);
688 case SVR4_SI_GETUDATA:
689 DPRINTF(("SI_GETUDATA\n"));
690 return si_getudata(fp, fd, ioc, td);
693 DPRINTF(("Unknown sockmod ioctl %lx\n", ioc->cmd));
701 ti_getinfo(fp, fd, ioc, td)
704 struct svr4_strioctl *ioc;
708 struct svr4_infocmd info;
710 memset(&info, 0, sizeof(info));
712 if (ioc->len < 0 || ioc->len > sizeof(info))
715 if ((error = copyin(ioc->buf, &info, ioc->len)) != 0)
718 if (info.cmd != SVR4_TI_INFO_REQUEST)
721 info.cmd = SVR4_TI_INFO_REPLY;
733 ioc->len = sizeof(info);
734 if ((error = copyout(&info, ioc->buf, ioc->len)) != 0)
742 ti_bind(fp, fd, ioc, td)
745 struct svr4_strioctl *ioc;
749 struct svr4_strm *st = svr4_stream_get(fp);
750 struct sockaddr_in sain;
751 struct sockaddr_un saun;
752 struct sockaddr *skp;
754 struct svr4_strmcmd bnd;
757 DPRINTF(("ti_bind: bad file descriptor\n"));
761 if (ioc->len < 0 || ioc->len > sizeof(bnd))
764 if ((error = copyin(ioc->buf, &bnd, ioc->len)) != 0)
767 if (bnd.cmd != SVR4_TI_OLD_BIND_REQUEST) {
768 DPRINTF(("ti_bind: bad request %ld\n", bnd.cmd));
772 switch (st->s_family) {
774 skp = (struct sockaddr *)&sain;
775 sasize = sizeof(sain);
780 netaddr_to_sockaddr_in(&sain, &bnd);
782 DPRINTF(("TI_BIND: fam %d, port %d, addr %x\n",
783 sain.sin_family, sain.sin_port,
784 sain.sin_addr.s_addr));
788 skp = (struct sockaddr *)&saun;
789 sasize = sizeof(saun);
793 netaddr_to_sockaddr_un(&saun, &bnd);
795 if (saun.sun_path[0] == '\0')
798 DPRINTF(("TI_BIND: fam %d, path %s\n",
799 saun.sun_family, saun.sun_path));
801 if ((error = clean_pipe(td, saun.sun_path)) != 0)
804 bnd.pad[28] = 0x00001000; /* magic again */
808 DPRINTF(("TI_BIND: Unsupported address family %d\n",
813 DPRINTF(("TI_BIND: fileno %d\n", fd));
815 if ((error = kern_bind(td, fd, skp)) != 0) {
816 DPRINTF(("TI_BIND: bind failed %d\n", error));
822 memset(&bnd, 0, sizeof(bnd));
823 bnd.len = sasize + 4;
824 bnd.offs = 0x10; /* XXX */
827 bnd.cmd = SVR4_TI_BIND_REPLY;
829 if ((error = copyout(&bnd, ioc->buf, ioc->len)) != 0)
837 timod(fp, fd, ioc, td)
840 struct svr4_strioctl *ioc;
844 case SVR4_TI_GETINFO:
845 DPRINTF(("TI_GETINFO\n"));
846 return ti_getinfo(fp, fd, ioc, td);
848 case SVR4_TI_OPTMGMT:
849 DPRINTF(("TI_OPTMGMT\n"));
853 DPRINTF(("TI_BIND\n"));
854 return ti_bind(fp, fd, ioc, td);
857 DPRINTF(("TI_UNBIND\n"));
861 DPRINTF(("Unknown timod ioctl %lx\n", ioc->cmd));
868 svr4_stream_ti_ioctl(fp, td, retval, fd, cmd, dat)
876 struct svr4_strbuf skb, *sub = (struct svr4_strbuf *) dat;
877 struct svr4_strm *st = svr4_stream_get(fp);
880 socklen_t sasize, oldsasize;
881 struct svr4_strmcmd sc;
883 DPRINTF(("svr4_stream_ti_ioctl\n"));
890 if ((error = copyin(sub, &skb, sizeof(skb))) != 0) {
891 DPRINTF(("ti_ioctl: error copying in strbuf\n"));
895 switch (st->s_family) {
897 sasize = sizeof(struct sockaddr_in);
901 sasize = sizeof(struct sockaddr_un);
905 DPRINTF(("ti_ioctl: Unsupported address family %d\n",
912 case SVR4_TI_GETMYNAME:
913 DPRINTF(("TI_GETMYNAME\n"));
915 error = kern_getsockname(td, fd, &sa, &sasize);
917 DPRINTF(("ti_ioctl: getsockname error\n"));
923 case SVR4_TI_GETPEERNAME:
924 DPRINTF(("TI_GETPEERNAME\n"));
926 error = kern_getpeername(td, fd, &sa, &sasize);
928 DPRINTF(("ti_ioctl: getpeername error\n"));
934 case SVR4_TI_SETMYNAME:
935 DPRINTF(("TI_SETMYNAME\n"));
938 case SVR4_TI_SETPEERNAME:
939 DPRINTF(("TI_SETPEERNAME\n"));
942 DPRINTF(("ti_ioctl: Unknown ioctl %lx\n", cmd));
946 if (sasize < 0 || sasize > oldsasize) {
951 switch (st->s_family) {
953 sockaddr_to_netaddr_in(&sc, (struct sockaddr_in *)sa);
958 sockaddr_to_netaddr_un(&sc, (struct sockaddr_un *)sa);
959 skb.len = sasize + 4;
968 if ((error = copyout(SVR4_ADDROF(&sc), skb.buf, sasize)) != 0) {
969 DPRINTF(("ti_ioctl: error copying out socket data\n"));
974 if ((error = copyout(&skb, sub, sizeof(skb))) != 0) {
975 DPRINTF(("ti_ioctl: error copying out strbuf\n"));
986 i_nread(fp, td, retval, fd, cmd, dat)
998 * We are supposed to return the message length in nread, and the
999 * number of messages in retval. We don't have the notion of number
1000 * of stream messages, so we just find out if we have any bytes waiting
1001 * for us, and if we do, then we assume that we have at least one
1002 * message waiting for us.
1004 if ((error = fo_ioctl(fp, FIONREAD, (caddr_t) &nread, td->td_ucred,
1013 return copyout(&nread, dat, sizeof(nread));
1017 i_fdinsert(fp, td, retval, fd, cmd, dat)
1026 * Major hack again here. We assume that we are using this to
1027 * implement accept(2). If that is the case, we have already
1028 * called accept, and we have stored the file descriptor in
1029 * afd. We find the file descriptor that the code wants to use
1030 * in fd insert, and then we dup2() our accepted file descriptor
1034 struct svr4_strm *st = svr4_stream_get(fp);
1035 struct svr4_strfdinsert fdi;
1036 struct dup2_args d2p;
1039 DPRINTF(("fdinsert: bad file type\n"));
1044 if (st->s_afd == -1) {
1045 DPRINTF(("fdinsert: accept fd not found\n"));
1050 if ((error = copyin(dat, &fdi, sizeof(fdi))) != 0) {
1051 DPRINTF(("fdinsert: copyin failed %d\n", error));
1056 d2p.from = st->s_afd;
1059 if ((error = sys_dup2(td, &d2p)) != 0) {
1060 DPRINTF(("fdinsert: dup2(%d, %d) failed %d\n",
1061 st->s_afd, fdi.fd, error));
1066 if ((error = kern_close(td, st->s_afd)) != 0) {
1067 DPRINTF(("fdinsert: close(%d) failed %d\n",
1082 _i_bind_rsvd(fp, td, retval, fd, cmd, dat)
1090 struct mkfifo_args ap;
1093 * This is a supposed to be a kernel and library only ioctl.
1094 * It gets called before ti_bind, when we have a unix
1095 * socket, to physically create the socket transport and
1096 * ``reserve'' it. I don't know how this get reserved inside
1097 * the kernel, but we are going to create it nevertheless.
1102 return sys_mkfifo(td, &ap);
1106 _i_rele_rsvd(fp, td, retval, fd, cmd, dat)
1114 struct unlink_args ap;
1117 * This is a supposed to be a kernel and library only ioctl.
1118 * I guess it is supposed to release the socket.
1122 return sys_unlink(td, &ap);
1126 i_str(fp, td, retval, fd, cmd, dat)
1135 struct svr4_strioctl ioc;
1137 if ((error = copyin(dat, &ioc, sizeof(ioc))) != 0)
1141 if ((error = show_ioc(">", &ioc)) != 0)
1143 #endif /* DEBUG_SVR4 */
1145 switch (ioc.cmd & 0xff00) {
1147 if ((error = sockmod(fp, fd, &ioc, td)) != 0)
1152 if ((error = timod(fp, fd, &ioc, td)) != 0)
1157 DPRINTF(("Unimplemented module %c %ld\n",
1158 (char) (cmd >> 8), cmd & 0xff));
1163 if ((error = show_ioc("<", &ioc)) != 0)
1165 #endif /* DEBUG_SVR4 */
1166 return copyout(&ioc, dat, sizeof(ioc));
1170 i_setsig(fp, td, retval, fd, cmd, dat)
1179 * This is the best we can do for now; we cannot generate
1180 * signals only for specific events so the signal mask gets
1181 * ignored; we save it just to pass it to a possible I_GETSIG...
1183 * We alse have to fix the O_ASYNC fcntl bit, so the
1184 * process will get SIGPOLLs.
1187 register_t oflags, flags;
1188 struct svr4_strm *st = svr4_stream_get(fp);
1191 DPRINTF(("i_setsig: bad file descriptor\n"));
1194 /* get old status flags */
1195 error = kern_fcntl(td, fd, F_GETFL, 0);
1199 oflags = td->td_retval[0];
1201 /* update the flags */
1206 flags = oflags | O_ASYNC;
1207 if ((error = copyin(dat, &mask, sizeof(mask))) != 0) {
1208 DPRINTF(("i_setsig: bad eventmask pointer\n"));
1211 if (mask & SVR4_S_ALLMASK) {
1212 DPRINTF(("i_setsig: bad eventmask data %x\n", mask));
1215 st->s_eventmask = mask;
1218 flags = oflags & ~O_ASYNC;
1219 st->s_eventmask = 0;
1223 /* set the new flags, if changed */
1224 if (flags != oflags) {
1225 error = kern_fcntl(td, fd, F_SETFL, flags);
1228 flags = td->td_retval[0];
1231 /* set up SIGIO receiver if needed */
1233 return (kern_fcntl(td, fd, F_SETOWN, td->td_proc->p_pid));
1238 i_getsig(fp, td, retval, fd, cmd, dat)
1246 int error, eventmask;
1249 struct svr4_strm *st = svr4_stream_get(fp);
1252 DPRINTF(("i_getsig: bad file descriptor\n"));
1256 eventmask = st->s_eventmask;
1258 if ((error = copyout(&eventmask, dat,
1259 sizeof(eventmask))) != 0) {
1260 DPRINTF(("i_getsig: bad eventmask pointer\n"));
1268 svr4_stream_ioctl(fp, td, retval, fd, cmd, dat)
1279 * All the following stuff assumes "sockmod" is pushed...
1283 DPRINTF(("I_NREAD\n"));
1284 return i_nread(fp, td, retval, fd, cmd, dat);
1287 DPRINTF(("I_PUSH %p\n", dat));
1288 #if defined(DEBUG_SVR4)
1289 show_strbuf((struct svr4_strbuf *)dat);
1294 DPRINTF(("I_POP\n"));
1298 DPRINTF(("I_LOOK\n"));
1302 DPRINTF(("I_FLUSH\n"));
1306 DPRINTF(("I_SRDOPT\n"));
1310 DPRINTF(("I_GRDOPT\n"));
1314 DPRINTF(("I_STR\n"));
1315 return i_str(fp, td, retval, fd, cmd, dat);
1318 DPRINTF(("I_SETSIG\n"));
1319 return i_setsig(fp, td, retval, fd, cmd, dat);
1322 DPRINTF(("I_GETSIG\n"));
1323 return i_getsig(fp, td, retval, fd, cmd, dat);
1326 DPRINTF(("I_FIND\n"));
1328 * Here we are not pushing modules really, we just
1329 * pretend all are present
1335 DPRINTF(("I_LINK\n"));
1339 DPRINTF(("I_UNLINK\n"));
1342 case SVR4_I_ERECVFD:
1343 DPRINTF(("I_ERECVFD\n"));
1347 DPRINTF(("I_PEEK\n"));
1350 case SVR4_I_FDINSERT:
1351 DPRINTF(("I_FDINSERT\n"));
1352 return i_fdinsert(fp, td, retval, fd, cmd, dat);
1355 DPRINTF(("I_SENDFD\n"));
1359 DPRINTF(("I_RECVFD\n"));
1363 DPRINTF(("I_SWROPT\n"));
1367 DPRINTF(("I_GWROPT\n"));
1371 DPRINTF(("I_LIST\n"));
1375 DPRINTF(("I_PLINK\n"));
1378 case SVR4_I_PUNLINK:
1379 DPRINTF(("I_PUNLINK\n"));
1383 DPRINTF(("I_SETEV\n"));
1387 DPRINTF(("I_GETEV\n"));
1391 DPRINTF(("I_STREV\n"));
1394 case SVR4_I_UNSTREV:
1395 DPRINTF(("I_UNSTREV\n"));
1398 case SVR4_I_FLUSHBAND:
1399 DPRINTF(("I_FLUSHBAND\n"));
1403 DPRINTF(("I_CKBAND\n"));
1406 case SVR4_I_GETBAND:
1407 DPRINTF(("I_GETBANK\n"));
1411 DPRINTF(("I_ATMARK\n"));
1414 case SVR4_I_SETCLTIME:
1415 DPRINTF(("I_SETCLTIME\n"));
1418 case SVR4_I_GETCLTIME:
1419 DPRINTF(("I_GETCLTIME\n"));
1423 DPRINTF(("I_CANPUT\n"));
1426 case SVR4__I_BIND_RSVD:
1427 DPRINTF(("_I_BIND_RSVD\n"));
1428 return _i_bind_rsvd(fp, td, retval, fd, cmd, dat);
1430 case SVR4__I_RELE_RSVD:
1431 DPRINTF(("_I_RELE_RSVD\n"));
1432 return _i_rele_rsvd(fp, td, retval, fd, cmd, dat);
1435 DPRINTF(("unimpl cmd = %lx\n", cmd));
1445 svr4_sys_putmsg(td, uap)
1447 struct svr4_sys_putmsg_args *uap;
1452 if ((error = fget(td, uap->fd, CAP_WRITE, &fp)) != 0) {
1454 uprintf("putmsg: bad fp\n");
1458 error = svr4_do_putmsg(td, uap, fp);
1464 svr4_do_putmsg(td, uap, fp)
1466 struct svr4_sys_putmsg_args *uap;
1469 struct svr4_strbuf dat, ctl;
1470 struct svr4_strmcmd sc;
1471 struct sockaddr_in sain;
1472 struct sockaddr_un saun;
1473 struct sockaddr *sa;
1474 int sasize, *retval;
1475 struct svr4_strm *st;
1478 retval = td->td_retval;
1481 show_msg(">putmsg", uap->fd, uap->ctl,
1482 uap->dat, uap->flags);
1483 #endif /* DEBUG_SVR4 */
1485 if (uap->ctl != NULL) {
1486 if ((error = copyin(uap->ctl, &ctl, sizeof(ctl))) != 0) {
1488 uprintf("putmsg: copyin(): %d\n", error);
1496 if (uap->dat != NULL) {
1497 if ((error = copyin(uap->dat, &dat, sizeof(dat))) != 0) {
1499 uprintf("putmsg: copyin(): %d (2)\n", error);
1508 * Only for sockets for now.
1510 if ((st = svr4_stream_get(fp)) == NULL) {
1511 DPRINTF(("putmsg: bad file type\n"));
1515 if (ctl.len < 0 || ctl.len > sizeof(sc)) {
1516 DPRINTF(("putmsg: Bad control size %d != %d\n", ctl.len,
1517 sizeof(struct svr4_strmcmd)));
1521 if ((error = copyin(ctl.buf, &sc, ctl.len)) != 0)
1524 switch (st->s_family) {
1526 if (sc.len != sizeof(sain)) {
1527 if (sc.cmd == SVR4_TI_DATA_REQUEST) {
1528 struct write_args wa;
1530 /* Solaris seems to use sc.cmd = 3 to
1531 * send "expedited" data. telnet uses
1532 * this for options processing, sending EOF,
1533 * etc. I'm sure other things use it too.
1534 * I don't have any documentation
1535 * on it, so I'm making a guess that this
1536 * is how it works. newton@atdot.dotat.org XXX
1538 DPRINTF(("sending expedited data ??\n"));
1542 return sys_write(td, &wa);
1544 DPRINTF(("putmsg: Invalid inet length %ld\n", sc.len));
1547 netaddr_to_sockaddr_in(&sain, &sc);
1548 sa = (struct sockaddr *)&sain;
1549 sasize = sizeof(sain);
1550 if (sain.sin_family != st->s_family)
1556 /* We are doing an accept; succeed */
1557 DPRINTF(("putmsg: Do nothing\n"));
1562 /* Maybe we've been given a device/inode pair */
1563 dev_t *dev = SVR4_ADDROF(&sc);
1564 ino_t *ino = (ino_t *) &dev[1];
1565 if (svr4_find_socket(td, fp, *dev, *ino, &saun) != 0) {
1566 /* I guess we have it by name */
1567 netaddr_to_sockaddr_un(&saun, &sc);
1569 sa = (struct sockaddr *)&saun;
1570 sasize = sizeof(saun);
1575 DPRINTF(("putmsg: Unsupported address family %d\n",
1584 case SVR4_TI_CONNECT_REQUEST: /* connect */
1587 return (kern_connect(td, uap->fd, sa));
1590 case SVR4_TI_SENDTO_REQUEST: /* sendto */
1596 msg.msg_namelen = sasize;
1597 msg.msg_iov = &aiov;
1599 msg.msg_control = 0;
1601 aiov.iov_base = dat.buf;
1602 aiov.iov_len = dat.len;
1603 error = kern_sendit(td, uap->fd, &msg, uap->flags,
1604 NULL, UIO_USERSPACE);
1605 DPRINTF(("sendto_request error: %d\n", error));
1611 DPRINTF(("putmsg: Unimplemented command %lx\n", sc.cmd));
1617 svr4_sys_getmsg(td, uap)
1619 struct svr4_sys_getmsg_args *uap;
1624 if ((error = fget(td, uap->fd, CAP_READ, &fp)) != 0) {
1626 uprintf("getmsg: bad fp\n");
1630 error = svr4_do_getmsg(td, uap, fp);
1636 svr4_do_getmsg(td, uap, fp)
1638 struct svr4_sys_getmsg_args *uap;
1641 struct svr4_strbuf dat, ctl;
1642 struct svr4_strmcmd sc;
1646 struct sockaddr_in sain;
1647 struct sockaddr_un saun;
1648 struct sockaddr *sa;
1650 struct svr4_strm *st;
1654 retval = td->td_retval;
1658 memset(&sc, 0, sizeof(sc));
1661 show_msg(">getmsg", uap->fd, uap->ctl,
1663 #endif /* DEBUG_SVR4 */
1665 if (uap->ctl != NULL) {
1666 if ((error = copyin(uap->ctl, &ctl, sizeof(ctl))) != 0)
1676 if (uap->dat != NULL) {
1677 if ((error = copyin(uap->dat, &dat, sizeof(dat))) != 0)
1686 * Only for sockets for now.
1688 if ((st = svr4_stream_get(fp)) == NULL) {
1689 DPRINTF(("getmsg: bad file type\n"));
1693 if (ctl.maxlen == -1 || dat.maxlen == -1) {
1694 DPRINTF(("getmsg: Cannot handle -1 maxlen (yet)\n"));
1698 switch (st->s_family) {
1700 sasize = sizeof(sain);
1704 sasize = sizeof(saun);
1708 DPRINTF(("getmsg: Unsupported address family %d\n",
1714 switch (st->s_cmd) {
1715 case SVR4_TI_CONNECT_REQUEST:
1716 DPRINTF(("getmsg: TI_CONNECT_REQUEST\n"));
1718 * We do the connect in one step, so the putmsg should
1719 * have gotten the error.
1721 sc.cmd = SVR4_TI_OK_REPLY;
1730 case SVR4_TI_OK_REPLY:
1731 DPRINTF(("getmsg: TI_OK_REPLY\n"));
1733 * We are immediately after a connect reply, so we send
1734 * a connect verification.
1737 error = kern_getpeername(td, uap->fd, &sa, &sasize);
1740 DPRINTF(("getmsg: getpeername failed %d\n", error));
1744 sc.cmd = SVR4_TI_CONNECT_REPLY;
1748 sc.pad[2] = 0x04000402;
1750 switch (st->s_family) {
1753 sockaddr_to_netaddr_in(&sc, (struct sockaddr_in *)sa);
1757 sc.len = sasize + 4;
1758 sockaddr_to_netaddr_un(&sc, (struct sockaddr_un *)sa);
1774 case SVR4_TI__ACCEPT_OK:
1775 DPRINTF(("getmsg: TI__ACCEPT_OK\n"));
1777 * We do the connect in one step, so the putmsg should
1778 * have gotten the error.
1780 sc.cmd = SVR4_TI_OK_REPLY;
1786 st->s_cmd = SVR4_TI__ACCEPT_WAIT;
1789 case SVR4_TI__ACCEPT_WAIT:
1790 DPRINTF(("getmsg: TI__ACCEPT_WAIT\n"));
1792 * We are after a listen, so we try to accept...
1795 error = kern_accept(td, uap->fd, &sa, &sasize, &afp);
1798 DPRINTF(("getmsg: accept failed %d\n", error));
1802 st->s_afd = *retval;
1804 DPRINTF(("getmsg: Accept fd = %d\n", st->s_afd));
1806 sc.cmd = SVR4_TI_ACCEPT_REPLY;
1810 switch (st->s_family) {
1813 sockaddr_to_netaddr_in(&sc, (struct sockaddr_in *)&sa);
1819 sc.pad[1] = 0x00010000;
1820 sc.pad[2] = 0xf6bcdaa0; /* I don't know what that is */
1821 sc.pad[3] = 0x00010000;
1823 sc.len = sasize + 4;
1827 fdclose(td->td_proc->p_fd, afp, st->s_afd, td);
1838 st->s_cmd = SVR4_TI__ACCEPT_OK;
1841 case SVR4_TI_SENDTO_REQUEST:
1842 DPRINTF(("getmsg: TI_SENDTO_REQUEST\n"));
1843 if (ctl.maxlen > 36 && ctl.len < 36)
1846 if (ctl.len > sizeof(sc))
1847 ctl.len = sizeof(sc);
1849 if ((error = copyin(ctl.buf, &sc, ctl.len)) != 0) {
1854 switch (st->s_family) {
1856 sa = (struct sockaddr *)&sain;
1857 sockaddr_to_netaddr_in(&sc, &sain);
1861 sa = (struct sockaddr *)&saun;
1862 sockaddr_to_netaddr_un(&sc, &saun);
1871 msg.msg_namelen = sasize;
1872 msg.msg_iov = &aiov;
1874 msg.msg_control = 0;
1875 aiov.iov_base = dat.buf;
1876 aiov.iov_len = dat.maxlen;
1879 error = kern_recvit(td, uap->fd, &msg, UIO_SYSSPACE, NULL);
1883 DPRINTF(("getmsg: recvit failed %d\n", error));
1887 sc.cmd = SVR4_TI_RECVFROM_IND;
1889 switch (st->s_family) {
1892 sockaddr_to_netaddr_in(&sc, &sain);
1896 sc.len = sasize + 4;
1897 sockaddr_to_netaddr_un(&sc, &saun);
1912 if (st->s_cmd == SVR4_TI_CONNECT_REQUEST) {
1913 struct read_args ra;
1915 /* More weirdness: Again, I can't find documentation
1916 * to back this up, but when a process does a generic
1917 * "getmsg()" call it seems that the command field is
1918 * zero and the length of the data area is zero. I
1919 * think processes expect getmsg() to fill in dat.len
1920 * after reading at most dat.maxlen octets from the
1921 * stream. Since we're using sockets I can let
1922 * read() look after it and frob return values
1923 * appropriately (or inappropriately :-)
1924 * -- newton@atdot.dotat.org XXX
1928 ra.nbyte = dat.maxlen;
1929 if ((error = sys_read(td, &ra)) != 0) {
1935 st->s_cmd = SVR4_TI_SENDTO_REQUEST;
1939 DPRINTF(("getmsg: Unknown state %x\n", st->s_cmd));
1944 if (ctl.len > sizeof(sc))
1945 ctl.len = sizeof(sc);
1947 error = copyout(&sc, ctl.buf, ctl.len);
1950 error = copyout(&ctl, uap->ctl, sizeof(ctl));
1955 error = copyout(&dat, uap->dat, sizeof(dat));
1958 if (uap->flags) { /* XXX: Need translation */
1960 error = copyout(&fl, uap->flags, sizeof(fl));
1965 fdclose(td->td_proc->p_fd, afp, st->s_afd, td);
1979 show_msg("<getmsg", uap->fd, uap->ctl,
1981 #endif /* DEBUG_SVR4 */
1985 int svr4_sys_send(td, uap)
1987 struct svr4_sys_send_args *uap;
1989 struct sendto_args sta;
1994 sta.flags = uap->flags;
1998 return (sys_sendto(td, &sta));
2001 int svr4_sys_recv(td, uap)
2003 struct svr4_sys_recv_args *uap;
2005 struct recvfrom_args rfa;
2010 rfa.flags = uap->flags;
2012 rfa.fromlenaddr = NULL;
2014 return (sys_recvfrom(td, &rfa));
2018 * XXX This isn't necessary, but it's handy for inserting debug code into
2019 * sendto(). Let's leave it here for now...
2022 svr4_sys_sendto(td, uap)
2024 struct svr4_sys_sendto_args *uap;
2026 struct sendto_args sa;
2031 sa.flags = uap->flags;
2032 sa.to = (caddr_t)uap->to;
2033 sa.tolen = uap->tolen;
2035 DPRINTF(("calling sendto()\n"));
2036 return sys_sendto(td, &sa);