set-permissions.c 25.2 KB
Newer Older
Paul Eggert's avatar
Paul Eggert committed
1
/* Set permissions of a file.  -*- coding: utf-8 -*-
2

Paul Eggert's avatar
Paul Eggert committed
3
   Copyright (C) 2002-2003, 2005-2020 Free Software Foundation, Inc.
4 5 6 7 8 9 10 11 12 13 14 15

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
Paul Eggert's avatar
Paul Eggert committed
16
   along with this program.  If not, see <https://www.gnu.org/licenses/>.
17

Paul Eggert's avatar
Paul Eggert committed
18
   Written by Paul Eggert, Andreas Grünbacher, and Bruno Haible.  */
19 20 21 22 23 24 25 26

#include <config.h>

#include "acl.h"

#include "acl-internal.h"

#if USE_ACL
Paul Eggert's avatar
Paul Eggert committed
27
# if ! defined HAVE_ACL_FROM_MODE && defined HAVE_ACL_FROM_TEXT /* FreeBSD, IRIX, Tru64, Cygwin >= 2.5 */
Paul Eggert's avatar
Paul Eggert committed
28 29
#  if HAVE_ACL_GET_FILE && !HAVE_ACL_TYPE_EXTENDED

Paul Eggert's avatar
Paul Eggert committed
30 31 32 33 34
static acl_t
acl_from_mode (mode_t mode)
{
#  if HAVE_ACL_FREE_TEXT /* Tru64 */
  char acl_text[] = "u::---,g::---,o::---,";
Paul Eggert's avatar
Paul Eggert committed
35
#  else /* FreeBSD, IRIX, Cygwin >= 2.5 */
Paul Eggert's avatar
Paul Eggert committed
36
  char acl_text[] = "u::---,g::---,o::---";
37 38
#  endif

Paul Eggert's avatar
Paul Eggert committed
39 40 41 42 43 44 45 46 47 48 49 50
  if (mode & S_IRUSR) acl_text[ 3] = 'r';
  if (mode & S_IWUSR) acl_text[ 4] = 'w';
  if (mode & S_IXUSR) acl_text[ 5] = 'x';
  if (mode & S_IRGRP) acl_text[10] = 'r';
  if (mode & S_IWGRP) acl_text[11] = 'w';
  if (mode & S_IXGRP) acl_text[12] = 'x';
  if (mode & S_IROTH) acl_text[17] = 'r';
  if (mode & S_IWOTH) acl_text[18] = 'w';
  if (mode & S_IXOTH) acl_text[19] = 'x';

  return acl_from_text (acl_text);
}
Paul Eggert's avatar
Paul Eggert committed
51
#  endif
Paul Eggert's avatar
Paul Eggert committed
52
# endif
53

