lib/libc/posix1e/acl_entry.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2001-2002 Chris D. Faulhaber
   5  * All rights reserved.
   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 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/types.h>
  33 #include "namespace.h"
  34 #include <sys/acl.h>
  35 #include "un-namespace.h"
  36
  37 #include <errno.h>
  38 #include <stdlib.h>
  39
  40 /*
  41  * acl_create_entry() (23.4.7): create a new ACL entry in the ACL pointed
  42  * to by acl_p.
  43  */
  44 int
  45 acl_create_entry(acl_t *acl_p, acl_entry_t *entry_p)
  46 {
  47         struct acl *acl_int;
  48
  49         if (acl_p == NULL) {
  50                 errno = EINVAL;
  51                 return (-1);
  52         }
  53
  54         acl_int = &(*acl_p)->ats_acl;
  55
  56         /*
  57          * +1, because we are checking if there is space left for one more
  58          * entry.
  59          */
  60         if (acl_int->acl_cnt + 1 >= ACL_MAX_ENTRIES) {
  61                 errno = EINVAL;
  62                 return (-1);
  63         }
  64
  65         *entry_p = &acl_int->acl_entry[acl_int->acl_cnt++];
  66
  67         (**entry_p).ae_tag  = ACL_UNDEFINED_TAG;
  68         (**entry_p).ae_id   = ACL_UNDEFINED_ID;
  69         (**entry_p).ae_perm = ACL_PERM_NONE;
  70         (**entry_p).ae_entry_type = 0;
  71         (**entry_p).ae_flags = 0;
  72
  73         (*acl_p)->ats_cur_entry = 0;
  74
  75         return (0);
  76 }
  77
  78 int
  79 acl_create_entry_np(acl_t *acl_p, acl_entry_t *entry_p, int offset)
  80 {
  81         int i;
  82         struct acl *acl_int;
  83
  84         if (acl_p == NULL) {
  85                 errno = EINVAL;
  86                 return (-1);
  87         }
  88
  89         acl_int = &(*acl_p)->ats_acl;
  90
  91         if (acl_int->acl_cnt + 1 >= ACL_MAX_ENTRIES) {
  92                 errno = EINVAL;
  93                 return (-1);
  94         }
  95
  96         if (offset < 0 || offset > acl_int->acl_cnt) {
  97                 errno = EINVAL;
  98                 return (-1);
  99         }
 100
 101         /* Make room for the new entry. */
 102         for (i = acl_int->acl_cnt; i > offset; i--)
 103                 acl_int->acl_entry[i] = acl_int->acl_entry[i - 1];
 104
 105         acl_int->acl_cnt++;
 106
 107         *entry_p = &acl_int->acl_entry[offset];
 108
 109         (**entry_p).ae_tag  = ACL_UNDEFINED_TAG;
 110         (**entry_p).ae_id   = ACL_UNDEFINED_ID;
 111         (**entry_p).ae_perm = ACL_PERM_NONE;
 112         (**entry_p).ae_entry_type = 0;
 113         (**entry_p).ae_flags= 0;
 114
 115         (*acl_p)->ats_cur_entry = 0;
 116
 117         return (0);
 118 }
 119
 120 /*
 121  * acl_get_entry() (23.4.14): returns an ACL entry from an ACL
 122  * indicated by entry_id.
 123  */
 124 int
 125 acl_get_entry(acl_t acl, int entry_id, acl_entry_t *entry_p)
 126 {
 127         struct acl *acl_int;
 128
 129         if (acl == NULL) {
 130                 errno = EINVAL;
 131                 return (-1);
 132         }
 133         acl_int = &acl->ats_acl;
 134
 135         switch(entry_id) {
 136         case ACL_FIRST_ENTRY:
 137                 acl->ats_cur_entry = 0;
 138                 /* PASSTHROUGH */
 139         case ACL_NEXT_ENTRY:
 140                 if (acl->ats_cur_entry >= acl->ats_acl.acl_cnt)
 141                         return 0;
 142                 *entry_p = &acl_int->acl_entry[acl->ats_cur_entry++];
 143                 return (1);
 144         }
 145
 146         errno = EINVAL;
 147         return (-1);
 148 }