lib/libarchive/test/test_acl_freebsd.c

   1 /*-
   2  * Copyright (c) 2003-2008 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$");
  27
  28 #if defined(__FreeBSD__) && __FreeBSD__ > 4
  29 #include <sys/acl.h>
  30
  31 struct myacl_t {
  32         int type;  /* Type of ACL: "access" or "default" */
  33         int permset; /* Permissions for this class of users. */
  34         int tag; /* Owner, User, Owning group, group, other, etc. */
  35         int qual; /* GID or UID of user/group, depending on tag. */
  36         const char *name; /* Name of user/group, depending on tag. */
  37 };
  38
  39 static struct myacl_t acls2[] = {
  40         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_EXECUTE | ARCHIVE_ENTRY_ACL_READ,
  41           ARCHIVE_ENTRY_ACL_USER_OBJ, -1, "" },
  42         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_READ,
  43           ARCHIVE_ENTRY_ACL_USER, 77, "user77" },
  44         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0,
  45           ARCHIVE_ENTRY_ACL_USER, 78, "user78" },
  46         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_READ,
  47           ARCHIVE_ENTRY_ACL_GROUP_OBJ, -1, "" },
  48         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0007,
  49           ARCHIVE_ENTRY_ACL_GROUP, 78, "group78" },
  50         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
  51           ARCHIVE_ENTRY_ACL_WRITE | ARCHIVE_ENTRY_ACL_EXECUTE,
  52           ARCHIVE_ENTRY_ACL_OTHER, -1, "" },
  53         { ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
  54           ARCHIVE_ENTRY_ACL_WRITE | ARCHIVE_ENTRY_ACL_READ | ARCHIVE_ENTRY_ACL_EXECUTE,
  55           ARCHIVE_ENTRY_ACL_MASK, -1, "" },
  56         { 0, 0, 0, 0, NULL }
  57 };
  58
  59 static void
  60 set_acls(struct archive_entry *ae, struct myacl_t *acls)
  61 {
  62         int i;
  63
  64         archive_entry_acl_clear(ae);
  65         for (i = 0; acls[i].name != NULL; i++) {
  66                 archive_entry_acl_add_entry(ae,
  67                     acls[i].type, acls[i].permset, acls[i].tag, acls[i].qual,
  68                     acls[i].name);
  69         }
  70 }
  71
  72 static int
  73 acl_match(acl_entry_t aclent, struct myacl_t *myacl)
  74 {
  75         acl_tag_t tag_type;
  76         acl_permset_t opaque_ps;
  77         int permset = 0;
  78
  79         acl_get_tag_type(aclent, &tag_type);
  80
  81         /* translate the silly opaque permset to a bitmap */
  82         acl_get_permset(aclent, &opaque_ps);
  83         if (acl_get_perm_np(opaque_ps, ACL_EXECUTE))
  84                 permset |= ARCHIVE_ENTRY_ACL_EXECUTE;
  85         if (acl_get_perm_np(opaque_ps, ACL_WRITE))
  86                 permset |= ARCHIVE_ENTRY_ACL_WRITE;
  87         if (acl_get_perm_np(opaque_ps, ACL_READ))
  88                 permset |= ARCHIVE_ENTRY_ACL_READ;
  89
  90         if (permset != myacl->permset)
  91                 return (0);
  92
  93         switch (tag_type) {
  94         case ACL_USER_OBJ:
  95                 if (myacl->tag != ARCHIVE_ENTRY_ACL_USER_OBJ) return (0);
  96                 break;
  97         case ACL_USER:
  98                 if (myacl->tag != ARCHIVE_ENTRY_ACL_USER)
  99                         return (0);
 100                 if ((uid_t)myacl->qual != *(uid_t *)acl_get_qualifier(aclent))
 101                         return (0);
 102                 break;
 103         case ACL_GROUP_OBJ:
 104                 if (myacl->tag != ARCHIVE_ENTRY_ACL_GROUP_OBJ) return (0);
 105                 break;
 106         case ACL_GROUP:
 107                 if (myacl->tag != ARCHIVE_ENTRY_ACL_GROUP)
 108                         return (0);
 109                 if ((gid_t)myacl->qual != *(gid_t *)acl_get_qualifier(aclent))
 110                         return (0);
 111                 break;
 112         case ACL_MASK:
 113                 if (myacl->tag != ARCHIVE_ENTRY_ACL_MASK) return (0);
 114                 break;
 115         case ACL_OTHER:
 116                 if (myacl->tag != ARCHIVE_ENTRY_ACL_OTHER) return (0);
 117                 break;
 118         }
 119         return (1);
 120 }
 121
 122 static void
 123 compare_acls(acl_t acl, struct myacl_t *myacls)
 124 {
 125         int *marker;
 126         int entry_id = ACL_FIRST_ENTRY;
 127         int matched;
 128         int i, n;
 129         acl_entry_t acl_entry;
 130
 131         /* Count ACL entries in myacls array and allocate an indirect array. */
 132         for (n = 0; myacls[n].name != NULL; ++n)
 133                 continue;
 134         marker = malloc(sizeof(marker[0]) * n);
 135         for (i = 0; i < n; i++)
 136                 marker[i] = i;
 137
 138         /*
 139          * Iterate over acls in system acl object, try to match each
 140          * one with an item in the myacls array.
 141          */
 142         while (1 == acl_get_entry(acl, entry_id, &acl_entry)) {
 143                 /* After the first time... */
 144                 entry_id = ACL_NEXT_ENTRY;
 145
 146                 /* Search for a matching entry (tag and qualifier) */
 147                 for (i = 0, matched = 0; i < n && !matched; i++) {
 148                         if (acl_match(acl_entry, &myacls[marker[i]])) {
 149                                 /* We found a match; remove it. */
 150                                 marker[i] = marker[n - 1];
 151                                 n--;
 152                                 matched = 1;
 153                         }
 154                 }
 155
 156                 /* TODO: Print out more details in this case. */
 157                 failure("ACL entry on file that shouldn't be there");
 158                 assert(matched == 1);
 159         }
 160
 161         /* Dump entries in the myacls array that weren't in the system acl. */
 162         for (i = 0; i < n; ++i) {
 163                 failure(" ACL entry missing from file: "
 164                     "type=%d,permset=%d,tag=%d,qual=%d,name=``%s''\n",
 165                     myacls[marker[i]].type, myacls[marker[i]].permset,
 166                     myacls[marker[i]].tag, myacls[marker[i]].qual,
 167                     myacls[marker[i]].name);
 168                 assert(0); /* Record this as a failure. */
 169         }
 170         free(marker);
 171 }
 172
 173 #endif
 174
 175
 176 /*
 177  * Verify ACL restore-to-disk.  This test is FreeBSD-specific.
 178  */
 179
 180 DEFINE_TEST(test_acl_freebsd)
 181 {
 182 #if !defined(__FreeBSD__)
 183         skipping("FreeBSD-specific ACL restore test");
 184 #elif __FreeBSD__ < 5
 185         skipping("ACL restore supported only on FreeBSD 5.0 and later");
 186 #else
 187         struct stat st;
 188         struct archive *a;
 189         struct archive_entry *ae;
 190         int n, fd;
 191         acl_t acl;
 192
 193         /*
 194          * First, do a quick manual set/read of ACL data to
 195          * verify that the local filesystem does support ACLs.
 196          * If it doesn't, we'll simply skip the remaining tests.
 197          */
 198         acl = acl_from_text("u::rwx,u:1:rw,g::rwx,g:15:rx,o::rwx,m::rwx");
 199         assert((void *)acl != NULL);
 200         /* Create a test file and try to set an ACL on it. */
 201         fd = open("pretest", O_WRONLY | O_CREAT | O_EXCL, 0777);
 202         failure("Could not create test file?!");
 203         n = -1;
 204         if (assert(fd >= 0)) {
 205                 n = acl_set_fd(fd, acl);
 206                 failure("acl_set_fd(): errno = %d (%s)",
 207                     errno, strerror(errno));
 208                 assertEqualInt(0, n);
 209                 close(fd);
 210         }
 211
 212         if (fd < 0 || n != 0) {
 213                 skipping("ACL tests require that ACL support be enabled on the filesystem");
 214                 return;
 215         }
 216
 217         /* Create a write-to-disk object. */
 218         assert(NULL != (a = archive_write_disk_new()));
 219         archive_write_disk_set_options(a,
 220             ARCHIVE_EXTRACT_TIME | ARCHIVE_EXTRACT_PERM | ARCHIVE_EXTRACT_ACL);
 221
 222         /* Populate an archive entry with some metadata, including ACL info */
 223         ae = archive_entry_new();
 224         assert(ae != NULL);
 225         archive_entry_set_pathname(ae, "test0");
 226         archive_entry_set_mtime(ae, 123456, 7890);
 227         archive_entry_set_size(ae, 0);
 228         set_acls(ae, acls2);
 229         assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
 230         archive_entry_free(ae);
 231
 232         /* Close the archive. */
 233         assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
 234         assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 235
 236         /* Verify the data on disk. */
 237         assertEqualInt(0, stat("test0", &st));
 238         assertEqualInt(st.st_mtime, 123456);
 239         acl = acl_get_file("test0", ACL_TYPE_ACCESS);
 240         assert(acl != (acl_t)NULL);
 241         compare_acls(acl, acls2);
 242 #endif
 243 }