Paul Eggert's avatar
Paul Eggert committed
54
# if HAVE_FACL && defined GETACL /* Solaris, Cygwin < 2.5, not HP-UX */
Paul Eggert's avatar
Paul Eggert committed
55 56 57
static int
set_acls_from_mode (const char *name, int desc, mode_t mode, bool *must_chmod)
{
58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
#  ifdef ACE_GETACL
  /* Solaris also has a different variant of ACLs, used in ZFS and NFSv4
     file systems (whereas the other ones are used in UFS file systems).  */

  /* The flags in the ace_t structure changed in a binary incompatible way
     when ACL_NO_TRIVIAL etc. were introduced in <sys/acl.h> version 1.15.
     How to distinguish the two conventions at runtime?
     We fetch the existing ACL.  In the old convention, usually three ACEs have
     a_flags = ACE_OWNER / ACE_GROUP / ACE_OTHER, in the range 0x0100..0x0400.
     In the new convention, these values are not used.  */
  int convention;

  {
    /* Initially, try to read the entries into a stack-allocated buffer.
       Use malloc if it does not fit.  */
    enum
      {
        alloc_init = 4000 / sizeof (ace_t), /* >= 3 */
        alloc_max = MIN (INT_MAX, SIZE_MAX / sizeof (ace_t))
      };
    ace_t buf[alloc_init];
    size_t alloc = alloc_init;
    ace_t *entries = buf;
    ace_t *malloced = NULL;
    int count;

    for (;;)
      {
        count = (desc != -1
                 ? facl (desc, ACE_GETACL, alloc, entries)
                 : acl (name, ACE_GETACL, alloc, entries));
        if (count < 0 && errno == ENOSPC)
          {
            /* Increase the size of the buffer.  */
            free (malloced);
            if (alloc > alloc_max / 2)
              {
                errno = ENOMEM;
                return -1;
              }
            alloc = 2 * alloc; /* <= alloc_max */
            entries = malloced = (ace_t *) malloc (alloc * sizeof (ace_t));
            if (entries == NULL)
              {
                errno = ENOMEM;
                return -1;
              }
            continue;
          }
        break;
      }

    if (count <= 0)
      convention = -1;
    else
      {
        int i;

        convention = 0;
        for (i = 0; i < count; i++)
          if (entries[i].a_flags & (OLD_ACE_OWNER | OLD_ACE_GROUP | OLD_ACE_OTHER))
            {
              convention = 1;
              break;
            }
      }
    free (malloced);
  }

  if (convention >= 0)
    {
      ace_t entries[6];
      int count;
      int ret;

      if (convention)
        {
          /* Running on Solaris 10.  */
          entries[0].a_type = OLD_ALLOW;
          entries[0].a_flags = OLD_ACE_OWNER;
          entries[0].a_who = 0; /* irrelevant */
          entries[0].a_access_mask = (mode >> 6) & 7;
          entries[1].a_type = OLD_ALLOW;
          entries[1].a_flags = OLD_ACE_GROUP;
          entries[1].a_who = 0; /* irrelevant */
          entries[1].a_access_mask = (mode >> 3) & 7;
          entries[2].a_type = OLD_ALLOW;
          entries[2].a_flags = OLD_ACE_OTHER;
          entries[2].a_who = 0;
          entries[2].a_access_mask = mode & 7;
          count = 3;
        }
      else
        {
          /* Running on Solaris 10 (newer version) or Solaris 11.
             The details here were found through "/bin/ls -lvd somefiles".  */
          entries[0].a_type = NEW_ACE_ACCESS_DENIED_ACE_TYPE;
          entries[0].a_flags = NEW_ACE_OWNER;
          entries[0].a_who = 0; /* irrelevant */
          entries[0].a_access_mask = 0;
          entries[1].a_type = NEW_ACE_ACCESS_ALLOWED_ACE_TYPE;
          entries[1].a_flags = NEW_ACE_OWNER;
          entries[1].a_who = 0; /* irrelevant */
          entries[1].a_access_mask = NEW_ACE_WRITE_NAMED_ATTRS
                                     | NEW_ACE_WRITE_ATTRIBUTES
                                     | NEW_ACE_WRITE_ACL
                                     | NEW_ACE_WRITE_OWNER;
          if (mode & 0400)
            entries[1].a_access_mask |= NEW_ACE_READ_DATA;
          else
            entries[0].a_access_mask |= NEW_ACE_READ_DATA;
          if (mode & 0200)
            entries[1].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
          else
            entries[0].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
          if (mode & 0100)
            entries[1].a_access_mask |= NEW_ACE_EXECUTE;
          else
            entries[0].a_access_mask |= NEW_ACE_EXECUTE;
          entries[2].a_type = NEW_ACE_ACCESS_DENIED_ACE_TYPE;
          entries[2].a_flags = NEW_ACE_GROUP | NEW_ACE_IDENTIFIER_GROUP;
          entries[2].a_who = 0; /* irrelevant */
          entries[2].a_access_mask = 0;
          entries[3].a_type = NEW_ACE_ACCESS_ALLOWED_ACE_TYPE;
          entries[3].a_flags = NEW_ACE_GROUP | NEW_ACE_IDENTIFIER_GROUP;
          entries[3].a_who = 0; /* irrelevant */
          entries[3].a_access_mask = 0;
          if (mode & 0040)
            entries[3].a_access_mask |= NEW_ACE_READ_DATA;
          else
            entries[2].a_access_mask |= NEW_ACE_READ_DATA;
          if (mode & 0020)
            entries[3].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
          else
            entries[2].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
          if (mode & 0010)
            entries[3].a_access_mask |= NEW_ACE_EXECUTE;
          else
            entries[2].a_access_mask |= NEW_ACE_EXECUTE;
          entries[4].a_type = NEW_ACE_ACCESS_DENIED_ACE_TYPE;
          entries[4].a_flags = NEW_ACE_EVERYONE;
          entries[4].a_who = 0;
          entries[4].a_access_mask = NEW_ACE_WRITE_NAMED_ATTRS
                                     | NEW_ACE_WRITE_ATTRIBUTES
                                     | NEW_ACE_WRITE_ACL
                                     | NEW_ACE_WRITE_OWNER;
          entries[5].a_type = NEW_ACE_ACCESS_ALLOWED_ACE_TYPE;
          entries[5].a_flags = NEW_ACE_EVERYONE;
          entries[5].a_who = 0;
          entries[5].a_access_mask = NEW_ACE_READ_NAMED_ATTRS
                                     | NEW_ACE_READ_ATTRIBUTES
                                     | NEW_ACE_READ_ACL
                                     | NEW_ACE_SYNCHRONIZE;
          if (mode & 0004)
            entries[5].a_access_mask |= NEW_ACE_READ_DATA;
          else
            entries[4].a_access_mask |= NEW_ACE_READ_DATA;
          if (mode & 0002)
            entries[5].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
          else
            entries[4].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
          if (mode & 0001)
            entries[5].a_access_mask |= NEW_ACE_EXECUTE;
          else
            entries[4].a_access_mask |= NEW_ACE_EXECUTE;
          count = 6;
        }
      if (desc != -1)
        ret = facl (desc, ACE_SETACL, count, entries);
      else
        ret = acl (name, ACE_SETACL, count, entries);
      if (ret < 0 && errno != EINVAL && errno != ENOTSUP)
        {
          if (errno == ENOSYS)
Paul Eggert's avatar
Paul Eggert committed
232 233 234 235
            {
              *must_chmod = true;
              return 0;
            }
236 237 238
          return -1;
        }
      if (ret == 0)
Paul Eggert's avatar
Paul Eggert committed
239
        return 0;
240 241 242
    }
#  endif

Paul Eggert's avatar
Paul Eggert committed
243 244 245 246 247 248 249 250 251 252 253 254 255
  {
    aclent_t entries[3];
    int ret;

    entries[0].a_type = USER_OBJ;
    entries[0].a_id = 0; /* irrelevant */
    entries[0].a_perm = (mode >> 6) & 7;
    entries[1].a_type = GROUP_OBJ;
    entries[1].a_id = 0; /* irrelevant */
    entries[1].a_perm = (mode >> 3) & 7;
    entries[2].a_type = OTHER_OBJ;
    entries[2].a_id = 0;
    entries[2].a_perm = mode & 7;
256

Paul Eggert's avatar
Paul Eggert committed
257 258
    if (desc != -1)
      ret = facl (desc, SETACL,
Paul Eggert's avatar
Paul Eggert committed
259
                  sizeof (entries) / sizeof (aclent_t), entries);
Paul Eggert's avatar
Paul Eggert committed
260 261
    else
      ret = acl (name, SETACL,
Paul Eggert's avatar
Paul Eggert committed
262
                 sizeof (entries) / sizeof (aclent_t), entries);
Paul Eggert's avatar
Paul Eggert committed
263 264
    if (ret < 0)
      {
Paul Eggert's avatar
Paul Eggert committed
265 266 267 268 269 270
        if (errno == ENOSYS || errno == EOPNOTSUPP)
          {
            *must_chmod = true;
            return 0;
          }
        return -1;
Paul Eggert's avatar
Paul Eggert committed
271
      }
Paul Eggert's avatar
Paul Eggert committed
272
    return 0;
Paul Eggert's avatar
Paul Eggert committed
273 274
  }
}
275

