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/cloudabi/cloudabi_sock.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) 2015-2017 Nuxi, https://nuxi.nl/
    3  *
    4  * Redistribution and use in source and binary forms, with or without
    5  * modification, are permitted provided that the following conditions
    6  * are met:
    7  * 1. Redistributions of source code must retain the above copyright
    8  *    notice, this list of conditions and the following disclaimer.
    9  * 2. Redistributions in binary form must reproduce the above copyright
   10  *    notice, this list of conditions and the following disclaimer in the
   11  *    documentation and/or other materials provided with the distribution.
   12  *
   13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   16  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   23  * SUCH DAMAGE.
   24  */
   25 
   26 #include <sys/cdefs.h>
   27 __FBSDID("$FreeBSD: releng/11.1/sys/compat/cloudabi/cloudabi_sock.c 316574 2017-04-06 15:10:36Z ed $");
   28 
   29 #include <sys/param.h>
   30 #include <sys/capsicum.h>
   31 #include <sys/lock.h>
   32 #include <sys/malloc.h>
   33 #include <sys/mbuf.h>
   34 #include <sys/mutex.h>
   35 #include <sys/proc.h>
   36 #include <sys/protosw.h>
   37 #include <sys/socket.h>
   38 #include <sys/socketvar.h>
   39 #include <sys/syscallsubr.h>
   40 #include <sys/systm.h>
   41 #include <sys/un.h>
   42 
   43 #include <net/vnet.h>
   44 
   45 #include <netinet/in.h>
   46 
   47 #include <contrib/cloudabi/cloudabi_types_common.h>
   48 
   49 #include <compat/cloudabi/cloudabi_proto.h>
   50 #include <compat/cloudabi/cloudabi_util.h>
   51 
   52 /* Converts FreeBSD's struct sockaddr to CloudABI's cloudabi_sockaddr_t. */
   53 static void
   54 cloudabi_convert_sockaddr(const struct sockaddr *sa, socklen_t sal,
   55     cloudabi_sockaddr_t *rsa)
   56 {
   57         const struct sockaddr_in *sin;
   58         const struct sockaddr_in6 *sin6;
   59 
   60         /* Zero-sized socket address. */
   61         if (sal < offsetof(struct sockaddr, sa_family) + sizeof(sa->sa_family))
   62                 return;
   63 
   64         switch (sa->sa_family) {
   65         case AF_INET:
   66                 if (sal < sizeof(struct sockaddr_in))
   67                         return;
   68                 sin = (const struct sockaddr_in *)sa;
   69                 rsa->sa_family = CLOUDABI_AF_INET;
   70                 memcpy(&rsa->sa_inet.addr, &sin->sin_addr,
   71                     sizeof(rsa->sa_inet.addr));
   72                 rsa->sa_inet.port = ntohs(sin->sin_port);
   73                 return;
   74         case AF_INET6:
   75                 if (sal < sizeof(struct sockaddr_in6))
   76                         return;
   77                 sin6 = (const struct sockaddr_in6 *)sa;
   78                 rsa->sa_family = CLOUDABI_AF_INET6;
   79                 memcpy(&rsa->sa_inet6.addr, &sin6->sin6_addr,
   80                     sizeof(rsa->sa_inet6.addr));
   81                 rsa->sa_inet6.port = ntohs(sin6->sin6_port);
   82                 return;
   83         case AF_UNIX:
   84                 rsa->sa_family = CLOUDABI_AF_UNIX;
   85                 return;
   86         }
   87 }
   88 
   89 /* Copies a pathname into a UNIX socket address structure. */
   90 static int
   91 copyin_sockaddr_un(const char *path, size_t pathlen, struct sockaddr_un *sun)
   92 {
   93         int error;
   94 
   95         /* Copy in pathname string if there's enough space. */
   96         if (pathlen >= sizeof(sun->sun_path))
   97                 return (ENAMETOOLONG);
   98         error = copyin(path, &sun->sun_path, pathlen);
   99         if (error != 0)
  100                 return (error);
  101         if (memchr(sun->sun_path, '\0', pathlen) != NULL)
  102                 return (EINVAL);
  103 
  104         /* Initialize the rest of the socket address. */
  105         sun->sun_path[pathlen] = '\0';
  106         sun->sun_family = AF_UNIX;
  107         sun->sun_len = sizeof(*sun);
  108         return (0);
  109 }
  110 
  111 int
  112 cloudabi_sys_sock_accept(struct thread *td,
  113     struct cloudabi_sys_sock_accept_args *uap)
  114 {
  115         struct sockaddr *sa;
  116         cloudabi_sockstat_t ss = {};
  117         socklen_t sal;
  118         int error;
  119 
  120         if (uap->buf == NULL) {
  121                 /* Only return the new file descriptor number. */
  122                 return (kern_accept(td, uap->sock, NULL, NULL, NULL));
  123         } else {
  124                 /* Also return properties of the new socket descriptor. */
  125                 sal = MAX(sizeof(struct sockaddr_in),
  126                     sizeof(struct sockaddr_in6));
  127                 error = kern_accept(td, uap->sock, (void *)&sa, &sal, NULL);
  128                 if (error != 0)
  129                         return (error);
  130 
  131                 /* TODO(ed): Fill the other members of cloudabi_sockstat_t. */
  132                 cloudabi_convert_sockaddr(sa, sal, &ss.ss_peername);
  133                 free(sa, M_SONAME);
  134                 return (copyout(&ss, uap->buf, sizeof(ss)));
  135         }
  136 }
  137 
  138 int
  139 cloudabi_sys_sock_bind(struct thread *td,
  140     struct cloudabi_sys_sock_bind_args *uap)
  141 {
  142         struct sockaddr_un sun;
  143         int error;
  144 
  145         error = copyin_sockaddr_un(uap->path, uap->path_len, &sun);
  146         if (error != 0)
  147                 return (error);
  148         return (kern_bindat(td, uap->fd, uap->sock, (struct sockaddr *)&sun));
  149 }
  150 
  151 int
  152 cloudabi_sys_sock_connect(struct thread *td,
  153     struct cloudabi_sys_sock_connect_args *uap)
  154 {
  155         struct sockaddr_un sun;
  156         int error;
  157 
  158         error = copyin_sockaddr_un(uap->path, uap->path_len, &sun);
  159         if (error != 0)
  160                 return (error);
  161         return (kern_connectat(td, uap->fd, uap->sock,
  162             (struct sockaddr *)&sun));
  163 }
  164 
  165 int
  166 cloudabi_sys_sock_listen(struct thread *td,
  167     struct cloudabi_sys_sock_listen_args *uap)
  168 {
  169 
  170         return (kern_listen(td, uap->sock, uap->backlog));
  171 }
  172 
  173 int
  174 cloudabi_sys_sock_shutdown(struct thread *td,
  175     struct cloudabi_sys_sock_shutdown_args *uap)
  176 {
  177         int how;
  178 
  179         switch (uap->how) {
  180         case CLOUDABI_SHUT_RD:
  181                 how = SHUT_RD;
  182                 break;
  183         case CLOUDABI_SHUT_WR:
  184                 how = SHUT_WR;
  185                 break;
  186         case CLOUDABI_SHUT_RD | CLOUDABI_SHUT_WR:
  187                 how = SHUT_RDWR;
  188                 break;
  189         default:
  190                 return (EINVAL);
  191         }
  192 
  193         return (kern_shutdown(td, uap->sock, how));
  194 }
  195 
  196 int
  197 cloudabi_sys_sock_stat_get(struct thread *td,
  198     struct cloudabi_sys_sock_stat_get_args *uap)
  199 {
  200         cloudabi_sockstat_t ss = {};
  201         cap_rights_t rights;
  202         struct file *fp;
  203         struct sockaddr *sa;
  204         struct socket *so;
  205         int error;
  206 
  207         error = getsock_cap(td, uap->sock, cap_rights_init(&rights,
  208             CAP_GETSOCKOPT, CAP_GETPEERNAME, CAP_GETSOCKNAME), &fp, NULL, NULL);
  209         if (error != 0)
  210                 return (error);
  211         so = fp->f_data;
  212 
  213         CURVNET_SET(so->so_vnet);
  214 
  215         /* Set ss_sockname. */
  216         error = so->so_proto->pr_usrreqs->pru_sockaddr(so, &sa);
  217         if (error == 0) {
  218                 cloudabi_convert_sockaddr(sa, sa->sa_len, &ss.ss_sockname);
  219                 free(sa, M_SONAME);
  220         }
  221 
  222         /* Set ss_peername. */
  223         if ((so->so_state & (SS_ISCONNECTED | SS_ISCONFIRMING)) != 0) {
  224                 error = so->so_proto->pr_usrreqs->pru_peeraddr(so, &sa);
  225                 if (error == 0) {
  226                         cloudabi_convert_sockaddr(sa, sa->sa_len,
  227                             &ss.ss_peername);
  228                         free(sa, M_SONAME);
  229                 }
  230         }
  231 
  232         CURVNET_RESTORE();
  233 
  234         /* Set ss_error. */
  235         SOCK_LOCK(so);
  236         ss.ss_error = cloudabi_convert_errno(so->so_error);
  237         if ((uap->flags & CLOUDABI_SOCKSTAT_CLEAR_ERROR) != 0)
  238                 so->so_error = 0;
  239         SOCK_UNLOCK(so);
  240 
  241         /* Set ss_state. */
  242         if ((so->so_options & SO_ACCEPTCONN) != 0)
  243                 ss.ss_state |= CLOUDABI_SOCKSTATE_ACCEPTCONN;
  244 
  245         fdrop(fp, td);
  246         return (copyout(&ss, uap->buf, sizeof(ss)));
  247 }
  248 
  249 int
  250 cloudabi_sock_recv(struct thread *td, cloudabi_fd_t fd, struct iovec *data,
  251     size_t datalen, cloudabi_fd_t *fds, size_t fdslen,
  252     cloudabi_msgflags_t flags, size_t *rdatalen, size_t *rfdslen,
  253     cloudabi_sockaddr_t *peername, cloudabi_msgflags_t *rflags)
  254 {
  255         struct sockaddr_storage ss;
  256         struct msghdr hdr = {
  257                 .msg_name = &ss,
  258                 .msg_namelen = sizeof(ss),
  259                 .msg_iov = data,
  260                 .msg_iovlen = datalen,
  261         };
  262         struct mbuf *control;
  263         int error;
  264 
  265         /* Convert flags. */
  266         if (flags & CLOUDABI_MSG_PEEK)
  267                 hdr.msg_flags |= MSG_PEEK;
  268         if (flags & CLOUDABI_MSG_WAITALL)
  269                 hdr.msg_flags |= MSG_WAITALL;
  270 
  271         control = NULL;
  272         error = kern_recvit(td, fd, &hdr, UIO_SYSSPACE,
  273             fdslen > 0 ? &control : NULL);
  274         if (error != 0)
  275                 return (error);
  276 
  277         /* Convert return values. */
  278         *rdatalen = td->td_retval[0];
  279         td->td_retval[0] = 0;
  280         *rfdslen = 0;
  281         cloudabi_convert_sockaddr((struct sockaddr *)&ss,
  282             MIN(hdr.msg_namelen, sizeof(ss)), peername);
  283         *rflags = 0;
  284         if (hdr.msg_flags & MSG_EOR)
  285                 *rflags |= CLOUDABI_MSG_EOR;
  286         if (hdr.msg_flags & MSG_TRUNC)
  287                 *rflags |= CLOUDABI_MSG_TRUNC;
  288 
  289         /* Extract file descriptors from SCM_RIGHTS messages. */
  290         if (control != NULL) {
  291                 struct cmsghdr *chdr;
  292 
  293                 hdr.msg_control = mtod(control, void *);
  294                 hdr.msg_controllen = control->m_len;
  295                 for (chdr = CMSG_FIRSTHDR(&hdr); chdr != NULL;
  296                     chdr = CMSG_NXTHDR(&hdr, chdr)) {
  297                         if (chdr->cmsg_level == SOL_SOCKET &&
  298                             chdr->cmsg_type == SCM_RIGHTS) {
  299                                 size_t nfds;
  300 
  301                                 nfds = (chdr->cmsg_len - CMSG_LEN(0)) /
  302                                     sizeof(int);
  303                                 if (nfds > fdslen) {
  304                                         /* Unable to store file descriptors. */
  305                                         nfds = fdslen;
  306                                         *rflags |= CLOUDABI_MSG_CTRUNC;
  307                                 }
  308                                 error = copyout(CMSG_DATA(chdr), fds,
  309                                     nfds * sizeof(int));
  310                                 if (error != 0) {
  311                                         m_free(control);
  312                                         return (error);
  313                                 }
  314                                 fds += nfds;
  315                                 fdslen -= nfds;
  316                                 *rfdslen += nfds;
  317                         }
  318                 }
  319                 m_free(control);
  320         }
  321         return (0);
  322 }
  323 
  324 int
  325 cloudabi_sock_send(struct thread *td, cloudabi_fd_t fd, struct iovec *data,
  326     size_t datalen, const cloudabi_fd_t *fds, size_t fdslen,
  327     cloudabi_msgflags_t flags, size_t *rdatalen)
  328 {
  329         struct msghdr hdr = {
  330                 .msg_iov = data,
  331                 .msg_iovlen = datalen,
  332         };
  333         struct mbuf *control;
  334         int error, mflags;
  335 
  336         /* Convert flags. */
  337         mflags = MSG_NOSIGNAL;
  338         if (flags & CLOUDABI_MSG_EOR)
  339                 mflags |= MSG_EOR;
  340 
  341         /* Convert file descriptor array to an SCM_RIGHTS message. */
  342         if (fdslen > MCLBYTES || CMSG_SPACE(fdslen * sizeof(int)) > MCLBYTES) {
  343                 return (EINVAL);
  344         } else if (fdslen > 0) {
  345                 struct cmsghdr *chdr;
  346 
  347                 control = m_get2(CMSG_SPACE(fdslen * sizeof(int)),
  348                     M_WAITOK, MT_CONTROL, 0);
  349                 control->m_len = CMSG_SPACE(fdslen * sizeof(int));
  350 
  351                 chdr = mtod(control, struct cmsghdr *);
  352                 chdr->cmsg_len = CMSG_LEN(fdslen * sizeof(int));
  353                 chdr->cmsg_level = SOL_SOCKET;
  354                 chdr->cmsg_type = SCM_RIGHTS;
  355                 error = copyin(fds, CMSG_DATA(chdr), fdslen * sizeof(int));
  356                 if (error != 0) {
  357                         m_free(control);
  358                         return (error);
  359                 }
  360         } else {
  361                 control = NULL;
  362         }
  363 
  364         error = kern_sendit(td, fd, &hdr, mflags, control, UIO_USERSPACE);
  365         if (error != 0)
  366                 return (error);
  367         *rdatalen = td->td_retval[0];
  368         td->td_retval[0] = 0;
  369         return (0);
  370 }

Cache object: 5240d0420e54117066bf2e10cbb40b6c


[ 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.