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/dnv.h> 34 #include <sys/nv.h> 35 #include <sys/param.h> 36 37 #include <assert.h> 38 #include <errno.h> 39 #include <grp.h> 40 #include <stdlib.h> 41 #include <string.h> 42 43 #include <libcasper.h> 44 #include <libcasper_service.h> 45 46 #include "cap_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, nvlname[64]; 98 size_t nmem, datasize, strsize; 99 unsigned int ii; 100 int n; 101 102 if (!nvlist_exists_number(nvl, "gr_nmem")) { 103 datasize = _ALIGNBYTES + sizeof(char *); 104 if (datasize >= *bufsizep) 105 return (ERANGE); 106 outstrs = (char **)_ALIGN(*bufferp); 107 outstrs[0] = NULL; 108 *fieldp = outstrs; 109 *bufferp += datasize; 110 *bufsizep -= datasize; 111 return (0); 112 } 113 114 nmem = (size_t)nvlist_get_number(nvl, "gr_nmem"); 115 datasize = _ALIGNBYTES + sizeof(char *) * (nmem + 1); 116 for (ii = 0; ii < nmem; ii++) { 117 n = snprintf(nvlname, sizeof(nvlname), "gr_mem[%u]", ii); 118 assert(n > 0 && n < (int)sizeof(nvlname)); 119 mem = dnvlist_get_string(nvl, nvlname, NULL); 120 if (mem == NULL) 121 return (EINVAL); 122 datasize += strlen(mem) + 1; 123 } 124 125 if (datasize >= *bufsizep) 126 return (ERANGE); 127 128 outstrs = (char **)_ALIGN(*bufferp); 129 str = (char *)outstrs + sizeof(char *) * (nmem + 1); 130 for (ii = 0; ii < nmem; ii++) { 131 n = snprintf(nvlname, sizeof(nvlname), "gr_mem[%u]", ii); 132 assert(n > 0 && n < (int)sizeof(nvlname)); 133 mem = nvlist_get_string(nvl, nvlname); 134 strsize = strlen(mem) + 1; 135 memcpy(str, mem, strsize); 136 outstrs[ii] = str; 137 str += strsize; 138 } 139 assert(ii == nmem); 140 outstrs[ii] = NULL; 141 142 *fieldp = outstrs; 143 *bufferp += datasize; 144 *bufsizep -= datasize; 145 146 return (0); 147 } 148 149 static int 150 group_unpack(const nvlist_t *nvl, struct group *grp, char *buffer, 151 size_t bufsize) 152 { 153 int error; 154 155 if (!nvlist_exists_string(nvl, "gr_name")) 156 return (EINVAL); 157 158 memset(grp, 0, sizeof(*grp)); 159 160 error = group_unpack_string(nvl, "gr_name", &grp->gr_name, &buffer, 161 &bufsize); 162 if (error != 0) 163 return (error); 164 error = group_unpack_string(nvl, "gr_passwd", &grp->gr_passwd, &buffer, 165 &bufsize); 166 if (error != 0) 167 return (error); 168 grp->gr_gid = (gid_t)nvlist_get_number(nvl, "gr_gid"); 169 error = group_unpack_members(nvl, &grp->gr_mem, &buffer, &bufsize); 170 if (error != 0) 171 return (error); 172 173 return (0); 174 } 175 176 static int 177 cap_getgrcommon_r(cap_channel_t *chan, const char *cmd, const char *name, 178 gid_t gid, struct group *grp, char *buffer, size_t bufsize, 179 struct group **result) 180 { 181 nvlist_t *nvl; 182 bool getgr_r; 183 int error; 184 185 nvl = nvlist_create(0); 186 nvlist_add_string(nvl, "cmd", cmd); 187 if (strcmp(cmd, "getgrent") == 0 || strcmp(cmd, "getgrent_r") == 0) { 188 /* Add nothing. */ 189 } else if (strcmp(cmd, "getgrnam") == 0 || 190 strcmp(cmd, "getgrnam_r") == 0) { 191 nvlist_add_string(nvl, "name", name); 192 } else if (strcmp(cmd, "getgrgid") == 0 || 193 strcmp(cmd, "getgrgid_r") == 0) { 194 nvlist_add_number(nvl, "gid", (uint64_t)gid); 195 } else { 196 abort(); 197 } 198 nvl = cap_xfer_nvlist(chan, nvl, 0); 199 if (nvl == NULL) { 200 assert(errno != 0); 201 *result = NULL; 202 return (errno); 203 } 204 error = (int)nvlist_get_number(nvl, "error"); 205 if (error != 0) { 206 nvlist_destroy(nvl); 207 *result = NULL; 208 return (error); 209 } 210 211 if (!nvlist_exists_string(nvl, "gr_name")) { 212 /* Not found. */ 213 nvlist_destroy(nvl); 214 *result = NULL; 215 return (0); 216 } 217 218 getgr_r = (strcmp(cmd, "getgrent_r") == 0 || 219 strcmp(cmd, "getgrnam_r") == 0 || strcmp(cmd, "getgrgid_r") == 0); 220 221 for (;;) { 222 error = group_unpack(nvl, grp, buffer, bufsize); 223 if (getgr_r || error != ERANGE) 224 break; 225 assert(buffer == gbuffer); 226 assert(bufsize == gbufsize); 227 error = group_resize(); 228 if (error != 0) 229 break; 230 /* Update pointers after resize. */ 231 buffer = gbuffer; 232 bufsize = gbufsize; 233 } 234 235 nvlist_destroy(nvl); 236 237 if (error == 0) 238 *result = grp; 239 else 240 *result = NULL; 241 242 return (error); 243 } 244 245 static struct group * 246 cap_getgrcommon(cap_channel_t *chan, const char *cmd, const char *name, 247 gid_t gid) 248 { 249 struct group *result; 250 int error, serrno; 251 252 serrno = errno; 253 254 error = cap_getgrcommon_r(chan, cmd, name, gid, &ggrp, gbuffer, 255 gbufsize, &result); 256 if (error != 0) { 257 errno = error; 258 return (NULL); 259 } 260 261 errno = serrno; 262 263 return (result); 264 } 265 266 struct group * 267 cap_getgrent(cap_channel_t *chan) 268 { 269 270 return (cap_getgrcommon(chan, "getgrent", NULL, 0)); 271 } 272 273 struct group * 274 cap_getgrnam(cap_channel_t *chan, const char *name) 275 { 276 277 return (cap_getgrcommon(chan, "getgrnam", name, 0)); 278 } 279 280 struct group * 281 cap_getgrgid(cap_channel_t *chan, gid_t gid) 282 { 283 284 return (cap_getgrcommon(chan, "getgrgid", NULL, gid)); 285 } 286 287 int 288 cap_getgrent_r(cap_channel_t *chan, struct group *grp, char *buffer, 289 size_t bufsize, struct group **result) 290 { 291 292 return (cap_getgrcommon_r(chan, "getgrent_r", NULL, 0, grp, buffer, 293 bufsize, result)); 294 } 295 296 int 297 cap_getgrnam_r(cap_channel_t *chan, const char *name, struct group *grp, 298 char *buffer, size_t bufsize, struct group **result) 299 { 300 301 return (cap_getgrcommon_r(chan, "getgrnam_r", name, 0, grp, buffer, 302 bufsize, result)); 303 } 304 305 int 306 cap_getgrgid_r(cap_channel_t *chan, gid_t gid, struct group *grp, char *buffer, 307 size_t bufsize, struct group **result) 308 { 309 310 return (cap_getgrcommon_r(chan, "getgrgid_r", NULL, gid, grp, buffer, 311 bufsize, result)); 312 } 313 314 int 315 cap_setgroupent(cap_channel_t *chan, int stayopen) 316 { 317 nvlist_t *nvl; 318 319 nvl = nvlist_create(0); 320 nvlist_add_string(nvl, "cmd", "setgroupent"); 321 nvlist_add_bool(nvl, "stayopen", stayopen != 0); 322 nvl = cap_xfer_nvlist(chan, nvl, 0); 323 if (nvl == NULL) 324 return (0); 325 if (nvlist_get_number(nvl, "error") != 0) { 326 errno = nvlist_get_number(nvl, "error"); 327 nvlist_destroy(nvl); 328 return (0); 329 } 330 nvlist_destroy(nvl); 331 332 return (1); 333 } 334 335 int 336 cap_setgrent(cap_channel_t *chan) 337 { 338 nvlist_t *nvl; 339 340 nvl = nvlist_create(0); 341 nvlist_add_string(nvl, "cmd", "setgrent"); 342 nvl = cap_xfer_nvlist(chan, nvl, 0); 343 if (nvl == NULL) 344 return (0); 345 if (nvlist_get_number(nvl, "error") != 0) { 346 errno = nvlist_get_number(nvl, "error"); 347 nvlist_destroy(nvl); 348 return (0); 349 } 350 nvlist_destroy(nvl); 351 352 return (1); 353 } 354 355 void 356 cap_endgrent(cap_channel_t *chan) 357 { 358 nvlist_t *nvl; 359 360 nvl = nvlist_create(0); 361 nvlist_add_string(nvl, "cmd", "endgrent"); 362 /* Ignore any errors, we have no way to report them. */ 363 nvlist_destroy(cap_xfer_nvlist(chan, nvl, 0)); 364 } 365 366 int 367 cap_grp_limit_cmds(cap_channel_t *chan, const char * const *cmds, size_t ncmds) 368 { 369 nvlist_t *limits, *nvl; 370 unsigned int i; 371 372 if (cap_limit_get(chan, &limits) < 0) 373 return (-1); 374 if (limits == NULL) { 375 limits = nvlist_create(0); 376 } else { 377 if (nvlist_exists_nvlist(limits, "cmds")) 378 nvlist_free_nvlist(limits, "cmds"); 379 } 380 nvl = nvlist_create(0); 381 for (i = 0; i < ncmds; i++) 382 nvlist_add_null(nvl, cmds[i]); 383 nvlist_move_nvlist(limits, "cmds", nvl); 384 return (cap_limit_set(chan, limits)); 385 } 386 387 int 388 cap_grp_limit_fields(cap_channel_t *chan, const char * const *fields, 389 size_t nfields) 390 { 391 nvlist_t *limits, *nvl; 392 unsigned int i; 393 394 if (cap_limit_get(chan, &limits) < 0) 395 return (-1); 396 if (limits == NULL) { 397 limits = nvlist_create(0); 398 } else { 399 if (nvlist_exists_nvlist(limits, "fields")) 400 nvlist_free_nvlist(limits, "fields"); 401 } 402 nvl = nvlist_create(0); 403 for (i = 0; i < nfields; i++) 404 nvlist_add_null(nvl, fields[i]); 405 nvlist_move_nvlist(limits, "fields", nvl); 406 return (cap_limit_set(chan, limits)); 407 } 408 409 int 410 cap_grp_limit_groups(cap_channel_t *chan, const char * const *names, 411 size_t nnames, gid_t *gids, size_t ngids) 412 { 413 nvlist_t *limits, *groups; 414 unsigned int i; 415 char nvlname[64]; 416 int n; 417 418 if (cap_limit_get(chan, &limits) < 0) 419 return (-1); 420 if (limits == NULL) { 421 limits = nvlist_create(0); 422 } else { 423 if (nvlist_exists_nvlist(limits, "groups")) 424 nvlist_free_nvlist(limits, "groups"); 425 } 426 groups = nvlist_create(0); 427 for (i = 0; i < ngids; i++) { 428 n = snprintf(nvlname, sizeof(nvlname), "gid%u", i); 429 assert(n > 0 && n < (int)sizeof(nvlname)); 430 nvlist_add_number(groups, nvlname, (uint64_t)gids[i]); 431 } 432 for (i = 0; i < nnames; i++) { 433 n = snprintf(nvlname, sizeof(nvlname), "gid%u", i); 434 assert(n > 0 && n < (int)sizeof(nvlname)); 435 nvlist_add_string(groups, nvlname, names[i]); 436 } 437 nvlist_move_nvlist(limits, "groups", groups); 438 return (cap_limit_set(chan, limits)); 439 } 440 441 /* 442 * Service functions. 443 */ 444 static bool 445 grp_allowed_cmd(const nvlist_t *limits, const char *cmd) 446 { 447 448 if (limits == NULL) 449 return (true); 450 451 /* 452 * If no limit was set on allowed commands, then all commands 453 * are allowed. 454 */ 455 if (!nvlist_exists_nvlist(limits, "cmds")) 456 return (true); 457 458 limits = nvlist_get_nvlist(limits, "cmds"); 459 return (nvlist_exists_null(limits, cmd)); 460 } 461 462 static int 463 grp_allowed_cmds(const nvlist_t *oldlimits, const nvlist_t *newlimits) 464 { 465 const char *name; 466 void *cookie; 467 int type; 468 469 cookie = NULL; 470 while ((name = nvlist_next(newlimits, &type, &cookie)) != NULL) { 471 if (type != NV_TYPE_NULL) 472 return (EINVAL); 473 if (!grp_allowed_cmd(oldlimits, name)) 474 return (ENOTCAPABLE); 475 } 476 477 return (0); 478 } 479 480 static bool 481 grp_allowed_group(const nvlist_t *limits, const char *gname, gid_t gid) 482 { 483 const char *name; 484 void *cookie; 485 int type; 486 487 if (limits == NULL) 488 return (true); 489 490 /* 491 * If no limit was set on allowed groups, then all groups are allowed. 492 */ 493 if (!nvlist_exists_nvlist(limits, "groups")) 494 return (true); 495 496 limits = nvlist_get_nvlist(limits, "groups"); 497 cookie = NULL; 498 while ((name = nvlist_next(limits, &type, &cookie)) != NULL) { 499 switch (type) { 500 case NV_TYPE_NUMBER: 501 if (gid != (gid_t)-1 && 502 nvlist_get_number(limits, name) == (uint64_t)gid) { 503 return (true); 504 } 505 break; 506 case NV_TYPE_STRING: 507 if (gname != NULL && 508 strcmp(nvlist_get_string(limits, name), 509 gname) == 0) { 510 return (true); 511 } 512 break; 513 default: 514 abort(); 515 } 516 } 517 518 return (false); 519 } 520 521 static int 522 grp_allowed_groups(const nvlist_t *oldlimits, const nvlist_t *newlimits) 523 { 524 const char *name, *gname; 525 void *cookie; 526 gid_t gid; 527 int type; 528 529 cookie = NULL; 530 while ((name = nvlist_next(newlimits, &type, &cookie)) != NULL) { 531 switch (type) { 532 case NV_TYPE_NUMBER: 533 gid = (gid_t)nvlist_get_number(newlimits, name); 534 gname = NULL; 535 break; 536 case NV_TYPE_STRING: 537 gid = (gid_t)-1; 538 gname = nvlist_get_string(newlimits, name); 539 break; 540 default: 541 return (EINVAL); 542 } 543 if (!grp_allowed_group(oldlimits, gname, gid)) 544 return (ENOTCAPABLE); 545 } 546 547 return (0); 548 } 549 550 static bool 551 grp_allowed_field(const nvlist_t *limits, const char *field) 552 { 553 554 if (limits == NULL) 555 return (true); 556 557 /* 558 * If no limit was set on allowed fields, then all fields are allowed. 559 */ 560 if (!nvlist_exists_nvlist(limits, "fields")) 561 return (true); 562 563 limits = nvlist_get_nvlist(limits, "fields"); 564 return (nvlist_exists_null(limits, field)); 565 } 566 567 static int 568 grp_allowed_fields(const nvlist_t *oldlimits, const nvlist_t *newlimits) 569 { 570 const char *name; 571 void *cookie; 572 int type; 573 574 cookie = NULL; 575 while ((name = nvlist_next(newlimits, &type, &cookie)) != NULL) { 576 if (type != NV_TYPE_NULL) 577 return (EINVAL); 578 if (!grp_allowed_field(oldlimits, name)) 579 return (ENOTCAPABLE); 580 } 581 582 return (0); 583 } 584 585 static bool 586 grp_pack(const nvlist_t *limits, const struct group *grp, nvlist_t *nvl) 587 { 588 char nvlname[64]; 589 int n; 590 591 if (grp == NULL) 592 return (true); 593 594 /* 595 * If either name or GID is allowed, we allow it. 596 */ 597 if (!grp_allowed_group(limits, grp->gr_name, grp->gr_gid)) 598 return (false); 599 600 if (grp_allowed_field(limits, "gr_name")) 601 nvlist_add_string(nvl, "gr_name", grp->gr_name); 602 else 603 nvlist_add_string(nvl, "gr_name", ""); 604 if (grp_allowed_field(limits, "gr_passwd")) 605 nvlist_add_string(nvl, "gr_passwd", grp->gr_passwd); 606 else 607 nvlist_add_string(nvl, "gr_passwd", ""); 608 if (grp_allowed_field(limits, "gr_gid")) 609 nvlist_add_number(nvl, "gr_gid", (uint64_t)grp->gr_gid); 610 else 611 nvlist_add_number(nvl, "gr_gid", (uint64_t)-1); 612 if (grp_allowed_field(limits, "gr_mem") && grp->gr_mem[0] != NULL) { 613 unsigned int ngroups; 614 615 for (ngroups = 0; grp->gr_mem[ngroups] != NULL; ngroups++) { 616 n = snprintf(nvlname, sizeof(nvlname), "gr_mem[%u]", 617 ngroups); 618 assert(n > 0 && n < (ssize_t)sizeof(nvlname)); 619 nvlist_add_string(nvl, nvlname, grp->gr_mem[ngroups]); 620 } 621 nvlist_add_number(nvl, "gr_nmem", (uint64_t)ngroups); 622 } 623 624 return (true); 625 } 626 627 static int 628 grp_getgrent(const nvlist_t *limits, const nvlist_t *nvlin __unused, 629 nvlist_t *nvlout) 630 { 631 struct group *grp; 632 633 for (;;) { 634 errno = 0; 635 grp = getgrent(); 636 if (errno != 0) 637 return (errno); 638 if (grp_pack(limits, grp, nvlout)) 639 return (0); 640 } 641 642 /* NOTREACHED */ 643 } 644 645 static int 646 grp_getgrnam(const nvlist_t *limits, const nvlist_t *nvlin, nvlist_t *nvlout) 647 { 648 struct group *grp; 649 const char *name; 650 651 if (!nvlist_exists_string(nvlin, "name")) 652 return (EINVAL); 653 name = nvlist_get_string(nvlin, "name"); 654 assert(name != NULL); 655 656 errno = 0; 657 grp = getgrnam(name); 658 if (errno != 0) 659 return (errno); 660 661 (void)grp_pack(limits, grp, nvlout); 662 663 return (0); 664 } 665 666 static int 667 grp_getgrgid(const nvlist_t *limits, const nvlist_t *nvlin, nvlist_t *nvlout) 668 { 669 struct group *grp; 670 gid_t gid; 671 672 if (!nvlist_exists_number(nvlin, "gid")) 673 return (EINVAL); 674 675 gid = (gid_t)nvlist_get_number(nvlin, "gid"); 676 677 errno = 0; 678 grp = getgrgid(gid); 679 if (errno != 0) 680 return (errno); 681 682 (void)grp_pack(limits, grp, nvlout); 683 684 return (0); 685 } 686 687 static int 688 grp_setgroupent(const nvlist_t *limits __unused, const nvlist_t *nvlin, 689 nvlist_t *nvlout __unused) 690 { 691 int stayopen; 692 693 if (!nvlist_exists_bool(nvlin, "stayopen")) 694 return (EINVAL); 695 696 stayopen = nvlist_get_bool(nvlin, "stayopen") ? 1 : 0; 697 698 return (setgroupent(stayopen) == 0 ? EFAULT : 0); 699 } 700 701 static int 702 grp_setgrent(const nvlist_t *limits __unused, const nvlist_t *nvlin __unused, 703 nvlist_t *nvlout __unused) 704 { 705 706 setgrent(); 707 708 return (0); 709 } 710 711 static int 712 grp_endgrent(const nvlist_t *limits __unused, const nvlist_t *nvlin __unused, 713 nvlist_t *nvlout __unused) 714 { 715 716 endgrent(); 717 718 return (0); 719 } 720 721 static int 722 grp_limit(const nvlist_t *oldlimits, const nvlist_t *newlimits) 723 { 724 const nvlist_t *limits; 725 const char *name; 726 void *cookie; 727 int error, type; 728 729 if (oldlimits != NULL && nvlist_exists_nvlist(oldlimits, "cmds") && 730 !nvlist_exists_nvlist(newlimits, "cmds")) { 731 return (ENOTCAPABLE); 732 } 733 if (oldlimits != NULL && nvlist_exists_nvlist(oldlimits, "fields") && 734 !nvlist_exists_nvlist(newlimits, "fields")) { 735 return (ENOTCAPABLE); 736 } 737 if (oldlimits != NULL && nvlist_exists_nvlist(oldlimits, "groups") && 738 !nvlist_exists_nvlist(newlimits, "groups")) { 739 return (ENOTCAPABLE); 740 } 741 742 cookie = NULL; 743 while ((name = nvlist_next(newlimits, &type, &cookie)) != NULL) { 744 if (type != NV_TYPE_NVLIST) 745 return (EINVAL); 746 limits = nvlist_get_nvlist(newlimits, name); 747 if (strcmp(name, "cmds") == 0) 748 error = grp_allowed_cmds(oldlimits, limits); 749 else if (strcmp(name, "fields") == 0) 750 error = grp_allowed_fields(oldlimits, limits); 751 else if (strcmp(name, "groups") == 0) 752 error = grp_allowed_groups(oldlimits, limits); 753 else 754 error = EINVAL; 755 if (error != 0) 756 return (error); 757 } 758 759 return (0); 760 } 761 762 static int 763 grp_command(const char *cmd, const nvlist_t *limits, nvlist_t *nvlin, 764 nvlist_t *nvlout) 765 { 766 int error; 767 768 if (!grp_allowed_cmd(limits, cmd)) 769 return (ENOTCAPABLE); 770 771 if (strcmp(cmd, "getgrent") == 0 || strcmp(cmd, "getgrent_r") == 0) 772 error = grp_getgrent(limits, nvlin, nvlout); 773 else if (strcmp(cmd, "getgrnam") == 0 || strcmp(cmd, "getgrnam_r") == 0) 774 error = grp_getgrnam(limits, nvlin, nvlout); 775 else if (strcmp(cmd, "getgrgid") == 0 || strcmp(cmd, "getgrgid_r") == 0) 776 error = grp_getgrgid(limits, nvlin, nvlout); 777 else if (strcmp(cmd, "setgroupent") == 0) 778 error = grp_setgroupent(limits, nvlin, nvlout); 779 else if (strcmp(cmd, "setgrent") == 0) 780 error = grp_setgrent(limits, nvlin, nvlout); 781 else if (strcmp(cmd, "endgrent") == 0) 782 error = grp_endgrent(limits, nvlin, nvlout); 783 else 784 error = EINVAL; 785 786 return (error); 787 } 788 789 CREATE_SERVICE("system.grp", grp_limit, grp_command, 0); 790