maint/gnulib/lib/set-permissions.c

/* */
This source file includes following definitions.
acl_from_mode
set_acls_from_mode
context_acl_from_mode
context_aclv_from_mode
set_acls_from_mode
context_acl_from_mode
context_acl_from_mode
set_acls
chmod_or_fchmod
set_permissions
   1 /* Set permissions of a file.  -*- coding: utf-8 -*-
   2 
   3    Copyright (C) 2002-2003, 2005-2021 Free Software Foundation, Inc.
   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 3 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    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <https://www.gnu.org/licenses/>.
  17 
  18    Written by Paul Eggert, Andreas Grünbacher, and Bruno Haible.  */
  19 
  20 #include <config.h>
  21 
  22 #include "acl.h"
  23 
  24 #include "acl-internal.h"
  25 
  26 #if USE_ACL
  27 # if ! defined HAVE_ACL_FROM_MODE && defined HAVE_ACL_FROM_TEXT /* FreeBSD, IRIX, Tru64, Cygwin >= 2.5 */
  28 #  if HAVE_ACL_GET_FILE && !HAVE_ACL_TYPE_EXTENDED
  29 
  30 static acl_t
  31 acl_from_mode (mode_t mode)
     /*  */
  32 {
  33 #  if HAVE_ACL_FREE_TEXT /* Tru64 */
  34   char acl_text[] = "u::---,g::---,o::---,";
  35 #  else /* FreeBSD, IRIX, Cygwin >= 2.5 */
  36   char acl_text[] = "u::---,g::---,o::---";
  37 #  endif
  38 
  39   if (mode & S_IRUSR) acl_text[ 3] = 'r';
  40   if (mode & S_IWUSR) acl_text[ 4] = 'w';
  41   if (mode & S_IXUSR) acl_text[ 5] = 'x';
  42   if (mode & S_IRGRP) acl_text[10] = 'r';
  43   if (mode & S_IWGRP) acl_text[11] = 'w';
  44   if (mode & S_IXGRP) acl_text[12] = 'x';
  45   if (mode & S_IROTH) acl_text[17] = 'r';
  46   if (mode & S_IWOTH) acl_text[18] = 'w';
  47   if (mode & S_IXOTH) acl_text[19] = 'x';
  48 
  49   return acl_from_text (acl_text);
  50 }
  51 #  endif
  52 # endif
  53 
  54 # if HAVE_FACL && defined GETACL /* Solaris, Cygwin < 2.5, not HP-UX */
  55 static int
  56 set_acls_from_mode (const char *name, int desc, mode_t mode, bool *must_chmod)
     /*  */
  57 {
  58 #  ifdef ACE_GETACL
  59   /* Solaris also has a different variant of ACLs, used in ZFS and NFSv4
  60      file systems (whereas the other ones are used in UFS file systems).  */
  61 
  62   /* The flags in the ace_t structure changed in a binary incompatible way
  63      when ACL_NO_TRIVIAL etc. were introduced in <sys/acl.h> version 1.15.
  64      How to distinguish the two conventions at runtime?
  65      We fetch the existing ACL.  In the old convention, usually three ACEs have
  66      a_flags = ACE_OWNER / ACE_GROUP / ACE_OTHER, in the range 0x0100..0x0400.
  67      In the new convention, these values are not used.  */
  68   int convention;
  69 
  70   {
  71     /* Initially, try to read the entries into a stack-allocated buffer.
  72        Use malloc if it does not fit.  */
  73     enum
  74       {
  75         alloc_init = 4000 / sizeof (ace_t), /* >= 3 */
  76         alloc_max = MIN (INT_MAX, SIZE_MAX / sizeof (ace_t))
  77       };
  78     ace_t buf[alloc_init];
  79     size_t alloc = alloc_init;
  80     ace_t *entries = buf;
  81     ace_t *malloced = NULL;
  82     int count;
  83 
  84     for (;;)
  85       {
  86         count = (desc != -1
  87                  ? facl (desc, ACE_GETACL, alloc, entries)
  88                  : acl (name, ACE_GETACL, alloc, entries));
  89         if (count < 0 && errno == ENOSPC)
  90           {
  91             /* Increase the size of the buffer.  */
  92             free (malloced);
  93             if (alloc > alloc_max / 2)
  94               {
  95                 errno = ENOMEM;
  96                 return -1;
  97               }
  98             alloc = 2 * alloc; /* <= alloc_max */
  99             entries = malloced = (ace_t *) malloc (alloc * sizeof (ace_t));
 100             if (entries == NULL)
 101               {
 102                 errno = ENOMEM;
 103                 return -1;
 104               }
 105             continue;
 106           }
 107         break;
 108       }
 109 
 110     if (count <= 0)
 111       convention = -1;
 112     else
 113       {
 114         int i;
 115 
 116         convention = 0;
 117         for (i = 0; i < count; i++)
 118           if (entries[i].a_flags & (OLD_ACE_OWNER | OLD_ACE_GROUP | OLD_ACE_OTHER))
 119             {
 120               convention = 1;
 121               break;
 122             }
 123       }
 124     free (malloced);
 125   }
 126 
 127   if (convention >= 0)
 128     {
 129       ace_t entries[6];
 130       int count;
 131       int ret;
 132 
 133       if (convention)
 134         {
 135           /* Running on Solaris 10.  */
 136           entries[0].a_type = OLD_ALLOW;
 137           entries[0].a_flags = OLD_ACE_OWNER;
 138           entries[0].a_who = 0; /* irrelevant */
 139           entries[0].a_access_mask = (mode >> 6) & 7;
 140           entries[1].a_type = OLD_ALLOW;
 141           entries[1].a_flags = OLD_ACE_GROUP;
 142           entries[1].a_who = 0; /* irrelevant */
 143           entries[1].a_access_mask = (mode >> 3) & 7;
 144           entries[2].a_type = OLD_ALLOW;
 145           entries[2].a_flags = OLD_ACE_OTHER;
 146           entries[2].a_who = 0;
 147           entries[2].a_access_mask = mode & 7;
 148           count = 3;
 149         }
 150       else
 151         {
 152           /* Running on Solaris 10 (newer version) or Solaris 11.
 153              The details here were found through "/bin/ls -lvd somefiles".  */
 154           entries[0].a_type = NEW_ACE_ACCESS_DENIED_ACE_TYPE;
 155           entries[0].a_flags = NEW_ACE_OWNER;
 156           entries[0].a_who = 0; /* irrelevant */
 157           entries[0].a_access_mask = 0;
 158           entries[1].a_type = NEW_ACE_ACCESS_ALLOWED_ACE_TYPE;
 159           entries[1].a_flags = NEW_ACE_OWNER;
 160           entries[1].a_who = 0; /* irrelevant */
 161           entries[1].a_access_mask = NEW_ACE_WRITE_NAMED_ATTRS
 162                                      | NEW_ACE_WRITE_ATTRIBUTES
 163                                      | NEW_ACE_WRITE_ACL
 164                                      | NEW_ACE_WRITE_OWNER;
 165           if (mode & 0400)
 166             entries[1].a_access_mask |= NEW_ACE_READ_DATA;
 167           else
 168             entries[0].a_access_mask |= NEW_ACE_READ_DATA;
 169           if (mode & 0200)
 170             entries[1].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
 171           else
 172             entries[0].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
 173           if (mode & 0100)
 174             entries[1].a_access_mask |= NEW_ACE_EXECUTE;
 175           else
 176             entries[0].a_access_mask |= NEW_ACE_EXECUTE;
 177           entries[2].a_type = NEW_ACE_ACCESS_DENIED_ACE_TYPE;
 178           entries[2].a_flags = NEW_ACE_GROUP | NEW_ACE_IDENTIFIER_GROUP;
 179           entries[2].a_who = 0; /* irrelevant */
 180           entries[2].a_access_mask = 0;
 181           entries[3].a_type = NEW_ACE_ACCESS_ALLOWED_ACE_TYPE;
 182           entries[3].a_flags = NEW_ACE_GROUP | NEW_ACE_IDENTIFIER_GROUP;
 183           entries[3].a_who = 0; /* irrelevant */
 184           entries[3].a_access_mask = 0;
 185           if (mode & 0040)
 186             entries[3].a_access_mask |= NEW_ACE_READ_DATA;
 187           else
 188             entries[2].a_access_mask |= NEW_ACE_READ_DATA;
 189           if (mode & 0020)
 190             entries[3].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
 191           else
 192             entries[2].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
 193           if (mode & 0010)
 194             entries[3].a_access_mask |= NEW_ACE_EXECUTE;
 195           else
 196             entries[2].a_access_mask |= NEW_ACE_EXECUTE;
 197           entries[4].a_type = NEW_ACE_ACCESS_DENIED_ACE_TYPE;
 198           entries[4].a_flags = NEW_ACE_EVERYONE;
 199           entries[4].a_who = 0;
 200           entries[4].a_access_mask = NEW_ACE_WRITE_NAMED_ATTRS
 201                                      | NEW_ACE_WRITE_ATTRIBUTES
 202                                      | NEW_ACE_WRITE_ACL
 203                                      | NEW_ACE_WRITE_OWNER;
 204           entries[5].a_type = NEW_ACE_ACCESS_ALLOWED_ACE_TYPE;
 205           entries[5].a_flags = NEW_ACE_EVERYONE;
 206           entries[5].a_who = 0;
 207           entries[5].a_access_mask = NEW_ACE_READ_NAMED_ATTRS
 208                                      | NEW_ACE_READ_ATTRIBUTES
 209                                      | NEW_ACE_READ_ACL
 210                                      | NEW_ACE_SYNCHRONIZE;
 211           if (mode & 0004)
 212             entries[5].a_access_mask |= NEW_ACE_READ_DATA;
 213           else
 214             entries[4].a_access_mask |= NEW_ACE_READ_DATA;
 215           if (mode & 0002)
 216             entries[5].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
 217           else
 218             entries[4].a_access_mask |= NEW_ACE_WRITE_DATA | NEW_ACE_APPEND_DATA;
 219           if (mode & 0001)
 220             entries[5].a_access_mask |= NEW_ACE_EXECUTE;
 221           else
 222             entries[4].a_access_mask |= NEW_ACE_EXECUTE;
 223           count = 6;
 224         }
 225       if (desc != -1)
 226         ret = facl (desc, ACE_SETACL, count, entries);
 227       else
 228         ret = acl (name, ACE_SETACL, count, entries);
 229       if (ret < 0 && errno != EINVAL && errno != ENOTSUP)
 230         {
 231           if (errno == ENOSYS)
 232             {
 233               *must_chmod = true;
 234               return 0;
 235             }
 236           return -1;
 237         }
 238       if (ret == 0)
 239         return 0;
 240     }
 241 #  endif
 242 
 243   {
 244     aclent_t entries[3];
 245     int ret;
 246 
 247     entries[0].a_type = USER_OBJ;
 248     entries[0].a_id = 0; /* irrelevant */
 249     entries[0].a_perm = (mode >> 6) & 7;
 250     entries[1].a_type = GROUP_OBJ;
 251     entries[1].a_id = 0; /* irrelevant */
 252     entries[1].a_perm = (mode >> 3) & 7;
 253     entries[2].a_type = OTHER_OBJ;
 254     entries[2].a_id = 0;
 255     entries[2].a_perm = mode & 7;
 256 
 257     if (desc != -1)
 258       ret = facl (desc, SETACL,
 259                   sizeof (entries) / sizeof (aclent_t), entries);
 260     else
 261       ret = acl (name, SETACL,
 262                  sizeof (entries) / sizeof (aclent_t), entries);
 263     if (ret < 0)
 264       {
 265         if (errno == ENOSYS || errno == EOPNOTSUPP)
 266           {
 267             *must_chmod = true;
 268             return 0;
 269           }
 270         return -1;
 271       }
 272     return 0;
 273   }
 274 }
 275 
 276 # elif HAVE_GETACL /* HP-UX */
 277 static int
 278 context_acl_from_mode (struct permission_context *ctx, const char *name, int desc)
     /*  */
 279 {
 280   struct stat statbuf;
 281   int ret;
 282 
 283   if (desc != -1)
 284     ret = fstat (desc, &statbuf);
 285   else
 286     ret = stat (name, &statbuf);
 287   if (ret < 0)
 288     return -1;
 289 
 290   ctx->entries[0].uid = statbuf.st_uid;
 291   ctx->entries[0].gid = ACL_NSGROUP;
 292   ctx->entries[0].mode = (ctx->mode >> 6) & 7;
 293   ctx->entries[1].uid = ACL_NSUSER;
 294   ctx->entries[1].gid = statbuf.st_gid;
 295   ctx->entries[1].mode = (ctx->mode >> 3) & 7;
 296   ctx->entries[2].uid = ACL_NSUSER;
 297   ctx->entries[2].gid = ACL_NSGROUP;
 298   ctx->entries[2].mode = ctx->mode & 7;
 299   ctx->count = 3;
 300   return 0;
 301 }
 302 
 303 #  if HAVE_ACLV_H /* HP-UX >= 11.11 */
 304 static int
 305 context_aclv_from_mode (struct permission_context *ctx)
     /*  */
 306 {
 307   int ret;
 308 
 309   ctx->aclv_entries[0].a_type = USER_OBJ;
 310   ctx->aclv_entries[0].a_id = 0; /* irrelevant */
 311   ctx->aclv_entries[0].a_perm = (ctx->mode >> 6) & 7;
 312   ctx->aclv_entries[1].a_type = GROUP_OBJ;
 313   ctx->aclv_entries[1].a_id = 0; /* irrelevant */
 314   ctx->aclv_entries[1].a_perm = (ctx->mode >> 3) & 7;
 315   ctx->aclv_entries[2].a_type = CLASS_OBJ;
 316   ctx->aclv_entries[2].a_id = 0;
 317   ctx->aclv_entries[2].a_perm = (ctx->mode >> 3) & 7;
 318   ctx->aclv_entries[3].a_type = OTHER_OBJ;
 319   ctx->aclv_entries[3].a_id = 0;
 320   ctx->aclv_entries[3].a_perm = ctx->mode & 7;
 321   ctx->aclv_count = 4;
 322 
 323   ret = aclsort (ctx->aclv_count, 1, ctx->aclv_entries);
 324   if (ret > 0)
 325     abort ();
 326   return ret;
 327 }
 328 #  endif
 329 
 330 # elif HAVE_ACLX_GET && defined ACL_AIX_WIP /* AIX */
 331 static int
 332 set_acls_from_mode (const char *name, int desc, mode_t mode, bool *must_chmod)
     /*  */
 333 {
 334   acl_type_list_t types;
 335   size_t types_size = sizeof (types);
 336   acl_type_t type;
 337 
 338   if (aclx_gettypes (name, &types, &types_size) < 0
 339       || types.num_entries == 0)
 340     {
 341       *must_chmod = true;
 342       return 0;
 343     }
 344 
 345   /* XXX Do we need to clear all types of ACLs for the given file, or is it
 346      sufficient to clear the first one?  */
 347   type = types.entries[0];
 348   if (type.u64 == ACL_AIXC)
 349     {
 350       union { struct acl a; char room[128]; } u;
 351       int ret;
 352 
 353       u.a.acl_len = (char *) &u.a.acl_ext[0] - (char *) &u.a; /* no entries */
 354       u.a.acl_mode = mode & ~(S_IXACL | 0777);
 355       u.a.u_access = (mode >> 6) & 7;
 356       u.a.g_access = (mode >> 3) & 7;
 357       u.a.o_access = mode & 7;
 358 
 359       if (desc != -1)
 360         ret = aclx_fput (desc, SET_ACL | SET_MODE_S_BITS,
 361                          type, &u.a, u.a.acl_len, mode);
 362       else
 363         ret = aclx_put (name, SET_ACL | SET_MODE_S_BITS,
 364                         type, &u.a, u.a.acl_len, mode);
 365       if (!(ret < 0 && errno == ENOSYS))
 366         return ret;
 367     }
 368   else if (type.u64 == ACL_NFS4)
 369     {
 370       union { nfs4_acl_int_t a; char room[128]; } u;
 371       nfs4_ace_int_t *ace;
 372       int ret;
 373 
 374       u.a.aclVersion = NFS4_ACL_INT_STRUCT_VERSION;
 375       u.a.aclEntryN = 0;
 376       ace = &u.a.aclEntry[0];
 377       {
 378         ace->flags = ACE4_ID_SPECIAL;
 379         ace->aceWho.special_whoid = ACE4_WHO_OWNER;
 380         ace->aceType = ACE4_ACCESS_ALLOWED_ACE_TYPE;
 381         ace->aceFlags = 0;
 382         ace->aceMask =
 383           (mode & 0400 ? ACE4_READ_DATA | ACE4_LIST_DIRECTORY : 0)
 384           | (mode & 0200
 385              ? ACE4_WRITE_DATA | ACE4_ADD_FILE | ACE4_APPEND_DATA
 386                | ACE4_ADD_SUBDIRECTORY
 387              : 0)
 388           | (mode & 0100 ? ACE4_EXECUTE : 0);
 389         ace->aceWhoString[0] = '\0';
 390         ace->entryLen = (char *) &ace->aceWhoString[4] - (char *) ace;
 391         ace = (nfs4_ace_int_t *) (char *) &ace->aceWhoString[4];
 392         u.a.aclEntryN++;
 393       }
 394       {
 395         ace->flags = ACE4_ID_SPECIAL;
 396         ace->aceWho.special_whoid = ACE4_WHO_GROUP;
 397         ace->aceType = ACE4_ACCESS_ALLOWED_ACE_TYPE;
 398         ace->aceFlags = 0;
 399         ace->aceMask =
 400           (mode & 0040 ? ACE4_READ_DATA | ACE4_LIST_DIRECTORY : 0)
 401           | (mode & 0020
 402              ? ACE4_WRITE_DATA | ACE4_ADD_FILE | ACE4_APPEND_DATA
 403                | ACE4_ADD_SUBDIRECTORY
 404              : 0)
 405           | (mode & 0010 ? ACE4_EXECUTE : 0);
 406         ace->aceWhoString[0] = '\0';
 407         ace->entryLen = (char *) &ace->aceWhoString[4] - (char *) ace;
 408         ace = (nfs4_ace_int_t *) (char *) &ace->aceWhoString[4];
 409         u.a.aclEntryN++;
 410       }
 411       {
 412         ace->flags = ACE4_ID_SPECIAL;
 413         ace->aceWho.special_whoid = ACE4_WHO_EVERYONE;
 414         ace->aceType = ACE4_ACCESS_ALLOWED_ACE_TYPE;
 415         ace->aceFlags = 0;
 416         ace->aceMask =
 417           (mode & 0004 ? ACE4_READ_DATA | ACE4_LIST_DIRECTORY : 0)
 418           | (mode & 0002
 419              ? ACE4_WRITE_DATA | ACE4_ADD_FILE | ACE4_APPEND_DATA
 420                | ACE4_ADD_SUBDIRECTORY
 421              : 0)
 422           | (mode & 0001 ? ACE4_EXECUTE : 0);
 423         ace->aceWhoString[0] = '\0';
 424         ace->entryLen = (char *) &ace->aceWhoString[4] - (char *) ace;
 425         ace = (nfs4_ace_int_t *) (char *) &ace->aceWhoString[4];
 426         u.a.aclEntryN++;
 427       }
 428       u.a.aclLength = (char *) ace - (char *) &u.a;
 429 
 430       if (desc != -1)
 431         ret = aclx_fput (desc, SET_ACL | SET_MODE_S_BITS,
 432                          type, &u.a, u.a.aclLength, mode);
 433       else
 434         ret = aclx_put (name, SET_ACL | SET_MODE_S_BITS,
 435                         type, &u.a, u.a.aclLength, mode);
 436       if (!(ret < 0 && errno == ENOSYS))
 437         return ret;
 438     }
 439 
 440   *must_chmod = true;
 441   return 0;
 442 }
 443 
 444 # elif HAVE_STATACL /* older AIX */
 445 static int
 446 context_acl_from_mode (struct permission_context *ctx)
     /*  */
 447 {
 448   ctx->u.a.acl_len = (char *) &ctx->u.a.acl_ext[0] - (char *) &ctx->u.a; /* no entries */
 449   ctx->u.a.acl_mode = ctx->mode & ~(S_IXACL | 0777);
 450   ctx->u.a.u_access = (ctx->mode >> 6) & 7;
 451   ctx->u.a.g_access = (ctx->mode >> 3) & 7;
 452   ctx->u.a.o_access = ctx->mode & 7;
 453   ctx->have_u = true;
 454   return 0;
 455 }
 456 
 457 # elif HAVE_ACLSORT /* NonStop Kernel */
 458 static int
 459 context_acl_from_mode (struct permission_context *ctx)
     /*  */
 460 {
 461   int ret;
 462 
 463   ctx->entries[0].a_type = USER_OBJ;
 464   ctx->entries[0].a_id = 0; /* irrelevant */
 465   ctx->entries[0].a_perm = (ctx->mode >> 6) & 7;
 466   ctx->entries[1].a_type = GROUP_OBJ;
 467   ctx->entries[1].a_id = 0; /* irrelevant */
 468   ctx->entries[1].a_perm = (ctx->mode >> 3) & 7;
 469   ctx->entries[2].a_type = CLASS_OBJ;
 470   ctx->entries[2].a_id = 0;
 471   ctx->entries[2].a_perm = (ctx->mode >> 3) & 7;
 472   ctx->entries[3].a_type = OTHER_OBJ;
 473   ctx->entries[3].a_id = 0;
 474   ctx->entries[3].a_perm = ctx->mode & 7;
 475   ctx->count = 4;
 476 
 477   ret = aclsort (ctx->count, 1, entries);
 478   if (ret > 0)
 479     abort ();
 480   return ret;
 481 }
 482 # endif
 483 
 484 static int
 485 set_acls (struct permission_context *ctx, const char *name, int desc,
     /*  */
 486           int from_mode, bool *must_chmod, bool *acls_set)
 487 {
 488   int ret = 0;
 489 
 490 # if HAVE_ACL_GET_FILE
 491   /* POSIX 1003.1e (draft 17 -- abandoned) specific version.  */
 492   /* Linux, FreeBSD, Mac OS X, IRIX, Tru64, Cygwin >= 2.5 */
 493 #  if !HAVE_ACL_TYPE_EXTENDED
 494   /* Linux, FreeBSD, IRIX, Tru64, Cygwin >= 2.5 */
 495 
 496 #   ifndef HAVE_ACL_FROM_TEXT
 497 #    error Must have acl_from_text (see POSIX 1003.1e draft 17).
 498 #   endif
 499 #   ifndef HAVE_ACL_DELETE_DEF_FILE
 500 #    error Must have acl_delete_def_file (see POSIX 1003.1e draft 17).
 501 #   endif
 502 
 503   if (! ctx->acls_not_supported)
 504     {
 505       if (ret == 0 && from_mode)
 506         {
 507           if (ctx->acl)
 508             acl_free (ctx->acl);
 509           ctx->acl = acl_from_mode (ctx->mode);
 510           if (ctx->acl == NULL)
 511             ret = -1;
 512         }
 513 
 514       if (ret == 0 && ctx->acl)
 515         {
 516           if (HAVE_ACL_SET_FD && desc != -1)
 517             ret = acl_set_fd (desc, ctx->acl);
 518           else
 519             ret = acl_set_file (name, ACL_TYPE_ACCESS, ctx->acl);
 520           if (ret != 0)
 521             {
 522               if (! acl_errno_valid (errno))
 523                 {
 524                   ctx->acls_not_supported = true;
 525                   if (from_mode || acl_access_nontrivial (ctx->acl) == 0)
 526                     ret = 0;
 527                 }
 528             }
 529           else
 530             {
 531               *acls_set = true;
 532               if (S_ISDIR(ctx->mode))
 533                 {
 534                   if (! from_mode && ctx->default_acl &&
 535                       acl_default_nontrivial (ctx->default_acl))
 536                     ret = acl_set_file (name, ACL_TYPE_DEFAULT,
 537                                         ctx->default_acl);
 538                   else
 539                     ret = acl_delete_def_file (name);
 540                 }
 541             }
 542         }
 543     }
 544 
 545 #   if HAVE_ACL_TYPE_NFS4  /* FreeBSD */
 546 
 547   /* File systems either support POSIX ACLs (for example, ufs) or NFS4 ACLs
 548      (for example, zfs). */
 549 
 550   /* TODO: Implement setting ACLs once get_permissions() reads them. */
 551 
 552 #   endif
 553 
 554 #  else /* HAVE_ACL_TYPE_EXTENDED */
 555   /* Mac OS X */
 556 
 557   /* On Mac OS X,  acl_get_file (name, ACL_TYPE_ACCESS)
 558      and           acl_get_file (name, ACL_TYPE_DEFAULT)
 559      always return NULL / EINVAL.  You have to use
 560                    acl_get_file (name, ACL_TYPE_EXTENDED)
 561      or            acl_get_fd (open (name, ...))
 562      to retrieve an ACL.
 563      On the other hand,
 564                    acl_set_file (name, ACL_TYPE_ACCESS, acl)
 565      and           acl_set_file (name, ACL_TYPE_DEFAULT, acl)
 566      have the same effect as
 567                    acl_set_file (name, ACL_TYPE_EXTENDED, acl):
 568      Each of these calls sets the file's ACL.  */
 569 
 570   if (ctx->acl == NULL)
 571     {
 572       acl_t acl;
 573 
 574       /* Remove ACLs if the file has ACLs.  */
 575       if (HAVE_ACL_GET_FD && desc != -1)
 576         acl = acl_get_fd (desc);
 577       else
 578         acl = acl_get_file (name, ACL_TYPE_EXTENDED);
 579       if (acl)
 580         {
 581           acl_free (acl);
 582 
 583           acl = acl_init (0);
 584           if (acl)
 585             {
 586               if (HAVE_ACL_SET_FD && desc != -1)
 587                 ret = acl_set_fd (desc, acl);
 588               else
 589                 ret = acl_set_file (name, ACL_TYPE_EXTENDED, acl);
 590               acl_free (acl);
 591             }
 592           else
 593             ret = -1;
 594         }
 595     }
 596   else
 597     {
 598       if (HAVE_ACL_SET_FD && desc != -1)
 599         ret = acl_set_fd (desc, ctx->acl);
 600       else
 601         ret = acl_set_file (name, ACL_TYPE_EXTENDED, ctx->acl);
 602       if (ret != 0)
 603         {
 604           if (! acl_errno_valid (errno)
 605               && ! acl_extended_nontrivial (ctx->acl))
 606             ret = 0;
 607         }
 608     }
 609   *acls_set = true;
 610 
 611 #  endif
 612 
 613 # elif defined GETACL /* Solaris, Cygwin, not HP-UX */
 614 
 615   /* Solaris 2.5 through Solaris 10, Cygwin, and contemporaneous versions
 616      of Unixware.  The acl() call returns the access and default ACL both
 617      at once.  */
 618 
 619   /* If both ace_entries and entries are available, try SETACL before
 620      ACE_SETACL, because SETACL cannot fail with ENOTSUP whereas ACE_SETACL
 621      can.  */
 622 
 623   if (from_mode)
 624     return set_acls_from_mode (name, desc, ctx->mode, must_chmod);
 625 
 626   if (ret == 0 && ctx->count)
 627     {
 628       if (desc != -1)
 629         ret = facl (desc, SETACL, ctx->count, ctx->entries);
 630       else
 631         ret = acl (name, SETACL, ctx->count, ctx->entries);
 632       if (ret < 0)
 633         {
 634           if ((errno == ENOSYS || errno == EOPNOTSUPP || errno == EINVAL)
 635               && acl_nontrivial (ctx->count, ctx->entries) == 0)
 636             ret = 0;
 637         }
 638       else
 639         *acls_set = true;
 640     }
 641 
 642 #  ifdef ACE_GETACL
 643   if (ret == 0 && ctx->ace_count)
 644     {
 645       if (desc != -1)
 646         ret = facl (desc, ACE_SETACL, ctx->ace_count, ctx->ace_entries);
 647       else
 648         ret = acl (name, ACE_SETACL, ctx->ace_count, ctx->ace_entries);
 649       if (ret < 0)
 650         {
 651           if ((errno == ENOSYS || errno == EINVAL || errno == ENOTSUP)
 652               && acl_ace_nontrivial (ctx->ace_count, ctx->ace_entries) == 0)
 653             ret = 0;
 654         }
 655       else
 656         *acls_set = true;
 657     }
 658 #  endif
 659 
 660 # elif HAVE_GETACL /* HP-UX */
 661 
 662   if (from_mode)
 663     ret = context_acl_from_mode (ctx, name, desc);
 664 
 665   if (ret == 0 && ctx->count > 0)
 666     {
 667       if (desc != -1)
 668         ret = fsetacl (desc, ctx->count, ctx->entries);
 669       else
 670         ret = setacl (name, ctx->count, ctx->entries);
 671       if (ret < 0)
 672         {
 673           if ((errno == ENOSYS || errno == EOPNOTSUPP || errno == ENOTSUP)
 674               && (from_mode || !acl_nontrivial (ctx->count, ctx->entries)))
 675             ret = 0;
 676         }
 677       else
 678         *acls_set = true;
 679     }
 680 
 681 #  if HAVE_ACLV_H
 682   if (from_mode)
 683     ret = context_aclv_from_mode (ctx);
 684 
 685   if (ret == 0 && ctx->aclv_count > 0)
 686     {
 687       ret = acl ((char *) name, ACL_SET, ctx->aclv_count, ctx->aclv_entries);
 688       if (ret < 0)
 689         {
 690           if ((errno == ENOSYS || errno == EOPNOTSUPP || errno == EINVAL)
 691               && (from_mode || !aclv_nontrivial (ctx->aclv_count, ctx->aclv_entries)))
 692             ret = 0;
 693         }
 694       else
 695         *acls_set = true;
 696     }
 697 #  endif
 698 
 699 # elif HAVE_ACLX_GET && ACL_AIX_WIP /* AIX */
 700 
 701   /* TODO: Implement setting ACLs once get_permissions() reads them. */
 702 
 703   if (from_mode)
 704     ret = set_acls_from_mode (name, desc, mode, must_chmod);
 705 
 706 # elif HAVE_STATACL /* older AIX */
 707 
 708   if (from_mode)
 709     ret = context_acl_from_mode (ctx);
 710 
 711   if (ret == 0 && ctx->have_u)
 712     {
 713       if (desc != -1)
 714         ret = fchacl (desc, &ctx->u.a, ctx->u.a.acl_len);
 715       else
 716         ret = chacl ((char *) name, &ctx->u.a, ctx->u.a.acl_len);
 717       if (ret < 0)
 718         {
 719           if (errno == ENOSYS && from_mode)
 720             ret = 0;
 721         }
 722       else
 723         *acls_set = true;
 724     }
 725 
 726 # elif HAVE_ACLSORT /* NonStop Kernel */
 727 
 728   if (from_mode)
 729     ret = context_acl_from_mode (ctx);
 730 
 731   if (ret == 0 && ctx->count)
 732     {
 733       ret = acl ((char *) name, ACL_SET, ctx->count, ctx->entries);
 734       if (ret != 0)
 735         {
 736           if (!acl_nontrivial (ctx->count, ctx->entries))
 737             ret = 0;
 738         }
 739       else
 740         *acls_set = true;
 741     }
 742 
 743 # else  /* No ACLs */
 744 
 745   /* Nothing to do. */
 746 
 747 # endif
 748 
 749   return ret;
 750 }
 751 #endif
 752 
 753 /* If DESC is a valid file descriptor use fchmod to change the
 754    file's mode to MODE on systems that have fchmod. On systems
 755    that don't have fchmod and if DESC is invalid, use chmod on
 756    NAME instead.
 757    Return 0 if successful.  Return -1 and set errno upon failure.  */
 758 
 759 int
 760 chmod_or_fchmod (const char *name, int desc, mode_t mode)
     /*  */
 761 {
 762   if (HAVE_FCHMOD && desc != -1)
 763     return fchmod (desc, mode);
 764   else
 765     return chmod (name, mode);
 766 }
 767 
 768 /* Set the permissions in CTX on a file. If DESC is a valid file descriptor,
 769    use file descriptor operations, else use filename based operations on NAME.
 770    If access control lists are not available, fchmod the target file to the
 771    mode in CTX.  Also sets the non-permission bits of the destination file
 772    (S_ISUID, S_ISGID, S_ISVTX) to those from the mode in CTX if any are set.
 773    Return 0 if successful.  Return -1 and set errno upon failure.  */
 774 
 775 int
 776 set_permissions (struct permission_context *ctx, const char *name, int desc)
     /*  */
 777 {
 778   _GL_UNUSED bool acls_set = false;
 779   bool early_chmod;
 780   bool must_chmod = false;
 781   int ret = 0;
 782 
 783 #if USE_ACL
 784 # if HAVE_STATACL
 785   /* older AIX */
 786   /* There is no need to call chmod_or_fchmod, since the mode
 787      bits S_ISUID, S_ISGID, S_ISVTX are also stored in the ACL.  */
 788 
 789   early_chmod = false;
 790 # else
 791   /* All other platforms */
 792   /* On Cygwin, it is necessary to call chmod before acl, because
 793      chmod can change the contents of the ACL (in ways that don't
 794      change the allowed accesses, but still visible).  */
 795 
 796   early_chmod = (! MODE_INSIDE_ACL || (ctx->mode & (S_ISUID | S_ISGID | S_ISVTX)));
 797 # endif
 798 #else
 799   /* No ACLs */
 800 
 801   early_chmod = true;
 802 #endif
 803 
 804   if (early_chmod)
 805     {
 806       ret = chmod_or_fchmod (name, desc, ctx->mode);
 807       if (ret != 0)
 808         return -1;
 809     }
 810 
 811 #if USE_ACL
 812   ret = set_acls (ctx, name, desc, false, &must_chmod, &acls_set);
 813   if (! acls_set)
 814     {
 815       int saved_errno = ret ? errno : 0;
 816 
 817       /* If we can't set an acl which we expect to be able to set, try setting
 818          the permissions to ctx->mode. Due to possible inherited permissions,
 819          we cannot simply chmod.  */
 820 
 821       ret = set_acls (ctx, name, desc, true, &must_chmod, &acls_set);
 822       if (! acls_set)
 823         must_chmod = true;
 824 
 825       if (saved_errno)
 826         {
 827           errno = saved_errno;
 828           ret = -1;
 829         }
 830     }
 831 #endif
 832 
 833   if (must_chmod && ! early_chmod)
 834     {
 835       int saved_errno = ret ? errno : 0;
 836 
 837       ret = chmod_or_fchmod (name, desc, ctx->mode);
 838 
 839       if (saved_errno)
 840         {
 841           errno = saved_errno;
 842           ret = -1;
 843         }
 844     }
 845 
 846   return ret;
 847 }
/* */
root/maint/gnulib/lib/set-permissions.c

DEFINITIONS
