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 } 280