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 <grp.h>
  45 #include <pwd.h>
  46 #include <stdio.h>
  47 #include <stdlib.h>
  48 #include <string.h>
  49 #include <unistd.h>
  50
  51 int     more_than_one = 0;
  52
  53 static void
  54 usage(void)
  55 {
  56
  57         fprintf(stderr, "getfacl [-dhq] [file ...]\n");
  58 }
  59
  60 static char *
  61 getuname(uid_t uid)
  62 {
  63         struct passwd *pw;
  64         static char uids[10];
  65
  66         if ((pw = getpwuid(uid)) == NULL) {
  67                 (void)snprintf(uids, sizeof(uids), "%u", uid);
  68                 return (uids);
  69         } else
  70                 return (pw->pw_name);
  71 }
  72
  73 static char *
  74 getgname(gid_t gid)
  75 {
  76         struct group *gr;
  77         static char gids[10];
  78
  79         if ((gr = getgrgid(gid)) == NULL) {
  80                 (void)snprintf(gids, sizeof(gids), "%u", gid);
  81                 return (gids);
  82         } else
  83                 return (gr->gr_name);
  84 }
  85
  86 /*
  87  * return an ACL corresponding to the permissions
  88  * contained in struct stat
  89  */
  90 static acl_t
  91 acl_from_stat(struct stat sb)
  92 {
  93         acl_t acl;
  94         acl_entry_t entry;
  95         acl_permset_t perms;
  96
  97         /* create the ACL */
  98         acl = acl_init(3);
  99         if (!acl)
 100                 return NULL;
 101
 102         /* First entry: ACL_USER_OBJ */
 103         if (acl_create_entry(&acl, &entry) == -1)
 104                 return NULL;
 105         if (acl_set_tag_type(entry, ACL_USER_OBJ) == -1)
 106                 return NULL;
 107
 108         if (acl_get_permset(entry, &perms) == -1)
 109                 return NULL;
 110         if (acl_clear_perms(perms) == -1)
 111                 return NULL;
 112
 113         /* calculate user mode */
 114         if (sb.st_mode & S_IRUSR)
 115                 if (acl_add_perm(perms, ACL_READ) == -1)
 116                         return NULL;
 117         if (sb.st_mode & S_IWUSR)
 118                 if (acl_add_perm(perms, ACL_WRITE) == -1)
 119                         return NULL;
 120         if (sb.st_mode & S_IXUSR)
 121                 if (acl_add_perm(perms, ACL_EXECUTE) == -1)
 122                         return NULL;
 123         if (acl_set_permset(entry, perms) == -1)
 124                 return NULL;
 125
 126         /* Second entry: ACL_GROUP_OBJ */
 127         if (acl_create_entry(&acl, &entry) == -1)
 128                 return NULL;
 129         if (acl_set_tag_type(entry, ACL_GROUP_OBJ) == -1)
 130                 return NULL;
 131
 132         if (acl_get_permset(entry, &perms) == -1)
 133                 return NULL;
 134         if (acl_clear_perms(perms) == -1)
 135                 return NULL;
 136
 137         /* calculate group mode */
 138         if (sb.st_mode & S_IRGRP)
 139                 if (acl_add_perm(perms, ACL_READ) == -1)
 140                         return NULL;
 141         if (sb.st_mode & S_IWGRP)
 142                 if (acl_add_perm(perms, ACL_WRITE) == -1)
 143                         return NULL;
 144         if (sb.st_mode & S_IXGRP)
 145                 if (acl_add_perm(perms, ACL_EXECUTE) == -1)
 146                         return NULL;
 147         if (acl_set_permset(entry, perms) == -1)
 148                 return NULL;
 149
 150         /* Third entry: ACL_OTHER */
 151         if (acl_create_entry(&acl, &entry) == -1)
 152                 return NULL;
 153         if (acl_set_tag_type(entry, ACL_OTHER) == -1)
 154                 return NULL;
 155
 156         if (acl_get_permset(entry, &perms) == -1)
 157                 return NULL;
 158         if (acl_clear_perms(perms) == -1)
 159                 return NULL;
 160
 161         /* calculate other mode */
 162         if (sb.st_mode & S_IROTH)
 163                 if (acl_add_perm(perms, ACL_READ) == -1)
 164                         return NULL;
 165         if (sb.st_mode & S_IWOTH)
 166                 if (acl_add_perm(perms, ACL_WRITE) == -1)
 167                         return NULL;
 168         if (sb.st_mode & S_IXOTH)
 169                 if (acl_add_perm(perms, ACL_EXECUTE) == -1)
 170                         return NULL;
 171         if (acl_set_permset(entry, perms) == -1)
 172                 return NULL;
 173
 174         return(acl);
 175 }
 176
 177 static int
 178 print_acl(char *path, acl_type_t type, int hflag, int qflag)
 179 {
 180         struct stat     sb;
 181         acl_t   acl;
 182         char    *acl_text;
 183         int     error;
 184
 185         if (hflag)
 186                 error = lstat(path, &sb);
 187         else
 188                 error = stat(path, &sb);
 189         if (error == -1) {
 190                 warn("%s", path);
 191                 return(-1);
 192         }
 193
 194         if (more_than_one)
 195                 printf("\n");
 196         else
 197                 more_than_one++;
 198
 199         if (!qflag)
 200                 printf("# file: %s\n# owner: %s\n# group: %s\n", path,
 201                     getuname(sb.st_uid), getgname(sb.st_gid));
 202
 203         if (hflag)
 204                 acl = acl_get_link_np(path, type);
 205         else
 206                 acl = acl_get_file(path, type);
 207         if (!acl) {
 208                 if (errno != EOPNOTSUPP) {
 209                         warn("%s", path);
 210                         return(-1);
 211                 }
 212                 errno = 0;
 213                 if (type != ACL_TYPE_ACCESS)
 214                         return(0);
 215                 acl = acl_from_stat(sb);
 216                 if (!acl) {
 217                         warn("acl_from_stat()");
 218                         return(-1);
 219                 }
 220         }
 221
 222         acl_text = acl_to_text(acl, 0);
 223         if (!acl_text) {
 224                 warn("%s", path);
 225                 return(-1);
 226         }
 227
 228         printf("%s", acl_text);
 229
 230         (void)acl_free(acl);
 231         (void)acl_free(acl_text);
 232
 233         return(0);
 234 }
 235
 236 static int
 237 print_acl_from_stdin(acl_type_t type, int hflag, int qflag)
 238 {
 239         char    *p, pathname[PATH_MAX];
 240         int     carried_error = 0;
 241
 242         while (fgets(pathname, (int)sizeof(pathname), stdin)) {
 243                 if ((p = strchr(pathname, '\n')) != NULL)
 244                         *p = '\0';
 245                 if (print_acl(pathname, type, hflag, qflag) == -1) {
 246                         carried_error = -1;
 247                 }
 248         }
 249
 250         return(carried_error);
 251 }
 252
 253 int
 254 main(int argc, char *argv[])
 255 {
 256         acl_type_t      type = ACL_TYPE_ACCESS;
 257         int     carried_error = 0;
 258         int     ch, error, i;
 259         int     hflag, qflag;
 260
 261         hflag = 0;
 262         qflag = 0;
 263         while ((ch = getopt(argc, argv, "dhq")) != -1)
 264                 switch(ch) {
 265                 case 'd':
 266                         type = ACL_TYPE_DEFAULT;
 267                         break;
 268                 case 'h':
 269                         hflag = 1;
 270                         break;
 271                 case 'q':
 272                         qflag = 1;
 273                         break;
 274                 default:
 275                         usage();
 276                         return(-1);
 277                 }
 278         argc -= optind;
 279         argv += optind;
 280
 281         if (argc == 0) {
 282                 error = print_acl_from_stdin(type, hflag, qflag);
 283                 return(error ? 1 : 0);
 284         }
 285
 286         for (i = 0; i < argc; i++) {
 287                 if (!strcmp(argv[i], "-")) {
 288                         error = print_acl_from_stdin(type, hflag, qflag);
 289                         if (error == -1)
 290                                 carried_error = -1;
 291                 } else {
 292                         error = print_acl(argv[i], type, hflag, qflag);
 293                         if (error == -1)
 294                                 carried_error = -1;
 295                 }
 296         }
 297
 298         return(carried_error ? 1 : 0);
 299 }