lib/libcapsicum/libcapsicum_grp.c

   1 /*-
   2  * Copyright (c) 2013 The FreeBSD Foundation
   3  * All rights reserved.
   4  *
   5  * This software was developed by Pawel Jakub Dawidek under sponsorship from
   6  * the FreeBSD Foundation.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 #include <sys/param.h>
  34
  35 #include <assert.h>
  36 #include <errno.h>
  37 #include <grp.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <unistd.h>
  41
  42 #include <dnv.h>
  43 #include <nv.h>
  44
  45 #include "libcapsicum.h"
  46 #include "libcapsicum_grp.h"
  47
  48 static struct group ggrp;
  49 static char *gbuffer;
  50 static size_t gbufsize;
  51
  52 static int
  53 group_resize(void)
  54 {
  55         char *buf;
  56
  57         if (gbufsize == 0)
  58                 gbufsize = 1024;
  59         else
  60                 gbufsize *= 2;
  61
  62         buf = gbuffer;
  63         gbuffer = realloc(buf, gbufsize);
  64         if (gbuffer == NULL) {
  65                 free(buf);
  66                 gbufsize = 0;
  67                 return (ENOMEM);
  68         }
  69         memset(gbuffer, 0, gbufsize);
  70
  71         return (0);
  72 }
  73
  74 static int
  75 group_unpack_string(const nvlist_t *nvl, const char *fieldname, char **fieldp,
  76     char **bufferp, size_t *bufsizep)
  77 {
  78         const char *str;
  79         size_t len;
  80
  81         str = nvlist_get_string(nvl, fieldname);
  82         len = strlcpy(*bufferp, str, *bufsizep);
  83         if (len >= *bufsizep)
  84                 return (ERANGE);
  85         *fieldp = *bufferp;
  86         *bufferp += len + 1;
  87         *bufsizep -= len + 1;
  88
  89         return (0);
  90 }
  91
  92 static int
  93 group_unpack_members(const nvlist_t *nvl, char ***fieldp, char **bufferp,
  94     size_t *bufsizep)
  95 {
  96         const char *mem;
  97         char **outstrs, *str;
  98         size_t nmem, datasize, strsize;
  99         unsigned int ii;
 100
 101         if (!nvlist_exists_number(nvl, "gr_nmem")) {
 102                 datasize = _ALIGNBYTES + sizeof(char *);
 103                 if (datasize >= *bufsizep)
 104                         return (ERANGE);
 105                 outstrs = (char **)_ALIGN(*bufferp);
 106                 outstrs[0] = NULL;
 107                 *fieldp = outstrs;
 108                 *bufferp += datasize;
 109                 *bufsizep -= datasize;
 110                 return (0);
 111         }
 112
 113         nmem = (size_t)nvlist_get_number(nvl, "gr_nmem");
 114         datasize = _ALIGNBYTES + sizeof(char *) * (nmem + 1);
 115         for (ii = 0; ii < nmem; ii++) {
 116                 mem = dnvlist_getf_string(nvl, NULL, "gr_mem[%u]", ii);
 117                 if (mem == NULL)
 118                         return (EINVAL);
 119                 datasize += strlen(mem) + 1;
 120         }
 121
 122         if (datasize >= *bufsizep)
 123                 return (ERANGE);
 124
 125         outstrs = (char **)_ALIGN(*bufferp);
 126         str = (char *)outstrs + sizeof(char *) * (nmem + 1);
 127         for (ii = 0; ii < nmem; ii++) {
 128                 mem = nvlist_getf_string(nvl, "gr_mem[%u]", ii);
 129                 strsize = strlen(mem) + 1;
 130                 memcpy(str, mem, strsize);
 131                 outstrs[ii] = str;
 132                 str += strsize;
 133         }
 134         assert(ii == nmem);
 135         outstrs[ii] = NULL;
 136
 137         *fieldp = outstrs;
 138         *bufferp += datasize;
 139         *bufsizep -= datasize;
 140
 141         return (0);
 142 }
 143
 144 static int
 145 group_unpack(const nvlist_t *nvl, struct group *grp, char *buffer,
 146     size_t bufsize)
 147 {
 148         int error;
 149
 150         if (!nvlist_exists_string(nvl, "gr_name"))
 151                 return (EINVAL);
 152
 153         memset(grp, 0, sizeof(*grp));
 154
 155         error = group_unpack_string(nvl, "gr_name", &grp->gr_name, &buffer,
 156             &bufsize);
 157         if (error != 0)
 158                 return (error);
 159         error = group_unpack_string(nvl, "gr_passwd", &grp->gr_passwd, &buffer,
 160             &bufsize);
 161         if (error != 0)
 162                 return (error);
 163         grp->gr_gid = (gid_t)nvlist_get_number(nvl, "gr_gid");
 164         error = group_unpack_members(nvl, &grp->gr_mem, &buffer, &bufsize);
 165         if (error != 0)
 166                 return (error);
 167
 168         return (0);
 169 }
 170
 171 static int
 172 cap_getgrcommon_r(cap_channel_t *chan, const char *cmd, const char *name,
 173     gid_t gid, struct group *grp, char *buffer, size_t bufsize,
 174     struct group **result)
 175 {
 176         nvlist_t *nvl;
 177         bool getgr_r;
 178         int error;
 179
 180         nvl = nvlist_create(0);
 181         nvlist_add_string(nvl, "cmd", cmd);
 182         if (strcmp(cmd, "getgrent") == 0 || strcmp(cmd, "getgrent_r") == 0) {
 183                 /* Add nothing. */
 184         } else if (strcmp(cmd, "getgrnam") == 0 ||
 185             strcmp(cmd, "getgrnam_r") == 0) {
 186                 nvlist_add_string(nvl, "name", name);
 187         } else if (strcmp(cmd, "getgrgid") == 0 ||
 188             strcmp(cmd, "getgrgid_r") == 0) {
 189                 nvlist_add_number(nvl, "gid", (uint64_t)gid);
 190         } else {
 191                 abort();
 192         }
 193         nvl = cap_xfer_nvlist(chan, nvl);
 194         if (nvl == NULL) {
 195                 assert(errno != 0);
 196                 *result = NULL;
 197                 return (errno);
 198         }
 199         error = (int)nvlist_get_number(nvl, "error");
 200         if (error != 0) {
 201                 nvlist_destroy(nvl);
 202                 *result = NULL;
 203                 return (error);
 204         }
 205
 206         if (!nvlist_exists_string(nvl, "gr_name")) {
 207                 /* Not found. */
 208                 nvlist_destroy(nvl);
 209                 *result = NULL;
 210                 return (0);
 211         }
 212
 213         getgr_r = (strcmp(cmd, "getgrent_r") == 0 ||
 214             strcmp(cmd, "getgrnam_r") == 0 || strcmp(cmd, "getgrgid_r") == 0);
 215
 216         for (;;) {
 217                 error = group_unpack(nvl, grp, buffer, bufsize);
 218                 if (getgr_r || error != ERANGE)
 219                         break;
 220                 assert(buffer == gbuffer);
 221                 assert(bufsize == gbufsize);
 222                 error = group_resize();
 223                 if (error != 0)
 224                         break;
 225                 /* Update pointers after resize. */
 226                 buffer = gbuffer;
 227                 bufsize = gbufsize;
 228         }
 229
 230         nvlist_destroy(nvl);
 231
 232         if (error == 0)
 233                 *result = grp;
 234         else
 235                 *result = NULL;
 236
 237         return (error);
 238 }
 239
 240 static struct group *
 241 cap_getgrcommon(cap_channel_t *chan, const char *cmd, const char *name,
 242     gid_t gid)
 243 {
 244         struct group *result;
 245         int error, serrno;
 246
 247         serrno = errno;
 248
 249         error = cap_getgrcommon_r(chan, cmd, name, gid, &ggrp, gbuffer,
 250             gbufsize, &result);
 251         if (error != 0) {
 252                 errno = error;
 253                 return (NULL);
 254         }
 255
 256         errno = serrno;
 257
 258         return (result);
 259 }
 260
 261 struct group *
 262 cap_getgrent(cap_channel_t *chan)
 263 {
 264
 265         return (cap_getgrcommon(chan, "getgrent", NULL, 0));
 266 }
 267
 268 struct group *
 269 cap_getgrnam(cap_channel_t *chan, const char *name)
 270 {
 271
 272         return (cap_getgrcommon(chan, "getgrnam", name, 0));
 273 }
 274
 275 struct group *
 276 cap_getgrgid(cap_channel_t *chan, gid_t gid)
 277 {
 278
 279         return (cap_getgrcommon(chan, "getgrgid", NULL, gid));
 280 }
 281
 282 int
 283 cap_getgrent_r(cap_channel_t *chan, struct group *grp, char *buffer,
 284     size_t bufsize, struct group **result)
 285 {
 286
 287         return (cap_getgrcommon_r(chan, "getgrent_r", NULL, 0, grp, buffer,
 288             bufsize, result));
 289 }
 290
 291 int
 292 cap_getgrnam_r(cap_channel_t *chan, const char *name, struct group *grp,
 293     char *buffer, size_t bufsize, struct group **result)
 294 {
 295
 296         return (cap_getgrcommon_r(chan, "getgrnam_r", name, 0, grp, buffer,
 297             bufsize, result));
 298 }
 299
 300 int
 301 cap_getgrgid_r(cap_channel_t *chan, gid_t gid, struct group *grp, char *buffer,
 302     size_t bufsize, struct group **result)
 303 {
 304
 305         return (cap_getgrcommon_r(chan, "getgrgid_r", NULL, gid, grp, buffer,
 306             bufsize, result));
 307 }
 308
 309 int
 310 cap_setgroupent(cap_channel_t *chan, int stayopen)
 311 {
 312         nvlist_t *nvl;
 313
 314         nvl = nvlist_create(0);
 315         nvlist_add_string(nvl, "cmd", "setgroupent");
 316         nvlist_add_bool(nvl, "stayopen", stayopen != 0);
 317         nvl = cap_xfer_nvlist(chan, nvl);
 318         if (nvl == NULL)
 319                 return (0);
 320         if (nvlist_get_number(nvl, "error") != 0) {
 321                 errno = nvlist_get_number(nvl, "error");
 322                 nvlist_destroy(nvl);
 323                 return (0);
 324         }
 325         nvlist_destroy(nvl);
 326
 327         return (1);
 328 }
 329
 330 int
 331 cap_setgrent(cap_channel_t *chan)
 332 {
 333         nvlist_t *nvl;
 334
 335         nvl = nvlist_create(0);
 336         nvlist_add_string(nvl, "cmd", "setgrent");
 337         nvl = cap_xfer_nvlist(chan, nvl);
 338         if (nvl == NULL)
 339                 return (0);
 340         if (nvlist_get_number(nvl, "error") != 0) {
 341                 errno = nvlist_get_number(nvl, "error");
 342                 nvlist_destroy(nvl);
 343                 return (0);
 344         }
 345         nvlist_destroy(nvl);
 346
 347         return (1);
 348 }
 349
 350 void
 351 cap_endgrent(cap_channel_t *chan)
 352 {
 353         nvlist_t *nvl;
 354
 355         nvl = nvlist_create(0);
 356         nvlist_add_string(nvl, "cmd", "endgrent");
 357         /* Ignore any errors, we have no way to report them. */
 358         nvlist_destroy(cap_xfer_nvlist(chan, nvl));
 359 }
 360
 361 int
 362 cap_grp_limit_cmds(cap_channel_t *chan, const char * const *cmds, size_t ncmds)
 363 {
 364         nvlist_t *limits, *nvl;
 365         unsigned int i;
 366
 367         if (cap_limit_get(chan, &limits) < 0)
 368                 return (-1);
 369         if (limits == NULL) {
 370                 limits = nvlist_create(0);
 371         } else {
 372                 if (nvlist_exists_nvlist(limits, "cmds"))
 373                         nvlist_free_nvlist(limits, "cmds");
 374         }
 375         nvl = nvlist_create(0);
 376         for (i = 0; i < ncmds; i++)
 377                 nvlist_add_null(nvl, cmds[i]);
 378         nvlist_move_nvlist(limits, "cmds", nvl);
 379         return (cap_limit_set(chan, limits));
 380 }
 381
 382 int
 383 cap_grp_limit_fields(cap_channel_t *chan, const char * const *fields,
 384     size_t nfields)
 385 {
 386         nvlist_t *limits, *nvl;
 387         unsigned int i;
 388
 389         if (cap_limit_get(chan, &limits) < 0)
 390                 return (-1);
 391         if (limits == NULL) {
 392                 limits = nvlist_create(0);
 393         } else {
 394                 if (nvlist_exists_nvlist(limits, "fields"))
 395                         nvlist_free_nvlist(limits, "fields");
 396         }
 397         nvl = nvlist_create(0);
 398         for (i = 0; i < nfields; i++)
 399                 nvlist_add_null(nvl, fields[i]);
 400         nvlist_move_nvlist(limits, "fields", nvl);
 401         return (cap_limit_set(chan, limits));
 402 }
 403
 404 int
 405 cap_grp_limit_groups(cap_channel_t *chan, const char * const *names,
 406     size_t nnames, gid_t *gids, size_t ngids)
 407 {
 408         nvlist_t *limits, *groups;
 409         unsigned int i;
 410
 411         if (cap_limit_get(chan, &limits) < 0)
 412                 return (-1);
 413         if (limits == NULL) {
 414                 limits = nvlist_create(0);
 415         } else {
 416                 if (nvlist_exists_nvlist(limits, "groups"))
 417                         nvlist_free_nvlist(limits, "groups");
 418         }
 419         groups = nvlist_create(0);
 420         for (i = 0; i < ngids; i++)
 421                 nvlist_addf_number(groups, (uint64_t)gids[i], "gid%u", i);
 422         for (i = 0; i < nnames; i++)
 423                 nvlist_addf_string(groups, names[i], "name%u", i);
 424         nvlist_move_nvlist(limits, "groups", groups);
 425         return (cap_limit_set(chan, limits));
 426 }