lib/libc/posix1e/acl_set.c

   1 /*-
   2  * Copyright (c) 1999, 2000, 2001, 2002 Robert N. M. Watson
   3  * All rights reserved.
   4  *
   5  * This software was developed by Robert Watson for the TrustedBSD Project.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28 /*
  29  * acl_set_file -- set a file/directory ACL by name
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <sys/types.h>
  36 #include "namespace.h"
  37 #include <sys/acl.h>
  38 #include "un-namespace.h"
  39
  40 #include <errno.h>
  41 #include <stdlib.h>
  42 #include <string.h>
  43
  44 #include "acl_support.h"
  45
  46 /*
  47  * For POSIX.1e-semantic ACLs, do a presort so the kernel doesn't have to
  48  * (the POSIX.1e semantic code will reject unsorted ACL submission).  If it's
  49  * not a semantic that the library knows about, just submit it flat and
  50  * assume the caller knows what they're up to.
  51  */
  52 int
  53 acl_set_file(const char *path_p, acl_type_t type, acl_t acl)
  54 {
  55         int     error;
  56
  57         if (acl == NULL || path_p == NULL) {
  58                 errno = EINVAL;
  59                 return (-1);
  60         }
  61         if (_posix1e_acl(acl, type)) {
  62                 error = _posix1e_acl_sort(acl);
  63                 if (error) {
  64                         errno = error;
  65                         return (-1);
  66                 }
  67         }
  68
  69         acl->ats_cur_entry = 0;
  70
  71         return (__acl_set_file(path_p, type, &acl->ats_acl));
  72 }
  73
  74 int
  75 acl_set_link_np(const char *path_p, acl_type_t type, acl_t acl)
  76 {
  77         int     error;
  78
  79         if (acl == NULL || path_p == NULL) {
  80                 errno = EINVAL;
  81                 return (-1);
  82         }
  83         if (_posix1e_acl(acl, type)) {
  84                 error = _posix1e_acl_sort(acl);
  85                 if (error) {
  86                         errno = error;
  87                         return (-1);
  88                 }
  89         }
  90
  91         acl->ats_cur_entry = 0;
  92
  93         return (__acl_set_link(path_p, type, &acl->ats_acl));
  94 }
  95
  96 int
  97 acl_set_fd(int fd, acl_t acl)
  98 {
  99         int     error;
 100
 101         error = _posix1e_acl_sort(acl);
 102         if (error) {
 103                 errno = error;
 104                 return(-1);
 105         }
 106
 107         acl->ats_cur_entry = 0;
 108
 109         return (___acl_set_fd(fd, ACL_TYPE_ACCESS, &acl->ats_acl));
 110 }
 111
 112 int
 113 acl_set_fd_np(int fd, acl_t acl, acl_type_t type)
 114 {
 115         int     error;
 116
 117         if (_posix1e_acl(acl, type)) {
 118                 error = _posix1e_acl_sort(acl);
 119                 if (error) {
 120                         errno = error;
 121                         return (-1);
 122                 }
 123         }
 124
 125         acl->ats_cur_entry = 0;
 126
 127         return (___acl_set_fd(fd, type, &acl->ats_acl));
 128 }
 129
 130 /*
 131  * acl_set_permset() (23.4.23): sets the permissions of ACL entry entry_d
 132  * with the permissions in permset_d
 133  */
 134 int
 135 acl_set_permset(acl_entry_t entry_d, acl_permset_t permset_d)
 136 {
 137
 138         if (!entry_d) {
 139                 errno = EINVAL;
 140                 return (-1);
 141         }
 142
 143         entry_d->ae_perm = *permset_d;
 144
 145         return (0);
 146 }
 147
 148 /*
 149  * acl_set_qualifier() sets the qualifier (ae_id) of the tag for
 150  * ACL entry entry_d to the value referred to by tag_qualifier_p
 151  */
 152 int
 153 acl_set_qualifier(acl_entry_t entry_d, const void *tag_qualifier_p)
 154 {
 155         if (!entry_d || !tag_qualifier_p) {
 156                 errno = EINVAL;
 157                 return (-1);
 158         }
 159
 160         switch(entry_d->ae_tag) {
 161         case ACL_USER:
 162         case ACL_GROUP:
 163                 entry_d->ae_id = *(uid_t *)tag_qualifier_p;
 164                 break;
 165         default:
 166                 errno = EINVAL;
 167                 return (-1);
 168         }
 169
 170         return (0);
 171 }
 172
 173 /*
 174  * acl_set_tag_type() sets the tag type for ACL entry entry_d to the
 175  * value of tag_type
 176  */
 177 int
 178 acl_set_tag_type(acl_entry_t entry_d, acl_tag_t tag_type)
 179 {
 180
 181         if (entry_d == NULL) {
 182                 errno = EINVAL;
 183                 return (-1);
 184         }
 185
 186         switch(tag_type) {
 187         case ACL_USER_OBJ:
 188         case ACL_USER:
 189         case ACL_GROUP_OBJ:
 190         case ACL_GROUP:
 191         case ACL_MASK:
 192         case ACL_OTHER:
 193                 entry_d->ae_tag = tag_type;
 194                 return (0);
 195         }
 196
 197         errno = EINVAL;
 198         return (-1);
 199 }