libatalk/acl/unix.c

   1 /*
   2   Copyright (c) 2010 Frank Lahm <franklahm@gmail.com>
   3   Copyright (c) 2011 Laura Mueller <laura-mueller@uni-duesseldorf.de>
   4
   5   This program is free software; you can redistribute it and/or modify
   6   it under the terms of the GNU General Public License as published by
   7   the Free Software Foundation; either version 2 of the License, or
   8   (at your option) any later version.
   9
  10   This program is distributed in the hope that it will be useful,
  11   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13   GNU General Public License for more details.
  14 */
  15
  16 #ifdef HAVE_CONFIG_H
  17 #include "config.h"
  18 #endif /* HAVE_CONFIG_H */
  19
  20 #ifdef HAVE_ACLS
  21
  22 #include <unistd.h>
  23 #include <sys/types.h>
  24 #include <sys/stat.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <time.h>
  29 #include <errno.h>
  30 #include <sys/acl.h>
  31
  32 #include <atalk/logger.h>
  33 #include <atalk/afp.h>
  34 #include <atalk/util.h>
  35 #include <atalk/acl.h>
  36
  37 #ifdef HAVE_SOLARIS_ACLS
  38
  39 /* Get ACL. Allocates storage as needed. Caller must free.
  40  * Returns no of ACEs or -1 on error.  */
  41 int get_nfsv4_acl(const char *name, ace_t **retAces)
  42 {
  43     int ace_count = -1;
  44     ace_t *aces;
  45     struct stat st;
  46
  47     *retAces = NULL;
  48     /* Only call acl() for regular files and directories, otherwise just return 0 */
  49     if (lstat(name, &st) != 0) {
  50         LOG(log_warning, logtype_afpd, "get_nfsv4_acl(\"%s/%s\"): %s", getcwdpath(), name, strerror(errno));
  51         return -1;
  52     }
  53
  54     if (S_ISLNK(st.st_mode))
  55         /* sorry, no ACLs for symlinks */
  56         return 0;
  57
  58     if ( ! (S_ISREG(st.st_mode) || S_ISDIR(st.st_mode))) {
  59         LOG(log_debug, logtype_afpd, "get_nfsv4_acl(\"%s/%s\"): special", getcwdpath(), name);
  60         return 0;
  61     }
  62
  63     if ((ace_count = acl(name, ACE_GETACLCNT, 0, NULL)) == 0) {
  64         LOG(log_debug, logtype_afpd, "get_nfsv4_acl(\"%s/%s\"): 0 ACEs", getcwdpath(), name);
  65         return 0;
  66     }
  67
  68     if (ace_count == -1) {
  69         LOG(log_debug, logtype_afpd, "get_nfsv4_acl: acl('%s/%s', ACE_GETACLCNT): ace_count %i, error: %s",
  70             getcwdpath(), name, ace_count, strerror(errno));
  71         return -1;
  72     }
  73
  74     aces = malloc(ace_count * sizeof(ace_t));
  75     if (aces == NULL) {
  76         LOG(log_error, logtype_afpd, "get_nfsv4_acl: malloc error");
  77         return -1;
  78     }
  79
  80     if ( (acl(name, ACE_GETACL, ace_count, aces)) == -1 ) {
  81         LOG(log_error, logtype_afpd, "get_nfsv4_acl: acl(ACE_GETACL) error");
  82         free(aces);
  83         return -1;
  84     }
  85
  86     LOG(log_debug9, logtype_afpd, "get_nfsv4_acl: file: %s -> No. of ACEs: %d", name, ace_count);
  87     *retAces = aces;
  88
  89     return ace_count;
  90 }
  91
  92 /*
  93   Concatenate ACEs
  94 */
  95 ace_t *concat_aces(ace_t *aces1, int ace1count, ace_t *aces2, int ace2count)
  96 {
  97     ace_t *new_aces;
  98     int i, j;
  99
 100     /* malloc buffer for new ACL */
 101     if ((new_aces = malloc((ace1count + ace2count) * sizeof(ace_t))) == NULL) {
 102         LOG(log_error, logtype_afpd, "combine_aces: malloc %s", strerror(errno));
 103         return NULL;
 104     }
 105
 106     /* Copy ACEs from buf1 */
 107     for (i=0; i < ace1count; ) {
 108         memcpy(&new_aces[i], &aces1[i], sizeof(ace_t));
 109         i++;
 110     }
 111
 112     j = i;
 113
 114     /* Copy ACEs from buf2 */
 115     for (i=0; i < ace2count; ) {
 116         memcpy(&new_aces[j], &aces2[i], sizeof(ace_t));
 117         i++;
 118         j++;
 119     }
 120     return new_aces;
 121 }
 122
 123 /*
 124   Remove any trivial ACE "in-place". Returns no of non-trivial ACEs
 125 */
 126 int strip_trivial_aces(ace_t **saces, int sacecount)
 127 {
 128     int i,j;
 129     int nontrivaces = 0;
 130     ace_t *aces = *saces;
 131     ace_t *new_aces;
 132
 133     if (aces == NULL || sacecount <= 0)
 134         return 0;
 135
 136     /* Count non-trivial ACEs */
 137     for (i=0; i < sacecount; ) {
 138         if ( ! (aces[i].a_flags & (ACE_OWNER | ACE_GROUP | ACE_EVERYONE)))
 139             nontrivaces++;
 140         i++;
 141     }
 142     /* malloc buffer for new ACL */
 143     if ((new_aces = malloc(nontrivaces * sizeof(ace_t))) == NULL) {
 144         LOG(log_error, logtype_afpd, "strip_trivial_aces: malloc %s", strerror(errno));
 145         return -1;
 146     }
 147
 148     /* Copy non-trivial ACEs */
 149     for (i=0, j=0; i < sacecount; ) {
 150         if ( ! (aces[i].a_flags & (ACE_OWNER | ACE_GROUP | ACE_EVERYONE))) {
 151             memcpy(&new_aces[j], &aces[i], sizeof(ace_t));
 152             j++;
 153         }
 154         i++;
 155     }
 156
 157     free(aces);
 158     *saces = new_aces;
 159
 160     LOG(log_debug7, logtype_afpd, "strip_trivial_aces: non-trivial ACEs: %d", nontrivaces);
 161
 162     return nontrivaces;
 163 }
 164
 165 /*
 166   Remove non-trivial ACEs "in-place". Returns no of trivial ACEs.
 167 */
 168 int strip_nontrivial_aces(ace_t **saces, int sacecount)
 169 {
 170     int i,j;
 171     int trivaces = 0;
 172     ace_t *aces = *saces;
 173     ace_t *new_aces;
 174
 175     /* Count trivial ACEs */
 176     for (i=0; i < sacecount; ) {
 177         if ((aces[i].a_flags & (ACE_OWNER | ACE_GROUP | ACE_EVERYONE)))
 178             trivaces++;
 179         i++;
 180     }
 181     /* malloc buffer for new ACL */
 182     if ((new_aces = malloc(trivaces * sizeof(ace_t))) == NULL) {
 183         LOG(log_error, logtype_afpd, "strip_nontrivial_aces: malloc %s", strerror(errno));
 184         return -1;
 185     }
 186
 187     /* Copy trivial ACEs */
 188     for (i=0, j=0; i < sacecount; ) {
 189         if ((aces[i].a_flags & (ACE_OWNER | ACE_GROUP | ACE_EVERYONE))) {
 190             memcpy(&new_aces[j], &aces[i], sizeof(ace_t));
 191             j++;
 192         }
 193         i++;
 194     }
 195     /* Free old ACEs */
 196     free(aces);
 197     *saces = new_aces;
 198
 199     LOG(log_debug7, logtype_afpd, "strip_nontrivial_aces: trivial ACEs: %d", trivaces);
 200
 201     return trivaces;
 202 }
 203
 204 /*!
 205  * Change mode of file preserving existing explicit ACEs
 206  *
 207  * nfsv4_chmod
 208  * (1) reads objects ACL (acl1), may return 0 or -1 NFSv4 ACEs on eg UFS fs
 209  * (2) removes all trivial ACEs from the ACL by calling strip_trivial_aces(), possibly
 210  *     leaving 0 ACEs in the ACL if there were only trivial ACEs as mapped from the mode
 211  * (3) calls chmod() with mode, we're done if step (1) returned 0 for noaces
 212  * (4) reads the changed ACL (acl2) which
 213  *     a) might still contain explicit ACEs (up to onnv132)
 214  *     b) will have any explicit ACE removed (starting with onnv145/Openindiana)
 215  * (5) strip any explicit ACE from acl2 using strip_nontrivial_aces()
 216  * (6) merge acl2 and acl2
 217  * (7) set the ACL merged ACL on the object
 218  */
 219 int nfsv4_chmod(char *name, mode_t mode)
 220 {
 221     int ret = -1;
 222     int noaces, nnaces;
 223     ace_t *oacl = NULL, *nacl = NULL, *cacl = NULL;
 224
 225     LOG(log_debug, logtype_afpd, "nfsv4_chmod(\"%s/%s\", %04o)",
 226         getcwdpath(), name, mode);
 227
 228     if ((noaces = get_nfsv4_acl(name, &oacl)) < 1) /* (1) */
 229         return chmod(name, mode);
 230
 231     if ((noaces = strip_trivial_aces(&oacl, noaces)) == -1) /* (2) */
 232         goto exit;
 233
 234     if (chmod(name, mode) != 0) /* (3) */
 235         goto exit;
 236
 237     if ((nnaces = get_nfsv4_acl(name, &nacl)) == -1) /* (4) */
 238         goto exit;
 239     if ((nnaces = strip_nontrivial_aces(&nacl, nnaces)) == -1) /* (5) */
 240         goto exit;
 241
 242     if ((cacl = concat_aces(oacl, noaces, nacl, nnaces)) == NULL) /* (6) */
 243         goto exit;
 244
 245     if ((ret = acl(name, ACE_SETACL, noaces + nnaces, cacl)) != 0) {
 246         LOG(log_error, logtype_afpd, "nfsv4_chmod: error setting acl: %s", strerror(errno));
 247         goto exit;
 248     }
 249
 250 exit:
 251     if (oacl) free(oacl);
 252     if (nacl) free(nacl);
 253     if (cacl) free(cacl);
 254
 255     LOG(log_debug, logtype_afpd, "nfsv4_chmod(\"%s/%s\", %04o): result: %u",
 256         getcwdpath(), name, mode, ret);
 257
 258     return ret;
 259 }
 260
 261 #endif /* HAVE_SOLARIS_ACLS */
 262
 263 #ifdef HAVE_POSIX_ACLS
 264
 265 /* This is a workaround for chmod() on filestystems supporting Posix 1003.1e draft 17
 266  * compliant ACLs. For objects with extented ACLs, eg objects with an ACL_MASK entry,
 267  * chmod() manipulates ACL_MASK instead of ACL_GROUP_OBJ. As OS X isn't aware of
 268  * this behavior calling FPSetFileDirParms may lead to unpredictable results. For
 269  * more information see section 23.1.2 of Posix 1003.1e draft 17.
 270  *
 271  * posix_chmod() accepts the same arguments as chmod() and returns 0 in case of
 272  * success or -1 in case something went wrong.
 273  */
 274
 275 #define SEARCH_GROUP_OBJ 0x01
 276 #define SEARCH_MASK 0x02
 277
 278 int posix_chmod(const char *name, mode_t mode) {
 279     int ret = 0;
 280     int entry_id = ACL_FIRST_ENTRY;
 281     acl_entry_t entry;
 282     acl_entry_t group_entry;
 283     acl_tag_t tag;
 284     acl_t acl;
 285     u_char not_found = (SEARCH_GROUP_OBJ|SEARCH_MASK); /* used as flags */
 286
 287     LOG(log_maxdebug, logtype_afpd, "posix_chmod: %s mode: 0x%08x", name, mode);
 288
 289     /* Call chmod() first because there might be some special bits to be set which
 290      * aren't related to access control.
 291      */
 292     ret = chmod(name, mode);
 293
 294     if (ret)
 295         goto done;
 296
 297     /* Check if the underlying filesystem supports ACLs. */
 298     acl = acl_get_file(name, ACL_TYPE_ACCESS);
 299
 300     if (acl) {
 301         /* There is no need to keep iterating once we have found ACL_GROUP_OBJ and ACL_MASK. */
 302         while ((acl_get_entry(acl, entry_id, &entry) == 1) && not_found) {
 303             entry_id = ACL_NEXT_ENTRY;
 304
 305             ret = acl_get_tag_type(entry, &tag);
 306
 307             if (ret) {
 308                 LOG(log_error, logtype_afpd, "posix_chmod: Failed to get tag type.");
 309                 goto cleanup;
 310             }
 311
 312             switch (tag) {
 313                 case ACL_GROUP_OBJ:
 314                     group_entry = entry;
 315                     not_found &= ~SEARCH_GROUP_OBJ;
 316                     break;
 317
 318                 case ACL_MASK:
 319                     not_found &= ~SEARCH_MASK;
 320                     break;
 321
 322                 default:
 323                     break;
 324             }
 325         }
 326         if (!not_found) {
 327             /* The filesystem object has extented ACLs. We have to update ACL_GROUP_OBJ
 328              * with the group permissions.
 329              */
 330             acl_permset_t permset;
 331             acl_perm_t perm = 0;
 332
 333             ret = acl_get_permset(group_entry, &permset);
 334
 335             if (ret) {
 336                 LOG(log_error, logtype_afpd, "posix_chmod: Can't get permset.");
 337                 goto cleanup;
 338             }
 339             ret = acl_clear_perms(permset);
 340
 341             if (ret)
 342                 goto cleanup;
 343
 344             if (mode & S_IXGRP)
 345                 perm |= ACL_EXECUTE;
 346
 347             if (mode & S_IWGRP)
 348                 perm |= ACL_WRITE;
 349
 350             if (mode & S_IRGRP)
 351                 perm |= ACL_READ;
 352
 353             ret = acl_add_perm(permset, perm);
 354
 355             if (ret)
 356                 goto cleanup;
 357
 358             ret = acl_set_permset(group_entry, permset);
 359
 360             if (ret) {
 361                 LOG(log_error, logtype_afpd, "posix_chmod: Can't set permset.");
 362                 goto cleanup;
 363             }
 364             /* also update ACL_MASK */
 365             ret = acl_calc_mask(&acl);
 366
 367             if (ret) {
 368                 LOG(log_error, logtype_afpd, "posix_chmod: acl_calc_mask failed.");
 369                 goto cleanup;
 370             }
 371             ret = acl_set_file(name, ACL_TYPE_ACCESS, acl);
 372         }
 373 cleanup:
 374         acl_free(acl);
 375     }
 376 done:
 377     LOG(log_maxdebug, logtype_afpd, "posix_chmod: %d", ret);
 378     return ret;
 379 }
 380
 381 /*
 382  * posix_fchmod() accepts the same arguments as fchmod() and returns 0 in case of
 383  * success or -1 in case something went wrong.
 384  */
 385 int posix_fchmod(int fd, mode_t mode) {
 386     int ret = 0;
 387     int entry_id = ACL_FIRST_ENTRY;
 388     acl_entry_t entry;
 389     acl_entry_t group_entry;
 390     acl_tag_t tag;
 391     acl_t acl;
 392     u_char not_found = (SEARCH_GROUP_OBJ|SEARCH_MASK); /* used as flags */
 393
 394     /* Call chmod() first because there might be some special bits to be set which
 395      * aren't related to access control.
 396      */
 397     ret = fchmod(fd, mode);
 398
 399     if (ret)
 400         goto done;
 401
 402     /* Check if the underlying filesystem supports ACLs. */
 403     acl = acl_get_fd(fd);
 404
 405     if (acl) {
 406         /* There is no need to keep iterating once we have found ACL_GROUP_OBJ and ACL_MASK. */
 407         while ((acl_get_entry(acl, entry_id, &entry) == 1) && not_found) {
 408             entry_id = ACL_NEXT_ENTRY;
 409
 410             ret = acl_get_tag_type(entry, &tag);
 411
 412             if (ret) {
 413                 LOG(log_error, logtype_afpd, "posix_fchmod: Failed to get tag type.");
 414                 goto cleanup;
 415             }
 416
 417             switch (tag) {
 418                 case ACL_GROUP_OBJ:
 419                     group_entry = entry;
 420                     not_found &= ~SEARCH_GROUP_OBJ;
 421                     break;
 422
 423                 case ACL_MASK:
 424                     not_found &= ~SEARCH_MASK;
 425                     break;
 426
 427                 default:
 428                     break;
 429             }
 430         }
 431         if (!not_found) {
 432             /* The filesystem object has extented ACLs. We have to update ACL_GROUP_OBJ
 433              * with the group permissions.
 434              */
 435             acl_permset_t permset;
 436             acl_perm_t perm = 0;
 437
 438             ret = acl_get_permset(group_entry, &permset);
 439
 440             if (ret) {
 441                 LOG(log_error, logtype_afpd, "posix_fchmod: Can't get permset.");
 442                 goto cleanup;
 443             }
 444             ret = acl_clear_perms(permset);
 445
 446             if (ret)
 447                 goto cleanup;
 448
 449             if (mode & S_IXGRP)
 450                 perm |= ACL_EXECUTE;
 451
 452             if (mode & S_IWGRP)
 453                 perm |= ACL_WRITE;
 454
 455             if (mode & S_IRGRP)
 456                 perm |= ACL_READ;
 457
 458             ret = acl_add_perm(permset, perm);
 459
 460             if (ret)
 461                 goto cleanup;
 462
 463             ret = acl_set_permset(group_entry, permset);
 464
 465             if (ret) {
 466                 LOG(log_error, logtype_afpd, "posix_fchmod: Can't set permset.");
 467                 goto cleanup;
 468             }
 469             /* also update ACL_MASK */
 470             ret = acl_calc_mask(&acl);
 471
 472             if (ret) {
 473                 LOG(log_error, logtype_afpd, "posix_fchmod: acl_calc_mask failed.");
 474                 goto cleanup;
 475             }
 476             ret = acl_set_fd(fd, acl);
 477         }
 478 cleanup:
 479         acl_free(acl);
 480     }
 481 done:
 482     return ret;
 483 }
 484
 485 #endif /* HAVE_POSIX_ACLS */
 486
 487 #endif /* HAVE_ACLS */