The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/compat/svr4/svr4_stream.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

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

Cache object: 45bb4eeb5ec1b10c179d1d643362eb3c


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.