lib/qcopy-acl.c

   1 /* copy-acl.c - copy access control list from one file to another file
   2
   3    Copyright (C) 2002-2003, 2005-2015 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 <http://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
  27 /* Copy access control lists from one file to another. If SOURCE_DESC is
  28    a valid file descriptor, use file descriptor operations, else use
  29    filename based operations on SRC_NAME. Likewise for DEST_DESC and
  30    DST_NAME.
  31    If access control lists are not available, fchmod the target file to
  32    MODE.  Also sets the non-permission bits of the destination file
  33    (S_ISUID, S_ISGID, S_ISVTX) to those from MODE if any are set.
  34    Return 0 if successful.
  35    Return -2 and set errno for an error relating to the source file.
  36    Return -1 and set errno for an error relating to the destination file.  */
  37
  38 int
  39 qcopy_acl (const char *src_name, int source_desc, const char *dst_name,
  40            int dest_desc, mode_t mode)
  41 {
  42 #if USE_ACL && HAVE_ACL_GET_FILE
  43   /* POSIX 1003.1e (draft 17 -- abandoned) specific version.  */
  44   /* Linux, FreeBSD, Mac OS X, IRIX, Tru64 */
  45 # if !HAVE_ACL_TYPE_EXTENDED
  46   /* Linux, FreeBSD, IRIX, Tru64 */
  47
  48   acl_t acl;
  49   int ret;
  50
  51   if (HAVE_ACL_GET_FD && source_desc != -1)
  52     acl = acl_get_fd (source_desc);
  53   else
  54     acl = acl_get_file (src_name, ACL_TYPE_ACCESS);
  55   if (acl == NULL)
  56     {
  57       if (! acl_errno_valid (errno))
  58         return qset_acl (dst_name, dest_desc, mode);
  59       else
  60         return -2;
  61     }
  62
  63   if (HAVE_ACL_SET_FD && dest_desc != -1)
  64     ret = acl_set_fd (dest_desc, acl);
  65   else
  66     ret = acl_set_file (dst_name, ACL_TYPE_ACCESS, acl);
  67   if (ret != 0)
  68     {
  69       int saved_errno = errno;
  70
  71       if (! acl_errno_valid (errno) && !acl_access_nontrivial (acl))
  72         {
  73           acl_free (acl);
  74           return chmod_or_fchmod (dst_name, dest_desc, mode);
  75         }
  76       else
  77         {
  78           acl_free (acl);
  79           chmod_or_fchmod (dst_name, dest_desc, mode);
  80           errno = saved_errno;
  81           return -1;
  82         }
  83     }
  84   else
  85     acl_free (acl);
  86
  87   if (!MODE_INSIDE_ACL || (mode & (S_ISUID | S_ISGID | S_ISVTX)))
  88     {
  89       /* We did not call chmod so far, and either the mode and the ACL are
  90          separate or special bits are to be set which don't fit into ACLs.  */
  91
  92       if (chmod_or_fchmod (dst_name, dest_desc, mode) != 0)
  93         return -1;
  94     }
  95
  96   if (S_ISDIR (mode))
  97     {
  98       acl = acl_get_file (src_name, ACL_TYPE_DEFAULT);
  99       if (acl == NULL)
 100         return -2;
 101
 102       if (acl_set_file (dst_name, ACL_TYPE_DEFAULT, acl))
 103         {
 104           int saved_errno = errno;
 105
 106           acl_free (acl);
 107           errno = saved_errno;
 108           return -1;
 109         }
 110       else
 111         acl_free (acl);
 112     }
 113   return 0;
 114
 115 # else /* HAVE_ACL_TYPE_EXTENDED */
 116   /* Mac OS X */
 117
 118   /* On Mac OS X,  acl_get_file (name, ACL_TYPE_ACCESS)
 119      and           acl_get_file (name, ACL_TYPE_DEFAULT)
 120      always return NULL / EINVAL.  You have to use
 121                    acl_get_file (name, ACL_TYPE_EXTENDED)
 122      or            acl_get_fd (open (name, ...))
 123      to retrieve an ACL.
 124      On the other hand,
 125                    acl_set_file (name, ACL_TYPE_ACCESS, acl)
 126      and           acl_set_file (name, ACL_TYPE_DEFAULT, acl)
 127      have the same effect as
 128                    acl_set_file (name, ACL_TYPE_EXTENDED, acl):
 129      Each of these calls sets the file's ACL.  */
 130
 131   acl_t acl;
 132   int ret;
 133
 134   if (HAVE_ACL_GET_FD && source_desc != -1)
 135     acl = acl_get_fd (source_desc);
 136   else
 137     acl = acl_get_file (src_name, ACL_TYPE_EXTENDED);
 138   if (acl == NULL)
 139     {
 140       if (!acl_errno_valid (errno))
 141         return qset_acl (dst_name, dest_desc, mode);
 142       else
 143         return -2;
 144     }
 145
 146   if (HAVE_ACL_SET_FD && dest_desc != -1)
 147     ret = acl_set_fd (dest_desc, acl);
 148   else
 149     ret = acl_set_file (dst_name, ACL_TYPE_EXTENDED, acl);
 150   if (ret != 0)
 151     {
 152       int saved_errno = errno;
 153
 154       if (!acl_errno_valid (saved_errno) && !acl_extended_nontrivial (acl))
 155         {
 156           acl_free (acl);
 157           return chmod_or_fchmod (dst_name, dest_desc, mode);
 158         }
 159       else
 160         {
 161           acl_free (acl);
 162           chmod_or_fchmod (dst_name, dest_desc, mode);
 163           errno = saved_errno;
 164           return -1;
 165         }
 166     }
 167   else
 168     acl_free (acl);
 169
 170   /* Since !MODE_INSIDE_ACL, we have to call chmod explicitly.  */
 171   return chmod_or_fchmod (dst_name, dest_desc, mode);
 172
 173 # endif
 174
 175 #elif USE_ACL && defined GETACL /* Solaris, Cygwin, not HP-UX */
 176
 177   /* Solaris 2.5 through Solaris 10, Cygwin, and contemporaneous versions
 178      of Unixware.  The acl() call returns the access and default ACL both
 179      at once.  */
 180 # ifdef ACE_GETACL
 181   int ace_count;
 182   ace_t *ace_entries;
 183 # endif
 184   int count;
 185   aclent_t *entries;
 186   int did_chmod;
 187   int saved_errno;
 188   int ret;
 189
 190 # ifdef ACE_GETACL
 191   /* Solaris also has a different variant of ACLs, used in ZFS and NFSv4
 192      file systems (whereas the other ones are used in UFS file systems).
 193      There is an API
 194        pathconf (name, _PC_ACL_ENABLED)
 195        fpathconf (desc, _PC_ACL_ENABLED)
 196      that allows to determine which of the two kinds of ACLs is supported
 197      for the given file.  But some file systems may implement this call
 198      incorrectly, so better not use it.
 199      When fetching the source ACL, we simply fetch both ACL types.
 200      When setting the destination ACL, we try either ACL types, assuming
 201      that the kernel will translate the ACL from one form to the other.
 202      (See in <http://docs.sun.com/app/docs/doc/819-2241/6n4huc7ia?l=en&a=view>
 203      the description of ENOTSUP.)  */
 204   for (;;)
 205     {
 206       ace_count = (source_desc != -1
 207                    ? facl (source_desc, ACE_GETACLCNT, 0, NULL)
 208                    : acl (src_name, ACE_GETACLCNT, 0, NULL));
 209
 210       if (ace_count < 0)
 211         {
 212           if (errno == ENOSYS || errno == EINVAL)
 213             {
 214               ace_count = 0;
 215               ace_entries = NULL;
 216               break;
 217             }
 218           else
 219             return -2;
 220         }
 221
 222       if (ace_count == 0)
 223         {
 224           ace_entries = NULL;
 225           break;
 226         }
 227
 228       ace_entries = (ace_t *) malloc (ace_count * sizeof (ace_t));
 229       if (ace_entries == NULL)
 230         {
 231           errno = ENOMEM;
 232           return -2;
 233         }
 234
 235       ret = (source_desc != -1
 236              ? facl (source_desc, ACE_GETACL, ace_count, ace_entries)
 237              : acl (src_name, ACE_GETACL, ace_count, ace_entries));
 238       if (ret < 0)
 239         {
 240           free (ace_entries);
 241           if (errno == ENOSYS || errno == EINVAL)
 242             {
 243               ace_count = 0;
 244               ace_entries = NULL;
 245               break;
 246             }
 247           else
 248             return -2;
 249         }
 250       if (ret == ace_count)
 251         break;
 252       /* Huh? The number of ACL entries changed since the last call.
 253          Repeat.  */
 254     }
 255 # endif
 256
 257   for (;;)
 258     {
 259       count = (source_desc != -1
 260                ? facl (source_desc, GETACLCNT, 0, NULL)
 261                : acl (src_name, GETACLCNT, 0, NULL));
 262
 263       if (count < 0)
 264         {
 265           if (errno == ENOSYS || errno == ENOTSUP || errno == EOPNOTSUPP)
 266             {
 267               count = 0;
 268               entries = NULL;
 269               break;
 270             }
 271           else
 272             return -2;
 273         }
 274
 275       if (count == 0)
 276         {
 277           entries = NULL;
 278           break;
 279         }
 280
 281       entries = (aclent_t *) malloc (count * sizeof (aclent_t));
 282       if (entries == NULL)
 283         {
 284           errno = ENOMEM;
 285           return -2;
 286         }
 287
 288       if ((source_desc != -1
 289            ? facl (source_desc, GETACL, count, entries)
 290            : acl (src_name, GETACL, count, entries))
 291           == count)
 292         break;
 293       /* Huh? The number of ACL entries changed since the last call.
 294          Repeat.  */
 295     }
 296
 297   /* Is there an ACL of either kind?  */
 298 # ifdef ACE_GETACL
 299   if (ace_count == 0)
 300 # endif
 301     if (count == 0)
 302       return qset_acl (dst_name, dest_desc, mode);
 303
 304   did_chmod = 0; /* set to 1 once the mode bits in 0777 have been set */
 305   saved_errno = 0; /* the first non-ignorable error code */
 306
 307   if (!MODE_INSIDE_ACL)
 308     {
 309       /* On Cygwin, it is necessary to call chmod before acl, because
 310          chmod can change the contents of the ACL (in ways that don't
 311          change the allowed accesses, but still visible).  */
 312       if (chmod_or_fchmod (dst_name, dest_desc, mode) != 0)
 313         saved_errno = errno;
 314       did_chmod = 1;
 315     }
 316
 317   /* If both ace_entries and entries are available, try SETACL before
 318      ACE_SETACL, because SETACL cannot fail with ENOTSUP whereas ACE_SETACL
 319      can.  */
 320
 321   if (count > 0)
 322     {
 323       ret = (dest_desc != -1
 324              ? facl (dest_desc, SETACL, count, entries)
 325              : acl (dst_name, SETACL, count, entries));
 326       if (ret < 0 && saved_errno == 0)
 327         {
 328           saved_errno = errno;
 329           if ((errno == ENOSYS || errno == EOPNOTSUPP || errno == EINVAL)
 330               && !acl_nontrivial (count, entries))
 331             saved_errno = 0;
 332         }
 333       else
 334         did_chmod = 1;
 335     }
 336   free (entries);
 337
 338 # ifdef ACE_GETACL
 339   if (ace_count > 0)
 340     {
 341       ret = (dest_desc != -1
 342              ? facl (dest_desc, ACE_SETACL, ace_count, ace_entries)
 343              : acl (dst_name, ACE_SETACL, ace_count, ace_entries));
 344       if (ret < 0 && saved_errno == 0)
 345         {
 346           saved_errno = errno;
 347           if ((errno == ENOSYS || errno == EINVAL || errno == ENOTSUP)
 348               && !acl_ace_nontrivial (ace_count, ace_entries))
 349             saved_errno = 0;
 350         }
 351     }
 352   free (ace_entries);
 353 # endif
 354
 355   if (MODE_INSIDE_ACL
 356       && did_chmod <= ((mode & (S_ISUID | S_ISGID | S_ISVTX)) ? 1 : 0))
 357     {
 358       /* We did not call chmod so far, and either the mode and the ACL are
 359          separate or special bits are to be set which don't fit into ACLs.  */
 360
 361       if (chmod_or_fchmod (dst_name, dest_desc, mode) != 0)
 362         {
 363           if (saved_errno == 0)
 364             saved_errno = errno;
 365         }
 366     }
 367
 368   if (saved_errno)
 369     {
 370       errno = saved_errno;
 371       return -1;
 372     }
 373   return 0;
 374
 375 #elif USE_ACL && HAVE_GETACL /* HP-UX */
 376
 377   struct acl_entry entries[NACLENTRIES];
 378   int count;
 379 # if HAVE_ACLV_H
 380   struct acl aclv_entries[NACLVENTRIES];
 381   int aclv_count;
 382 # endif
 383   int did_chmod;
 384   int saved_errno;
 385   int ret;
 386
 387   count = (source_desc != -1
 388            ? fgetacl (source_desc, NACLENTRIES, entries)
 389            : getacl (src_name, NACLENTRIES, entries));
 390
 391   if (count < 0)
 392     {
 393       if (errno == ENOSYS || errno == EOPNOTSUPP || errno == ENOTSUP)
 394         count = 0;
 395       else
 396         return -2;
 397     }
 398   else if (count > 0)
 399     {
 400       if (count > NACLENTRIES)
 401         /* If NACLENTRIES cannot be trusted, use dynamic memory allocation.  */
 402         abort ();
 403     }
 404
 405 # if HAVE_ACLV_H
 406   aclv_count = acl ((char *) src_name, ACL_GET, NACLVENTRIES, aclv_entries);
 407
 408   if (aclv_count < 0)
 409     {
 410       if (errno == ENOSYS || errno == EOPNOTSUPP || errno == EINVAL)
 411         count = 0;
 412       else
 413         return -2;
 414     }
 415   else if (aclv_count > 0)
 416     {
 417       if (aclv_count > NACLVENTRIES)
 418         /* If NACLVENTRIES cannot be trusted, use dynamic memory allocation.  */
 419         abort ();
 420     }
 421 # endif
 422
 423   if (count == 0)
 424 # if HAVE_ACLV_H
 425     if (aclv_count == 0)
 426 # endif
 427       return qset_acl (dst_name, dest_desc, mode);
 428
 429   did_chmod = 0; /* set to 1 once the mode bits in 0777 have been set */
 430   saved_errno = 0; /* the first non-ignorable error code */
 431
 432   if (count > 0)
 433     {
 434       ret = (dest_desc != -1
 435              ? fsetacl (dest_desc, count, entries)
 436              : setacl (dst_name, count, entries));
 437       if (ret < 0 && saved_errno == 0)
 438         {
 439           saved_errno = errno;
 440           if (errno == ENOSYS || errno == EOPNOTSUPP || errno == ENOTSUP
 441               && !acl_nontrivial (count, entries))
 442                 saved_errno = 0;
 443         }
 444       else
 445         did_chmod = 1;
 446     }
 447
 448 # if HAVE_ACLV_H
 449   if (aclv_count > 0)
 450     {
 451       ret = acl ((char *) dst_name, ACL_SET, aclv_count, aclv_entries);
 452       if (ret < 0 && saved_errno == 0)
 453         {
 454           saved_errno = errno;
 455           if (errno == ENOSYS || errno == EOPNOTSUPP || errno == EINVAL)
 456             {
 457               if (!aclv_nontrivial (aclv_count, aclv_entries))
 458                 saved_errno = 0;
 459             }
 460         }
 461       else
 462         did_chmod = 1;
 463     }
 464 # endif
 465
 466   if (did_chmod <= ((mode & (S_ISUID | S_ISGID | S_ISVTX)) ? 1 : 0))
 467     {
 468       /* We did not call chmod so far, and special bits are to be set which
 469          don't fit into ACLs.  */
 470
 471       if (chmod_or_fchmod (dst_name, dest_desc, mode) != 0)
 472         {
 473           if (saved_errno == 0)
 474             saved_errno = errno;
 475         }
 476     }
 477
 478   if (saved_errno)
 479     {
 480       errno = saved_errno;
 481       return -1;
 482     }
 483   return 0;
 484
 485 #elif USE_ACL && HAVE_ACLX_GET && 0 /* AIX */
 486
 487   /* TODO */
 488
 489 #elif USE_ACL && HAVE_STATACL /* older AIX */
 490
 491   union { struct acl a; char room[4096]; } u;
 492   int ret;
 493
 494   if ((source_desc != -1
 495        ? fstatacl (source_desc, STX_NORMAL, &u.a, sizeof (u))
 496        : statacl (src_name, STX_NORMAL, &u.a, sizeof (u)))
 497       < 0)
 498     return -2;
 499
 500   ret = (dest_desc != -1
 501          ? fchacl (dest_desc, &u.a, u.a.acl_len)
 502          : chacl (dst_name, &u.a, u.a.acl_len));
 503   if (ret < 0)
 504     {
 505       int saved_errno = errno;
 506
 507       chmod_or_fchmod (dst_name, dest_desc, mode);
 508       errno = saved_errno;
 509       return -1;
 510     }
 511
 512   /* No need to call chmod_or_fchmod at this point, since the mode bits
 513      S_ISUID, S_ISGID, S_ISVTX are also stored in the ACL.  */
 514
 515   return 0;
 516
 517 #elif USE_ACL && HAVE_ACLSORT /* NonStop Kernel */
 518
 519   struct acl entries[NACLENTRIES];
 520   int count;
 521   int ret;
 522
 523   count = acl ((char *) src_name, ACL_GET, NACLENTRIES, entries);
 524
 525   if (count < 0)
 526     {
 527       if (0)
 528         count = 0;
 529       else
 530         return -2;
 531     }
 532   else if (count > 0)
 533     {
 534       if (count > NACLENTRIES)
 535         /* If NACLENTRIES cannot be trusted, use dynamic memory allocation.  */
 536         abort ();
 537     }
 538
 539   if (count == 0)
 540     return qset_acl (dst_name, dest_desc, mode);
 541
 542   ret = acl ((char *) dst_name, ACL_SET, count, entries);
 543   if (ret < 0)
 544     {
 545       int saved_errno = errno;
 546
 547       if (0)
 548         {
 549           if (!acl_nontrivial (count, entries))
 550             return chmod_or_fchmod (dst_name, dest_desc, mode);
 551         }
 552
 553       chmod_or_fchmod (dst_name, dest_desc, mode);
 554       errno = saved_errno;
 555       return -1;
 556     }
 557
 558   if (mode & (S_ISUID | S_ISGID | S_ISVTX))
 559     {
 560       /* We did not call chmod so far, and either the mode and the ACL are
 561          separate or special bits are to be set which don't fit into ACLs.  */
 562
 563       return chmod_or_fchmod (dst_name, dest_desc, mode);
 564     }
 565   return 0;
 566
 567 #else
 568
 569   return qset_acl (dst_name, dest_desc, mode);
 570
 571 #endif
 572 }