lib/libc/posix1e/acl_set.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 1999, 2000, 2001, 2002 Robert N. M. Watson
   5  * All rights reserved.
   6  *
   7  * This software was developed by Robert Watson for the TrustedBSD Project.
   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 AUTHOR 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 AUTHOR 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  * acl_set_file -- set a file/directory ACL by name
  32  */
  33
  34 #include <sys/cdefs.h>
  35 __FBSDID("$FreeBSD$");
  36
  37 #include <sys/types.h>
  38 #include "namespace.h"
  39 #include <sys/acl.h>
  40 #include "un-namespace.h"
  41
  42 #include <errno.h>
  43 #include <stdlib.h>
  44 #include <string.h>
  45 #include <unistd.h>
  46
  47 #include "acl_support.h"
  48
  49 /*
  50  * For POSIX.1e-semantic ACLs, do a presort so the kernel doesn't have to
  51  * (the POSIX.1e semantic code will reject unsorted ACL submission).  If it's
  52  * not a semantic that the library knows about, just submit it flat and
  53  * assume the caller knows what they're up to.
  54  */
  55 int
  56 acl_set_file(const char *path_p, acl_type_t type, acl_t acl)
  57 {
  58
  59         if (acl == NULL || path_p == NULL) {
  60                 errno = EINVAL;
  61                 return (-1);
  62         }
  63         type = _acl_type_unold(type);
  64         if (_acl_type_not_valid_for_acl(acl, type)) {
  65                 errno = EINVAL;
  66                 return (-1);
  67         }
  68         if (_posix1e_acl(acl, type))
  69                 _posix1e_acl_sort(acl);
  70
  71         acl->ats_cur_entry = 0;
  72
  73         return (__acl_set_file(path_p, type, &acl->ats_acl));
  74 }
  75
  76 int
  77 acl_set_link_np(const char *path_p, acl_type_t type, acl_t acl)
  78 {
  79
  80         if (acl == NULL || path_p == NULL) {
  81                 errno = EINVAL;
  82                 return (-1);
  83         }
  84         type = _acl_type_unold(type);
  85         if (_acl_type_not_valid_for_acl(acl, type)) {
  86                 errno = EINVAL;
  87                 return (-1);
  88         }
  89         if (_posix1e_acl(acl, type))
  90                 _posix1e_acl_sort(acl);
  91
  92         acl->ats_cur_entry = 0;
  93
  94         return (__acl_set_link(path_p, type, &acl->ats_acl));
  95 }
  96
  97 int
  98 acl_set_fd(int fd, acl_t acl)
  99 {
 100
 101         if (fpathconf(fd, _PC_ACL_NFS4) == 1)
 102                 return (acl_set_fd_np(fd, acl, ACL_TYPE_NFS4));
 103
 104         return (acl_set_fd_np(fd, acl, ACL_TYPE_ACCESS));
 105 }
 106
 107 int
 108 acl_set_fd_np(int fd, acl_t acl, acl_type_t type)
 109 {
 110
 111         if (acl == NULL) {
 112                 errno = EINVAL;
 113                 return (-1);
 114         }
 115         type = _acl_type_unold(type);
 116         if (_acl_type_not_valid_for_acl(acl, type)) {
 117                 errno = EINVAL;
 118                 return (-1);
 119         }
 120         if (_posix1e_acl(acl, type))
 121                 _posix1e_acl_sort(acl);
 122
 123         acl->ats_cur_entry = 0;
 124
 125         return (___acl_set_fd(fd, type, &acl->ats_acl));
 126 }
 127
 128 /*
 129  * acl_set_permset() (23.4.23): sets the permissions of ACL entry entry_d
 130  * with the permissions in permset_d
 131  */
 132 int
 133 acl_set_permset(acl_entry_t entry_d, acl_permset_t permset_d)
 134 {
 135
 136         if (!entry_d) {
 137                 errno = EINVAL;
 138                 return (-1);
 139         }
 140
 141         if ((*permset_d & ACL_POSIX1E_BITS) != *permset_d) {
 142                 if ((*permset_d & ACL_NFS4_PERM_BITS) != *permset_d) {
 143                         errno = EINVAL;
 144                         return (-1);
 145                 }
 146                 if (!_entry_brand_may_be(entry_d, ACL_BRAND_NFS4)) {
 147                         errno = EINVAL;
 148                         return (-1);
 149                 }
 150                 _entry_brand_as(entry_d, ACL_BRAND_NFS4);
 151         }
 152
 153         entry_d->ae_perm = *permset_d;
 154
 155         return (0);
 156 }
 157
 158 /*
 159  * acl_set_qualifier() sets the qualifier (ae_id) of the tag for
 160  * ACL entry entry_d to the value referred to by tag_qualifier_p
 161  */
 162 int
 163 acl_set_qualifier(acl_entry_t entry_d, const void *tag_qualifier_p)
 164 {
 165
 166         if (!entry_d || !tag_qualifier_p) {
 167                 errno = EINVAL;
 168                 return (-1);
 169         }
 170         switch(entry_d->ae_tag) {
 171         case ACL_USER:
 172         case ACL_GROUP:
 173                 entry_d->ae_id = *(uid_t *)tag_qualifier_p;
 174                 break;
 175         default:
 176                 errno = EINVAL;
 177                 return (-1);
 178         }
 179
 180         return (0);
 181 }
 182
 183 /*
 184  * acl_set_tag_type() sets the tag type for ACL entry entry_d to the
 185  * value of tag_type
 186  */
 187 int
 188 acl_set_tag_type(acl_entry_t entry_d, acl_tag_t tag_type)
 189 {
 190
 191         if (entry_d == NULL) {
 192                 errno = EINVAL;
 193                 return (-1);
 194         }
 195
 196         switch(tag_type) {
 197         case ACL_OTHER:
 198         case ACL_MASK:
 199                 if (!_entry_brand_may_be(entry_d, ACL_BRAND_POSIX)) {
 200                         errno = EINVAL;
 201                         return (-1);
 202                 }
 203                 _entry_brand_as(entry_d, ACL_BRAND_POSIX);
 204                 break;
 205         case ACL_EVERYONE:
 206                 if (!_entry_brand_may_be(entry_d, ACL_BRAND_NFS4)) {
 207                         errno = EINVAL;
 208                         return (-1);
 209                 }
 210                 _entry_brand_as(entry_d, ACL_BRAND_NFS4);
 211                 break;
 212         }
 213
 214         switch(tag_type) {
 215         case ACL_USER_OBJ:
 216         case ACL_USER:
 217         case ACL_GROUP_OBJ:
 218         case ACL_GROUP:
 219         case ACL_MASK:
 220         case ACL_OTHER:
 221         case ACL_EVERYONE:
 222                 entry_d->ae_tag = tag_type;
 223                 return (0);
 224         }
 225
 226         errno = EINVAL;
 227         return (-1);
 228 }
 229
 230 int
 231 acl_set_entry_type_np(acl_entry_t entry_d, acl_entry_type_t entry_type)
 232 {
 233
 234         if (entry_d == NULL) {
 235                 errno = EINVAL;
 236                 return (-1);
 237         }
 238         if (!_entry_brand_may_be(entry_d, ACL_BRAND_NFS4)) {
 239                 errno = EINVAL;
 240                 return (-1);
 241         }
 242         _entry_brand_as(entry_d, ACL_BRAND_NFS4);
 243
 244         switch (entry_type) {
 245         case ACL_ENTRY_TYPE_ALLOW:
 246         case ACL_ENTRY_TYPE_DENY:
 247         case ACL_ENTRY_TYPE_AUDIT:
 248         case ACL_ENTRY_TYPE_ALARM:
 249                 entry_d->ae_entry_type = entry_type;
 250                 return (0);
 251         }
 252
 253         errno = EINVAL;
 254         return (-1);
 255 }