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.2/sys/compat/cloudabi/cloudabi_sock.c 324250 2017-10-04 07:35:01Z 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
42 #include <net/vnet.h>
43
44 #include <netinet/in.h>
45
46 #include <contrib/cloudabi/cloudabi_types_common.h>
47
48 #include <compat/cloudabi/cloudabi_proto.h>
49 #include <compat/cloudabi/cloudabi_util.h>
50
51 int
52 cloudabi_sys_sock_shutdown(struct thread *td,
53 struct cloudabi_sys_sock_shutdown_args *uap)
54 {
55 int how;
56
57 switch (uap->how) {
58 case CLOUDABI_SHUT_RD:
59 how = SHUT_RD;
60 break;
61 case CLOUDABI_SHUT_WR:
62 how = SHUT_WR;
63 break;
64 case CLOUDABI_SHUT_RD | CLOUDABI_SHUT_WR:
65 how = SHUT_RDWR;
66 break;
67 default:
68 return (EINVAL);
69 }
70
71 return (kern_shutdown(td, uap->sock, how));
72 }
73
74 int
75 cloudabi_sock_recv(struct thread *td, cloudabi_fd_t fd, struct iovec *data,
76 size_t datalen, cloudabi_fd_t *fds, size_t fdslen,
77 cloudabi_riflags_t flags, size_t *rdatalen, size_t *rfdslen,
78 cloudabi_roflags_t *rflags)
79 {
80 struct msghdr hdr = {
81 .msg_iov = data,
82 .msg_iovlen = datalen,
83 };
84 struct mbuf *control;
85 int error;
86
87 /* Convert flags. */
88 if (flags & CLOUDABI_SOCK_RECV_PEEK)
89 hdr.msg_flags |= MSG_PEEK;
90 if (flags & CLOUDABI_SOCK_RECV_WAITALL)
91 hdr.msg_flags |= MSG_WAITALL;
92
93 control = NULL;
94 error = kern_recvit(td, fd, &hdr, UIO_SYSSPACE,
95 fdslen > 0 ? &control : NULL);
96 if (error != 0)
97 return (error);
98
99 /* Convert return values. */
100 *rdatalen = td->td_retval[0];
101 td->td_retval[0] = 0;
102 *rfdslen = 0;
103 *rflags = 0;
104 if (hdr.msg_flags & MSG_TRUNC)
105 *rflags |= CLOUDABI_SOCK_RECV_DATA_TRUNCATED;
106
107 /* Extract file descriptors from SCM_RIGHTS messages. */
108 if (control != NULL) {
109 struct cmsghdr *chdr;
110
111 hdr.msg_control = mtod(control, void *);
112 hdr.msg_controllen = control->m_len;
113 for (chdr = CMSG_FIRSTHDR(&hdr); chdr != NULL;
114 chdr = CMSG_NXTHDR(&hdr, chdr)) {
115 if (chdr->cmsg_level == SOL_SOCKET &&
116 chdr->cmsg_type == SCM_RIGHTS) {
117 size_t nfds;
118
119 nfds = (chdr->cmsg_len - CMSG_LEN(0)) /
120 sizeof(int);
121 if (nfds > fdslen) {
122 /* Unable to store file descriptors. */
123 nfds = fdslen;
124 *rflags |=
125 CLOUDABI_SOCK_RECV_FDS_TRUNCATED;
126 }
127 error = copyout(CMSG_DATA(chdr), fds,
128 nfds * sizeof(int));
129 if (error != 0) {
130 m_free(control);
131 return (error);
132 }
133 fds += nfds;
134 fdslen -= nfds;
135 *rfdslen += nfds;
136 }
137 }
138 m_free(control);
139 }
140 return (0);
141 }
142
143 int
144 cloudabi_sock_send(struct thread *td, cloudabi_fd_t fd, struct iovec *data,
145 size_t datalen, const cloudabi_fd_t *fds, size_t fdslen, size_t *rdatalen)
146 {
147 struct msghdr hdr = {
148 .msg_iov = data,
149 .msg_iovlen = datalen,
150 };
151 struct mbuf *control;
152 int error;
153
154 /* Convert file descriptor array to an SCM_RIGHTS message. */
155 if (fdslen > MCLBYTES || CMSG_SPACE(fdslen * sizeof(int)) > MCLBYTES) {
156 return (EINVAL);
157 } else if (fdslen > 0) {
158 struct cmsghdr *chdr;
159
160 control = m_get2(CMSG_SPACE(fdslen * sizeof(int)),
161 M_WAITOK, MT_CONTROL, 0);
162 control->m_len = CMSG_SPACE(fdslen * sizeof(int));
163
164 chdr = mtod(control, struct cmsghdr *);
165 chdr->cmsg_len = CMSG_LEN(fdslen * sizeof(int));
166 chdr->cmsg_level = SOL_SOCKET;
167 chdr->cmsg_type = SCM_RIGHTS;
168 error = copyin(fds, CMSG_DATA(chdr), fdslen * sizeof(int));
169 if (error != 0) {
170 m_free(control);
171 return (error);
172 }
173 } else {
174 control = NULL;
175 }
176
177 error = kern_sendit(td, fd, &hdr, MSG_NOSIGNAL, control, UIO_USERSPACE);
178 if (error != 0)
179 return (error);
180 *rdatalen = td->td_retval[0];
181 td->td_retval[0] = 0;
182 return (0);
183 }
Cache object: eb622692d6bccdf098acd0a11248ae5e
|