usr/src/lib/libc/port/gen/priv_str_xlate.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*
  28  *      priv_str_xlate.c - Privilege translation routines.
  29  */
  30
  31 #pragma weak _priv_str_to_set = priv_str_to_set
  32 #pragma weak _priv_set_to_str = priv_set_to_str
  33 #pragma weak _priv_gettext = priv_gettext
  34
  35 #include "lint.h"
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <ctype.h>
  39 #include <strings.h>
  40 #include <errno.h>
  41 #include <string.h>
  42 #include <locale.h>
  43 #include <sys/param.h>
  44 #include <priv.h>
  45 #include <alloca.h>
  46 #include <locale.h>
  47 #include "libc.h"
  48 #include "../i18n/_loc_path.h"
  49 #include "priv_private.h"
  50
  51 priv_set_t *
  52 priv_basic(void)
  53 {
  54         priv_data_t *d;
  55
  56         LOADPRIVDATA(d);
  57
  58         return (d->pd_basicset);
  59 }
  60
  61 /*
  62  *      Name:   priv_str_to_set()
  63  *
  64  *      Description:    Given a buffer with privilege strings, the
  65  *      equivalent privilege set is returned.
  66  *
  67  *      Special tokens recognized: all, none, basic and "".
  68  *
  69  *      On failure, this function returns NULL.
  70  *      *endptr == NULL and errno set: resource error.
  71  *      *endptr != NULL: parse error.
  72  */
  73 priv_set_t *
  74 priv_str_to_set(const char *priv_names,
  75     const char *separators,
  76     const char **endptr)
  77 {
  78
  79         char *base;
  80         char *offset;
  81         char *last;
  82         priv_set_t *pset = NULL;
  83         priv_set_t *zone;
  84         priv_set_t *basic;
  85
  86         if (endptr != NULL)
  87                 *endptr = NULL;
  88
  89         if ((base = libc_strdup(priv_names)) == NULL ||
  90             (pset = priv_allocset()) == NULL) {
  91                 /* Whether base is NULL or allocated, this works */
  92                 libc_free(base);
  93                 return (NULL);
  94         }
  95
  96         priv_emptyset(pset);
  97         basic = priv_basic();
  98         zone = privdata->pd_zoneset;
  99
 100         /* This is how to use strtok_r nicely in a while loop ... */
 101         last = base;
 102
 103         while ((offset = strtok_r(NULL, separators, &last)) != NULL) {
 104                 /*
 105                  * Search for these special case strings.
 106                  */
 107                 if (basic != NULL && strcasecmp(offset, "basic") == 0) {
 108                         priv_union(basic, pset);
 109                 } else if (strcasecmp(offset, "none") == 0) {
 110                         priv_emptyset(pset);
 111                 } else if (strcasecmp(offset, "all") == 0) {
 112                         priv_fillset(pset);
 113                 } else if (strcasecmp(offset, "zone") == 0) {
 114                         priv_union(zone, pset);
 115                 } else {
 116                         boolean_t neg = (*offset == '-' || *offset == '!');
 117                         int privid;
 118                         int slen;
 119
 120                         privid = priv_getbyname(offset +
 121                             ((neg || *offset == '+') ? 1 : 0));
 122                         if (privid < 0) {
 123                                 slen = offset - base;
 124                                 libc_free(base);
 125                                 priv_freeset(pset);
 126                                 if (endptr != NULL)
 127                                         *endptr = priv_names + slen;
 128                                 errno = EINVAL;
 129                                 return (NULL);
 130                         } else {
 131                                 if (neg)
 132                                         PRIV_DELSET(pset, privid);
 133                                 else
 134                                         PRIV_ADDSET(pset, privid);
 135                         }
 136                 }
 137         }
 138
 139         libc_free(base);
 140         return (pset);
 141 }
 142
 143 /*
 144  *      Name:   priv_set_to_str()
 145  *
 146  *      Description:    Given a set of privileges, list of privileges are
 147  *      returned in privilege numeric order (which can be an ASCII sorted
 148  *      list as our implementation allows renumbering.
 149  *
 150  *      String "none" identifies an empty privilege set, and string "all"
 151  *      identifies a full set.
 152  *
 153  *      A pointer to a buffer is returned which needs to be freed by
 154  *      the caller.
 155  *
 156  *      Several types of output are supported:
 157  *              PRIV_STR_PORT           - portable output: basic,!basic
 158  *              PRIV_STR_LIT            - literal output
 159  *              PRIV_STR_SHORT          - shortest output
 160  *
 161  * NOTE: this function is called both from inside the library for the
 162  * current environment and from outside the library using an externally
 163  * generated priv_data_t * in order to analyze core files.  It should
 164  * return strings which can be free()ed by applications and it should
 165  * not use any data from the current environment except in the special
 166  * case that it is called from within libc, with a NULL priv_data_t *
 167  * argument.
 168  */
 169
 170 char *
 171 __priv_set_to_str(
 172         priv_data_t *d,
 173         const priv_set_t *pset,
 174         char separator,
 175         int flag)
 176 {
 177         const char *pstr;
 178         char *res, *resp;
 179         int i;
 180         char neg = separator == '!' ? '-' : '!';
 181         priv_set_t *zone;
 182         boolean_t all;
 183         boolean_t use_libc_data = (d == NULL);
 184
 185         if (use_libc_data)
 186                 LOADPRIVDATA(d);
 187
 188         if (flag != PRIV_STR_PORT && __priv_isemptyset(d, pset))
 189                 return (strdup("none"));
 190         if (flag != PRIV_STR_LIT && __priv_isfullset(d, pset))
 191                 return (strdup("all"));
 192
 193         /* Safe upper bound: global info contains all NULL separated privs */
 194         res = resp = alloca(d->pd_pinfo->priv_globalinfosize);
 195
 196         /*
 197          * Compute the shortest form; i.e., the form with the fewest privilege
 198          * tokens.
 199          * The following forms are possible:
 200          *      literal: priv1,priv2,priv3
 201          *              tokcount = present
 202          *      port: basic,!missing_basic,other
 203          *              tokcount = 1 + present - presentbasic + missingbasic
 204          *      zone: zone,!missing_zone
 205          *              tokcount = 1 + missingzone
 206          *      all: all,!missing1,!missing2
 207          *              tokcount = 1 + d->pd_nprivs - present;
 208          *
 209          * Note that zone and all forms are identical in the global zone;
 210          * in that case (or any other where the token count is the same),
 211          * all is preferred.  Also, the zone form is only used when the
 212          * indicated privileges are a subset of the zone set.
 213          */
 214
 215         if (use_libc_data)
 216                 LOCKPRIVDATA();
 217
 218         if (flag == PRIV_STR_SHORT) {
 219                 int presentbasic, missingbasic, present, missing;
 220                 int presentzone, missingzone;
 221                 int count;
 222
 223                 presentbasic = missingbasic = present = 0;
 224                 presentzone = missingzone = 0;
 225                 zone = d->pd_zoneset;
 226
 227                 for (i = 0; i < d->pd_nprivs; i++) {
 228                         int mem = PRIV_ISMEMBER(pset, i);
 229                         if (d->pd_basicset != NULL &&
 230                             PRIV_ISMEMBER(d->pd_basicset, i)) {
 231                                 if (mem)
 232                                         presentbasic++;
 233                                 else
 234                                         missingbasic++;
 235                         }
 236                         if (zone != NULL && PRIV_ISMEMBER(zone, i)) {
 237                                 if (mem)
 238                                         presentzone++;
 239                                 else
 240                                         missingzone++;
 241                         }
 242                         if (mem)
 243                                 present++;
 244                 }
 245                 missing = d->pd_nprivs - present;
 246
 247                 if (1 - presentbasic + missingbasic < 0) {
 248                         flag = PRIV_STR_PORT;
 249                         count = present + 1 - presentbasic + missingbasic;
 250                 } else {
 251                         flag = PRIV_STR_LIT;
 252                         count = present;
 253                 }
 254                 if (count >= 1 + missing) {
 255                         flag = PRIV_STR_SHORT;
 256                         count = 1 + missing;
 257                         all = B_TRUE;
 258                 }
 259                 if (present == presentzone && 1 + missingzone < count) {
 260                         flag = PRIV_STR_SHORT;
 261                         all = B_FALSE;
 262                 }
 263         }
 264
 265         switch (flag) {
 266         case PRIV_STR_LIT:
 267                 *res = '\0';
 268                 break;
 269         case PRIV_STR_PORT:
 270                 (void) strcpy(res, "basic");
 271                 if (d->pd_basicset == NULL)
 272                         flag = PRIV_STR_LIT;
 273                 break;
 274         case PRIV_STR_SHORT:
 275                 if (all)
 276                         (void) strcpy(res, "all");
 277                 else
 278                         (void) strcpy(res, "zone");
 279                 break;
 280         default:
 281                 if (use_libc_data)
 282                         UNLOCKPRIVDATA();
 283                 return (NULL);
 284         }
 285         res += strlen(res);
 286
 287         for (i = 0; i < d->pd_nprivs; i++) {
 288                 /* Map the privilege to the next one sorted by name */
 289                 int priv = d->pd_setsort[i];
 290
 291                 if (PRIV_ISMEMBER(pset, priv)) {
 292                         switch (flag) {
 293                         case PRIV_STR_SHORT:
 294                                 if (all || PRIV_ISMEMBER(zone, priv))
 295                                         continue;
 296                                 break;
 297                         case PRIV_STR_PORT:
 298                                 if (PRIV_ISMEMBER(d->pd_basicset, priv))
 299                                         continue;
 300                                 break;
 301                         case PRIV_STR_LIT:
 302                                 break;
 303                         }
 304                         if (res != resp)
 305                                 *res++ = separator;
 306                 } else {
 307                         switch (flag) {
 308                         case PRIV_STR_LIT:
 309                                 continue;
 310                         case PRIV_STR_PORT:
 311                                 if (!PRIV_ISMEMBER(d->pd_basicset, priv))
 312                                         continue;
 313                                 break;
 314                         case PRIV_STR_SHORT:
 315                                 if (!all && !PRIV_ISMEMBER(zone, priv))
 316                                         continue;
 317                                 break;
 318                         }
 319                         if (res != resp)
 320                                 *res++ = separator;
 321                         *res++ = neg;
 322                 }
 323                 pstr = __priv_getbynum(d, priv);
 324                 (void) strcpy(res, pstr);
 325                 res += strlen(pstr);
 326         }
 327         if (use_libc_data)
 328                 UNLOCKPRIVDATA();
 329         /* Special case the set with some high bits set */
 330         return (strdup(*resp == '\0' ? "none" : resp));
 331 }
 332
 333 /*
 334  * priv_set_to_str() is defined to return a string that
 335  * the caller must deallocate with free(3C).  Grr...
 336  */
 337 char *
 338 priv_set_to_str(const priv_set_t *pset, char separator, int flag)
 339 {
 340         return (__priv_set_to_str(NULL, pset, separator, flag));
 341 }
 342
 343 static char *
 344 do_priv_gettext(const char *priv, const char *file)
 345 {
 346         char buf[8*1024];
 347         boolean_t inentry = B_FALSE;
 348         FILE    *namefp;
 349
 350         namefp = fopen(file, "rF");
 351         if (namefp == NULL)
 352                 return (NULL);
 353
 354         /*
 355          * parse the file; it must have the following format
 356          * Lines starting with comments "#"
 357          * Lines starting with non white space with one single token:
 358          * the privileges; white space indented lines which are the
 359          * description; no empty lines are allowed in the description.
 360          */
 361         while (fgets(buf, sizeof (buf), namefp) != NULL) {
 362                 char *lp;               /* pointer to the current line */
 363
 364                 if (buf[0] == '#')
 365                         continue;
 366
 367                 if (buf[0] == '\n') {
 368                         inentry = B_FALSE;
 369                         continue;
 370                 }
 371
 372                 if (inentry)
 373                         continue;
 374
 375                 /* error; not skipping; yet line starts with white space */
 376                 if (isspace((unsigned char)buf[0]))
 377                         goto out;
 378
 379                 /* Trim trailing newline */
 380                 buf[strlen(buf) - 1] = '\0';
 381
 382                 if (strcasecmp(buf, priv) != 0) {
 383                         inentry = B_TRUE;
 384                         continue;
 385                 }
 386
 387                 lp = buf;
 388                 while (fgets(lp, sizeof (buf) - (lp - buf), namefp) != NULL) {
 389                         char *tstart;   /* start of text */
 390                         int len;
 391
 392                         /* Empty line or start of next entry terminates */
 393                         if (*lp == '\n' || !isspace((unsigned char)*lp)) {
 394                                 *lp = '\0';
 395                                 (void) fclose(namefp);
 396                                 return (strdup(buf));
 397                         }
 398
 399                         /* Remove leading white space */
 400                         tstart = lp;
 401                         while (*tstart != '\0' &&
 402                             isspace((unsigned char)*tstart)) {
 403                                 tstart++;
 404                         }
 405
 406                         len = strlen(tstart);
 407                         (void) memmove(lp, tstart, len + 1);
 408                         lp += len;
 409
 410                         /* Entry to big; prevent fgets() loop */
 411                         if (lp == &buf[sizeof (buf) - 1])
 412                                 goto out;
 413                 }
 414                 if (lp != buf) {
 415                         *lp = '\0';
 416                         (void) fclose(namefp);
 417                         return (strdup(buf));
 418                 }
 419         }
 420 out:
 421         (void) fclose(namefp);
 422         return (NULL);
 423 }
 424
 425 /*
 426  * priv_gettext() is defined to return a string that
 427  * the caller must deallocate with free(3C).  Grr...
 428  */
 429 char *
 430 priv_gettext(const char *priv)
 431 {
 432         char file[MAXPATHLEN];
 433         locale_t curloc;
 434         const char *loc;
 435         char    *ret;
 436
 437         /* Not a valid privilege */
 438         if (priv_getbyname(priv) < 0)
 439                 return (NULL);
 440
 441         curloc = uselocale(NULL);
 442         loc = current_locale(curloc, LC_MESSAGES);
 443
 444         if (snprintf(file, sizeof (file),
 445             _DFLT_LOC_PATH "%s/LC_MESSAGES/priv_names", loc) < sizeof (file)) {
 446                 ret = do_priv_gettext(priv, (const char *)file);
 447                 if (ret != NULL)
 448                         return (ret);
 449         }
 450
 451         /* If the path is too long or can't be opened, punt to default */
 452         ret = do_priv_gettext(priv, "/etc/security/priv_names");
 453         return (ret);
 454 }