sys/emulation/svr4/svr4_stream.c

   1 /*
   2  * Copyright (c) 1998 Mark Newton.  All rights reserved.
   3  * Copyright (c) 1994, 1996 Christos Zoulas.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   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.
  18  *
  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.
  29  *
  30  * $FreeBSD: src/sys/svr4/svr4_stream.c,v 1.12.2.2 2000/11/26 04:42:27 dillon Exp $
  31  * $DragonFly: src/sys/emulation/svr4/Attic/svr4_stream.c,v 1.10 2003/10/08 01:30:32 daver Exp $
  32  */
  33
  34 /*
  35  * Pretend that we have streams...
  36  * Yes, this is gross.
  37  *
  38  * ToDo: The state machine for getmsg needs re-thinking
  39  */
  40
  41 #define COMPAT_43 1
  42
  43 #include <sys/param.h>
  44 #include <sys/systm.h>
  45 #include <sys/buf.h>
  46 #include <sys/malloc.h>
  47 #include <sys/file.h>
  48 #include <sys/filedesc.h>
  49 #include <sys/fcntl.h>
  50 #include <sys/filio.h>
  51 #include <sys/select.h>
  52 #include <sys/socket.h>
  53 #include <sys/socketvar.h>
  54 #include <sys/un.h>
  55 #include <netinet/in.h>
  56 #include <sys/mbuf.h>
  57 #include <sys/protosw.h>
  58 #include <sys/signal.h>
  59 #include <sys/signalvar.h>
  60 #include <sys/uio.h>
  61 #include <sys/ktrace.h>
  62 #include <sys/proc.h>
  63 #include <sys/stat.h>
  64 #include <sys/file2.h>
  65
  66 #include <sys/sysproto.h>
  67
  68 #include "svr4.h"
  69 #include "svr4_types.h"
  70 #include "svr4_util.h"
  71 #include "svr4_signal.h"
  72 #include "svr4_proto.h"
  73 #include "svr4_stropts.h"
  74 #include "svr4_timod.h"
  75 #include "svr4_sockmod.h"
  76 #include "svr4_ioctl.h"
  77 #include "svr4_socket.h"
  78
  79 /* Utils */
  80 static int clean_pipe (const char *);
  81 static void getparm (struct file *, struct svr4_si_sockparms *);
  82
  83 /* Address Conversions */
  84 static void sockaddr_to_netaddr_in (struct svr4_strmcmd *,
  85                                         const struct sockaddr_in *);
  86 static void sockaddr_to_netaddr_un (struct svr4_strmcmd *,
  87                                         const struct sockaddr_un *);
  88 static void netaddr_to_sockaddr_in (struct sockaddr_in *,
  89                                         const struct svr4_strmcmd *);
  90 static void netaddr_to_sockaddr_un (struct sockaddr_un *,
  91                                         const struct svr4_strmcmd *);
  92
  93 /* stream ioctls */
  94 static int i_nread (struct file *, struct thread *, register_t *, int,
  95                         u_long, caddr_t);
  96 static int i_fdinsert (struct file *, struct thread *, register_t *, int,
  97                            u_long, caddr_t);
  98 static int i_str   (struct file *, struct thread *, register_t *, int,
  99                         u_long, caddr_t);
 100 static int i_setsig   (struct file *, struct thread *, register_t *, int,
 101                         u_long, caddr_t);
 102 static int i_getsig   (struct file *, struct thread *, register_t *, int,
 103                         u_long, caddr_t);
 104 static int _i_bind_rsvd (struct file *, struct thread *, register_t *, int,
 105                              u_long, caddr_t);
 106 static int _i_rele_rsvd (struct file *, struct thread *, register_t *, int,
 107                              u_long, caddr_t);
 108
 109 /* i_str sockmod calls */
 110 static int sockmod       (struct file *, int, struct svr4_strioctl *,
 111                               struct thread *);
 112 static int si_listen     (struct file *, int, struct svr4_strioctl *,
 113                               struct thread *);
 114 static int si_ogetudata  (struct file *, int, struct svr4_strioctl *,
 115                               struct thread *);
 116 static int si_sockparams (struct file *, int, struct svr4_strioctl *,
 117                               struct thread *);
 118 static int si_shutdown   (struct file *, int, struct svr4_strioctl *,
 119                               struct thread *);
 120 static int si_getudata   (struct file *, int, struct svr4_strioctl *,
 121                               struct thread *);
 122
 123 /* i_str timod calls */
 124 static int timod         (struct file *, int, struct svr4_strioctl *,
 125                               struct thread *);
 126 static int ti_getinfo    (struct file *, int, struct svr4_strioctl *,
 127                               struct thread *);
 128 static int ti_bind       (struct file *, int, struct svr4_strioctl *,
 129                               struct thread *);
 130
 131 /* infrastructure */
 132 static int svr4_sendit (struct thread *td, int s, struct msghdr *mp,
 133                             int flags, int *retval);
 134
 135 static int svr4_recvit (struct thread *td, int s, struct msghdr *mp,
 136                             caddr_t namelenp, int *retval);
 137
 138 /* <sigh>  Ok, so we shouldn't use sendit() in uipc_syscalls.c because
 139  * it isn't part of a "public" interface;  We're supposed to use
 140  * pru_sosend instead.  Same goes for recvit()/pru_soreceive() for
 141  * that matter.  Solution:  Suck sendit()/recvit() into here where we
 142  * can do what we like.
 143  *
 144  * I hate code duplication.
 145  *
 146  * I will take out all the #ifdef COMPAT_OLDSOCK gumph, though.
 147  */
 148 static int
 149 svr4_sendit(td, s, mp, flags, retval)
 150         struct thread *td;
 151         int s;
 152         struct msghdr *mp;
 153         int flags;
 154         int *retval;
 155 {
 156         struct proc *p;
 157         struct file *fp;
 158         struct uio auio;
 159         struct iovec *iov;
 160         int i;
 161         struct mbuf *control;
 162         struct sockaddr *to;
 163         int len, error;
 164         struct socket *so;
 165 #ifdef KTRACE
 166         struct iovec *ktriov = NULL;
 167         struct uio ktruio;
 168 #endif
 169
 170         p = td->td_proc;
 171         KKASSERT(p);
 172
 173         error = holdsock(p->p_fd, s, &fp);
 174         if (error)
 175                 return (error);
 176         auio.uio_iov = mp->msg_iov;
 177         auio.uio_iovcnt = mp->msg_iovlen;
 178         auio.uio_segflg = UIO_USERSPACE;
 179         auio.uio_rw = UIO_WRITE;
 180         auio.uio_td = td;
 181         auio.uio_offset = 0;                    /* XXX */
 182         auio.uio_resid = 0;
 183         iov = mp->msg_iov;
 184         for (i = 0; i < mp->msg_iovlen; i++, iov++) {
 185                 if ((auio.uio_resid += iov->iov_len) < 0) {
 186                         fdrop(fp, td);
 187                         return (EINVAL);
 188                 }
 189         }
 190         if (mp->msg_name) {
 191                 error = getsockaddr(&to, mp->msg_name, mp->msg_namelen);
 192                 if (error) {
 193                         fdrop(fp, td);
 194                         return (error);
 195                 }
 196         } else {
 197                 to = 0;
 198         }
 199         if (mp->msg_control) {
 200                 if (mp->msg_controllen < sizeof(struct cmsghdr)) {
 201                         error = EINVAL;
 202                         goto bad;
 203                 }
 204                 control = m_get(M_WAIT, MT_CONTROL);
 205                 if (control == NULL) {
 206                         error = ENOBUFS;
 207                         goto bad;
 208                 }
 209                 control->m_len = mp->msg_controllen;
 210                 error = copyin(mp->msg_control, mtod(control, caddr_t),
 211                     mp->msg_controllen);
 212                 if (error) {
 213                         m_free(control);
 214                         goto bad;
 215                 }
 216         } else {
 217                 control = 0;
 218         }
 219 #ifdef KTRACE
 220         if (KTRPOINT(p->p_thread, KTR_GENIO)) {
 221                 int iovlen = auio.uio_iovcnt * sizeof (struct iovec);
 222
 223                 MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
 224                 bcopy((caddr_t)auio.uio_iov, (caddr_t)ktriov, iovlen);
 225                 ktruio = auio;
 226         }
 227 #endif
 228         len = auio.uio_resid;
 229         so = (struct socket *)fp->f_data;
 230         error = so->so_proto->pr_usrreqs->pru_sosend
 231                     (so, to, &auio, 0, control, flags, td);
 232         if (error) {
 233                 if (auio.uio_resid != len && (error == ERESTART ||
 234                     error == EINTR || error == EWOULDBLOCK))
 235                         error = 0;
 236                 if (error == EPIPE)
 237                         psignal(p, SIGPIPE);
 238         }
 239         if (error == 0)
 240                 *retval = len - auio.uio_resid;
 241 #ifdef KTRACE
 242         if (ktriov != NULL) {
 243                 if (error == 0) {
 244                         ktruio.uio_iov = ktriov;
 245                         ktruio.uio_resid = *retval;
 246                         ktrgenio(p->p_tracep, s, UIO_WRITE, &ktruio, error);
 247                 }
 248                 FREE(ktriov, M_TEMP);
 249         }
 250 #endif
 251 bad:
 252         fdrop(fp, td);
 253         if (to)
 254                 FREE(to, M_SONAME);
 255         return (error);
 256 }
 257
 258 static int
 259 svr4_recvit(td, s, mp, namelenp, retval)
 260         struct thread *td;
 261         int s;
 262         struct msghdr *mp;
 263         caddr_t namelenp;
 264         int *retval;
 265 {
 266         struct proc *p = td->td_proc;
 267         struct file *fp;
 268         struct uio auio;
 269         struct iovec *iov;
 270         int i;
 271         int len, error;
 272         struct mbuf *m, *control = 0;
 273         caddr_t ctlbuf;
 274         struct socket *so;
 275         struct sockaddr *fromsa = 0;
 276 #ifdef KTRACE
 277         struct iovec *ktriov = NULL;
 278         struct uio ktruio;
 279 #endif
 280         p = td->td_proc;
 281         KKASSERT(p);
 282
 283         error = holdsock(p->p_fd, s, &fp);
 284         if (error)
 285                 return (error);
 286         auio.uio_iov = mp->msg_iov;
 287         auio.uio_iovcnt = mp->msg_iovlen;
 288         auio.uio_segflg = UIO_USERSPACE;
 289         auio.uio_rw = UIO_READ;
 290         auio.uio_td = td;
 291         auio.uio_offset = 0;                    /* XXX */
 292         auio.uio_resid = 0;
 293         iov = mp->msg_iov;
 294         for (i = 0; i < mp->msg_iovlen; i++, iov++) {
 295                 if ((auio.uio_resid += iov->iov_len) < 0) {
 296                         fdrop(fp, td);
 297                         return (EINVAL);
 298                 }
 299         }
 300 #ifdef KTRACE
 301         if (KTRPOINT(p->p_thread, KTR_GENIO)) {
 302                 int iovlen = auio.uio_iovcnt * sizeof (struct iovec);
 303
 304                 MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
 305                 bcopy((caddr_t)auio.uio_iov, (caddr_t)ktriov, iovlen);
 306                 ktruio = auio;
 307         }
 308 #endif
 309         len = auio.uio_resid;
 310         so = (struct socket *)fp->f_data;
 311         error = so->so_proto->pr_usrreqs->pru_soreceive(so, &fromsa, &auio,
 312             (struct mbuf **)0, mp->msg_control ? &control : (struct mbuf **)0,
 313             &mp->msg_flags);
 314         if (error) {
 315                 if (auio.uio_resid != len && (error == ERESTART ||
 316                     error == EINTR || error == EWOULDBLOCK))
 317                         error = 0;
 318         }
 319 #ifdef KTRACE
 320         if (ktriov != NULL) {
 321                 if (error == 0) {
 322                         ktruio.uio_iov = ktriov;
 323                         ktruio.uio_resid = len - auio.uio_resid;
 324                         ktrgenio(p->p_tracep, s, UIO_READ, &ktruio, error);
 325                 }
 326                 FREE(ktriov, M_TEMP);
 327         }
 328 #endif
 329         if (error)
 330                 goto out;
 331         *retval = len - auio.uio_resid;
 332         if (mp->msg_name) {
 333                 len = mp->msg_namelen;
 334                 if (len <= 0 || fromsa == 0)
 335                         len = 0;
 336                 else {
 337 #ifndef MIN
 338 #define MIN(a,b) ((a)>(b)?(b):(a))
 339 #endif
 340                         /* save sa_len before it is destroyed by MSG_COMPAT */
 341                         len = MIN(len, fromsa->sa_len);
 342                         error = copyout(fromsa,
 343                             (caddr_t)mp->msg_name, (unsigned)len);
 344                         if (error)
 345                                 goto out;
 346                 }
 347                 mp->msg_namelen = len;
 348                 if (namelenp &&
 349                     (error = copyout((caddr_t)&len, namelenp, sizeof (int)))) {
 350                         goto out;
 351                 }
 352         }
 353         if (mp->msg_control) {
 354                 len = mp->msg_controllen;
 355                 m = control;
 356                 mp->msg_controllen = 0;
 357                 ctlbuf = (caddr_t) mp->msg_control;
 358
 359                 while (m && len > 0) {
 360                         unsigned int tocopy;
 361
 362                         if (len >= m->m_len)
 363                                 tocopy = m->m_len;
 364                         else {
 365                                 mp->msg_flags |= MSG_CTRUNC;
 366                                 tocopy = len;
 367                         }
 368
 369                         if ((error = copyout((caddr_t)mtod(m, caddr_t),
 370                                         ctlbuf, tocopy)) != 0)
 371                                 goto out;
 372
 373                         ctlbuf += tocopy;
 374                         len -= tocopy;
 375                         m = m->m_next;
 376                 }
 377                 mp->msg_controllen = ctlbuf - (caddr_t)mp->msg_control;
 378         }
 379 out:
 380         if (fromsa)
 381                 FREE(fromsa, M_SONAME);
 382         if (control)
 383                 m_freem(control);
 384         fdrop(fp, td);
 385         return (error);
 386 }
 387
 388 #ifdef DEBUG_SVR4
 389 static void bufprint (u_char *, size_t);
 390 static int show_ioc (const char *, struct svr4_strioctl *);
 391 static int show_strbuf (struct svr4_strbuf *);
 392 static void show_msg (const char *, int, struct svr4_strbuf *,
 393                           struct svr4_strbuf *, int);
 394
 395 static void
 396 bufprint(buf, len)
 397         u_char *buf;
 398         size_t len;
 399 {
 400         size_t i;
 401
 402         uprintf("\n\t");
 403         for (i = 0; i < len; i++) {
 404                 uprintf("%x ", buf[i]);
 405                 if (i && (i % 16) == 0)
 406                         uprintf("\n\t");
 407         }
 408 }
 409
 410 static int
 411 show_ioc(str, ioc)
 412         const char              *str;
 413         struct svr4_strioctl    *ioc;
 414 {
 415         u_char *ptr = (u_char *) malloc(ioc->len, M_TEMP, M_WAITOK);
 416         int error;
 417
 418         uprintf("%s cmd = %ld, timeout = %d, len = %d, buf = %p { ",
 419             str, ioc->cmd, ioc->timeout, ioc->len, ioc->buf);
 420
 421         if ((error = copyin(ioc->buf, ptr, ioc->len)) != 0) {
 422                 free((char *) ptr, M_TEMP);
 423                 return error;
 424         }
 425
 426         bufprint(ptr, ioc->len);
 427
 428         uprintf("}\n");
 429
 430         free((char *) ptr, M_TEMP);
 431         return 0;
 432 }
 433
 434
 435 static int
 436 show_strbuf(str)
 437         struct svr4_strbuf *str;
 438 {
 439         int error;
 440         u_char *ptr = NULL;
 441         int maxlen = str->maxlen;
 442         int len = str->len;
 443
 444         if (maxlen < 0)
 445                 maxlen = 0;
 446
 447         if (len >= maxlen)
 448                 len = maxlen;
 449
 450         if (len > 0) {
 451             ptr = (u_char *) malloc(len, M_TEMP, M_WAITOK);
 452
 453             if ((error = copyin(str->buf, ptr, len)) != 0) {
 454                     free((char *) ptr, M_TEMP);
 455                     return error;
 456             }
 457         }
 458
 459         uprintf(", { %d, %d, %p=[ ", str->maxlen, str->len, str->buf);
 460
 461         if (ptr)
 462                 bufprint(ptr, len);
 463
 464         uprintf("]}");
 465
 466         if (ptr)
 467                 free((char *) ptr, M_TEMP);
 468
 469         return 0;
 470 }
 471
 472
 473 static void
 474 show_msg(str, fd, ctl, dat, flags)
 475         const char              *str;
 476         int                      fd;
 477         struct svr4_strbuf      *ctl;
 478         struct svr4_strbuf      *dat;
 479         int                      flags;
 480 {
 481         struct svr4_strbuf      buf;
 482         int error;
 483
 484         uprintf("%s(%d", str, fd);
 485         if (ctl != NULL) {
 486                 if ((error = copyin(ctl, &buf, sizeof(buf))) != 0)
 487                         return;
 488                 show_strbuf(&buf);
 489         }
 490         else
 491                 uprintf(", NULL");
 492
 493         if (dat != NULL) {
 494                 if ((error = copyin(dat, &buf, sizeof(buf))) != 0)
 495                         return;
 496                 show_strbuf(&buf);
 497         }
 498         else
 499                 uprintf(", NULL");
 500
 501         uprintf(", %x);\n", flags);
 502 }
 503
 504 #endif /* DEBUG_SVR4 */
 505
 506 /*
 507  * We are faced with an interesting situation. On svr4 unix sockets
 508  * are really pipes. But we really have sockets, and we might as
 509  * well use them. At the point where svr4 calls TI_BIND, it has
 510  * already created a named pipe for the socket using mknod(2).
 511  * We need to create a socket with the same name when we bind,
 512  * so we need to remove the pipe before, otherwise we'll get address
 513  * already in use. So we *carefully* remove the pipe, to avoid
 514  * using this as a random file removal tool. We use system calls
 515  * to avoid code duplication.
 516  */
 517 static int
 518 clean_pipe(const char *path)
 519 {
 520         struct lstat_args la;
 521         struct unlink_args ua;
 522         struct stat st;
 523         int error;
 524         caddr_t sg = stackgap_init();
 525         size_t l = strlen(path) + 1;
 526         void *tpath;
 527
 528         tpath = stackgap_alloc(&sg, l);
 529         SCARG(&la, ub) = stackgap_alloc(&sg, sizeof(struct stat));
 530
 531         if ((error = copyout(path, tpath, l)) != 0)
 532                 return error;
 533
 534         SCARG(&la, path) = tpath;
 535
 536         if ((error = lstat(&la)) != 0)
 537                 return 0;
 538
 539         if ((error = copyin(SCARG(&la, ub), &st, sizeof(st))) != 0)
 540                 return 0;
 541
 542         /*
 543          * Make sure we are dealing with a mode 0 named pipe.
 544          */
 545         if ((st.st_mode & S_IFMT) != S_IFIFO)
 546                 return 0;
 547
 548         if ((st.st_mode & ALLPERMS) != 0)
 549                 return 0;
 550
 551         SCARG(&ua, path) = SCARG(&la, path);
 552
 553         if ((error = unlink(&ua)) != 0) {
 554                 DPRINTF(("clean_pipe: unlink failed %d\n", error));
 555                 return error;
 556         }
 557
 558         return 0;
 559 }
 560
 561
 562 static void
 563 sockaddr_to_netaddr_in(sc, sain)
 564         struct svr4_strmcmd *sc;
 565         const struct sockaddr_in *sain;
 566 {
 567         struct svr4_netaddr_in *na;
 568         na = SVR4_ADDROF(sc);
 569
 570         na->family = sain->sin_family;
 571         na->port = sain->sin_port;
 572         na->addr = sain->sin_addr.s_addr;
 573         DPRINTF(("sockaddr_in -> netaddr %d %d %lx\n", na->family, na->port,
 574                  na->addr));
 575 }
 576
 577
 578 static void
 579 sockaddr_to_netaddr_un(sc, saun)
 580         struct svr4_strmcmd *sc;
 581         const struct sockaddr_un *saun;
 582 {
 583         struct svr4_netaddr_un *na;
 584         char *dst, *edst = ((char *) sc) + sc->offs + sizeof(na->family) + 1  -
 585             sizeof(*sc);
 586         const char *src;
 587
 588         na = SVR4_ADDROF(sc);
 589         na->family = saun->sun_family;
 590         for (src = saun->sun_path, dst = na->path; (*dst++ = *src++) != '\0'; )
 591                 if (dst == edst)
 592                         break;
 593         DPRINTF(("sockaddr_un -> netaddr %d %s\n", na->family, na->path));
 594 }
 595
 596
 597 static void
 598 netaddr_to_sockaddr_in(sain, sc)
 599         struct sockaddr_in *sain;
 600         const struct svr4_strmcmd *sc;
 601 {
 602         const struct svr4_netaddr_in *na;
 603
 604
 605         na = SVR4_C_ADDROF(sc);
 606         memset(sain, 0, sizeof(*sain));
 607         sain->sin_len = sizeof(*sain);
 608         sain->sin_family = na->family;
 609         sain->sin_port = na->port;
 610         sain->sin_addr.s_addr = na->addr;
 611         DPRINTF(("netaddr -> sockaddr_in %d %d %x\n", sain->sin_family,
 612                  sain->sin_port, sain->sin_addr.s_addr));
 613 }
 614
 615
 616 static void
 617 netaddr_to_sockaddr_un(saun, sc)
 618         struct sockaddr_un *saun;
 619         const struct svr4_strmcmd *sc;
 620 {
 621         const struct svr4_netaddr_un *na;
 622         char *dst, *edst = &saun->sun_path[sizeof(saun->sun_path) - 1];
 623         const char *src;
 624
 625         na = SVR4_C_ADDROF(sc);
 626         memset(saun, 0, sizeof(*saun));
 627         saun->sun_family = na->family;
 628         for (src = na->path, dst = saun->sun_path; (*dst++ = *src++) != '\0'; )
 629                 if (dst == edst)
 630                         break;
 631         saun->sun_len = dst - saun->sun_path;
 632         DPRINTF(("netaddr -> sockaddr_un %d %s\n", saun->sun_family,
 633                  saun->sun_path));
 634 }
 635
 636
 637 static void
 638 getparm(fp, pa)
 639         struct file *fp;
 640         struct svr4_si_sockparms *pa;
 641 {
 642         struct svr4_strm *st = svr4_stream_get(fp);
 643         struct socket *so = (struct socket *) fp->f_data;
 644
 645         if (st == NULL)
 646                 return;
 647
 648         pa->family = st->s_family;
 649
 650         switch (so->so_type) {
 651         case SOCK_DGRAM:
 652                 pa->type = SVR4_T_CLTS;
 653                 pa->protocol = IPPROTO_UDP;
 654                 DPRINTF(("getparm(dgram)\n"));
 655                 return;
 656
 657         case SOCK_STREAM:
 658                 pa->type = SVR4_T_COTS;  /* What about T_COTS_ORD? XXX */
 659                 pa->protocol = IPPROTO_IP;
 660                 DPRINTF(("getparm(stream)\n"));
 661                 return;
 662
 663         case SOCK_RAW:
 664                 pa->type = SVR4_T_CLTS;
 665                 pa->protocol = IPPROTO_RAW;
 666                 DPRINTF(("getparm(raw)\n"));
 667                 return;
 668
 669         default:
 670                 pa->type = 0;
 671                 pa->protocol = 0;
 672                 DPRINTF(("getparm(type %d?)\n", so->so_type));
 673                 return;
 674         }
 675 }
 676
 677
 678 static int
 679 si_ogetudata(fp, fd, ioc, td)
 680         struct file             *fp;
 681         int                      fd;
 682         struct svr4_strioctl    *ioc;
 683         struct thread           *td;
 684 {
 685         int error;
 686         struct svr4_si_oudata ud;
 687         struct svr4_si_sockparms pa;
 688
 689         if (ioc->len != sizeof(ud) && ioc->len != sizeof(ud) - sizeof(int)) {
 690                 DPRINTF(("SI_OGETUDATA: Wrong size %d != %d\n",
 691                          sizeof(ud), ioc->len));
 692                 return EINVAL;
 693         }
 694
 695         if ((error = copyin(ioc->buf, &ud, sizeof(ud))) != 0)
 696                 return error;
 697
 698         getparm(fp, &pa);
 699
 700         switch (pa.family) {
 701         case AF_INET:
 702             ud.tidusize = 16384;
 703             ud.addrsize = sizeof(struct svr4_sockaddr_in);
 704             if (pa.type == SVR4_SOCK_STREAM)
 705                     ud.etsdusize = 1;
 706             else
 707                     ud.etsdusize = 0;
 708             break;
 709
 710         case AF_LOCAL:
 711             ud.tidusize = 65536;
 712             ud.addrsize = 128;
 713             ud.etsdusize = 128;
 714             break;
 715
 716         default:
 717             DPRINTF(("SI_OGETUDATA: Unsupported address family %d\n",
 718                      pa.family));
 719             return ENOSYS;
 720         }
 721
 722         /* I have no idea what these should be! */
 723         ud.optsize = 128;
 724         ud.tsdusize = 128;
 725
 726         ud.servtype = pa.type;
 727
 728         /* XXX: Fixme */
 729         ud.so_state = 0;
 730         ud.so_options = 0;
 731         return copyout(&ud, ioc->buf, ioc->len);
 732 }
 733
 734
 735 static int
 736 si_sockparams(fp, fd, ioc, td)
 737         struct file             *fp;
 738         int                      fd;
 739         struct svr4_strioctl    *ioc;
 740         struct thread           *td;
 741 {
 742         struct svr4_si_sockparms pa;
 743
 744         getparm(fp, &pa);
 745         return copyout(&pa, ioc->buf, sizeof(pa));
 746 }
 747
 748
 749 static int
 750 si_listen(fp, fd, ioc, td)
 751         struct file             *fp;
 752         int                      fd;
 753         struct svr4_strioctl    *ioc;
 754         struct thread           *td;
 755 {
 756         int error;
 757         struct svr4_strm *st = svr4_stream_get(fp);
 758         struct svr4_strmcmd lst;
 759         struct listen_args la;
 760
 761         if (st == NULL)
 762                 return EINVAL;
 763
 764         if ((error = copyin(ioc->buf, &lst, ioc->len)) != 0)
 765                 return error;
 766
 767         if (lst.cmd != SVR4_TI_OLD_BIND_REQUEST) {
 768                 DPRINTF(("si_listen: bad request %ld\n", lst.cmd));
 769                 return EINVAL;
 770         }
 771
 772         /*
 773          * We are making assumptions again...
 774          */
 775         SCARG(&la, s) = fd;
 776         DPRINTF(("SI_LISTEN: fileno %d backlog = %d\n", fd, 5));
 777         SCARG(&la, backlog) = 5;
 778
 779         if ((error = listen(&la)) != 0) {
 780                 DPRINTF(("SI_LISTEN: listen failed %d\n", error));
 781                 return error;
 782         }
 783
 784         st->s_cmd = SVR4_TI__ACCEPT_WAIT;
 785         lst.cmd = SVR4_TI_BIND_REPLY;
 786
 787         switch (st->s_family) {
 788         case AF_INET:
 789                 /* XXX: Fill the length here */
 790                 break;
 791
 792         case AF_LOCAL:
 793                 lst.len = 140;
 794                 lst.pad[28] = 0x00000000;       /* magic again */
 795                 lst.pad[29] = 0x00000800;       /* magic again */
 796                 lst.pad[30] = 0x80001400;       /* magic again */
 797                 break;
 798
 799         default:
 800                 DPRINTF(("SI_LISTEN: Unsupported address family %d\n",
 801                     st->s_family));
 802                 return ENOSYS;
 803         }
 804
 805
 806         if ((error = copyout(&lst, ioc->buf, ioc->len)) != 0)
 807                 return error;
 808
 809         return 0;
 810 }
 811
 812
 813 static int
 814 si_getudata(fp, fd, ioc, td)
 815         struct file             *fp;
 816         int                      fd;
 817         struct svr4_strioctl    *ioc;
 818         struct thread           *td;
 819 {
 820         int error;
 821         struct svr4_si_udata ud;
 822
 823         if (sizeof(ud) != ioc->len) {
 824                 DPRINTF(("SI_GETUDATA: Wrong size %d != %d\n",
 825                          sizeof(ud), ioc->len));
 826                 return EINVAL;
 827         }
 828
 829         if ((error = copyin(ioc->buf, &ud, sizeof(ud))) != 0)
 830                 return error;
 831
 832         getparm(fp, &ud.sockparms);
 833
 834         switch (ud.sockparms.family) {
 835         case AF_INET:
 836             DPRINTF(("getudata_inet\n"));
 837             ud.tidusize = 16384;
 838             ud.tsdusize = 16384;
 839             ud.addrsize = sizeof(struct svr4_sockaddr_in);
 840             if (ud.sockparms.type == SVR4_SOCK_STREAM)
 841                     ud.etsdusize = 1;
 842             else
 843                     ud.etsdusize = 0;
 844             ud.optsize = 0;
 845             break;
 846
 847         case AF_LOCAL:
 848             DPRINTF(("getudata_local\n"));
 849             ud.tidusize = 65536;
 850             ud.tsdusize = 128;
 851             ud.addrsize = 128;
 852             ud.etsdusize = 128;
 853             ud.optsize = 128;
 854             break;
 855
 856         default:
 857             DPRINTF(("SI_GETUDATA: Unsupported address family %d\n",
 858                      ud.sockparms.family));
 859             return ENOSYS;
 860         }
 861
 862
 863         ud.servtype = ud.sockparms.type;
 864         DPRINTF(("ud.servtype = %d\n", ud.servtype));
 865         /* XXX: Fixme */
 866         ud.so_state = 0;
 867         ud.so_options = 0;
 868         return copyout(&ud, ioc->buf, sizeof(ud));
 869 }
 870
 871
 872 static int
 873 si_shutdown(fp, fd, ioc, td)
 874         struct file             *fp;
 875         int                      fd;
 876         struct svr4_strioctl    *ioc;
 877         struct thread           *td;
 878 {
 879         int error;
 880         struct shutdown_args ap;
 881
 882         if (ioc->len != sizeof(SCARG(&ap, how))) {
 883                 DPRINTF(("SI_SHUTDOWN: Wrong size %d != %d\n",
 884                          sizeof(SCARG(&ap, how)), ioc->len));
 885                 return EINVAL;
 886         }
 887
 888         if ((error = copyin(ioc->buf, &SCARG(&ap, how), ioc->len)) != 0)
 889                 return error;
 890
 891         SCARG(&ap, s) = fd;
 892
 893         return shutdown(&ap);
 894 }
 895
 896
 897 static int
 898 sockmod(fp, fd, ioc, td)
 899         struct file             *fp;
 900         int                      fd;
 901         struct svr4_strioctl    *ioc;
 902         struct thread           *td;
 903 {
 904         switch (ioc->cmd) {
 905         case SVR4_SI_OGETUDATA:
 906                 DPRINTF(("SI_OGETUDATA\n"));
 907                 return si_ogetudata(fp, fd, ioc, td);
 908
 909         case SVR4_SI_SHUTDOWN:
 910                 DPRINTF(("SI_SHUTDOWN\n"));
 911                 return si_shutdown(fp, fd, ioc, td);
 912
 913         case SVR4_SI_LISTEN:
 914                 DPRINTF(("SI_LISTEN\n"));
 915                 return si_listen(fp, fd, ioc, td);
 916
 917         case SVR4_SI_SETMYNAME:
 918                 DPRINTF(("SI_SETMYNAME\n"));
 919                 return 0;
 920
 921         case SVR4_SI_SETPEERNAME:
 922                 DPRINTF(("SI_SETPEERNAME\n"));
 923                 return 0;
 924
 925         case SVR4_SI_GETINTRANSIT:
 926                 DPRINTF(("SI_GETINTRANSIT\n"));
 927                 return 0;
 928
 929         case SVR4_SI_TCL_LINK:
 930                 DPRINTF(("SI_TCL_LINK\n"));
 931                 return 0;
 932
 933         case SVR4_SI_TCL_UNLINK:
 934                 DPRINTF(("SI_TCL_UNLINK\n"));
 935                 return 0;
 936
 937         case SVR4_SI_SOCKPARAMS:
 938                 DPRINTF(("SI_SOCKPARAMS\n"));
 939                 return si_sockparams(fp, fd, ioc, td);
 940
 941         case SVR4_SI_GETUDATA:
 942                 DPRINTF(("SI_GETUDATA\n"));
 943                 return si_getudata(fp, fd, ioc, td);
 944
 945         default:
 946                 DPRINTF(("Unknown sockmod ioctl %lx\n", ioc->cmd));
 947                 return 0;
 948
 949         }
 950 }
 951
 952
 953 static int
 954 ti_getinfo(fp, fd, ioc, td)
 955         struct file             *fp;
 956         int                      fd;
 957         struct svr4_strioctl    *ioc;
 958         struct thread           *td;
 959 {
 960         int error;
 961         struct svr4_infocmd info;
 962
 963         memset(&info, 0, sizeof(info));
 964
 965         if ((error = copyin(ioc->buf, &info, ioc->len)) != 0)
 966                 return error;
 967
 968         if (info.cmd != SVR4_TI_INFO_REQUEST)
 969                 return EINVAL;
 970
 971         info.cmd = SVR4_TI_INFO_REPLY;
 972         info.tsdu = 0;
 973         info.etsdu = 1;
 974         info.cdata = -2;
 975         info.ddata = -2;
 976         info.addr = 16;
 977         info.opt = -1;
 978         info.tidu = 16384;
 979         info.serv = 2;
 980         info.current = 0;
 981         info.provider = 2;
 982
 983         ioc->len = sizeof(info);
 984         if ((error = copyout(&info, ioc->buf, ioc->len)) != 0)
 985                 return error;
 986
 987         return 0;
 988 }
 989
 990
 991 static int
 992 ti_bind(fp, fd, ioc, td)
 993         struct file             *fp;
 994         int                      fd;
 995         struct svr4_strioctl    *ioc;
 996         struct thread           *td;
 997 {
 998         int error;
 999         struct svr4_strm *st = svr4_stream_get(fp);
1000         struct sockaddr_in sain;
1001         struct sockaddr_un saun;
1002         caddr_t sg;
1003         void *skp, *sup = NULL;
1004         int sasize;
1005         struct svr4_strmcmd bnd;
1006         struct bind_args ba;
1007
1008         if (st == NULL) {
1009                 DPRINTF(("ti_bind: bad file descriptor\n"));
1010                 return EINVAL;
1011         }
1012
1013         if ((error = copyin(ioc->buf, &bnd, ioc->len)) != 0)
1014                 return error;
1015
1016         if (bnd.cmd != SVR4_TI_OLD_BIND_REQUEST) {
1017                 DPRINTF(("ti_bind: bad request %ld\n", bnd.cmd));
1018                 return EINVAL;
1019         }
1020
1021         switch (st->s_family) {
1022         case AF_INET:
1023                 skp = &sain;
1024                 sasize = sizeof(sain);
1025
1026                 if (bnd.offs == 0)
1027                         goto reply;
1028
1029                 netaddr_to_sockaddr_in(&sain, &bnd);
1030
1031                 DPRINTF(("TI_BIND: fam %d, port %d, addr %x\n",
1032                          sain.sin_family, sain.sin_port,
1033                          sain.sin_addr.s_addr));
1034                 break;
1035
1036         case AF_LOCAL:
1037                 skp = &saun;
1038                 sasize = sizeof(saun);
1039                 if (bnd.offs == 0)
1040                         goto reply;
1041
1042                 netaddr_to_sockaddr_un(&saun, &bnd);
1043
1044                 if (saun.sun_path[0] == '\0')
1045                         goto reply;
1046
1047                 DPRINTF(("TI_BIND: fam %d, path %s\n",
1048                          saun.sun_family, saun.sun_path));
1049
1050                 if ((error = clean_pipe(saun.sun_path)) != 0)
1051                         return error;
1052
1053                 bnd.pad[28] = 0x00001000;       /* magic again */
1054                 break;
1055
1056         default:
1057                 DPRINTF(("TI_BIND: Unsupported address family %d\n",
1058                          st->s_family));
1059                 return ENOSYS;
1060         }
1061
1062         sg = stackgap_init();
1063         sup = stackgap_alloc(&sg, sasize);
1064
1065         if ((error = copyout(skp, sup, sasize)) != 0)
1066                 return error;
1067
1068         SCARG(&ba, s) = fd;
1069         DPRINTF(("TI_BIND: fileno %d\n", fd));
1070         SCARG(&ba, name) = (void *) sup;
1071         SCARG(&ba, namelen) = sasize;
1072
1073         if ((error = bind(&ba)) != 0) {
1074                 DPRINTF(("TI_BIND: bind failed %d\n", error));
1075                 return error;
1076         }
1077
1078 reply:
1079         if (sup == NULL) {
1080                 memset(&bnd, 0, sizeof(bnd));
1081                 bnd.len = sasize + 4;
1082                 bnd.offs = 0x10;        /* XXX */
1083         }
1084
1085         bnd.cmd = SVR4_TI_BIND_REPLY;
1086
1087         if ((error = copyout(&bnd, ioc->buf, ioc->len)) != 0)
1088                 return error;
1089
1090         return 0;
1091 }
1092
1093
1094 static int
1095 timod(fp, fd, ioc, td)
1096         struct file             *fp;
1097         int                      fd;
1098         struct svr4_strioctl    *ioc;
1099         struct thread           *td;
1100 {
1101         switch (ioc->cmd) {
1102         case SVR4_TI_GETINFO:
1103                 DPRINTF(("TI_GETINFO\n"));
1104                 return ti_getinfo(fp, fd, ioc, td);
1105
1106         case SVR4_TI_OPTMGMT:
1107                 DPRINTF(("TI_OPTMGMT\n"));
1108                 return 0;
1109
1110         case SVR4_TI_BIND:
1111                 DPRINTF(("TI_BIND\n"));
1112                 return ti_bind(fp, fd, ioc, td);
1113
1114         case SVR4_TI_UNBIND:
1115                 DPRINTF(("TI_UNBIND\n"));
1116                 return 0;
1117
1118         default:
1119                 DPRINTF(("Unknown timod ioctl %lx\n", ioc->cmd));
1120                 return 0;
1121         }
1122 }
1123
1124
1125 int
1126 svr4_stream_ti_ioctl(fp, td, retval, fd, cmd, dat)
1127         struct file *fp;
1128         struct thread *td;
1129         register_t *retval;
1130         int fd;
1131         u_long cmd;
1132         caddr_t dat;
1133 {
1134         struct svr4_strbuf skb, *sub = (struct svr4_strbuf *) dat;
1135         struct svr4_strm *st = svr4_stream_get(fp);
1136         int error;
1137         void *skp, *sup;
1138         struct sockaddr_in sain;
1139         struct sockaddr_un saun;
1140         struct svr4_strmcmd sc;
1141         int sasize;
1142         caddr_t sg;
1143         int *lenp;
1144
1145         DPRINTF(("svr4_stream_ti_ioctl\n"));
1146
1147         if (st == NULL)
1148                 return EINVAL;
1149
1150         sc.offs = 0x10;
1151
1152         if ((error = copyin(sub, &skb, sizeof(skb))) != 0) {
1153                 DPRINTF(("ti_ioctl: error copying in strbuf\n"));
1154                 return error;
1155         }
1156
1157         switch (st->s_family) {
1158         case AF_INET:
1159                 skp = &sain;
1160                 sasize = sizeof(sain);
1161                 break;
1162
1163         case AF_LOCAL:
1164                 skp = &saun;
1165                 sasize = sizeof(saun);
1166                 break;
1167
1168         default:
1169                 DPRINTF(("ti_ioctl: Unsupported address family %d\n",
1170                          st->s_family));
1171                 return ENOSYS;
1172         }
1173
1174         sg = stackgap_init();
1175         sup = stackgap_alloc(&sg, sasize);
1176         lenp = stackgap_alloc(&sg, sizeof(*lenp));
1177
1178         if ((error = copyout(&sasize, lenp, sizeof(*lenp))) != 0) {
1179                 DPRINTF(("ti_ioctl: error copying out lenp\n"));
1180                 return error;
1181         }
1182
1183         switch (cmd) {
1184         case SVR4_TI_GETMYNAME:
1185                 DPRINTF(("TI_GETMYNAME\n"));
1186                 {
1187                         struct getsockname_args ap;
1188                         SCARG(&ap, fdes) = fd;
1189                         SCARG(&ap, asa) = sup;
1190                         SCARG(&ap, alen) = lenp;
1191                         if ((error = getsockname(&ap)) != 0) {
1192                                 DPRINTF(("ti_ioctl: getsockname error\n"));
1193                                 return error;
1194                         }
1195                 }
1196                 break;
1197
1198         case SVR4_TI_GETPEERNAME:
1199                 DPRINTF(("TI_GETPEERNAME\n"));
1200                 {
1201                         struct getpeername_args ap;
1202                         SCARG(&ap, fdes) = fd;
1203                         SCARG(&ap, asa) = sup;
1204                         SCARG(&ap, alen) = lenp;
1205                         if ((error = getpeername(&ap)) != 0) {
1206                                 DPRINTF(("ti_ioctl: getpeername error\n"));
1207                                 return error;
1208                         }
1209                 }
1210                 break;
1211
1212         case SVR4_TI_SETMYNAME:
1213                 DPRINTF(("TI_SETMYNAME\n"));
1214                 return 0;
1215
1216         case SVR4_TI_SETPEERNAME:
1217                 DPRINTF(("TI_SETPEERNAME\n"));
1218                 return 0;
1219         default:
1220                 DPRINTF(("ti_ioctl: Unknown ioctl %lx\n", cmd));
1221                 return ENOSYS;
1222         }
1223
1224         if ((error = copyin(sup, skp, sasize)) != 0) {
1225                 DPRINTF(("ti_ioctl: error copying in socket data\n"));
1226                 return error;
1227         }
1228
1229         if ((error = copyin(lenp, &sasize, sizeof(*lenp))) != 0) {
1230                 DPRINTF(("ti_ioctl: error copying in socket size\n"));
1231                 return error;
1232         }
1233
1234         switch (st->s_family) {
1235         case AF_INET:
1236                 sockaddr_to_netaddr_in(&sc, &sain);
1237                 skb.len = sasize;
1238                 break;
1239
1240         case AF_LOCAL:
1241                 sockaddr_to_netaddr_un(&sc, &saun);
1242                 skb.len = sasize + 4;
1243                 break;
1244
1245         default:
1246                 return ENOSYS;
1247         }
1248
1249
1250         if ((error = copyout(SVR4_ADDROF(&sc), skb.buf, sasize)) != 0) {
1251                 DPRINTF(("ti_ioctl: error copying out socket data\n"));
1252                 return error;
1253         }
1254
1255
1256         if ((error = copyout(&skb, sub, sizeof(skb))) != 0) {
1257                 DPRINTF(("ti_ioctl: error copying out strbuf\n"));
1258                 return error;
1259         }
1260
1261         return error;
1262 }
1263
1264
1265
1266
1267 static int
1268 i_nread(fp, td, retval, fd, cmd, dat)
1269         struct file *fp;
1270         struct thread *td;
1271         register_t *retval;
1272         int fd;
1273         u_long cmd;
1274         caddr_t dat;
1275 {
1276         int error;
1277         int nread = 0;
1278
1279         /*
1280          * We are supposed to return the message length in nread, and the
1281          * number of messages in retval. We don't have the notion of number
1282          * of stream messages, so we just find out if we have any bytes waiting
1283          * for us, and if we do, then we assume that we have at least one
1284          * message waiting for us.
1285          */
1286         if ((error = fo_ioctl(fp, FIONREAD, (caddr_t) &nread, td)) != 0)
1287                 return error;
1288
1289         if (nread != 0)
1290                 *retval = 1;
1291         else
1292                 *retval = 0;
1293
1294         return copyout(&nread, dat, sizeof(nread));
1295 }
1296
1297 static int
1298 i_fdinsert(fp, td, retval, fd, cmd, dat)
1299         struct file *fp;
1300         struct thread *td;
1301         register_t *retval;
1302         int fd;
1303         u_long cmd;
1304         caddr_t dat;
1305 {
1306         /*
1307          * Major hack again here. We assume that we are using this to
1308          * implement accept(2). If that is the case, we have already
1309          * called accept, and we have stored the file descriptor in
1310          * afd. We find the file descriptor that the code wants to use
1311          * in fd insert, and then we dup2() our accepted file descriptor
1312          * to it.
1313          */
1314         int error;
1315         struct svr4_strm *st = svr4_stream_get(fp);
1316         struct svr4_strfdinsert fdi;
1317         struct dup2_args d2p;
1318         struct close_args clp;
1319
1320         if (st == NULL) {
1321                 DPRINTF(("fdinsert: bad file type\n"));
1322                 return EINVAL;
1323         }
1324
1325         if (st->s_afd == -1) {
1326                 DPRINTF(("fdinsert: accept fd not found\n"));
1327                 return ENOENT;
1328         }
1329
1330         if ((error = copyin(dat, &fdi, sizeof(fdi))) != 0) {
1331                 DPRINTF(("fdinsert: copyin failed %d\n", error));
1332                 return error;
1333         }
1334
1335         SCARG(&d2p, from) = st->s_afd;
1336         SCARG(&d2p, to) = fdi.fd;
1337
1338         if ((error = dup2(&d2p)) != 0) {
1339                 DPRINTF(("fdinsert: dup2(%d, %d) failed %d\n",
1340                     st->s_afd, fdi.fd, error));
1341                 return error;
1342         }
1343
1344         SCARG(&clp, fd) = st->s_afd;
1345
1346         if ((error = close(&clp)) != 0) {
1347                 DPRINTF(("fdinsert: close(%d) failed %d\n",
1348                     st->s_afd, error));
1349                 return error;
1350         }
1351
1352         st->s_afd = -1;
1353
1354         *retval = 0;
1355         return 0;
1356 }
1357
1358
1359 static int
1360 _i_bind_rsvd(fp, td, retval, fd, cmd, dat)
1361         struct file *fp;
1362         struct thread *td;
1363         register_t *retval;
1364         int fd;
1365         u_long cmd;
1366         caddr_t dat;
1367 {
1368         struct mkfifo_args ap;
1369
1370         /*
1371          * This is a supposed to be a kernel and library only ioctl.
1372          * It gets called before ti_bind, when we have a unix
1373          * socket, to physically create the socket transport and
1374          * ``reserve'' it. I don't know how this get reserved inside
1375          * the kernel, but we are going to create it nevertheless.
1376          */
1377         SCARG(&ap, path) = dat;
1378         SCARG(&ap, mode) = S_IFIFO;
1379
1380         return mkfifo(&ap);
1381 }
1382
1383 static int
1384 _i_rele_rsvd(fp, td, retval, fd, cmd, dat)
1385         struct file *fp;
1386         struct thread *td;
1387         register_t *retval;
1388         int fd;
1389         u_long cmd;
1390         caddr_t dat;
1391 {
1392         struct unlink_args ap;
1393
1394         /*
1395          * This is a supposed to be a kernel and library only ioctl.
1396          * I guess it is supposed to release the socket.
1397          */
1398         SCARG(&ap, path) = dat;
1399
1400         return unlink(&ap);
1401 }
1402
1403 static int
1404 i_str(fp, td, retval, fd, cmd, dat)
1405         struct file *fp;
1406         struct thread *td;
1407         register_t *retval;
1408         int fd;
1409         u_long cmd;
1410         caddr_t dat;
1411 {
1412         int                      error;
1413         struct svr4_strioctl     ioc;
1414
1415         if ((error = copyin(dat, &ioc, sizeof(ioc))) != 0)
1416                 return error;
1417
1418 #ifdef DEBUG_SVR4
1419         if ((error = show_ioc(">", &ioc)) != 0)
1420                 return error;
1421 #endif /* DEBUG_SVR4 */
1422
1423         switch (ioc.cmd & 0xff00) {
1424         case SVR4_SIMOD:
1425                 if ((error = sockmod(fp, fd, &ioc, td)) != 0)
1426                         return error;
1427                 break;
1428
1429         case SVR4_TIMOD:
1430                 if ((error = timod(fp, fd, &ioc, td)) != 0)
1431                         return error;
1432                 break;
1433
1434         default:
1435                 DPRINTF(("Unimplemented module %c %ld\n",
1436                          (char) (cmd >> 8), cmd & 0xff));
1437                 return 0;
1438         }
1439
1440 #ifdef DEBUG_SVR4
1441         if ((error = show_ioc("<", &ioc)) != 0)
1442                 return error;
1443 #endif /* DEBUG_SVR4 */
1444         return copyout(&ioc, dat, sizeof(ioc));
1445 }
1446
1447 static int
1448 i_setsig(fp, td, retval, fd, cmd, dat)
1449         struct file *fp;
1450         struct thread *td;
1451         register_t *retval;
1452         int fd;
1453         u_long cmd;
1454         caddr_t dat;
1455 {
1456         /*
1457          * This is the best we can do for now; we cannot generate
1458          * signals only for specific events so the signal mask gets
1459          * ignored; we save it just to pass it to a possible I_GETSIG...
1460          *
1461          * We alse have to fix the O_ASYNC fcntl bit, so the
1462          * process will get SIGPOLLs.
1463          */
1464         struct proc *p = td->td_proc;
1465         struct fcntl_args fa;
1466         int error;
1467         register_t oflags, flags;
1468         struct svr4_strm *st = svr4_stream_get(fp);
1469
1470         KKASSERT(p);
1471
1472         if (st == NULL) {
1473                 DPRINTF(("i_setsig: bad file descriptor\n"));
1474                 return EINVAL;
1475         }
1476         /* get old status flags */
1477         SCARG(&fa, fd) = fd;
1478         SCARG(&fa, cmd) = F_GETFL;
1479         if ((error = fcntl(&fa)) != 0)
1480                 return error;
1481
1482         oflags = fa.sysmsg_result;
1483
1484         /* update the flags */
1485         if (dat != NULL) {
1486                 int mask;
1487
1488                 flags = oflags | O_ASYNC;
1489                 if ((error = copyin(dat, &mask, sizeof(mask))) != 0) {
1490                           DPRINTF(("i_setsig: bad eventmask pointer\n"));
1491                           return error;
1492                 }
1493                 if (mask & SVR4_S_ALLMASK) {
1494                           DPRINTF(("i_setsig: bad eventmask data %x\n", mask));
1495                           return EINVAL;
1496                 }
1497                 st->s_eventmask = mask;
1498         }
1499         else {
1500                 flags = oflags & ~O_ASYNC;
1501                 st->s_eventmask = 0;
1502         }
1503
1504         /* set the new flags, if changed */
1505         if (flags != oflags) {
1506                 SCARG(&fa, cmd) = F_SETFL;
1507                 SCARG(&fa, arg) = (long) flags;
1508                 if ((error = fcntl(&fa)) != 0)
1509                           return error;
1510                 flags =fa.sysmsg_result;
1511         }
1512
1513         /* set up SIGIO receiver if needed */
1514         if (dat != NULL) {
1515                 SCARG(&fa, cmd) = F_SETOWN;
1516                 SCARG(&fa, arg) = (long) p->p_pid;
1517                 error = fcntl(&fa);
1518                 *retval = fa.sysmsg_result;
1519                 return(error);
1520         }
1521         *retval = fa.sysmsg_result;
1522         return 0;
1523 }
1524
1525 static int
1526 i_getsig(fp, td, retval, fd, cmd, dat)
1527         struct file *fp;
1528         struct thread *td;
1529         register_t *retval;
1530         int fd;
1531         u_long cmd;
1532         caddr_t dat;
1533 {
1534         int error;
1535
1536         if (dat != NULL) {
1537                 struct svr4_strm *st = svr4_stream_get(fp);
1538
1539                 if (st == NULL) {
1540                         DPRINTF(("i_getsig: bad file descriptor\n"));
1541                         return EINVAL;
1542                 }
1543                 if ((error = copyout(&st->s_eventmask, dat,
1544                                      sizeof(st->s_eventmask))) != 0) {
1545                         DPRINTF(("i_getsig: bad eventmask pointer\n"));
1546                         return error;
1547                 }
1548         }
1549         return 0;
1550 }
1551
1552 int
1553 svr4_stream_ioctl(fp, td, retval, fd, cmd, dat)
1554         struct file *fp;
1555         struct thread *td;
1556         register_t *retval;
1557         int fd;
1558         u_long cmd;
1559         caddr_t dat;
1560 {
1561         *retval = 0;
1562
1563         /*
1564          * All the following stuff assumes "sockmod" is pushed...
1565          */
1566         switch (cmd) {
1567         case SVR4_I_NREAD:
1568                 DPRINTF(("I_NREAD\n"));
1569                 return i_nread(fp, td, retval, fd, cmd, dat);
1570
1571         case SVR4_I_PUSH:
1572                 DPRINTF(("I_PUSH %p\n", dat));
1573 #if defined(DEBUG_SVR4)
1574                 show_strbuf((void *)dat);
1575 #endif
1576                 return 0;
1577
1578         case SVR4_I_POP:
1579                 DPRINTF(("I_POP\n"));
1580                 return 0;
1581
1582         case SVR4_I_LOOK:
1583                 DPRINTF(("I_LOOK\n"));
1584                 return 0;
1585
1586         case SVR4_I_FLUSH:
1587                 DPRINTF(("I_FLUSH\n"));
1588                 return 0;
1589
1590         case SVR4_I_SRDOPT:
1591                 DPRINTF(("I_SRDOPT\n"));
1592                 return 0;
1593
1594         case SVR4_I_GRDOPT:
1595                 DPRINTF(("I_GRDOPT\n"));
1596                 return 0;
1597
1598         case SVR4_I_STR:
1599                 DPRINTF(("I_STR\n"));
1600                 return i_str(fp, td, retval, fd, cmd, dat);
1601
1602         case SVR4_I_SETSIG:
1603                 DPRINTF(("I_SETSIG\n"));
1604                 return i_setsig(fp, td, retval, fd, cmd, dat);
1605
1606         case SVR4_I_GETSIG:
1607                 DPRINTF(("I_GETSIG\n"));
1608                 return i_getsig(fp, td, retval, fd, cmd, dat);
1609
1610         case SVR4_I_FIND:
1611                 DPRINTF(("I_FIND\n"));
1612                 /*
1613                  * Here we are not pushing modules really, we just
1614                  * pretend all are present
1615                  */
1616                 *retval = 0;
1617                 return 0;
1618
1619         case SVR4_I_LINK:
1620                 DPRINTF(("I_LINK\n"));
1621                 return 0;
1622
1623         case SVR4_I_UNLINK:
1624                 DPRINTF(("I_UNLINK\n"));
1625                 return 0;
1626
1627         case SVR4_I_ERECVFD:
1628                 DPRINTF(("I_ERECVFD\n"));
1629                 return 0;
1630
1631         case SVR4_I_PEEK:
1632                 DPRINTF(("I_PEEK\n"));
1633                 return 0;
1634
1635         case SVR4_I_FDINSERT:
1636                 DPRINTF(("I_FDINSERT\n"));
1637                 return i_fdinsert(fp, td, retval, fd, cmd, dat);
1638
1639         case SVR4_I_SENDFD:
1640                 DPRINTF(("I_SENDFD\n"));
1641                 return 0;
1642
1643         case SVR4_I_RECVFD:
1644                 DPRINTF(("I_RECVFD\n"));
1645                 return 0;
1646
1647         case SVR4_I_SWROPT:
1648                 DPRINTF(("I_SWROPT\n"));
1649                 return 0;
1650
1651         case SVR4_I_GWROPT:
1652                 DPRINTF(("I_GWROPT\n"));
1653                 return 0;
1654
1655         case SVR4_I_LIST:
1656                 DPRINTF(("I_LIST\n"));
1657                 return 0;
1658
1659         case SVR4_I_PLINK:
1660                 DPRINTF(("I_PLINK\n"));
1661                 return 0;
1662
1663         case SVR4_I_PUNLINK:
1664                 DPRINTF(("I_PUNLINK\n"));
1665                 return 0;
1666
1667         case SVR4_I_SETEV:
1668                 DPRINTF(("I_SETEV\n"));
1669                 return 0;
1670
1671         case SVR4_I_GETEV:
1672                 DPRINTF(("I_GETEV\n"));
1673                 return 0;
1674
1675         case SVR4_I_STREV:
1676                 DPRINTF(("I_STREV\n"));
1677                 return 0;
1678
1679         case SVR4_I_UNSTREV:
1680                 DPRINTF(("I_UNSTREV\n"));
1681                 return 0;
1682
1683         case SVR4_I_FLUSHBAND:
1684                 DPRINTF(("I_FLUSHBAND\n"));
1685                 return 0;
1686
1687         case SVR4_I_CKBAND:
1688                 DPRINTF(("I_CKBAND\n"));
1689                 return 0;
1690
1691         case SVR4_I_GETBAND:
1692                 DPRINTF(("I_GETBANK\n"));
1693                 return 0;
1694
1695         case SVR4_I_ATMARK:
1696                 DPRINTF(("I_ATMARK\n"));
1697                 return 0;
1698
1699         case SVR4_I_SETCLTIME:
1700                 DPRINTF(("I_SETCLTIME\n"));
1701                 return 0;
1702
1703         case SVR4_I_GETCLTIME:
1704                 DPRINTF(("I_GETCLTIME\n"));
1705                 return 0;
1706
1707         case SVR4_I_CANPUT:
1708                 DPRINTF(("I_CANPUT\n"));
1709                 return 0;
1710
1711         case SVR4__I_BIND_RSVD:
1712                 DPRINTF(("_I_BIND_RSVD\n"));
1713                 return _i_bind_rsvd(fp, td, retval, fd, cmd, dat);
1714
1715         case SVR4__I_RELE_RSVD:
1716                 DPRINTF(("_I_RELE_RSVD\n"));
1717                 return _i_rele_rsvd(fp, td, retval, fd, cmd, dat);
1718
1719         default:
1720                 DPRINTF(("unimpl cmd = %lx\n", cmd));
1721                 break;
1722         }
1723
1724         return 0;
1725 }
1726
1727
1728
1729 int
1730 svr4_sys_putmsg(struct svr4_sys_putmsg_args *uap)
1731 {
1732         struct thread *td = curthread;
1733         struct proc *p = td->td_proc;
1734         struct filedesc *fdp;
1735         struct file     *fp;
1736         struct svr4_strbuf dat, ctl;
1737         struct svr4_strmcmd sc;
1738         struct sockaddr_in sain;
1739         struct sockaddr_un saun;
1740         void *skp, *sup;
1741         int sasize, *retval;
1742         struct svr4_strm *st;
1743         int error;
1744         caddr_t sg;
1745
1746         KKASSERT(p);
1747         fdp = p->p_fd;
1748         retval = &uap->sysmsg_result;
1749         fp = fdp->fd_ofiles[SCARG(uap, fd)];
1750
1751         if (((u_int)SCARG(uap, fd) >= fdp->fd_nfiles) || (fp == NULL)) {
1752 #ifdef DEBUG_SVR4
1753                 uprintf("putmsg: bad fp\n");
1754 #endif
1755                 return EBADF;
1756         }
1757
1758 #ifdef DEBUG_SVR4
1759         show_msg(">putmsg", SCARG(uap, fd), SCARG(uap, ctl),
1760                  SCARG(uap, dat), SCARG(uap, flags));
1761 #endif /* DEBUG_SVR4 */
1762
1763         if (((u_int)SCARG(uap, fd) >= fdp->fd_nfiles) || (fp == NULL)) {
1764 #ifdef DEBUG_SVR4
1765                 uprintf("putmsg: bad fp(2)\n");
1766 #endif
1767                 return EBADF;
1768         }
1769
1770         if (SCARG(uap, ctl) != NULL) {
1771           if ((error = copyin(SCARG(uap, ctl), &ctl, sizeof(ctl))) != 0) {
1772 #ifdef DEBUG_SVR4
1773             uprintf("putmsg: copyin(): %d\n", error);
1774 #endif
1775             return error;
1776           }
1777         }
1778         else
1779                 ctl.len = -1;
1780
1781         if (SCARG(uap, dat) != NULL) {
1782           if ((error = copyin(SCARG(uap, dat), &dat, sizeof(dat))) != 0) {
1783 #ifdef DEBUG_SVR4
1784             uprintf("putmsg: copyin(): %d (2)\n", error);
1785 #endif
1786             return error;
1787           }
1788         }
1789         else
1790                 dat.len = -1;
1791
1792         /*
1793          * Only for sockets for now.
1794          */
1795         if ((st = svr4_stream_get(fp)) == NULL) {
1796                 DPRINTF(("putmsg: bad file type\n"));
1797                 return EINVAL;
1798         }
1799
1800         if (ctl.len > sizeof(sc)) {
1801                 DPRINTF(("putmsg: Bad control size %d != %d\n", ctl.len,
1802                          sizeof(struct svr4_strmcmd)));
1803                 return EINVAL;
1804         }
1805
1806         if ((error = copyin(ctl.buf, &sc, ctl.len)) != 0)
1807                 return error;
1808
1809         switch (st->s_family) {
1810         case AF_INET:
1811                 if (sc.len != sizeof(sain)) {
1812                         if (sc.cmd == SVR4_TI_DATA_REQUEST) {
1813                                 struct write_args wa;
1814
1815                                 /* Solaris seems to use sc.cmd = 3 to
1816                                  * send "expedited" data.  telnet uses
1817                                  * this for options processing, sending EOF,
1818                                  * etc.  I'm sure other things use it too.
1819                                  * I don't have any documentation
1820                                  * on it, so I'm making a guess that this
1821                                  * is how it works. newton@atdot.dotat.org XXX
1822                                  */
1823                                 DPRINTF(("sending expedited data ??\n"));
1824                                 SCARG(&wa, fd) = SCARG(uap, fd);
1825                                 SCARG(&wa, buf) = dat.buf;
1826                                 SCARG(&wa, nbyte) = dat.len;
1827                                 wa.sysmsg_result = 0;
1828
1829                                 error = write(&wa);
1830                                 *retval = wa.sysmsg_result;
1831                                 return(error);
1832                         }
1833                         DPRINTF(("putmsg: Invalid inet length %ld\n", sc.len));
1834                         return EINVAL;
1835                 }
1836                 netaddr_to_sockaddr_in(&sain, &sc);
1837                 skp = &sain;
1838                 sasize = sizeof(sain);
1839                 error = sain.sin_family != st->s_family;
1840                 break;
1841
1842         case AF_LOCAL:
1843                 if (ctl.len == 8) {
1844                         /* We are doing an accept; succeed */
1845                         DPRINTF(("putmsg: Do nothing\n"));
1846                         *retval = 0;
1847                         return 0;
1848                 }
1849                 else {
1850                         /* Maybe we've been given a device/inode pair */
1851                         udev_t *dev = SVR4_ADDROF(&sc);
1852                         ino_t *ino = (ino_t *) &dev[1];
1853                         skp = svr4_find_socket(td, fp, *dev, *ino);
1854                         if (skp == NULL) {
1855                                 skp = &saun;
1856                                 /* I guess we have it by name */
1857                                 netaddr_to_sockaddr_un(skp, &sc);
1858                         }
1859                         sasize = sizeof(saun);
1860                 }
1861                 break;
1862
1863         default:
1864                 DPRINTF(("putmsg: Unsupported address family %d\n",
1865                          st->s_family));
1866                 return ENOSYS;
1867         }
1868
1869         sg = stackgap_init();
1870         sup = stackgap_alloc(&sg, sasize);
1871
1872         if ((error = copyout(skp, sup, sasize)) != 0)
1873                 return error;
1874
1875         switch (st->s_cmd = sc.cmd) {
1876         case SVR4_TI_CONNECT_REQUEST:   /* connect      */
1877                 {
1878                         struct connect_args co;
1879
1880                         SCARG(&co, s) = SCARG(uap, fd);
1881                         SCARG(&co, name) = (void *) sup;
1882                         SCARG(&co, namelen) = (int) sasize;
1883                         co.sysmsg_result = 0;
1884
1885                         error = connect(&co);
1886                         *retval = co.sysmsg_result;
1887                         return(error);
1888                 }
1889
1890         case SVR4_TI_SENDTO_REQUEST:    /* sendto       */
1891                 {
1892                         struct msghdr msg;
1893                         struct iovec aiov;
1894
1895                         msg.msg_name = (caddr_t) sup;
1896                         msg.msg_namelen = sasize;
1897                         msg.msg_iov = &aiov;
1898                         msg.msg_iovlen = 1;
1899                         msg.msg_control = 0;
1900                         msg.msg_flags = 0;
1901                         aiov.iov_base = dat.buf;
1902                         aiov.iov_len = dat.len;
1903 #if 0
1904                         error = so->so_proto->pr_usrreqs->pru_sosend
1905                                     (so, 0, uio, 0, 0, 0, uio->uio_td);
1906 #endif
1907                         error = svr4_sendit(td, SCARG(uap, fd), &msg,
1908                                        SCARG(uap, flags), retval);
1909                         DPRINTF(("sendto_request error: %d\n", error));
1910                         *retval = 0;
1911                         return error;
1912                 }
1913
1914         default:
1915                 DPRINTF(("putmsg: Unimplemented command %lx\n", sc.cmd));
1916                 return ENOSYS;
1917         }
1918 }
1919
1920 int
1921 svr4_sys_getmsg(struct svr4_sys_getmsg_args *uap)
1922 {
1923         struct thread *td = curthread;
1924         struct proc *p = td->td_proc;
1925         struct filedesc *fdp;
1926         struct file     *fp;
1927         struct getpeername_args ga;
1928         struct accept_args aa;
1929         struct svr4_strbuf dat, ctl;
1930         struct svr4_strmcmd sc;
1931         int error, *retval;
1932         struct msghdr msg;
1933         struct iovec aiov;
1934         struct sockaddr_in sain;
1935         struct sockaddr_un saun;
1936         void *skp, *sup;
1937         int sasize;
1938         struct svr4_strm *st;
1939         int *flen;
1940         int fl;
1941         caddr_t sg;
1942
1943         KKASSERT(p);
1944         fdp = p->p_fd;
1945         retval = &uap->sysmsg_result;
1946         fp = fdp->fd_ofiles[SCARG(uap, fd)];
1947
1948         if (((u_int)SCARG(uap, fd) >= fdp->fd_nfiles) || (fp == NULL))
1949                 return EBADF;
1950
1951         memset(&sc, 0, sizeof(sc));
1952
1953 #ifdef DEBUG_SVR4
1954         show_msg(">getmsg", SCARG(uap, fd), SCARG(uap, ctl),
1955                  SCARG(uap, dat), 0);
1956 #endif /* DEBUG_SVR4 */
1957
1958         if (((u_int)SCARG(uap, fd) >= fdp->fd_nfiles) || (fp == NULL))
1959                 return EBADF;
1960
1961         if (SCARG(uap, ctl) != NULL) {
1962                 if ((error = copyin(SCARG(uap, ctl), &ctl, sizeof(ctl))) != 0)
1963                         return error;
1964         }
1965         else {
1966                 ctl.len = -1;
1967                 ctl.maxlen = 0;
1968         }
1969
1970         if (SCARG(uap, dat) != NULL) {
1971                 if ((error = copyin(SCARG(uap, dat), &dat, sizeof(dat))) != 0)
1972                         return error;
1973         }
1974         else {
1975                 dat.len = -1;
1976                 dat.maxlen = 0;
1977         }
1978
1979         /*
1980          * Only for sockets for now.
1981          */
1982         if ((st = svr4_stream_get(fp)) == NULL) {
1983                 DPRINTF(("getmsg: bad file type\n"));
1984                 return EINVAL;
1985         }
1986
1987         if (ctl.maxlen == -1 || dat.maxlen == -1) {
1988                 DPRINTF(("getmsg: Cannot handle -1 maxlen (yet)\n"));
1989                 return ENOSYS;
1990         }
1991
1992         switch (st->s_family) {
1993         case AF_INET:
1994                 skp = &sain;
1995                 sasize = sizeof(sain);
1996                 break;
1997
1998         case AF_LOCAL:
1999                 skp = &saun;
2000                 sasize = sizeof(saun);
2001                 break;
2002
2003         default:
2004                 DPRINTF(("getmsg: Unsupported address family %d\n",
2005                          st->s_family));
2006                 return ENOSYS;
2007         }
2008
2009         sg = stackgap_init();
2010         sup = stackgap_alloc(&sg, sasize);
2011         flen = (int *) stackgap_alloc(&sg, sizeof(*flen));
2012
2013         fl = sasize;
2014         if ((error = copyout(&fl, flen, sizeof(fl))) != 0)
2015                 return error;
2016
2017         switch (st->s_cmd) {
2018         case SVR4_TI_CONNECT_REQUEST:
2019                 DPRINTF(("getmsg: TI_CONNECT_REQUEST\n"));
2020                 /*
2021                  * We do the connect in one step, so the putmsg should
2022                  * have gotten the error.
2023                  */
2024                 sc.cmd = SVR4_TI_OK_REPLY;
2025                 sc.len = 0;
2026
2027                 ctl.len = 8;
2028                 dat.len = -1;
2029                 fl = 1;
2030                 st->s_cmd = sc.cmd;
2031                 break;
2032
2033         case SVR4_TI_OK_REPLY:
2034                 DPRINTF(("getmsg: TI_OK_REPLY\n"));
2035                 /*
2036                  * We are immediately after a connect reply, so we send
2037                  * a connect verification.
2038                  */
2039
2040                 SCARG(&ga, fdes) = SCARG(uap, fd);
2041                 SCARG(&ga, asa) = (void *) sup;
2042                 SCARG(&ga, alen) = flen;
2043
2044                 if ((error = getpeername(&ga)) != 0) {
2045                         DPRINTF(("getmsg: getpeername failed %d\n", error));
2046                         return error;
2047                 }
2048
2049                 if ((error = copyin(sup, skp, sasize)) != 0)
2050                         return error;
2051
2052                 sc.cmd = SVR4_TI_CONNECT_REPLY;
2053                 sc.pad[0] = 0x4;
2054                 sc.offs = 0x18;
2055                 sc.pad[1] = 0x14;
2056                 sc.pad[2] = 0x04000402;
2057
2058                 switch (st->s_family) {
2059                 case AF_INET:
2060                         sc.len = sasize;
2061                         sockaddr_to_netaddr_in(&sc, &sain);
2062                         break;
2063
2064                 case AF_LOCAL:
2065                         sc.len = sasize + 4;
2066                         sockaddr_to_netaddr_un(&sc, &saun);
2067                         break;
2068
2069                 default:
2070                         return ENOSYS;
2071                 }
2072
2073                 ctl.len = 40;
2074                 dat.len = -1;
2075                 fl = 0;
2076                 st->s_cmd = sc.cmd;
2077                 break;
2078
2079         case SVR4_TI__ACCEPT_OK:
2080                 DPRINTF(("getmsg: TI__ACCEPT_OK\n"));
2081                 /*
2082                  * We do the connect in one step, so the putmsg should
2083                  * have gotten the error.
2084                  */
2085                 sc.cmd = SVR4_TI_OK_REPLY;
2086                 sc.len = 1;
2087
2088                 ctl.len = 8;
2089                 dat.len = -1;
2090                 fl = 1;
2091                 st->s_cmd = SVR4_TI__ACCEPT_WAIT;
2092                 break;
2093
2094         case SVR4_TI__ACCEPT_WAIT:
2095                 DPRINTF(("getmsg: TI__ACCEPT_WAIT\n"));
2096                 /*
2097                  * We are after a listen, so we try to accept...
2098                  */
2099                 SCARG(&aa, s) = SCARG(uap, fd);
2100                 SCARG(&aa, name) = (void *) sup;
2101                 SCARG(&aa, anamelen) = flen;
2102
2103                 if ((error = accept(&aa)) != 0) {
2104                         DPRINTF(("getmsg: accept failed %d\n", error));
2105                         return error;
2106                 }
2107
2108                 st->s_afd = *retval;
2109
2110                 DPRINTF(("getmsg: Accept fd = %d\n", st->s_afd));
2111
2112                 if ((error = copyin(sup, skp, sasize)) != 0)
2113                         return error;
2114
2115                 sc.cmd = SVR4_TI_ACCEPT_REPLY;
2116                 sc.offs = 0x18;
2117                 sc.pad[0] = 0x0;
2118
2119                 switch (st->s_family) {
2120                 case AF_INET:
2121                         sc.pad[1] = 0x28;
2122                         sockaddr_to_netaddr_in(&sc, &sain);
2123                         ctl.len = 40;
2124                         sc.len = sasize;
2125                         break;
2126
2127                 case AF_LOCAL:
2128                         sc.pad[1] = 0x00010000;
2129                         sc.pad[2] = 0xf6bcdaa0; /* I don't know what that is */
2130                         sc.pad[3] = 0x00010000;
2131                         ctl.len = 134;
2132                         sc.len = sasize + 4;
2133                         break;
2134
2135                 default:
2136                         return ENOSYS;
2137                 }
2138
2139                 dat.len = -1;
2140                 fl = 0;
2141                 st->s_cmd = SVR4_TI__ACCEPT_OK;
2142                 break;
2143
2144         case SVR4_TI_SENDTO_REQUEST:
2145                 DPRINTF(("getmsg: TI_SENDTO_REQUEST\n"));
2146                 if (ctl.maxlen > 36 && ctl.len < 36)
2147                     ctl.len = 36;
2148
2149                 if ((error = copyin(ctl.buf, &sc, ctl.len)) != 0)
2150                         return error;
2151
2152                 switch (st->s_family) {
2153                 case AF_INET:
2154                         sockaddr_to_netaddr_in(&sc, &sain);
2155                         break;
2156
2157                 case AF_LOCAL:
2158                         sockaddr_to_netaddr_un(&sc, &saun);
2159                         break;
2160
2161                 default:
2162                         return ENOSYS;
2163                 }
2164
2165                 msg.msg_name = (caddr_t) sup;
2166                 msg.msg_namelen = sasize;
2167                 msg.msg_iov = &aiov;
2168                 msg.msg_iovlen = 1;
2169                 msg.msg_control = 0;
2170                 aiov.iov_base = dat.buf;
2171                 aiov.iov_len = dat.maxlen;
2172                 msg.msg_flags = 0;
2173
2174                 error = svr4_recvit(td, SCARG(uap, fd), &msg, (caddr_t) flen, retval);
2175
2176                 if (error) {
2177                         DPRINTF(("getmsg: recvit failed %d\n", error));
2178                         return error;
2179                 }
2180
2181                 if ((error = copyin(msg.msg_name, skp, sasize)) != 0)
2182                         return error;
2183
2184                 sc.cmd = SVR4_TI_RECVFROM_IND;
2185
2186                 switch (st->s_family) {
2187                 case AF_INET:
2188                         sc.len = sasize;
2189                         sockaddr_to_netaddr_in(&sc, &sain);
2190                         break;
2191
2192                 case AF_LOCAL:
2193                         sc.len = sasize + 4;
2194                         sockaddr_to_netaddr_un(&sc, &saun);
2195                         break;
2196
2197                 default:
2198                         return ENOSYS;
2199                 }
2200
2201                 dat.len = *retval;
2202                 fl = 0;
2203                 st->s_cmd = sc.cmd;
2204                 break;
2205
2206         default:
2207                 st->s_cmd = sc.cmd;
2208                 if (st->s_cmd == SVR4_TI_CONNECT_REQUEST) {
2209                         struct read_args ra;
2210
2211                         /* More wierdness:  Again, I can't find documentation
2212                          * to back this up, but when a process does a generic
2213                          * "getmsg()" call it seems that the command field is
2214                          * zero and the length of the data area is zero.  I
2215                          * think processes expect getmsg() to fill in dat.len
2216                          * after reading at most dat.maxlen octets from the
2217                          * stream.  Since we're using sockets I can let
2218                          * read() look after it and frob return values
2219                          * appropriately (or inappropriately :-)
2220                          *   -- newton@atdot.dotat.org        XXX
2221                          */
2222                         SCARG(&ra, fd) = SCARG(uap, fd);
2223                         SCARG(&ra, buf) = dat.buf;
2224                         SCARG(&ra, nbyte) = dat.maxlen;
2225                         if ((error = read(&ra)) != 0) {
2226                                 return error;
2227                         }
2228                         dat.len = *retval;
2229                         *retval = 0;
2230                         st->s_cmd = SVR4_TI_SENDTO_REQUEST;
2231                         break;
2232                 }
2233                 DPRINTF(("getmsg: Unknown state %x\n", st->s_cmd));
2234                 return EINVAL;
2235         }
2236
2237         if (SCARG(uap, ctl)) {
2238                 if (ctl.len != -1)
2239                         if ((error = copyout(&sc, ctl.buf, ctl.len)) != 0)
2240                                 return error;
2241
2242                 if ((error = copyout(&ctl, SCARG(uap, ctl), sizeof(ctl))) != 0)
2243                         return error;
2244         }
2245
2246         if (SCARG(uap, dat)) {
2247                 if ((error = copyout(&dat, SCARG(uap, dat), sizeof(dat))) != 0)
2248                         return error;
2249         }
2250
2251         if (SCARG(uap, flags)) { /* XXX: Need translation */
2252                 if ((error = copyout(&fl, SCARG(uap, flags), sizeof(fl))) != 0)
2253                         return error;
2254         }
2255
2256         *retval = 0;
2257
2258 #ifdef DEBUG_SVR4
2259         show_msg("<getmsg", SCARG(uap, fd), SCARG(uap, ctl),
2260                  SCARG(uap, dat), fl);
2261 #endif /* DEBUG_SVR4 */
2262         return error;
2263 }
2264
2265 int svr4_sys_send(struct svr4_sys_send_args *uap)
2266 {
2267         struct osend_args osa;
2268         int error;
2269
2270         SCARG(&osa, s) = SCARG(uap, s);
2271         SCARG(&osa, buf) = SCARG(uap, buf);
2272         SCARG(&osa, len) = SCARG(uap, len);
2273         SCARG(&osa, flags) = SCARG(uap, flags);
2274         osa.sysmsg_result = 0;
2275         error = osend(&osa);
2276         uap->sysmsg_result = osa.sysmsg_result;
2277         return(error);
2278 }
2279
2280 int svr4_sys_recv(struct svr4_sys_recv_args *uap)
2281 {
2282         struct orecv_args ora;
2283         int error;
2284
2285         SCARG(&ora, s) = SCARG(uap, s);
2286         SCARG(&ora, buf) = SCARG(uap, buf);
2287         SCARG(&ora, len) = SCARG(uap, len);
2288         SCARG(&ora, flags) = SCARG(uap, flags);
2289         ora.sysmsg_result = 0;
2290         error = orecv(&ora);
2291         uap->sysmsg_result = ora.sysmsg_result;
2292         return(error);
2293 }
2294
2295 /*
2296  * XXX This isn't necessary, but it's handy for inserting debug code into
2297  * sendto().  Let's leave it here for now...
2298  */
2299 int
2300 svr4_sys_sendto(struct svr4_sys_sendto_args *uap)
2301 {
2302         struct sendto_args sa;
2303         int error;
2304
2305         SCARG(&sa, s) = SCARG(uap, s);
2306         SCARG(&sa, buf) = SCARG(uap, buf);
2307         SCARG(&sa, len) = SCARG(uap, len);
2308         SCARG(&sa, flags) = SCARG(uap, flags);
2309         SCARG(&sa, to) = (caddr_t)SCARG(uap, to);
2310         SCARG(&sa, tolen) = SCARG(uap, tolen);
2311
2312         DPRINTF(("calling sendto()\n"));
2313         sa.sysmsg_result = 0;
2314         error = sendto(&sa);
2315         uap->sysmsg_result = sa.sysmsg_result;
2316         return(error);
2317 }
2318