Paul Eggert's avatar
Paul Eggert committed
276
# elif HAVE_GETACL /* HP-UX */
Paul Eggert's avatar
Paul Eggert committed
277 278 279
static int
context_acl_from_mode (struct permission_context *ctx, const char *name, int desc)
{
280 281 282 283 284 285 286 287 288 289
  struct stat statbuf;
  int ret;

  if (desc != -1)
    ret = fstat (desc, &statbuf);
  else
    ret = stat (name, &statbuf);
  if (ret < 0)
    return -1;

Paul Eggert's avatar
Paul Eggert committed
290 291
  ctx->entries[0].uid = statbuf.st_uid;
  ctx->entries[0].gid = ACL_NSGROUP;
Paul Eggert's avatar
Paul Eggert committed
292
  ctx->entries[0].mode = (ctx->mode >> 6) & 7;
Paul Eggert's avatar
Paul Eggert committed
293 294
  ctx->entries[1].uid = ACL_NSUSER;
  ctx->entries[1].gid = statbuf.st_gid;
Paul Eggert's avatar
Paul Eggert committed
295
  ctx->entries[1].mode = (ctx->mode >> 3) & 7;
Paul Eggert's avatar
Paul Eggert committed
296 297
  ctx->entries[2].uid = ACL_NSUSER;
  ctx->entries[2].gid = ACL_NSGROUP;
Paul Eggert's avatar
Paul Eggert committed
298
  ctx->entries[2].mode = ctx->mode & 7;
Paul Eggert's avatar
Paul Eggert committed
299 300 301
  ctx->count = 3;
  return 0;
}
302 303

#  if HAVE_ACLV_H /* HP-UX >= 11.11 */
Paul Eggert's avatar
Paul Eggert committed
304 305 306 307
static int
context_aclv_from_mode (struct permission_context *ctx)
{
  int ret;
308

Paul Eggert's avatar
Paul Eggert committed
309 310
  ctx->aclv_entries[0].a_type = USER_OBJ;
  ctx->aclv_entries[0].a_id = 0; /* irrelevant */
Paul Eggert's avatar
Paul Eggert committed
311
  ctx->aclv_entries[0].a_perm = (ctx->mode >> 6) & 7;
Paul Eggert's avatar
Paul Eggert committed
312 313
  ctx->aclv_entries[1].a_type = GROUP_OBJ;
  ctx->aclv_entries[1].a_id = 0; /* irrelevant */
Paul Eggert's avatar
Paul Eggert committed
314
  ctx->aclv_entries[1].a_perm = (ctx->mode >> 3) & 7;
Paul Eggert's avatar
Paul Eggert committed
315 316
  ctx->aclv_entries[2].a_type = CLASS_OBJ;
  ctx->aclv_entries[2].a_id = 0;
Paul Eggert's avatar
Paul Eggert committed
317
  ctx->aclv_entries[2].a_perm = (ctx->mode >> 3) & 7;
Paul Eggert's avatar
Paul Eggert committed
318 319
  ctx->aclv_entries[3].a_type = OTHER_OBJ;
  ctx->aclv_entries[3].a_id = 0;
Paul Eggert's avatar
Paul Eggert committed
320
  ctx->aclv_entries[3].a_perm = ctx->mode & 7;
Paul Eggert's avatar
Paul Eggert committed
321
  ctx->aclv_count = 4;
322

Paul Eggert's avatar
Paul Eggert committed
323
  ret = aclsort (ctx->aclv_count, 1, ctx->aclv_entries);
Paul Eggert's avatar
Paul Eggert committed
324 325 326 327
  if (ret > 0)
    abort ();
  return ret;
}
Paul Eggert's avatar
Paul Eggert committed
328
#  endif
329 330

