1 /*- 2 * Copyright (c) 2012-2013 The FreeBSD Foundation 3 * Copyright (c) 2015 Mariusz Zaborski <oshogbo@FreeBSD.org> 4 * All rights reserved. 5 * 6 * This software was developed by Pawel Jakub Dawidek under sponsorship from 7 * the FreeBSD Foundation. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 */ 30 31 #include <sys/cdefs.h> 32 __FBSDID("$FreeBSD$"); 33 34 #include <sys/types.h> 35 #include <sys/socket.h> 36 #include <sys/nv.h> 37 #include <sys/procdesc.h> 38 39 #include <assert.h> 40 #include <errno.h> 41 #include <stdbool.h> 42 #include <stdlib.h> 43 #include <string.h> 44 #include <unistd.h> 45 46 #include "libcasper.h" 47 #include "libcasper_impl.h" 48 49 /* 50 * Structure describing communication channel between two separated processes. 51 */ 52 #define CAP_CHANNEL_MAGIC 0xcac8a31 53 struct cap_channel { 54 /* 55 * Magic value helps to ensure that a pointer to the right structure is 56 * passed to our functions. 57 */ 58 int cch_magic; 59 /* Socket descriptor for IPC. */ 60 int cch_sock; 61 /* Process descriptor for casper. */ 62 int cch_pd; 63 }; 64 65 static bool 66 cap_add_pd(cap_channel_t *chan, int pd) 67 { 68 69 if (!fd_is_valid(pd)) 70 return (false); 71 chan->cch_pd = pd; 72 return (true); 73 } 74 75 cap_channel_t * 76 cap_init(void) 77 { 78 pid_t pid; 79 int sock[2], serrno, pfd; 80 bool ret; 81 cap_channel_t *chan; 82 83 if (socketpair(PF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0, 84 sock) == -1) { 85 return (NULL); 86 } 87 88 pid = pdfork(&pfd, 0); 89 if (pid == 0) { 90 /* Parent. */ 91 close(sock[0]); 92 casper_main_loop(sock[1]); 93 /* NOTREACHED. */ 94 } else if (pid > 0) { 95 /* Child. */ 96 close(sock[1]); 97 chan = cap_wrap(sock[0]); 98 if (chan == NULL) { 99 serrno = errno; 100 close(sock[0]); 101 close(pfd); 102 errno = serrno; 103 return (NULL); 104 } 105 ret = cap_add_pd(chan, pfd); 106 assert(ret); 107 return (chan); 108 } 109 110 /* Error. */ 111 serrno = errno; 112 close(sock[0]); 113 close(sock[1]); 114 errno = serrno; 115 return (NULL); 116 } 117 118 cap_channel_t * 119 cap_wrap(int sock) 120 { 121 cap_channel_t *chan; 122 123 if (!fd_is_valid(sock)) 124 return (NULL); 125 126 chan = malloc(sizeof(*chan)); 127 if (chan != NULL) { 128 chan->cch_sock = sock; 129 chan->cch_pd = -1; 130 chan->cch_magic = CAP_CHANNEL_MAGIC; 131 } 132 133 return (chan); 134 } 135 136 int 137 cap_unwrap(cap_channel_t *chan) 138 { 139 int sock; 140 141 assert(chan != NULL); 142 assert(chan->cch_magic == CAP_CHANNEL_MAGIC); 143 144 sock = chan->cch_sock; 145 if (chan->cch_pd != -1) 146 close(chan->cch_pd); 147 chan->cch_magic = 0; 148 free(chan); 149 150 return (sock); 151 } 152 153 cap_channel_t * 154 cap_clone(const cap_channel_t *chan) 155 { 156 cap_channel_t *newchan; 157 nvlist_t *nvl; 158 int newsock; 159 160 assert(chan != NULL); 161 assert(chan->cch_magic == CAP_CHANNEL_MAGIC); 162 163 nvl = nvlist_create(0); 164 nvlist_add_string(nvl, "cmd", "clone"); 165 nvl = cap_xfer_nvlist(chan, nvl, 0); 166 if (nvl == NULL) 167 return (NULL); 168 if (nvlist_get_number(nvl, "error") != 0) { 169 errno = (int)nvlist_get_number(nvl, "error"); 170 nvlist_destroy(nvl); 171 return (NULL); 172 } 173 newsock = nvlist_take_descriptor(nvl, "sock"); 174 nvlist_destroy(nvl); 175 newchan = cap_wrap(newsock); 176 if (newchan == NULL) { 177 int serrno; 178 179 serrno = errno; 180 close(newsock); 181 errno = serrno; 182 } 183 184 return (newchan); 185 } 186 187 void 188 cap_close(cap_channel_t *chan) 189 { 190 191 assert(chan != NULL); 192 assert(chan->cch_magic == CAP_CHANNEL_MAGIC); 193 194 chan->cch_magic = 0; 195 if (chan->cch_pd != -1) 196 close(chan->cch_pd); 197 close(chan->cch_sock); 198 free(chan); 199 } 200 201 int 202 cap_sock(const cap_channel_t *chan) 203 { 204 205 assert(chan != NULL); 206 assert(chan->cch_magic == CAP_CHANNEL_MAGIC); 207 208 return (chan->cch_sock); 209 } 210 211 int 212 cap_limit_set(const cap_channel_t *chan, nvlist_t *limits) 213 { 214 nvlist_t *nvlmsg; 215 int error; 216 217 nvlmsg = nvlist_create(0); 218 nvlist_add_string(nvlmsg, "cmd", "limit_set"); 219 nvlist_add_nvlist(nvlmsg, "limits", limits); 220 nvlmsg = cap_xfer_nvlist(chan, nvlmsg, 0); 221 if (nvlmsg == NULL) { 222 nvlist_destroy(limits); 223 return (-1); 224 } 225 error = (int)nvlist_get_number(nvlmsg, "error"); 226 nvlist_destroy(nvlmsg); 227 nvlist_destroy(limits); 228 if (error != 0) { 229 errno = error; 230 return (-1); 231 } 232 return (0); 233 } 234 235 int 236 cap_limit_get(const cap_channel_t *chan, nvlist_t **limitsp) 237 { 238 nvlist_t *nvlmsg; 239 int error; 240 241 nvlmsg = nvlist_create(0); 242 nvlist_add_string(nvlmsg, "cmd", "limit_get"); 243 nvlmsg = cap_xfer_nvlist(chan, nvlmsg, 0); 244 if (nvlmsg == NULL) 245 return (-1); 246 error = (int)nvlist_get_number(nvlmsg, "error"); 247 if (error != 0) { 248 nvlist_destroy(nvlmsg); 249 errno = error; 250 return (-1); 251 } 252 if (nvlist_exists_null(nvlmsg, "limits")) 253 *limitsp = NULL; 254 else 255 *limitsp = nvlist_take_nvlist(nvlmsg, "limits"); 256 nvlist_destroy(nvlmsg); 257 return (0); 258 } 259 260 int 261 cap_send_nvlist(const cap_channel_t *chan, const nvlist_t *nvl) 262 { 263 264 assert(chan != NULL); 265 assert(chan->cch_magic == CAP_CHANNEL_MAGIC); 266 267 return (nvlist_send(chan->cch_sock, nvl)); 268 } 269 270 nvlist_t * 271 cap_recv_nvlist(const cap_channel_t *chan, int flags) 272 { 273 274 assert(chan != NULL); 275 assert(chan->cch_magic == CAP_CHANNEL_MAGIC); 276 277 return (nvlist_recv(chan->cch_sock, flags)); 278 } 279 280 nvlist_t * 281 cap_xfer_nvlist(const cap_channel_t *chan, nvlist_t *nvl, int flags) 282 { 283 284 assert(chan != NULL); 285 assert(chan->cch_magic == CAP_CHANNEL_MAGIC); 286 287 return (nvlist_xfer(chan->cch_sock, nvl, flags)); 288 } 289 290 cap_channel_t * 291 cap_service_open(const cap_channel_t *chan, const char *name) 292 { 293 cap_channel_t *newchan; 294 nvlist_t *nvl; 295 int sock, error; 296 297 sock = -1; 298 299 nvl = nvlist_create(0); 300 nvlist_add_string(nvl, "cmd", "open"); 301 nvlist_add_string(nvl, "service", name); 302 nvl = cap_xfer_nvlist(chan, nvl, 0); 303 if (nvl == NULL) 304 return (NULL); 305 error = (int)nvlist_get_number(nvl, "error"); 306 if (error != 0) { 307 nvlist_destroy(nvl); 308 errno = error; 309 return (NULL); 310 } 311 sock = nvlist_take_descriptor(nvl, "chanfd"); 312 assert(sock >= 0); 313 nvlist_destroy(nvl); 314 nvl = NULL; 315 newchan = cap_wrap(sock); 316 if (newchan == NULL) 317 goto fail; 318 return (newchan); 319 fail: 320 error = errno; 321 close(sock); 322 errno = error; 323 return (NULL); 324 } 325 326 int 327 cap_service_limit(const cap_channel_t *chan, const char * const *names, 328 size_t nnames) 329 { 330 nvlist_t *limits; 331 unsigned int i; 332 333 limits = nvlist_create(0); 334 for (i = 0; i < nnames; i++) 335 nvlist_add_null(limits, names[i]); 336 return (cap_limit_set(chan, limits)); 337 } 338