bin/getfacl/getfacl.c

   1 /*-
   2  * Copyright (c) 1999, 2001, 2002 Robert N M Watson
   3  * All rights reserved.
   4  *
   5  * This software was developed by Robert Watson for the TrustedBSD Project.
   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  * getfacl -- POSIX.1e utility to extract ACLs from files and directories
  30  * and send the results to stdout
  31  */
  32
  33
  34 #include <sys/cdefs.h>
  35 __FBSDID("$FreeBSD$");
  36
  37 #include <sys/types.h>
  38 #include <sys/param.h>
  39 #include <sys/acl.h>
  40 #include <sys/stat.h>
  41
  42 #include <err.h>
  43 #include <errno.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <unistd.h>
  48
  49 int     more_than_one = 0;
  50
  51 static void
  52 usage(void)
  53 {
  54
  55         fprintf(stderr, "getfacl [-dh] [file ...]\n");
  56 }
  57
  58 /*
  59  * return an ACL corresponding to the permissions
  60  * contained in struct stat
  61  */
  62 static acl_t
  63 acl_from_stat(struct stat sb)
  64 {
  65         acl_t acl;
  66         acl_entry_t entry;
  67         acl_permset_t perms;
  68
  69         /* create the ACL */
  70         acl = acl_init(3);
  71         if (!acl)
  72                 return NULL;
  73
  74         /* First entry: ACL_USER_OBJ */
  75         if (acl_create_entry(&acl, &entry) == -1)
  76                 return NULL;
  77         if (acl_set_tag_type(entry, ACL_USER_OBJ) == -1)
  78                 return NULL;
  79
  80         if (acl_get_permset(entry, &perms) == -1)
  81                 return NULL;
  82         if (acl_clear_perms(perms) == -1)
  83                 return NULL;
  84
  85         /* calculate user mode */
  86         if (sb.st_mode & S_IRUSR)
  87                 if (acl_add_perm(perms, ACL_READ) == -1)
  88                         return NULL;
  89         if (sb.st_mode & S_IWUSR)
  90                 if (acl_add_perm(perms, ACL_WRITE) == -1)
  91                         return NULL;
  92         if (sb.st_mode & S_IXUSR)
  93                 if (acl_add_perm(perms, ACL_EXECUTE) == -1)
  94                         return NULL;
  95         if (acl_set_permset(entry, perms) == -1)
  96                 return NULL;
  97
  98         /* Second entry: ACL_GROUP_OBJ */
  99         if (acl_create_entry(&acl, &entry) == -1)
 100                 return NULL;
 101         if (acl_set_tag_type(entry, ACL_GROUP_OBJ) == -1)
 102                 return NULL;
 103
 104         if (acl_get_permset(entry, &perms) == -1)
 105                 return NULL;
 106         if (acl_clear_perms(perms) == -1)
 107                 return NULL;
 108
 109         /* calculate group mode */
 110         if (sb.st_mode & S_IRGRP)
 111                 if (acl_add_perm(perms, ACL_READ) == -1)
 112                         return NULL;
 113         if (sb.st_mode & S_IWGRP)
 114                 if (acl_add_perm(perms, ACL_WRITE) == -1)
 115                         return NULL;
 116         if (sb.st_mode & S_IXGRP)
 117                 if (acl_add_perm(perms, ACL_EXECUTE) == -1)
 118                         return NULL;
 119         if (acl_set_permset(entry, perms) == -1)
 120                 return NULL;
 121
 122         /* Third entry: ACL_OTHER */
 123         if (acl_create_entry(&acl, &entry) == -1)
 124                 return NULL;
 125         if (acl_set_tag_type(entry, ACL_OTHER) == -1)
 126                 return NULL;
 127
 128         if (acl_get_permset(entry, &perms) == -1)
 129                 return NULL;
 130         if (acl_clear_perms(perms) == -1)
 131                 return NULL;
 132
 133         /* calculate other mode */
 134         if (sb.st_mode & S_IROTH)
 135                 if (acl_add_perm(perms, ACL_READ) == -1)
 136                         return NULL;
 137         if (sb.st_mode & S_IWOTH)
 138                 if (acl_add_perm(perms, ACL_WRITE) == -1)
 139                         return NULL;
 140         if (sb.st_mode & S_IXOTH)
 141                 if (acl_add_perm(perms, ACL_EXECUTE) == -1)
 142                         return NULL;
 143         if (acl_set_permset(entry, perms) == -1)
 144                 return NULL;
 145
 146         return(acl);
 147 }
 148
 149 static int
 150 print_acl(char *path, acl_type_t type, int hflag)
 151 {
 152         struct stat     sb;
 153         acl_t   acl;
 154         char    *acl_text;
 155         int     error;
 156
 157         if (hflag)
 158                 error = lstat(path, &sb);
 159         else
 160                 error = stat(path, &sb);
 161         if (error == -1) {
 162                 warn("%s", path);
 163                 return(-1);
 164         }
 165
 166         if (more_than_one)
 167                 printf("\n");
 168         else
 169                 more_than_one++;
 170
 171         printf("#file:%s\n#owner:%d\n#group:%d\n", path, sb.st_uid, sb.st_gid);
 172
 173         if (hflag)
 174                 acl = acl_get_link_np(path, type);
 175         else
 176                 acl = acl_get_file(path, type);
 177         if (!acl) {
 178                 if (errno != EOPNOTSUPP) {
 179                         warn("%s", path);
 180                         return(-1);
 181                 }
 182                 errno = 0;
 183                 if (type != ACL_TYPE_ACCESS)
 184                         return(0);
 185                 acl = acl_from_stat(sb);
 186                 if (!acl) {
 187                         warn("acl_from_stat()");
 188                         return(-1);
 189                 }
 190         }
 191
 192         acl_text = acl_to_text(acl, 0);
 193         if (!acl_text) {
 194                 warn("%s", path);
 195                 return(-1);
 196         }
 197
 198         printf("%s", acl_text);
 199
 200         (void)acl_free(acl);
 201         (void)acl_free(acl_text);
 202
 203         return(0);
 204 }
 205
 206 static int
 207 print_acl_from_stdin(acl_type_t type, int hflag)
 208 {
 209         char    *p, pathname[PATH_MAX];
 210         int     carried_error = 0;
 211
 212         while (fgets(pathname, (int)sizeof(pathname), stdin)) {
 213                 if ((p = strchr(pathname, '\n')) != NULL)
 214                         *p = '\0';
 215                 if (print_acl(pathname, type, hflag) == -1) {
 216                         carried_error = -1;
 217                 }
 218         }
 219
 220         return(carried_error);
 221 }
 222
 223 int
 224 main(int argc, char *argv[])
 225 {
 226         acl_type_t      type = ACL_TYPE_ACCESS;
 227         int     carried_error = 0;
 228         int     ch, error, i;
 229         int     hflag;
 230
 231         hflag = 0;
 232         while ((ch = getopt(argc, argv, "dh")) != -1)
 233                 switch(ch) {
 234                 case 'd':
 235                         type = ACL_TYPE_DEFAULT;
 236                         break;
 237                 case 'h':
 238                         hflag = 1;
 239                         break;
 240                 default:
 241                         usage();
 242                         return(-1);
 243                 }
 244         argc -= optind;
 245         argv += optind;
 246
 247         if (argc == 0) {
 248                 error = print_acl_from_stdin(type, hflag);
 249                 return(error ? 1 : 0);
 250         }
 251
 252         for (i = 0; i < argc; i++) {
 253                 if (!strcmp(argv[i], "-")) {
 254                         error = print_acl_from_stdin(type, hflag);
 255                         if (error == -1)
 256                                 carried_error = -1;
 257                 } else {
 258                         error = print_acl(argv[i], type, hflag);
 259                         if (error == -1)
 260                                 carried_error = -1;
 261                 }
 262         }
 263
 264         return(carried_error ? 1 : 0);
 265 }