# elif HAVE_ACLX_GET && defined ACL_AIX_WIP /* AIX */
Paul Eggert's avatar
Paul Eggert committed
331 332 333
static int
set_acls_from_mode (const char *name, int desc, mode_t mode, bool *must_chmod)
{
334 335 336 337 338 339
  acl_type_list_t types;
  size_t types_size = sizeof (types);
  acl_type_t type;

  if (aclx_gettypes (name, &types, &types_size) < 0
      || types.num_entries == 0)
Paul Eggert's avatar
Paul Eggert committed
340 341 342 343
    {
      *must_chmod = true;
      return 0;
    }
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439

  /* XXX Do we need to clear all types of ACLs for the given file, or is it
     sufficient to clear the first one?  */
  type = types.entries[0];
  if (type.u64 == ACL_AIXC)
    {
      union { struct acl a; char room[128]; } u;
      int ret;

      u.a.acl_len = (char *) &u.a.acl_ext[0] - (char *) &u.a; /* no entries */
      u.a.acl_mode = mode & ~(S_IXACL | 0777);
      u.a.u_access = (mode >> 6) & 7;
      u.a.g_access = (mode >> 3) & 7;
      u.a.o_access = mode & 7;

      if (desc != -1)
        ret = aclx_fput (desc, SET_ACL | SET_MODE_S_BITS,
                         type, &u.a, u.a.acl_len, mode);
      else
        ret = aclx_put (name, SET_ACL | SET_MODE_S_BITS,
                        type, &u.a, u.a.acl_len, mode);
      if (!(ret < 0 && errno == ENOSYS))
        return ret;
    }
  else if (type.u64 == ACL_NFS4)
    {
      union { nfs4_acl_int_t a; char room[128]; } u;
      nfs4_ace_int_t *ace;
      int ret;

      u.a.aclVersion = NFS4_ACL_INT_STRUCT_VERSION;
      u.a.aclEntryN = 0;
      ace = &u.a.aclEntry[0];
      {
        ace->flags = ACE4_ID_SPECIAL;
        ace->aceWho.special_whoid = ACE4_WHO_OWNER;
        ace->aceType = ACE4_ACCESS_ALLOWED_ACE_TYPE;
        ace->aceFlags = 0;
        ace->aceMask =
          (mode & 0400 ? ACE4_READ_DATA | ACE4_LIST_DIRECTORY : 0)
          | (mode & 0200
             ? ACE4_WRITE_DATA | ACE4_ADD_FILE | ACE4_APPEND_DATA
               | ACE4_ADD_SUBDIRECTORY
             : 0)
          | (mode & 0100 ? ACE4_EXECUTE : 0);
        ace->aceWhoString[0] = '\0';
        ace->entryLen = (char *) &ace->aceWhoString[4] - (char *) ace;
        ace = (nfs4_ace_int_t *) (char *) &ace->aceWhoString[4];
        u.a.aclEntryN++;
      }
      {
        ace->flags = ACE4_ID_SPECIAL;
        ace->aceWho.special_whoid = ACE4_WHO_GROUP;
        ace->aceType = ACE4_ACCESS_ALLOWED_ACE_TYPE;
        ace->aceFlags = 0;
        ace->aceMask =
          (mode & 0040 ? ACE4_READ_DATA | ACE4_LIST_DIRECTORY : 0)
          | (mode & 0020
             ? ACE4_WRITE_DATA | ACE4_ADD_FILE | ACE4_APPEND_DATA
               | ACE4_ADD_SUBDIRECTORY
             : 0)
          | (mode & 0010 ? ACE4_EXECUTE : 0);
        ace->aceWhoString[0] = '\0';
        ace->entryLen = (char *) &ace->aceWhoString[4] - (char *) ace;
        ace = (nfs4_ace_int_t *) (char *) &ace->aceWhoString[4];
        u.a.aclEntryN++;
      }
      {
        ace->flags = ACE4_ID_SPECIAL;
        ace->aceWho.special_whoid = ACE4_WHO_EVERYONE;
        ace->aceType = ACE4_ACCESS_ALLOWED_ACE_TYPE;
        ace->aceFlags = 0;
        ace->aceMask =
          (mode & 0004 ? ACE4_READ_DATA | ACE4_LIST_DIRECTORY : 0)
          | (mode & 0002
             ? ACE4_WRITE_DATA | ACE4_ADD_FILE | ACE4_APPEND_DATA
               | ACE4_ADD_SUBDIRECTORY
             : 0)
          | (mode & 0001 ? ACE4_EXECUTE : 0);
        ace->aceWhoString[0] = '\0';
        ace->entryLen = (char *) &ace->aceWhoString[4] - (char *) ace;
        ace = (nfs4_ace_int_t *) (char *) &ace->aceWhoString[4];
        u.a.aclEntryN++;
      }
      u.a.aclLength = (char *) ace - (char *) &u.a;

      if (desc != -1)
        ret = aclx_fput (desc, SET_ACL | SET_MODE_S_BITS,
                         type, &u.a, u.a.aclLength, mode);
      else
        ret = aclx_put (name, SET_ACL | SET_MODE_S_BITS,
                        type, &u.a, u.a.aclLength, mode);
      if (!(ret < 0 && errno == ENOSYS))
        return ret;
    }

Paul Eggert's avatar
Paul Eggert committed
440 441 442
  *must_chmod = true;
  return 0;
}
443 444

