contrib/libarchive/libarchive/test/test_acl_posix1e.c

   1 /*-
   2  * Copyright (c) 2003-2007 Tim Kientzle
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25 #include "test.h"
  26 __FBSDID("$FreeBSD: src/lib/libarchive/test/test_acl_basic.c,v 1.6 2008/10/19 00:13:57 kientzle Exp $");
  27
  28 /*
  29  * Exercise the system-independent portion of the ACL support.
  30  * Check that archive_entry objects can save and restore POSIX.1e-style ACL data.
  31  *
  32  * This should work on all systems, regardless of whether local
  33  * filesystems support ACLs or not.
  34  */
  35
  36 struct acl_t {
  37         int type;  /* Type of ACL: "access" or "default" */
  38         int permset; /* Permissions for this class of users. */
  39         int tag; /* Owner, User, Owning group, group, other, etc. */
  40         int qual; /* GID or UID of user/group, depending on tag. */
  41         const char *name; /* Name of user/group, depending on tag. */
  42 };
  43
  44 static struct acl_t acls0[] = {
  45         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_EXECUTE,
  46           ARCHIVE_ENTRY_ACL_USER_OBJ, 0, "" },
  47         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_READ,
  48           ARCHIVE_ENTRY_ACL_GROUP_OBJ, 0, "" },
  49         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_WRITE,
  50           ARCHIVE_ENTRY_ACL_OTHER, 0, "" },
  51 };
  52
  53 static struct acl_t acls1[] = {
  54         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_EXECUTE,
  55           ARCHIVE_ENTRY_ACL_USER_OBJ, -1, "" },
  56         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_READ,
  57           ARCHIVE_ENTRY_ACL_USER, 77, "user77" },
  58         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_READ,
  59           ARCHIVE_ENTRY_ACL_GROUP_OBJ, -1, "" },
  60         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_WRITE,
  61           ARCHIVE_ENTRY_ACL_OTHER, -1, "" },
  62 };
  63
  64 static struct acl_t acls2[] = {
  65         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_EXECUTE | ARCHIVE_ENTRY_ACL_READ,
  66           ARCHIVE_ENTRY_ACL_USER_OBJ, -1, "" },
  67         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_READ,
  68           ARCHIVE_ENTRY_ACL_USER, 77, "user77" },
  69         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0,
  70           ARCHIVE_ENTRY_ACL_USER, 78, "user78" },
  71         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_READ,
  72           ARCHIVE_ENTRY_ACL_GROUP_OBJ, -1, "" },
  73         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0007,
  74           ARCHIVE_ENTRY_ACL_GROUP, 78, "group78" },
  75         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_WRITE | ARCHIVE_ENTRY_ACL_EXECUTE,
  76           ARCHIVE_ENTRY_ACL_OTHER, -1, "" },
  77 };
  78
  79 /*
  80  * NFS4 entry types; attempts to set these on top of POSIX.1e
  81  * attributes should fail.
  82  */
  83 static struct acl_t acls_nfs4[] = {
  84         /* NFS4 types */
  85         { ARCHIVE_ENTRY_ACL_TYPE_ALLOW, ARCHIVE_ENTRY_ACL_READ,
  86           ARCHIVE_ENTRY_ACL_USER, 78, "" },
  87         { ARCHIVE_ENTRY_ACL_TYPE_DENY, ARCHIVE_ENTRY_ACL_READ,
  88           ARCHIVE_ENTRY_ACL_USER, 78, "" },
  89         { ARCHIVE_ENTRY_ACL_TYPE_AUDIT, ARCHIVE_ENTRY_ACL_READ,
  90           ARCHIVE_ENTRY_ACL_USER, 78, "" },
  91         { ARCHIVE_ENTRY_ACL_TYPE_ALARM, ARCHIVE_ENTRY_ACL_READ,
  92           ARCHIVE_ENTRY_ACL_USER, 78, "" },
  93
  94         /* NFS4 tags */
  95         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_READ,
  96           ARCHIVE_ENTRY_ACL_EVERYONE, -1, "" },
  97
  98         /* NFS4 inheritance markers */
  99         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 100           ARCHIVE_ENTRY_ACL_READ | ARCHIVE_ENTRY_ACL_ENTRY_FILE_INHERIT,
 101           ARCHIVE_ENTRY_ACL_USER, 79, "" },
 102         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 103           ARCHIVE_ENTRY_ACL_READ | ARCHIVE_ENTRY_ACL_ENTRY_FILE_INHERIT,
 104           ARCHIVE_ENTRY_ACL_USER_OBJ, -1, "" },
 105 };
 106
 107 static void
 108 set_acls(struct archive_entry *ae, struct acl_t *acls, int n)
 109 {
 110         int i;
 111
 112         archive_entry_acl_clear(ae);
 113         for (i = 0; i < n; i++) {
 114                 archive_entry_acl_add_entry(ae,
 115                     acls[i].type, acls[i].permset, acls[i].tag, acls[i].qual,
 116                     acls[i].name);
 117         }
 118 }
 119
 120 static int
 121 acl_match(struct acl_t *acl, int type, int permset, int tag, int qual, const char *name)
 122 {
 123         if (type != acl->type)
 124                 return (0);
 125         if (permset != acl->permset)
 126                 return (0);
 127         if (tag != acl->tag)
 128                 return (0);
 129         if (tag == ARCHIVE_ENTRY_ACL_USER_OBJ)
 130                 return (1);
 131         if (tag == ARCHIVE_ENTRY_ACL_GROUP_OBJ)
 132                 return (1);
 133         if (tag == ARCHIVE_ENTRY_ACL_OTHER)
 134                 return (1);
 135         if (qual != acl->qual)
 136                 return (0);
 137         if (name == NULL) {
 138                 if (acl->name == NULL || acl->name[0] == '\0')
 139                         return (1);
 140                 return (0);
 141         }
 142         if (acl->name == NULL) {
 143                 if (name[0] == '\0')
 144                         return (1);
 145                 return (0);
 146         }
 147         return (0 == strcmp(name, acl->name));
 148 }
 149
 150 static void
 151 compare_acls(struct archive_entry *ae, struct acl_t *acls, int n, int mode)
 152 {
 153         int *marker = malloc(sizeof(marker[0]) * n);
 154         int i;
 155         int r;
 156         int type, permset, tag, qual;
 157         int matched;
 158         const char *name;
 159
 160         for (i = 0; i < n; i++)
 161                 marker[i] = i;
 162
 163         while (0 == (r = archive_entry_acl_next(ae,
 164                          ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 165                          &type, &permset, &tag, &qual, &name))) {
 166                 for (i = 0, matched = 0; i < n && !matched; i++) {
 167                         if (acl_match(&acls[marker[i]], type, permset,
 168                                 tag, qual, name)) {
 169                                 /* We found a match; remove it. */
 170                                 marker[i] = marker[n - 1];
 171                                 n--;
 172                                 matched = 1;
 173                         }
 174                 }
 175                 if (tag == ARCHIVE_ENTRY_ACL_USER_OBJ) {
 176                         if (!matched) printf("No match for user_obj perm\n");
 177                         failure("USER_OBJ permset (%02o) != user mode (%02o)",
 178                             permset, 07 & (mode >> 6));
 179                         assert((permset << 6) == (mode & 0700));
 180                 } else if (tag == ARCHIVE_ENTRY_ACL_GROUP_OBJ) {
 181                         if (!matched) printf("No match for group_obj perm\n");
 182                         failure("GROUP_OBJ permset %02o != group mode %02o",
 183                             permset, 07 & (mode >> 3));
 184                         assert((permset << 3) == (mode & 0070));
 185                 } else if (tag == ARCHIVE_ENTRY_ACL_OTHER) {
 186                         if (!matched) printf("No match for other perm\n");
 187                         failure("OTHER permset (%02o) != other mode (%02o)",
 188                             permset, mode & 07);
 189                         assert((permset << 0) == (mode & 0007));
 190                 } else {
 191                         failure("Could not find match for ACL "
 192                             "(type=%d,permset=%d,tag=%d,qual=%d,name=``%s'')",
 193                             type, permset, tag, qual, name);
 194                         assert(matched == 1);
 195                 }
 196         }
 197         assertEqualInt(ARCHIVE_EOF, r);
 198         assert((mode_t)(mode & 0777) == (archive_entry_mode(ae) & 0777));
 199         failure("Could not find match for ACL "
 200             "(type=%d,permset=%d,tag=%d,qual=%d,name=``%s'')",
 201             acls[marker[0]].type, acls[marker[0]].permset,
 202             acls[marker[0]].tag, acls[marker[0]].qual, acls[marker[0]].name);
 203         assert(n == 0); /* Number of ACLs not matched should == 0 */
 204         free(marker);
 205 }
 206
 207 DEFINE_TEST(test_acl_posix1e)
 208 {
 209         struct archive_entry *ae;
 210         int i;
 211
 212         /* Create a simple archive_entry. */
 213         assert((ae = archive_entry_new()) != NULL);
 214         archive_entry_set_pathname(ae, "file");
 215         archive_entry_set_mode(ae, S_IFREG | 0777);
 216
 217         /* Basic owner/owning group should just update mode bits. */
 218
 219         /*
 220          * Note: This features of libarchive's ACL implementation
 221          * shouldn't be relied on and should probably be removed.  It
 222          * was done to identify trivial ACLs so we could avoid
 223          * triggering unnecessary extensions.  It's better to identify
 224          * trivial ACLs at the point they are being read from disk.
 225          */
 226         set_acls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]));
 227         failure("Basic ACLs shouldn't be stored as extended ACLs");
 228         assert(0 == archive_entry_acl_reset(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
 229         failure("Basic ACLs should set mode to 0142, not %04o",
 230             archive_entry_mode(ae)&0777);
 231         assert((archive_entry_mode(ae) & 0777) == 0142);
 232
 233
 234         /* With any extended ACL entry, we should read back a full set. */
 235         set_acls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]));
 236         failure("One extended ACL should flag all ACLs to be returned.");
 237         assert(4 == archive_entry_acl_reset(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
 238         compare_acls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]), 0142);
 239         failure("Basic ACLs should set mode to 0142, not %04o",
 240             archive_entry_mode(ae)&0777);
 241         assert((archive_entry_mode(ae) & 0777) == 0142);
 242
 243
 244         /* A more extensive set of ACLs. */
 245         set_acls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]));
 246         assertEqualInt(6, archive_entry_acl_reset(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
 247         compare_acls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]), 0543);
 248         failure("Basic ACLs should set mode to 0543, not %04o",
 249             archive_entry_mode(ae)&0777);
 250         assert((archive_entry_mode(ae) & 0777) == 0543);
 251
 252         /*
 253          * Check that clearing ACLs gets rid of them all by repeating
 254          * the first test.
 255          */
 256         set_acls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]));
 257         failure("Basic ACLs shouldn't be stored as extended ACLs");
 258         assert(0 == archive_entry_acl_reset(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
 259         failure("Basic ACLs should set mode to 0142, not %04o",
 260             archive_entry_mode(ae)&0777);
 261         assert((archive_entry_mode(ae) & 0777) == 0142);
 262
 263         /*
 264          * Different types of malformed ACL entries that should
 265          * fail when added to existing POSIX.1e ACLs.
 266          */
 267         set_acls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]));
 268         for (i = 0; i < (int)(sizeof(acls_nfs4)/sizeof(acls_nfs4[0])); ++i) {
 269                 struct acl_t *p = &acls_nfs4[i];
 270                 failure("Malformed ACL test #%d", i);
 271                 assertEqualInt(ARCHIVE_FAILED,
 272                     archive_entry_acl_add_entry(ae,
 273                         p->type, p->permset, p->tag, p->qual, p->name));
 274                 assertEqualInt(6,
 275                     archive_entry_acl_reset(ae,
 276                         ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
 277         }
 278         archive_entry_free(ae);
 279 }