src/acl_test.c

   1 /*
   2  * Copyright (c) 2001 Silicon Graphics, Inc.  All Rights Reserved.
   3  *
   4  * This prog is free software; you can redistribute it and/or modify it
   5  * under the terms of version 2 of the GNU General Public License as
   6  * published by the Free Software Foundation.
   7  *
   8  * This prog is distributed in the hope that it would be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  11  *
  12  * Further, this software is distributed without any warranty that it is
  13  * free of the rightful claim of any third person regarding infringement
  14  * or the like.  Any license provided herein, whether implied or
  15  * otherwise, applies only to this software file.  Patent licenses, if
  16  * any, provided herein do not apply to combinations of this prog with
  17  * other software, or any other product whatsoever.
  18  *
  19  * You should have received a copy of the GNU General Public License along
  20  * with this prog; if not, write the Free Software Foundation, Inc., 59
  21  * Temple Place - Suite 330, Boston MA 02111-1307, USA.
  22  *
  23  * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
  24  * Mountain View, CA  94043, or:
  25  *
  26  * http://www.sgi.com
  27  *
  28  * For further information regarding this notice, see:
  29  *
  30  * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
  31  */
  32
  33 /*
  34  * Test our various libacl functions.
  35  * Use IRIX semantics or Linux semantics if pertinent.
  36  */
  37
  38 #include "global.h"
  39
  40 #include <errno.h>
  41 #include <sys/acl.h>
  42
  43 char *prog;
  44 int irixsemantics = 0;
  45
  46 void usage(void)
  47 {
  48     fprintf(stderr, "usage: %s\n"
  49            "    -i - use irix semantics\n"
  50            ,prog);
  51
  52 }
  53
  54 void
  55 print_err(char *msg)
  56 {
  57     printf("%s: %s: %s\n", prog, msg, strerror(errno));
  58 }
  59
  60 void
  61 dump_ace(acl_entry_t ace)
  62 {
  63     printf("<tag:%d,id:%d,perm:%u>",
  64             ace->ae_tag, ace->ae_id, ace->ae_perm);
  65 }
  66
  67 void
  68 dump_acl(acl_t acl)
  69 {
  70     int i;
  71     printf("ACL[n=%d]: ", acl->acl_cnt);
  72     for (i=0;i<acl->acl_cnt;i++) {
  73         acl_entry_t ace = &acl->acl_entry[i];
  74         printf("%d: ", i);
  75         dump_ace(ace);
  76         printf(" ");
  77     }
  78     printf("\n");
  79
  80 }
  81
  82 void
  83 dump_acl_by_entry(acl_t acl)
  84 {
  85     int sts, i;
  86     acl_entry_t ace;
  87
  88     printf("Get 1st entry on filled ACL\n");
  89     sts = acl_get_entry(acl, ACL_FIRST_ENTRY, &ace);
  90     printf("acl_get_entry -> %d\n", sts);
  91     if (sts > 0) {
  92         printf("1: "); dump_ace(ace); printf("\n");
  93     }
  94
  95     for(i=2;i<=acl->acl_cnt+2;i++) {
  96         printf("Get %dth entry on filled ACL\n", i);
  97         sts = acl_get_entry(acl, ACL_NEXT_ENTRY, &ace);
  98         printf("acl_get_entry -> %d\n", sts);
  99         if (sts > 0) {
 100             printf("%d: ",i); dump_ace(ace); printf("\n");
 101         }
 102     }
 103 }
 104
 105 /*
 106  * create a full acl with entries with known bogus values
 107  */
 108 acl_t
 109 create_filled_acl(void)
 110 {
 111     acl_t acl;
 112     int i;
 113
 114     acl = acl_init(ACL_MAX_ENTRIES);
 115
 116     for(i=0;i<ACL_MAX_ENTRIES;i++) {
 117         acl_entry_t ace = &acl->acl_entry[i];
 118         ace->ae_tag = i;
 119         ace->ae_id = i+1;
 120         ace->ae_perm = i+2;
 121         acl->acl_cnt++;
 122     }
 123     return acl;
 124 }
 125
 126 void
 127 test_acl_get_qualifier(void)
 128 {
 129     struct acl_entry ace;
 130     uid_t *uidp;
 131
 132     printf("*** test out acl_get_qualifier ***\n");
 133
 134     /* simple ace */
 135     ace.ae_tag = ACL_USER;
 136     ace.ae_id = 1;
 137     ace.ae_perm = 1;
 138
 139     /* make sure we can get uid and free it */
 140     uidp = acl_get_qualifier(&ace);
 141     printf("uid = %d\n", *uidp);
 142     acl_free(uidp);
 143
 144     /* change to another valid tag with a qualifier */
 145     ace.ae_tag = ACL_GROUP;
 146     uidp = acl_get_qualifier(&ace);
 147     printf("uid = %d\n", *uidp);
 148     acl_free(uidp);
 149
 150     /* let's get some errors */
 151
 152     ace.ae_tag = ACL_USER_OBJ;
 153     uidp = acl_get_qualifier(&ace);
 154     if (uidp == NULL)
 155         printf("uidp is NULL: %s\n", strerror(errno));
 156     else
 157         printf("Error: uidp is NOT NULL\n");
 158
 159     uidp = acl_get_qualifier(NULL);
 160     if (uidp == NULL)
 161         printf("uidp is NULL: %s\n", strerror(errno));
 162     else
 163         printf("Error: uidp is NOT NULL\n");
 164 }
 165
 166 int
 167 main(int argc, char **argv)
 168 {
 169         int c, i;
 170         acl_t acl1, acl2, acl3;
 171         acl_entry_t ace1;
 172
 173         prog = basename(argv[0]);
 174
 175         while ((c = getopt(argc, argv, "i")) != -1) {
 176                 switch (c) {
 177                 case 'i':
 178                         irixsemantics = 1;
 179                         break;
 180                 case '?':
 181                         usage();
 182                         return 1;
 183                 }
 184         }
 185
 186         if (irixsemantics) {
 187             acl_set_compat(ACL_COMPAT_IRIXGET);
 188         }
 189
 190         /* ---------------------------------------------- */
 191         printf("*** test out creating an ACL ***\n");
 192
 193         printf("Test acl_init(ACL_MAX_ENTRIES+1)\n");
 194         acl1 = acl_init(ACL_MAX_ENTRIES+1);
 195         if (acl1 == NULL) {
 196             print_err("acl_init(max+1)");
 197         }
 198         printf("Test acl_init(-1)\n");
 199         acl1 = acl_init(-1);
 200         if (acl1 == NULL) {
 201             print_err("acl_init(-1)");
 202         }
 203         printf("Test acl_init(0)\n");
 204         acl1 = acl_init(0);
 205         if (acl1 == NULL) {
 206             print_err("acl_init(0)");
 207         }
 208
 209         printf("Test acl_create_entry(NULL, ...)\n");
 210         if (acl_create_entry(NULL, &ace1) == -1) {
 211             print_err("acl_create_entry(NULL,ace1)");
 212         }
 213         printf("Test acl_create_entry(..., NULL)\n");
 214         if (acl_create_entry(&acl1, NULL) == -1) {
 215             print_err("acl_create_entry(NULL,ace1)");
 216         }
 217         printf("Test acl_create_entry(acl1, ace1)\n");
 218         acl1 = NULL;
 219         if (acl_create_entry(&acl1, &ace1) == -1) {
 220             print_err("acl_create_entry(*null,ace1)");
 221         }
 222
 223         acl_free(acl1);
 224         acl1 = acl_init(0);
 225         for (i=0;i<=ACL_MAX_ENTRIES+1;i++) {
 226             printf("%d: creating ace\n", i);
 227             if (acl_create_entry(&acl1, &ace1) == -1) {
 228                 print_err("acl_create_entry");
 229             }
 230             dump_acl(acl1);
 231         }
 232
 233         /* ---------------------------------------------- */
 234         printf("*** test out getting ACEs ***\n");
 235
 236         dump_acl_by_entry(acl1);
 237
 238         printf("dump empty ACL\n");
 239         acl2 = acl_init(0);
 240         if (acl2 == NULL) {
 241             print_err("acl_init(0)");
 242         }
 243         dump_acl_by_entry(acl2);
 244
 245         printf("fill an ACL with known bogus values\n");
 246         acl3 = create_filled_acl();
 247         dump_acl_by_entry(acl3);
 248
 249         /* ---------------------------------------------- */
 250         printf("*** test out ACL to text for empty ACL***\n");
 251         {
 252             char *text;
 253             ssize_t len;
 254             acl_t empty_acl = acl_init(0);
 255             text = acl_to_text(empty_acl, NULL);
 256             printf("acl_to_text(empty_acl,NULL) -> \"%s\"\n", text);
 257             text = acl_to_text(empty_acl, &len);
 258             printf("acl_to_text(empty_acl,NULL) -> \"%s\", len = %u\n", text, len);
 259             text = acl_to_text(NULL, NULL);
 260             printf("acl_to_text(NULL,NULL) -> \"%s\"\n", text==NULL?"NULL":text);
 261         }
 262         /* NOTE: Other tests will test out the text for ACLs with ACEs.
 263          *       So don't have to test it here.
 264          *       It is simplest to choose ids not in /etc/passwd /etc/group
 265          *       which is done already in a script.
 266          */
 267
 268         test_acl_get_qualifier();
 269
 270         return 0;
 271 }