# elif HAVE_STATACL /* older AIX */
Paul Eggert's avatar
Paul Eggert committed
445 446 447 448 449 450 451 452 453 454 455
static int
context_acl_from_mode (struct permission_context *ctx)
{
  ctx->u.a.acl_len = (char *) &ctx->u.a.acl_ext[0] - (char *) &ctx->u.a; /* no entries */
  ctx->u.a.acl_mode = ctx->mode & ~(S_IXACL | 0777);
  ctx->u.a.u_access = (ctx->mode >> 6) & 7;
  ctx->u.a.g_access = (ctx->mode >> 3) & 7;
  ctx->u.a.o_access = ctx->mode & 7;
  ctx->have_u = true;
  return 0;
}
456

Paul Eggert's avatar
Paul Eggert committed
457 458 459 460
# elif HAVE_ACLSORT /* NonStop Kernel */
static int
context_acl_from_mode (struct permission_context *ctx)
{
461 462
  int ret;

Paul Eggert's avatar
Paul Eggert committed
463 464
  ctx->entries[0].a_type = USER_OBJ;
  ctx->entries[0].a_id = 0; /* irrelevant */
Paul Eggert's avatar
Paul Eggert committed
465
  ctx->entries[0].a_perm = (ctx->mode >> 6) & 7;
Paul Eggert's avatar
Paul Eggert committed
466 467
  ctx->entries[1].a_type = GROUP_OBJ;
  ctx->entries[1].a_id = 0; /* irrelevant */
Paul Eggert's avatar
Paul Eggert committed
468
  ctx->entries[1].a_perm = (ctx->mode >> 3) & 7;
Paul Eggert's avatar
Paul Eggert committed
469 470
  ctx->entries[2].a_type = CLASS_OBJ;
  ctx->entries[2].a_id = 0;
Paul Eggert's avatar
Paul Eggert committed
471
  ctx->entries[2].a_perm = (ctx->mode >> 3) & 7;
Paul Eggert's avatar
Paul Eggert committed
472 473
  ctx->entries[3].a_type = OTHER_OBJ;
  ctx->entries[3].a_id = 0;
Paul Eggert's avatar
Paul Eggert committed
474
  ctx->entries[3].a_perm = ctx->mode & 7;
Paul Eggert's avatar
Paul Eggert committed
475
  ctx->count = 4;
476

Paul Eggert's avatar
Paul Eggert committed
477
  ret = aclsort (ctx->count, 1, entries);
Paul Eggert's avatar
Paul Eggert committed
478 479 480 481 482 483 484 485
  if (ret > 0)
    abort ();
  return ret;
}
# endif

static int
set_acls (struct permission_context *ctx, const char *name, int desc,
Paul Eggert's avatar
Paul Eggert committed
486
          int from_mode, bool *must_chmod, bool *acls_set)
