usr/src/lib/libc/port/gen/ucred.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 #pragma weak _ucred_free = ucred_free
  29 #pragma weak _ucred_get = ucred_get
  30 #pragma weak _ucred_getegid = ucred_getegid
  31 #pragma weak _ucred_geteuid = ucred_geteuid
  32 #pragma weak _ucred_getgroups = ucred_getgroups
  33 #pragma weak _ucred_getpflags = ucred_getpflags
  34 #pragma weak _ucred_getpid = ucred_getpid
  35 #pragma weak _ucred_getzoneid = ucred_getzoneid
  36 #pragma weak _ucred_getprojid = ucred_getprojid
  37 #pragma weak _ucred_getprivset = ucred_getprivset
  38 #pragma weak _ucred_getrgid = ucred_getrgid
  39 #pragma weak _ucred_getruid = ucred_getruid
  40 #pragma weak _ucred_getsgid = ucred_getsgid
  41 #pragma weak _ucred_getsuid = ucred_getsuid
  42 #pragma weak _ucred_getauid = ucred_getauid
  43 #pragma weak _ucred_getasid = ucred_getasid
  44 #pragma weak _ucred_getatid = ucred_getatid
  45 #pragma weak _ucred_getamask = ucred_getamask
  46 #pragma weak _ucred_size = ucred_size
  47
  48 #include "lint.h"
  49
  50 #define _STRUCTURED_PROC        1
  51
  52 #include "priv_private.h"
  53 #include <errno.h>
  54 #include <priv.h>
  55 #include <stdarg.h>
  56 #include <stdlib.h>
  57 #include <stdio.h>
  58 #include <unistd.h>
  59 #include <ucred.h>
  60 #include <limits.h>
  61 #include <fcntl.h>
  62 #include <door.h>
  63 #include <alloca.h>
  64 #include <sys/ucred.h>
  65 #include <sys/procfs.h>
  66 #include <sys/sysmacros.h>
  67 #include <sys/zone.h>
  68
  69 ucred_t *
  70 _ucred_alloc(void)
  71 {
  72         ucred_t *r;
  73         size_t sz = ucred_size();
  74
  75         r = malloc(sz);
  76
  77         if (r != NULL)
  78                 r->uc_size = (uint32_t)sz;
  79
  80         return (r);
  81 }
  82
  83 void
  84 ucred_free(ucred_t *uc)
  85 {
  86         free(uc);
  87 }
  88
  89
  90 ucred_t *
  91 ucred_get(pid_t pid)
  92 {
  93         ucred_t *uc;
  94
  95         uc = _ucred_alloc();
  96
  97         if (uc == NULL)
  98                 return (NULL);
  99
 100         if (syscall(SYS_ucredsys, UCREDSYS_UCREDGET, pid, uc) != 0) {
 101                 ucred_free(uc);
 102                 return (NULL);
 103         }
 104
 105         return (uc);
 106 }
 107
 108 uid_t
 109 ucred_geteuid(const ucred_t *uc)
 110 {
 111         /* LINTED: alignment */
 112         const prcred_t *cr = UCCRED(uc);
 113
 114         if (cr == NULL) {
 115                 errno = EINVAL;
 116                 return ((uid_t)-1);
 117         }
 118
 119         return (cr->pr_euid);
 120 }
 121
 122 uid_t
 123 ucred_getruid(const ucred_t *uc)
 124 {
 125         /* LINTED: alignment */
 126         const prcred_t *cr = UCCRED(uc);
 127
 128         if (cr == NULL) {
 129                 errno = EINVAL;
 130                 return ((uid_t)-1);
 131         }
 132
 133         return (cr->pr_ruid);
 134 }
 135
 136 uid_t
 137 ucred_getsuid(const ucred_t *uc)
 138 {
 139         /* LINTED: alignment */
 140         const prcred_t *cr = UCCRED(uc);
 141
 142         if (cr == NULL) {
 143                 errno = EINVAL;
 144                 return ((uid_t)-1);
 145         }
 146
 147         return (cr->pr_suid);
 148 }
 149
 150 gid_t
 151 ucred_getegid(const ucred_t *uc)
 152 {
 153         /* LINTED: alignment */
 154         const prcred_t *cr = UCCRED(uc);
 155
 156         if (cr == NULL) {
 157                 errno = EINVAL;
 158                 return ((gid_t)-1);
 159         }
 160
 161         return (cr->pr_egid);
 162 }
 163
 164 gid_t
 165 ucred_getrgid(const ucred_t *uc)
 166 {
 167         /* LINTED: alignment */
 168         const prcred_t *cr = UCCRED(uc);
 169
 170         if (cr == NULL) {
 171                 errno = EINVAL;
 172                 return ((gid_t)-1);
 173         }
 174
 175         return (cr->pr_rgid);
 176 }
 177
 178 gid_t
 179 ucred_getsgid(const ucred_t *uc)
 180 {
 181         /* LINTED: alignment */
 182         const prcred_t *cr = UCCRED(uc);
 183
 184         if (cr == NULL) {
 185                 errno = EINVAL;
 186                 return ((gid_t)-1);
 187         }
 188
 189         return (cr->pr_sgid);
 190 }
 191
 192 int
 193 ucred_getgroups(const ucred_t *uc, const gid_t **grps)
 194 {
 195         /* LINTED: alignment */
 196         const prcred_t *cr = UCCRED(uc);
 197
 198         if (cr == NULL) {
 199                 errno = EINVAL;
 200                 return (-1);
 201         }
 202
 203         if (cr->pr_ngroups > 0)
 204                 *grps = &cr->pr_groups[0];
 205         else
 206                 *grps = NULL;
 207
 208         return (cr->pr_ngroups);
 209 }
 210
 211 const priv_set_t *
 212 ucred_getprivset(const ucred_t *uc, priv_ptype_t set)
 213 {
 214         /* LINTED: alignment */
 215         const prpriv_t *pr = UCPRIV(uc);
 216         int pset = priv_getsetbyname(set);
 217         priv_data_t *d;
 218
 219         if (pr == NULL || pset == -1) {
 220                 errno = EINVAL;
 221                 return (NULL);
 222         }
 223
 224         LOADPRIVDATA(d);
 225
 226         return ((const priv_set_t *)
 227             &pr->pr_sets[d->pd_pinfo->priv_setsize * pset]);
 228 }
 229
 230 pid_t
 231 ucred_getpid(const ucred_t *uc)
 232 {
 233
 234         if (uc->uc_pid == -1)
 235                 errno = EINVAL;
 236
 237         return (uc->uc_pid);
 238 }
 239
 240 projid_t
 241 ucred_getprojid(const ucred_t *uc)
 242 {
 243
 244         if (uc->uc_projid == -1)
 245                 errno = EINVAL;
 246
 247         return (uc->uc_projid);
 248 }
 249
 250 zoneid_t
 251 ucred_getzoneid(const ucred_t *uc)
 252 {
 253
 254         if (uc->uc_zoneid < MIN_ZONEID || uc->uc_zoneid > MAX_ZONEID) {
 255                 errno = EINVAL;
 256                 return (-1);
 257         }
 258
 259         return (uc->uc_zoneid);
 260 }
 261
 262 /*
 263  * For now, assume single bit flags.
 264  */
 265 uint_t
 266 ucred_getpflags(const ucred_t *uc, uint_t flag)
 267 {
 268         /* LINTED: alignment */
 269         prpriv_t *pr = UCPRIV(uc);
 270         char *x, *end;
 271
 272         if (pr == NULL) {
 273                 errno = EINVAL;
 274                 return ((uint_t)-1);
 275         }
 276
 277         end = (char *)pr + PRIV_PRPRIV_SIZE(pr);
 278         x = end - pr->pr_infosize;
 279
 280         while (x < end) {
 281                 /* LINTED: alignment */
 282                 priv_info_t *pi = (priv_info_t *)x;
 283                 priv_info_uint_t *pii;
 284
 285                 switch (pi->priv_info_type) {
 286                 case PRIV_INFO_FLAGS:
 287                         /* LINTED: alignment */
 288                         pii = (priv_info_uint_t *)x;
 289                         return ((pii->val & flag) ? 1 : 0);
 290                 }
 291                 /* Forward progress */
 292                 if (pi->priv_info_size < sizeof (priv_info_t))
 293                         break;
 294                 x += pi->priv_info_size;
 295         }
 296
 297         errno = EINVAL;
 298         return ((uint_t)-1);
 299 }
 300
 301 au_id_t
 302 ucred_getauid(const ucred_t *uc)
 303 {
 304         /* LINTED: alignment */
 305         const auditinfo64_addr_t *ainfo = UCAUD(uc);
 306
 307         if (ainfo == NULL)
 308                 return (AU_NOAUDITID);
 309
 310         return (ainfo->ai_auid);
 311 }
 312
 313 au_asid_t
 314 ucred_getasid(const ucred_t *uc)
 315 {
 316         /* LINTED: alignment */
 317         const auditinfo64_addr_t *ainfo = UCAUD(uc);
 318
 319         if (ainfo == NULL)
 320                 return ((au_asid_t)-1);
 321
 322         return (ainfo->ai_asid);
 323 }
 324
 325 const au_tid64_addr_t *
 326 ucred_getatid(const ucred_t *uc)
 327 {
 328         /* LINTED: alignment */
 329         const auditinfo64_addr_t *ainfo = UCAUD(uc);
 330
 331         if (ainfo == NULL) {
 332                 errno = EINVAL;
 333                 return (NULL);
 334         }
 335
 336         return (&ainfo->ai_termid);
 337 }
 338
 339 const au_mask_t *
 340 ucred_getamask(const ucred_t *uc)
 341 {
 342         /* LINTED: alignment */
 343         const auditinfo64_addr_t *ainfo = UCAUD(uc);
 344
 345         if (ainfo == NULL) {
 346                 errno = EINVAL;
 347                 return (NULL);
 348         }
 349
 350         return (&ainfo->ai_mask);
 351 }
 352
 353 size_t
 354 ucred_size(void)
 355 {
 356         priv_data_t *d;
 357
 358         LOADPRIVDATA(d);
 359
 360         return (d->pd_ucredsize);
 361 }