Paul Eggert's avatar
Paul Eggert committed
487 488 489
{
  int ret = 0;

Paul Eggert's avatar
Paul Eggert committed
490
# if HAVE_ACL_GET_FILE
Paul Eggert's avatar
Paul Eggert committed
491
  /* POSIX 1003.1e (draft 17 -- abandoned) specific version.  */
Paul Eggert's avatar
Paul Eggert committed
492
  /* Linux, FreeBSD, Mac OS X, IRIX, Tru64, Cygwin >= 2.5 */
Paul Eggert's avatar
Paul Eggert committed
493
#  if !HAVE_ACL_TYPE_EXTENDED
Paul Eggert's avatar
Paul Eggert committed
494
  /* Linux, FreeBSD, IRIX, Tru64, Cygwin >= 2.5 */
Paul Eggert's avatar
Paul Eggert committed
495

Paul Eggert's avatar
Paul Eggert committed
496 497 498 499 500 501
#   ifndef HAVE_ACL_FROM_TEXT
#    error Must have acl_from_text (see POSIX 1003.1e draft 17).
#   endif
#   ifndef HAVE_ACL_DELETE_DEF_FILE
#    error Must have acl_delete_def_file (see POSIX 1003.1e draft 17).
#   endif
Paul Eggert's avatar
Paul Eggert committed
502 503 504 505

  if (! ctx->acls_not_supported)
    {
      if (ret == 0 && from_mode)
Paul Eggert's avatar
Paul Eggert committed
506 507 508 509 510 511 512
        {
          if (ctx->acl)
            acl_free (ctx->acl);
          ctx->acl = acl_from_mode (ctx->mode);
          if (ctx->acl == NULL)
            ret = -1;
        }
Paul Eggert's avatar
Paul Eggert committed
513 514

      if (ret == 0 && ctx->acl)
Paul Eggert's avatar
Paul Eggert committed
515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542
        {
          if (HAVE_ACL_SET_FD && desc != -1)
            ret = acl_set_fd (desc, ctx->acl);
          else
            ret = acl_set_file (name, ACL_TYPE_ACCESS, ctx->acl);
          if (ret != 0)
            {
              if (! acl_errno_valid (errno))
                {
                  ctx->acls_not_supported = true;
                  if (from_mode || acl_access_nontrivial (ctx->acl) == 0)
                    ret = 0;
                }
            }
          else
            {
              *acls_set = true;
              if (S_ISDIR(ctx->mode))
                {
                  if (! from_mode && ctx->default_acl &&
                      acl_default_nontrivial (ctx->default_acl))
                    ret = acl_set_file (name, ACL_TYPE_DEFAULT,
                                        ctx->default_acl);
                  else
                    ret = acl_delete_def_file (name);
                }
            }
        }
Paul Eggert's avatar
Paul Eggert committed
543 544
    }

Paul Eggert's avatar
Paul Eggert committed
545
#   if HAVE_ACL_TYPE_NFS4  /* FreeBSD */
Paul Eggert's avatar
Paul Eggert committed
546 547 548 549 550 551

  /* File systems either support POSIX ACLs (for example, ufs) or NFS4 ACLs
     (for example, zfs). */

  /* TODO: Implement setting ACLs once get_permissions() reads them. */

Paul Eggert's avatar
Paul Eggert committed
552
#   endif
Paul Eggert's avatar
Paul Eggert committed
553

Paul Eggert's avatar
Paul Eggert committed
554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575
#  else /* HAVE_ACL_TYPE_EXTENDED */
  /* Mac OS X */

  /* On Mac OS X,  acl_get_file (name, ACL_TYPE_ACCESS)
     and           acl_get_file (name, ACL_TYPE_DEFAULT)
     always return NULL / EINVAL.  You have to use
                   acl_get_file (name, ACL_TYPE_EXTENDED)
     or            acl_get_fd (open (name, ...))
     to retrieve an ACL.
     On the other hand,
                   acl_set_file (name, ACL_TYPE_ACCESS, acl)
     and           acl_set_file (name, ACL_TYPE_DEFAULT, acl)
     have the same effect as
                   acl_set_file (name, ACL_TYPE_EXTENDED, acl):
     Each of these calls sets the file's ACL.  */

  if (ctx->acl == NULL)
    {
      acl_t acl;

      /* Remove ACLs if the file has ACLs.  */
      if (HAVE_ACL_GET_FD && desc != -1)
Paul Eggert's avatar
Paul Eggert committed
576
        acl = acl_get_fd (desc);
Paul Eggert's avatar
Paul Eggert committed
577
      else
Paul Eggert's avatar
Paul Eggert committed
578
        acl = acl_get_file (name, ACL_TYPE_EXTENDED);
Paul Eggert's avatar
Paul Eggert committed
579
      if (acl)
Paul Eggert's avatar
Paul Eggert committed
580 581 582 583 584 585 586 587 588 589 590 591 592 593 594
        {
          acl_free (acl);

          acl = acl_init (0);
          if (acl)
            {
              if (HAVE_ACL_SET_FD && desc != -1)
                ret = acl_set_fd (desc, acl);
              else
                ret = acl_set_file (name, ACL_TYPE_EXTENDED, acl);
              acl_free (acl);
            }
          else
            ret = -1;
        }
Paul Eggert's avatar
Paul Eggert committed
595
    }
596
  else
Paul Eggert's avatar
Paul Eggert committed
597 598
    {
      if (HAVE_ACL_SET_FD && desc != -1)
Paul Eggert's avatar
Paul Eggert committed
599
        ret = acl_set_fd (desc, ctx->acl);
Paul Eggert's avatar
Paul Eggert committed
600
      else
Paul Eggert's avatar
Paul Eggert committed
601
        ret = acl_set_file (name, ACL_TYPE_EXTENDED, ctx->acl);
Paul Eggert's avatar
Paul Eggert committed
602
      if (ret != 0)
Paul Eggert's avatar
Paul Eggert committed
603 604 605 606 607
        {
          if (! acl_errno_valid (errno)
              && ! acl_extended_nontrivial (ctx->acl))
            ret = 0;
        }
Paul Eggert's avatar
Paul Eggert committed
608 609
    }
  *acls_set = true;
610

Paul Eggert's avatar
Paul Eggert committed
611
#  endif
612

Paul Eggert's avatar
Paul Eggert committed
613
# elif defined GETACL /* Solaris, Cygwin, not HP-UX */
614

Paul Eggert's avatar
Paul Eggert committed
615 616 617
  /* Solaris 2.5 through Solaris 10, Cygwin, and contemporaneous versions
     of Unixware.  The acl() call returns the access and default ACL both
     at once.  */
618

Paul Eggert's avatar
Paul Eggert committed
619 620 621
  /* If both ace_entries and entries are available, try SETACL before
     ACE_SETACL, because SETACL cannot fail with ENOTSUP whereas ACE_SETACL
     can.  */
622

Paul Eggert's avatar
Paul Eggert committed
623 624
  if (from_mode)
    return set_acls_from_mode (name, desc, ctx->mode, must_chmod);
625

Paul Eggert's avatar
Paul Eggert committed
626
  if (ret == 0 && ctx->count)
627
    {
Paul Eggert's avatar
Paul Eggert committed
628
      if (desc != -1)
Paul Eggert's avatar
Paul Eggert committed
629
        ret = facl (desc, SETACL, ctx->count, ctx->entries);
Paul Eggert's avatar
Paul Eggert committed
630
      else
Paul Eggert's avatar
Paul Eggert committed
631
        ret = acl (name, SETACL, ctx->count, ctx->entries);
Paul Eggert's avatar
Paul Eggert committed
632
      if (ret < 0)
Paul Eggert's avatar
Paul Eggert committed
633 634 635 636 637
        {
          if ((errno == ENOSYS || errno == EOPNOTSUPP || errno == EINVAL)
              && acl_nontrivial (ctx->count, ctx->entries) == 0)
            ret = 0;
        }
Paul Eggert's avatar
Paul Eggert committed
638
      else
Paul Eggert's avatar
Paul Eggert committed
639
        *acls_set = true;
640 641
    }

Paul Eggert's avatar
Paul Eggert committed
642 643
#  ifdef ACE_GETACL
  if (ret == 0 && ctx->ace_count)
644
    {
Paul Eggert's avatar
Paul Eggert committed
645
      if (desc != -1)
Paul Eggert's avatar
Paul Eggert committed
646
        ret = facl (desc, ACE_SETACL, ctx->ace_count, ctx->ace_entries);
Paul Eggert's avatar
Paul Eggert committed
647
      else
Paul Eggert's avatar
Paul Eggert committed
648
        ret = acl (name, ACE_SETACL, ctx->ace_count, ctx->ace_entries);
Paul Eggert's avatar
Paul Eggert committed
649
      if (ret < 0)
Paul Eggert's avatar
Paul Eggert committed
650 651 652 653 654
        {
          if ((errno == ENOSYS || errno == EINVAL || errno == ENOTSUP)
              && acl_ace_nontrivial (ctx->ace_count, ctx->ace_entries) == 0)
            ret = 0;
        }
Paul Eggert's avatar
Paul Eggert committed
655
      else
Paul Eggert's avatar
Paul Eggert committed
656
        *acls_set = true;
657
    }
Paul Eggert's avatar
Paul Eggert committed
658
#  endif
Paul Eggert's avatar
Paul Eggert committed
659

Paul Eggert's avatar
Paul Eggert committed
660
# elif HAVE_GETACL /* HP-UX */
661

Paul Eggert's avatar
Paul Eggert committed
662 663 664 665
  if (from_mode)
    ret = context_acl_from_mode (ctx, name, desc);

  if (ret == 0 && ctx->count > 0)
666
    {
Paul Eggert's avatar
Paul Eggert committed
667
      if (desc != -1)
Paul Eggert's avatar
Paul Eggert committed
668
        ret = fsetacl (desc, ctx->count, ctx->entries);
Paul Eggert's avatar
Paul Eggert committed
669
      else
Paul Eggert's avatar
Paul Eggert committed
670
        ret = setacl (name, ctx->count, ctx->entries);
Paul Eggert's avatar
Paul Eggert committed
671
      if (ret < 0)
Paul Eggert's avatar
Paul Eggert committed
672 673 674 675 676
        {
          if ((errno == ENOSYS || errno == EOPNOTSUPP || errno == ENOTSUP)
              && (from_mode || !acl_nontrivial (ctx->count, ctx->entries)))
            ret = 0;
        }
Paul Eggert's avatar
Paul Eggert committed
677
      else
Paul Eggert's avatar
Paul Eggert committed
678
        *acls_set = true;
679 680
    }

Paul Eggert's avatar
Paul Eggert committed
681 682 683 684 685 686 687 688
#  if HAVE_ACLV_H
  if (from_mode)
    ret = context_aclv_from_mode (ctx);

  if (ret == 0 && ctx->aclv_count > 0)
    {
      ret = acl ((char *) name, ACL_SET, ctx->aclv_count, ctx->aclv_entries);
      if (ret < 0)
Paul Eggert's avatar
Paul Eggert committed
689 690 691 692 693
        {
          if ((errno == ENOSYS || errno == EOPNOTSUPP || errno == EINVAL)
              && (from_mode || !aclv_nontrivial (ctx->aclv_count, ctx->aclv_entries)))
            ret = 0;
        }
Paul Eggert's avatar
Paul Eggert committed
694
      else
Paul Eggert's avatar
Paul Eggert committed
695
        *acls_set = true;
Paul Eggert's avatar
Paul Eggert committed
696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713
    }
#  endif

# elif HAVE_ACLX_GET && ACL_AIX_WIP /* AIX */

  /* TODO: Implement setting ACLs once get_permissions() reads them. */

  if (from_mode)
    ret = set_acls_from_mode (name, desc, mode, must_chmod);

# elif HAVE_STATACL /* older AIX */

  if (from_mode)
    ret = context_acl_from_mode (ctx);

  if (ret == 0 && ctx->have_u)
    {
      if (desc != -1)
Paul Eggert's avatar
Paul Eggert committed
714
        ret = fchacl (desc, &ctx->u.a, ctx->u.a.acl_len);
Paul Eggert's avatar
Paul Eggert committed
715
      else
Paul Eggert's avatar
Paul Eggert committed
716
        ret = chacl ((char *) name, &ctx->u.a, ctx->u.a.acl_len);
Paul Eggert's avatar
Paul Eggert committed
717
      if (ret < 0)
Paul Eggert's avatar
Paul Eggert committed
718 719 720 721
        {
          if (errno == ENOSYS && from_mode)
            ret = 0;
        }
Paul Eggert's avatar
Paul Eggert committed
722
      else
Paul Eggert's avatar
Paul Eggert committed
723
        *acls_set = true;
Paul Eggert's avatar
Paul Eggert committed
724 725 726 727 728 729 730 731 732 733 734
    }

# elif HAVE_ACLSORT /* NonStop Kernel */

  if (from_mode)
    ret = context_acl_from_mode (ctx);

  if (ret == 0 && ctx->count)
    {
      ret = acl ((char *) name, ACL_SET, ctx->count, ctx->entries);
      if (ret != 0)
Paul Eggert's avatar
Paul Eggert committed
735 736 737 738
        {
          if (!acl_nontrivial (ctx->count, ctx->entries))
            ret = 0;
        }
Paul Eggert's avatar
Paul Eggert committed
739
      else
Paul Eggert's avatar
Paul Eggert committed
740
        *acls_set = true;
Paul Eggert's avatar
Paul Eggert committed
741 742 743 744 745 746
    }

# else  /* No ACLs */

  /* Nothing to do. */

Paul Eggert's avatar
Paul Eggert committed
747
# endif
Paul Eggert's avatar
Paul Eggert committed
748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790

  return ret;
}
#endif

/* If DESC is a valid file descriptor use fchmod to change the
   file's mode to MODE on systems that have fchmod. On systems
   that don't have fchmod and if DESC is invalid, use chmod on
   NAME instead.
   Return 0 if successful.  Return -1 and set errno upon failure.  */

int
chmod_or_fchmod (const char *name, int desc, mode_t mode)
{
  if (HAVE_FCHMOD && desc != -1)
    return fchmod (desc, mode);
  else
    return chmod (name, mode);
}

/* Set the permissions in CTX on a file. If DESC is a valid file descriptor,
   use file descriptor operations, else use filename based operations on NAME.
   If access control lists are not available, fchmod the target file to the
   mode in CTX.  Also sets the non-permission bits of the destination file
   (S_ISUID, S_ISGID, S_ISVTX) to those from the mode in CTX if any are set.
   Return 0 if successful.  Return -1 and set errno upon failure.  */

int
set_permissions (struct permission_context *ctx, const char *name, int desc)
{
  bool acls_set _GL_UNUSED = false;
  bool early_chmod;
  bool must_chmod = false;
  int ret = 0;

#if USE_ACL
# if HAVE_STATACL
  /* older AIX */
  /* There is no need to call chmod_or_fchmod, since the mode
     bits S_ISUID, S_ISGID, S_ISVTX are also stored in the ACL.  */

  early_chmod = false;
# else
791
  /* All other platforms */
Paul Eggert's avatar
Paul Eggert committed
792 793 794 795 796
  /* On Cygwin, it is necessary to call chmod before acl, because
     chmod can change the contents of the ACL (in ways that don't
     change the allowed accesses, but still visible).  */

  early_chmod = (! MODE_INSIDE_ACL || (ctx->mode & (S_ISUID | S_ISGID | S_ISVTX)));
797
# endif
Paul Eggert's avatar
Paul Eggert committed
798 799 800 801
#else
  /* No ACLs */

  early_chmod = true;
802
#endif
Paul Eggert's avatar
Paul Eggert committed
803 804 805 806 807

  if (early_chmod)
    {
      ret = chmod_or_fchmod (name, desc, ctx->mode);
      if (ret != 0)
Paul Eggert's avatar
Paul Eggert committed
808
        return -1;
Paul Eggert's avatar
Paul Eggert committed
809 810 811 812 813 814 815 816 817
    }

#if USE_ACL
  ret = set_acls (ctx, name, desc, false, &must_chmod, &acls_set);
  if (! acls_set)
    {
      int saved_errno = ret ? errno : 0;

      /* If we can't set an acl which we expect to be able to set, try setting
Paul Eggert's avatar
Paul Eggert committed
818 819
         the permissions to ctx->mode. Due to possible inherited permissions,
         we cannot simply chmod.  */
Paul Eggert's avatar
Paul Eggert committed
820 821 822

      ret = set_acls (ctx, name, desc, true, &must_chmod, &acls_set);
      if (! acls_set)
Paul Eggert's avatar
Paul Eggert committed
823
        must_chmod = true;
Paul Eggert's avatar
Paul Eggert committed
824 825

      if (saved_errno)
Paul Eggert's avatar
Paul Eggert committed
826 827 828 829
        {
          errno = saved_errno;
          ret = -1;
        }
Paul Eggert's avatar
Paul Eggert committed
830 831 832 833 834 835 836 837 838 839
    }
#endif

  if (must_chmod && ! early_chmod)
    {
      int saved_errno = ret ? errno : 0;

      ret = chmod_or_fchmod (name, desc, ctx->mode);

      if (saved_errno)
Paul Eggert's avatar
Paul Eggert committed
840 841 842 843
        {
          errno = saved_errno;
          ret = -1;
        }
Paul Eggert's avatar
Paul Eggert committed
844 845 846
    }

  return ret;
847
}