acls.c

   1 /*
   2  * Handle passing Access Control Lists between systems.
   3  *
   4  * Copyright (C) 1996 Andrew Tridgell
   5  * Copyright (C) 1996 Paul Mackerras
   6  * Copyright (C) 2006-2009 Wayne Davison
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 3 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with this program; if not, visit the http://fsf.org website.
  20  */
  21
  22 #include "rsync.h"
  23 #include "lib/sysacls.h"
  24
  25 #ifdef SUPPORT_ACLS
  26
  27 extern int dry_run;
  28 extern int am_root;
  29 extern int read_only;
  30 extern int list_only;
  31 extern int orig_umask;
  32 extern int numeric_ids;
  33 extern int inc_recurse;
  34
  35 /* Flags used to indicate what items are being transmitted for an entry. */
  36 #define XMIT_USER_OBJ (1<<0)
  37 #define XMIT_GROUP_OBJ (1<<1)
  38 #define XMIT_MASK_OBJ (1<<2)
  39 #define XMIT_OTHER_OBJ (1<<3)
  40 #define XMIT_NAME_LIST (1<<4)
  41
  42 #define NO_ENTRY ((uchar)0x80) /* Default value of a NON-name-list entry. */
  43
  44 #define NAME_IS_USER (1u<<31) /* Bit used only on a name-list entry. */
  45
  46 /* When we send the access bits over the wire, we shift them 2 bits to the
  47  * left and use the lower 2 bits as flags (relevant only to a name entry).
  48  * This makes the protocol more efficient than sending a value that would
  49  * be likely to have its hightest bits set. */
  50 #define XFLAG_NAME_FOLLOWS 0x0001u
  51 #define XFLAG_NAME_IS_USER 0x0002u
  52
  53 /* === ACL structures === */
  54
  55 typedef struct {
  56         id_t id;
  57         uint32 access;
  58 } id_access;
  59
  60 typedef struct {
  61         id_access *idas;
  62         int count;
  63 } ida_entries;
  64
  65 typedef struct {
  66         char *name;
  67         uchar len;
  68 } idname;
  69
  70 typedef struct rsync_acl {
  71         ida_entries names;
  72         /* These will be NO_ENTRY if there's no such entry. */
  73         uchar user_obj;
  74         uchar group_obj;
  75         uchar mask_obj;
  76         uchar other_obj;
  77 } rsync_acl;
  78
  79 typedef struct {
  80         rsync_acl racl;
  81         SMB_ACL_T sacl;
  82 } acl_duo;
  83
  84 static const rsync_acl empty_rsync_acl = {
  85         {NULL, 0}, NO_ENTRY, NO_ENTRY, NO_ENTRY, NO_ENTRY
  86 };
  87
  88 static item_list access_acl_list = EMPTY_ITEM_LIST;
  89 static item_list default_acl_list = EMPTY_ITEM_LIST;
  90
  91 static size_t prior_access_count = (size_t)-1;
  92 static size_t prior_default_count = (size_t)-1;
  93
  94 /* === Calculations on ACL types === */
  95
  96 static const char *str_acl_type(SMB_ACL_TYPE_T type)
  97 {
  98         switch (type) {
  99         case SMB_ACL_TYPE_ACCESS:
 100 #ifdef HAVE_OSX_ACLS
 101                 return "ACL_TYPE_EXTENDED";
 102 #else
 103                 return "ACL_TYPE_ACCESS";
 104 #endif
 105         case SMB_ACL_TYPE_DEFAULT:
 106                 return "ACL_TYPE_DEFAULT";
 107         default:
 108                 break;
 109         }
 110         return "unknown ACL type!";
 111 }
 112
 113 static int calc_sacl_entries(const rsync_acl *racl)
 114 {
 115         /* A System ACL always gets user/group/other permission entries. */
 116         return racl->names.count
 117 #ifdef ACLS_NEED_MASK
 118              + 4;
 119 #else
 120              + (racl->mask_obj != NO_ENTRY) + 3;
 121 #endif
 122 }
 123
 124 /* Extracts and returns the permission bits from the ACL.  This cannot be
 125  * called on an rsync_acl that has NO_ENTRY in any spot but the mask. */
 126 static int rsync_acl_get_perms(const rsync_acl *racl)
 127 {
 128         return (racl->user_obj << 6)
 129              + ((racl->mask_obj != NO_ENTRY ? racl->mask_obj : racl->group_obj) << 3)
 130              + racl->other_obj;
 131 }
 132
 133 /* Removes the permission-bit entries from the ACL because these
 134  * can be reconstructed from the file's mode. */
 135 static void rsync_acl_strip_perms(rsync_acl *racl)
 136 {
 137         racl->user_obj = NO_ENTRY;
 138         if (racl->mask_obj == NO_ENTRY)
 139                 racl->group_obj = NO_ENTRY;
 140         else {
 141                 if (racl->group_obj == racl->mask_obj)
 142                         racl->group_obj = NO_ENTRY;
 143                 if (racl->names.count != 0)
 144                         racl->mask_obj = NO_ENTRY;
 145         }
 146         racl->other_obj = NO_ENTRY;
 147 }
 148
 149 /* Given an empty rsync_acl, fake up the permission bits. */
 150 static void rsync_acl_fake_perms(rsync_acl *racl, mode_t mode)
 151 {
 152         racl->user_obj = (mode >> 6) & 7;
 153         racl->group_obj = (mode >> 3) & 7;
 154         racl->other_obj = mode & 7;
 155 }
 156
 157 /* === Rsync ACL functions === */
 158
 159 static rsync_acl *create_racl(void)
 160 {
 161         rsync_acl *racl = new(rsync_acl);
 162
 163         if (!racl)
 164                 out_of_memory("create_racl");
 165         *racl = empty_rsync_acl;
 166
 167         return racl;
 168 }
 169
 170 static BOOL ida_entries_equal(const ida_entries *ial1, const ida_entries *ial2)
 171 {
 172         id_access *ida1, *ida2;
 173         int count = ial1->count;
 174         if (count != ial2->count)
 175                 return False;
 176         ida1 = ial1->idas;
 177         ida2 = ial2->idas;
 178         for (; count--; ida1++, ida2++) {
 179                 if (ida1->access != ida2->access || ida1->id != ida2->id)
 180                         return False;
 181         }
 182         return True;
 183 }
 184
 185 static BOOL rsync_acl_equal(const rsync_acl *racl1, const rsync_acl *racl2)
 186 {
 187         return racl1->user_obj == racl2->user_obj
 188             && racl1->group_obj == racl2->group_obj
 189             && racl1->mask_obj == racl2->mask_obj
 190             && racl1->other_obj == racl2->other_obj
 191             && ida_entries_equal(&racl1->names, &racl2->names);
 192 }
 193
 194 /* Are the extended (non-permission-bit) entries equal?  If so, the rest of
 195  * the ACL will be handled by the normal mode-preservation code.  This is
 196  * only meaningful for access ACLs!  Note: the 1st arg is a fully-populated
 197  * rsync_acl, but the 2nd parameter can be a condensed rsync_acl, which means
 198  * that it might have several of its permission objects set to NO_ENTRY. */
 199 static BOOL rsync_acl_equal_enough(const rsync_acl *racl1,
 200                                    const rsync_acl *racl2, mode_t m)
 201 {
 202         if ((racl1->mask_obj ^ racl2->mask_obj) & NO_ENTRY)
 203                 return False; /* One has a mask and the other doesn't */
 204
 205         /* When there's a mask, the group_obj becomes an extended entry. */
 206         if (racl1->mask_obj != NO_ENTRY) {
 207                 /* A condensed rsync_acl with a mask can only have no
 208                  * group_obj when it was identical to the mask.  This
 209                  * means that it was also identical to the group attrs
 210                  * from the mode. */
 211                 if (racl2->group_obj == NO_ENTRY) {
 212                         if (racl1->group_obj != ((m >> 3) & 7))
 213                                 return False;
 214                 } else if (racl1->group_obj != racl2->group_obj)
 215                         return False;
 216         }
 217         return ida_entries_equal(&racl1->names, &racl2->names);
 218 }
 219
 220 static void rsync_acl_free(rsync_acl *racl)
 221 {
 222         if (racl->names.idas)
 223                 free(racl->names.idas);
 224         *racl = empty_rsync_acl;
 225 }
 226
 227 void free_acl(stat_x *sxp)
 228 {
 229         if (sxp->acc_acl) {
 230                 rsync_acl_free(sxp->acc_acl);
 231                 free(sxp->acc_acl);
 232                 sxp->acc_acl = NULL;
 233         }
 234         if (sxp->def_acl) {
 235                 rsync_acl_free(sxp->def_acl);
 236                 free(sxp->def_acl);
 237                 sxp->def_acl = NULL;
 238         }
 239 }
 240
 241 #ifdef SMB_ACL_NEED_SORT
 242 static int id_access_sorter(const void *r1, const void *r2)
 243 {
 244         id_access *ida1 = (id_access *)r1;
 245         id_access *ida2 = (id_access *)r2;
 246         id_t rid1 = ida1->id, rid2 = ida2->id;
 247         if ((ida1->access ^ ida2->access) & NAME_IS_USER)
 248                 return ida1->access & NAME_IS_USER ? -1 : 1;
 249         return rid1 == rid2 ? 0 : rid1 < rid2 ? -1 : 1;
 250 }
 251 #endif
 252
 253 /* === System ACLs === */
 254
 255 /* Unpack system ACL -> rsync ACL verbatim.  Return whether we succeeded. */
 256 static BOOL unpack_smb_acl(SMB_ACL_T sacl, rsync_acl *racl)
 257 {
 258         static item_list temp_ida_list = EMPTY_ITEM_LIST;
 259         SMB_ACL_ENTRY_T entry;
 260         const char *errfun;
 261         int rc;
 262
 263         errfun = "sys_acl_get_entry";
 264         for (rc = sys_acl_get_entry(sacl, SMB_ACL_FIRST_ENTRY, &entry);
 265              rc == 1;
 266              rc = sys_acl_get_entry(sacl, SMB_ACL_NEXT_ENTRY, &entry)) {
 267                 SMB_ACL_TAG_T tag_type;
 268                 uint32 access;
 269                 id_t g_u_id;
 270                 id_access *ida;
 271                 if ((rc = sys_acl_get_info(entry, &tag_type, &access, &g_u_id)) != 0) {
 272                         errfun = "sys_acl_get_info";
 273                         break;
 274                 }
 275                 /* continue == done with entry; break == store in temporary ida list */
 276                 switch (tag_type) {
 277 #ifndef HAVE_OSX_ACLS
 278                 case SMB_ACL_USER_OBJ:
 279                         if (racl->user_obj == NO_ENTRY)
 280                                 racl->user_obj = access;
 281                         else
 282                                 rprintf(FINFO, "unpack_smb_acl: warning: duplicate USER_OBJ entry ignored\n");
 283                         continue;
 284                 case SMB_ACL_GROUP_OBJ:
 285                         if (racl->group_obj == NO_ENTRY)
 286                                 racl->group_obj = access;
 287                         else
 288                                 rprintf(FINFO, "unpack_smb_acl: warning: duplicate GROUP_OBJ entry ignored\n");
 289                         continue;
 290                 case SMB_ACL_MASK:
 291                         if (racl->mask_obj == NO_ENTRY)
 292                                 racl->mask_obj = access;
 293                         else
 294                                 rprintf(FINFO, "unpack_smb_acl: warning: duplicate MASK entry ignored\n");
 295                         continue;
 296                 case SMB_ACL_OTHER:
 297                         if (racl->other_obj == NO_ENTRY)
 298                                 racl->other_obj = access;
 299                         else
 300                                 rprintf(FINFO, "unpack_smb_acl: warning: duplicate OTHER entry ignored\n");
 301                         continue;
 302 #endif
 303                 case SMB_ACL_USER:
 304                         access |= NAME_IS_USER;
 305                         break;
 306                 case SMB_ACL_GROUP:
 307                         break;
 308                 default:
 309                         rprintf(FINFO, "unpack_smb_acl: warning: entry with unrecognized tag type ignored\n");
 310                         continue;
 311                 }
 312                 ida = EXPAND_ITEM_LIST(&temp_ida_list, id_access, -10);
 313                 ida->id = g_u_id;
 314                 ida->access = access;
 315         }
 316         if (rc) {
 317                 rsyserr(FERROR_XFER, errno, "unpack_smb_acl: %s()", errfun);
 318                 rsync_acl_free(racl);
 319                 return False;
 320         }
 321
 322         /* Transfer the count id_access items out of the temp_ida_list
 323          * into the names ida_entries list in racl. */
 324         if (temp_ida_list.count) {
 325 #ifdef SMB_ACL_NEED_SORT
 326                 if (temp_ida_list.count > 1) {
 327                         qsort(temp_ida_list.items, temp_ida_list.count,
 328                               sizeof (id_access), id_access_sorter);
 329                 }
 330 #endif
 331                 if (!(racl->names.idas = new_array(id_access, temp_ida_list.count)))
 332                         out_of_memory("unpack_smb_acl");
 333                 memcpy(racl->names.idas, temp_ida_list.items,
 334                        temp_ida_list.count * sizeof (id_access));
 335         } else
 336                 racl->names.idas = NULL;
 337
 338         racl->names.count = temp_ida_list.count;
 339
 340         /* Truncate the temporary list now that its idas have been saved. */
 341         temp_ida_list.count = 0;
 342
 343 #ifdef ACLS_NEED_MASK
 344         if (!racl->names.count && racl->mask_obj != NO_ENTRY) {
 345                 /* Throw away a superfluous mask, but mask off the
 346                  * group perms with it first. */
 347                 racl->group_obj &= racl->mask_obj;
 348                 racl->mask_obj = NO_ENTRY;
 349         }
 350 #endif
 351
 352         return True;
 353 }
 354
 355 /* Synactic sugar for system calls */
 356
 357 #define CALL_OR_ERROR(func,args,str) \
 358         do { \
 359                 if (func args) { \
 360                         errfun = str; \
 361                         goto error_exit; \
 362                 } \
 363         } while (0)
 364
 365 #define COE(func,args) CALL_OR_ERROR(func,args,#func)
 366 #define COE2(func,args) CALL_OR_ERROR(func,args,NULL)
 367
 368 #ifndef HAVE_OSX_ACLS
 369 /* Store the permissions in the system ACL entry. */
 370 static int store_access_in_entry(uint32 access, SMB_ACL_ENTRY_T entry)
 371 {
 372         if (sys_acl_set_access_bits(entry, access)) {
 373                 rsyserr(FERROR_XFER, errno, "store_access_in_entry sys_acl_set_access_bits()");
 374                 return -1;
 375         }
 376         return 0;
 377 }
 378 #endif
 379
 380 /* Pack rsync ACL -> system ACL verbatim.  Return whether we succeeded. */
 381 static BOOL pack_smb_acl(SMB_ACL_T *smb_acl, const rsync_acl *racl)
 382 {
 383 #ifdef ACLS_NEED_MASK
 384         uchar mask_bits;
 385 #endif
 386         size_t count;
 387         id_access *ida;
 388         const char *errfun = NULL;
 389         SMB_ACL_ENTRY_T entry;
 390
 391         if (!(*smb_acl = sys_acl_init(calc_sacl_entries(racl)))) {
 392                 rsyserr(FERROR_XFER, errno, "pack_smb_acl: sys_acl_init()");
 393                 return False;
 394         }
 395
 396 #ifndef HAVE_OSX_ACLS
 397         COE( sys_acl_create_entry,(smb_acl, &entry) );
 398         COE( sys_acl_set_info,(entry, SMB_ACL_USER_OBJ, racl->user_obj & ~NO_ENTRY, 0) );
 399 #endif
 400
 401         for (ida = racl->names.idas, count = racl->names.count; count; ida++, count--) {
 402 #ifdef SMB_ACL_NEED_SORT
 403                 if (!(ida->access & NAME_IS_USER))
 404                         break;
 405 #endif
 406                 COE( sys_acl_create_entry,(smb_acl, &entry) );
 407                 COE( sys_acl_set_info,
 408                     (entry,
 409                      ida->access & NAME_IS_USER ? SMB_ACL_USER : SMB_ACL_GROUP,
 410                      ida->access & ~NAME_IS_USER, ida->id) );
 411         }
 412
 413 #ifndef HAVE_OSX_ACLS
 414         COE( sys_acl_create_entry,(smb_acl, &entry) );
 415         COE( sys_acl_set_info,(entry, SMB_ACL_GROUP_OBJ, racl->group_obj & ~NO_ENTRY, 0) );
 416
 417 #ifdef SMB_ACL_NEED_SORT
 418         for ( ; count; ida++, count--) {
 419                 COE( sys_acl_create_entry,(smb_acl, &entry) );
 420                 COE( sys_acl_set_info,(entry, SMB_ACL_GROUP, ida->access, ida->id) );
 421         }
 422 #endif
 423
 424 #ifdef ACLS_NEED_MASK
 425         mask_bits = racl->mask_obj == NO_ENTRY ? racl->group_obj & ~NO_ENTRY : racl->mask_obj;
 426         COE( sys_acl_create_entry,(smb_acl, &entry) );
 427         COE( sys_acl_set_info,(entry, SMB_ACL_MASK, mask_bits, NULL) );
 428 #else
 429         if (racl->mask_obj != NO_ENTRY) {
 430                 COE( sys_acl_create_entry,(smb_acl, &entry) );
 431                 COE( sys_acl_set_info,(entry, SMB_ACL_MASK, racl->mask_obj, 0) );
 432         }
 433 #endif
 434
 435         COE( sys_acl_create_entry,(smb_acl, &entry) );
 436         COE( sys_acl_set_info,(entry, SMB_ACL_OTHER, racl->other_obj & ~NO_ENTRY, 0) );
 437 #endif
 438
 439 #ifdef DEBUG
 440         if (sys_acl_valid(*smb_acl) < 0)
 441                 rprintf(FERROR_XFER, "pack_smb_acl: warning: system says the ACL I packed is invalid\n");
 442 #endif
 443
 444         return True;
 445
 446   error_exit:
 447         if (errfun) {
 448                 rsyserr(FERROR_XFER, errno, "pack_smb_acl %s()", errfun);
 449         }
 450         sys_acl_free_acl(*smb_acl);
 451         return False;
 452 }
 453
 454 static int find_matching_rsync_acl(const rsync_acl *racl, SMB_ACL_TYPE_T type,
 455                                    const item_list *racl_list)
 456 {
 457         static int access_match = -1, default_match = -1;
 458         int *match = type == SMB_ACL_TYPE_ACCESS ? &access_match : &default_match;
 459         size_t count = racl_list->count;
 460
 461         /* If this is the first time through or we didn't match the last
 462          * time, then start at the end of the list, which should be the
 463          * best place to start hunting. */
 464         if (*match == -1)
 465                 *match = racl_list->count - 1;
 466         while (count--) {
 467                 rsync_acl *base = racl_list->items;
 468                 if (rsync_acl_equal(base + *match, racl))
 469                         return *match;
 470                 if (!(*match)--)
 471                         *match = racl_list->count - 1;
 472         }
 473
 474         *match = -1;
 475         return *match;
 476 }
 477
 478 static int get_rsync_acl(const char *fname, rsync_acl *racl,
 479                          SMB_ACL_TYPE_T type, mode_t mode)
 480 {
 481         SMB_ACL_T sacl;
 482
 483 #ifdef SUPPORT_XATTRS
 484         /* --fake-super support: load ACLs from an xattr. */
 485         if (am_root < 0) {
 486                 char *buf;
 487                 size_t len;
 488                 int cnt;
 489
 490                 if ((buf = get_xattr_acl(fname, type == SMB_ACL_TYPE_ACCESS, &len)) == NULL)
 491                         return 0;
 492                 cnt = (len - 4*4) / (4+4);
 493                 if (len < 4*4 || len != (size_t)cnt*(4+4) + 4*4) {
 494                         free(buf);
 495                         return -1;
 496                 }
 497
 498                 racl->user_obj = IVAL(buf, 0);
 499                 racl->group_obj = IVAL(buf, 4);
 500                 racl->mask_obj = IVAL(buf, 8);
 501                 racl->other_obj = IVAL(buf, 12);
 502
 503                 if (cnt) {
 504                         char *bp = buf + 4*4;
 505                         id_access *ida;
 506                         if (!(ida = racl->names.idas = new_array(id_access, cnt)))
 507                                 out_of_memory("get_rsync_acl");
 508                         racl->names.count = cnt;
 509                         for ( ; cnt--; ida++, bp += 4+4) {
 510                                 ida->id = IVAL(bp, 0);
 511                                 ida->access = IVAL(bp, 4);
 512                         }
 513                 }
 514                 free(buf);
 515                 return 0;
 516         }
 517 #endif
 518
 519         if ((sacl = sys_acl_get_file(fname, type)) != 0) {
 520                 BOOL ok = unpack_smb_acl(sacl, racl);
 521
 522                 sys_acl_free_acl(sacl);
 523                 if (!ok) {
 524                         return -1;
 525                 }
 526         } else if (no_acl_syscall_error(errno)) {
 527                 /* ACLs are not supported, so pretend we have a basic ACL. */
 528                 if (type == SMB_ACL_TYPE_ACCESS)
 529                         rsync_acl_fake_perms(racl, mode);
 530         } else {
 531                 rsyserr(FERROR_XFER, errno, "get_acl: sys_acl_get_file(%s, %s)",
 532                         fname, str_acl_type(type));
 533                 return -1;
 534         }
 535
 536         return 0;
 537 }
 538
 539 /* Return the Access Control List for the given filename. */
 540 int get_acl(const char *fname, stat_x *sxp)
 541 {
 542         sxp->acc_acl = create_racl();
 543         if (get_rsync_acl(fname, sxp->acc_acl, SMB_ACL_TYPE_ACCESS,
 544                           sxp->st.st_mode) < 0) {
 545                 free_acl(sxp);
 546                 return -1;
 547         }
 548
 549         if (S_ISDIR(sxp->st.st_mode)) {
 550                 sxp->def_acl = create_racl();
 551                 if (get_rsync_acl(fname, sxp->def_acl, SMB_ACL_TYPE_DEFAULT,
 552                                   sxp->st.st_mode) < 0) {
 553                         free_acl(sxp);
 554                         return -1;
 555                 }
 556         }
 557
 558         return 0;
 559 }
 560
 561 /* === Send functions === */
 562
 563 /* Send the ida list over the file descriptor. */
 564 static void send_ida_entries(const ida_entries *idal, int f)
 565 {
 566         id_access *ida;
 567         size_t count = idal->count;
 568
 569         write_varint(f, idal->count);
 570
 571         for (ida = idal->idas; count--; ida++) {
 572                 uint32 xbits = ida->access << 2;
 573                 const char *name;
 574                 if (ida->access & NAME_IS_USER) {
 575                         xbits |= XFLAG_NAME_IS_USER;
 576                         name = add_uid(ida->id);
 577                 } else
 578                         name = add_gid(ida->id);
 579                 write_varint(f, ida->id);
 580                 if (inc_recurse && name) {
 581                         int len = strlen(name);
 582                         write_varint(f, xbits | XFLAG_NAME_FOLLOWS);
 583                         write_byte(f, len);
 584                         write_buf(f, name, len);
 585                 } else
 586                         write_varint(f, xbits);
 587         }
 588 }
 589
 590 static void send_rsync_acl(rsync_acl *racl, SMB_ACL_TYPE_T type,
 591                            item_list *racl_list, int f)
 592 {
 593         int ndx = find_matching_rsync_acl(racl, type, racl_list);
 594
 595         /* Send 0 (-1 + 1) to indicate that literal ACL data follows. */
 596         write_varint(f, ndx + 1);
 597
 598         if (ndx < 0) {
 599                 rsync_acl *new_racl = EXPAND_ITEM_LIST(racl_list, rsync_acl, 1000);
 600                 uchar flags = 0;
 601
 602                 if (racl->user_obj != NO_ENTRY)
 603                         flags |= XMIT_USER_OBJ;
 604                 if (racl->group_obj != NO_ENTRY)
 605                         flags |= XMIT_GROUP_OBJ;
 606                 if (racl->mask_obj != NO_ENTRY)
 607                         flags |= XMIT_MASK_OBJ;
 608                 if (racl->other_obj != NO_ENTRY)
 609                         flags |= XMIT_OTHER_OBJ;
 610                 if (racl->names.count)
 611                         flags |= XMIT_NAME_LIST;
 612
 613                 write_byte(f, flags);
 614
 615                 if (flags & XMIT_USER_OBJ)
 616                         write_varint(f, racl->user_obj);
 617                 if (flags & XMIT_GROUP_OBJ)
 618                         write_varint(f, racl->group_obj);
 619                 if (flags & XMIT_MASK_OBJ)
 620                         write_varint(f, racl->mask_obj);
 621                 if (flags & XMIT_OTHER_OBJ)
 622                         write_varint(f, racl->other_obj);
 623                 if (flags & XMIT_NAME_LIST)
 624                         send_ida_entries(&racl->names, f);
 625
 626                 /* Give the allocated data to the new list object. */
 627                 *new_racl = *racl;
 628                 *racl = empty_rsync_acl;
 629         }
 630 }
 631
 632 /* Send the ACL from the stat_x structure down the indicated file descriptor.
 633  * This also frees the ACL data. */
 634 void send_acl(stat_x *sxp, int f)
 635 {
 636         if (!sxp->acc_acl) {
 637                 sxp->acc_acl = create_racl();
 638                 rsync_acl_fake_perms(sxp->acc_acl, sxp->st.st_mode);
 639         }
 640         /* Avoid sending values that can be inferred from other data. */
 641         rsync_acl_strip_perms(sxp->acc_acl);
 642
 643         send_rsync_acl(sxp->acc_acl, SMB_ACL_TYPE_ACCESS, &access_acl_list, f);
 644
 645         if (S_ISDIR(sxp->st.st_mode)) {
 646                 if (!sxp->def_acl)
 647                         sxp->def_acl = create_racl();
 648
 649                 send_rsync_acl(sxp->def_acl, SMB_ACL_TYPE_DEFAULT, &default_acl_list, f);
 650         }
 651 }
 652
 653 /* === Receive functions === */
 654
 655 static uint32 recv_acl_access(uchar *name_follows_ptr, int f)
 656 {
 657         uint32 access = read_varint(f);
 658
 659         if (name_follows_ptr) {
 660                 int flags = access & 3;
 661                 access >>= 2;
 662                 if (am_root >= 0 && access & ~SMB_ACL_VALID_NAME_BITS)
 663                         goto value_error;
 664                 if (flags & XFLAG_NAME_FOLLOWS)
 665                         *name_follows_ptr = 1;
 666                 else
 667                         *name_follows_ptr = 0;
 668                 if (flags & XFLAG_NAME_IS_USER)
 669                         access |= NAME_IS_USER;
 670         } else if (am_root >= 0 && access & ~SMB_ACL_VALID_OBJ_BITS) {
 671           value_error:
 672                 rprintf(FERROR_XFER, "recv_acl_access: value out of range: %x\n",
 673                         access);
 674                 exit_cleanup(RERR_STREAMIO);
 675         }
 676
 677         return access;
 678 }
 679
 680 static uchar recv_ida_entries(ida_entries *ent, int f)
 681 {
 682         uchar computed_mask_bits = 0;
 683         int i, count = read_varint(f);
 684
 685         if (count) {
 686                 if (!(ent->idas = new_array(id_access, count)))
 687                         out_of_memory("recv_ida_entries");
 688         } else
 689                 ent->idas = NULL;
 690
 691         ent->count = count;
 692
 693         for (i = 0; i < count; i++) {
 694                 uchar has_name;
 695                 id_t id = read_varint(f);
 696                 uint32 access = recv_acl_access(&has_name, f);
 697
 698                 if (has_name) {
 699                         if (access & NAME_IS_USER)
 700                                 id = recv_user_name(f, id);
 701                         else
 702                                 id = recv_group_name(f, id, NULL);
 703                 } else if (access & NAME_IS_USER) {
 704                         if (inc_recurse && am_root && !numeric_ids)
 705                                 id = match_uid(id);
 706                 } else {
 707                         if (inc_recurse && (!am_root || !numeric_ids))
 708                                 id = match_gid(id, NULL);
 709                 }
 710
 711                 ent->idas[i].id = id;
 712                 ent->idas[i].access = access;
 713                 computed_mask_bits |= access;
 714         }
 715
 716         return computed_mask_bits & ~NO_ENTRY;
 717 }
 718
 719 static int recv_rsync_acl(item_list *racl_list, SMB_ACL_TYPE_T type, int f)
 720 {
 721         uchar computed_mask_bits = 0;
 722         acl_duo *duo_item;
 723         uchar flags;
 724         int ndx = read_varint(f);
 725
 726         if (ndx < 0 || (size_t)ndx > racl_list->count) {
 727                 rprintf(FERROR_XFER, "recv_acl_index: %s ACL index %d > %d\n",
 728                         str_acl_type(type), ndx, (int)racl_list->count);
 729                 exit_cleanup(RERR_STREAMIO);
 730         }
 731
 732         if (ndx != 0)
 733                 return ndx - 1;
 734
 735         ndx = racl_list->count;
 736         duo_item = EXPAND_ITEM_LIST(racl_list, acl_duo, 1000);
 737         duo_item->racl = empty_rsync_acl;
 738
 739         flags = read_byte(f);
 740
 741         if (flags & XMIT_USER_OBJ)
 742                 duo_item->racl.user_obj = recv_acl_access(NULL, f);
 743         if (flags & XMIT_GROUP_OBJ)
 744                 duo_item->racl.group_obj = recv_acl_access(NULL, f);
 745         if (flags & XMIT_MASK_OBJ)
 746                 duo_item->racl.mask_obj = recv_acl_access(NULL, f);
 747         if (flags & XMIT_OTHER_OBJ)
 748                 duo_item->racl.other_obj = recv_acl_access(NULL, f);
 749         if (flags & XMIT_NAME_LIST)
 750                 computed_mask_bits |= recv_ida_entries(&duo_item->racl.names, f);
 751
 752 #ifdef HAVE_OSX_ACLS
 753         /* If we received a superfluous mask, throw it away. */
 754         duo_item->racl.mask_obj = NO_ENTRY;
 755 #else
 756         if (duo_item->racl.names.count && duo_item->racl.mask_obj == NO_ENTRY) /* Must be non-empty with lists. */
 757                 duo_item->racl.mask_obj = (computed_mask_bits | duo_item->racl.group_obj) & ~NO_ENTRY;
 758 #endif
 759
 760         duo_item->sacl = NULL;
 761
 762         return ndx;
 763 }
 764
 765 /* Receive the ACL info the sender has included for this file-list entry. */
 766 void receive_acl(struct file_struct *file, int f)
 767 {
 768         F_ACL(file) = recv_rsync_acl(&access_acl_list, SMB_ACL_TYPE_ACCESS, f);
 769
 770         if (S_ISDIR(file->mode))
 771                 F_DIR_DEFACL(file) = recv_rsync_acl(&default_acl_list, SMB_ACL_TYPE_DEFAULT, f);
 772 }
 773
 774 static int cache_rsync_acl(rsync_acl *racl, SMB_ACL_TYPE_T type, item_list *racl_list)
 775 {
 776         int ndx;
 777
 778         if (!racl)
 779                 ndx = -1;
 780         else if ((ndx = find_matching_rsync_acl(racl, type, racl_list)) == -1) {
 781                 acl_duo *new_duo;
 782                 ndx = racl_list->count;
 783                 new_duo = EXPAND_ITEM_LIST(racl_list, acl_duo, 1000);
 784                 new_duo->racl = *racl;
 785                 new_duo->sacl = NULL;
 786                 *racl = empty_rsync_acl;
 787         }
 788
 789         return ndx;
 790 }
 791
 792 /* Turn the ACL data in stat_x into cached ACL data, setting the index
 793  * values in the file struct. */
 794 void cache_tmp_acl(struct file_struct *file, stat_x *sxp)
 795 {
 796         if (prior_access_count == (size_t)-1)
 797                 prior_access_count = access_acl_list.count;
 798
 799         F_ACL(file) = cache_rsync_acl(sxp->acc_acl,
 800                                       SMB_ACL_TYPE_ACCESS, &access_acl_list);
 801
 802         if (S_ISDIR(sxp->st.st_mode)) {
 803                 if (prior_default_count == (size_t)-1)
 804                         prior_default_count = default_acl_list.count;
 805                 F_DIR_DEFACL(file) = cache_rsync_acl(sxp->def_acl,
 806                                       SMB_ACL_TYPE_DEFAULT, &default_acl_list);
 807         }
 808 }
 809
 810 static void uncache_duo_acls(item_list *duo_list, size_t start)
 811 {
 812         acl_duo *duo_item = duo_list->items;
 813         acl_duo *duo_start = duo_item + start;
 814
 815         duo_item += duo_list->count;
 816         duo_list->count = start;
 817
 818         while (duo_item-- > duo_start) {
 819                 rsync_acl_free(&duo_item->racl);
 820                 if (duo_item->sacl)
 821                         sys_acl_free_acl(duo_item->sacl);
 822         }
 823 }
 824
 825 void uncache_tmp_acls(void)
 826 {
 827         if (prior_access_count != (size_t)-1) {
 828                 uncache_duo_acls(&access_acl_list, prior_access_count);
 829                 prior_access_count = (size_t)-1;
 830         }
 831
 832         if (prior_default_count != (size_t)-1) {
 833                 uncache_duo_acls(&default_acl_list, prior_default_count);
 834                 prior_default_count = (size_t)-1;
 835         }
 836 }
 837
 838 #ifndef HAVE_OSX_ACLS
 839 static mode_t change_sacl_perms(SMB_ACL_T sacl, rsync_acl *racl, mode_t old_mode, mode_t mode)
 840 {
 841         SMB_ACL_ENTRY_T entry;
 842         const char *errfun;
 843         int rc;
 844
 845         if (S_ISDIR(mode)) {
 846                 /* If the sticky bit is going on, it's not safe to allow all
 847                  * the new ACL to go into effect before it gets set. */
 848 #ifdef SMB_ACL_LOSES_SPECIAL_MODE_BITS
 849                 if (mode & S_ISVTX)
 850                         mode &= ~0077;
 851 #else
 852                 if (mode & S_ISVTX && !(old_mode & S_ISVTX))
 853                         mode &= ~0077;
 854         } else {
 855                 /* If setuid or setgid is going off, it's not safe to allow all
 856                  * the new ACL to go into effect before they get cleared. */
 857                 if ((old_mode & S_ISUID && !(mode & S_ISUID))
 858                  || (old_mode & S_ISGID && !(mode & S_ISGID)))
 859                         mode &= ~0077;
 860 #endif
 861         }
 862
 863         errfun = "sys_acl_get_entry";
 864         for (rc = sys_acl_get_entry(sacl, SMB_ACL_FIRST_ENTRY, &entry);
 865              rc == 1;
 866              rc = sys_acl_get_entry(sacl, SMB_ACL_NEXT_ENTRY, &entry)) {
 867                 SMB_ACL_TAG_T tag_type;
 868                 if ((rc = sys_acl_get_tag_type(entry, &tag_type)) != 0) {
 869                         errfun = "sys_acl_get_tag_type";
 870                         break;
 871                 }
 872                 switch (tag_type) {
 873                 case SMB_ACL_USER_OBJ:
 874                         COE2( store_access_in_entry,((mode >> 6) & 7, entry) );
 875                         break;
 876                 case SMB_ACL_GROUP_OBJ:
 877                         /* group is only empty when identical to group perms. */
 878                         if (racl->group_obj != NO_ENTRY)
 879                                 break;
 880                         COE2( store_access_in_entry,((mode >> 3) & 7, entry) );
 881                         break;
 882                 case SMB_ACL_MASK:
 883 #ifndef ACLS_NEED_MASK
 884                         /* mask is only empty when we don't need it. */
 885                         if (racl->mask_obj == NO_ENTRY)
 886                                 break;
 887 #endif
 888                         COE2( store_access_in_entry,((mode >> 3) & 7, entry) );
 889                         break;
 890                 case SMB_ACL_OTHER:
 891                         COE2( store_access_in_entry,(mode & 7, entry) );
 892                         break;
 893                 }
 894         }
 895         if (rc) {
 896           error_exit:
 897                 if (errfun) {
 898                         rsyserr(FERROR_XFER, errno, "change_sacl_perms: %s()",
 899                                 errfun);
 900                 }
 901                 return (mode_t)~0;
 902         }
 903
 904 #ifdef SMB_ACL_LOSES_SPECIAL_MODE_BITS
 905         /* Ensure that chmod() will be called to restore any lost setid bits. */
 906         if (old_mode & (S_ISUID | S_ISGID | S_ISVTX)
 907          && BITS_EQUAL(old_mode, mode, CHMOD_BITS))
 908                 old_mode &= ~(S_ISUID | S_ISGID | S_ISVTX);
 909 #endif
 910
 911         /* Return the mode of the file on disk, as we will set them. */
 912         return (old_mode & ~ACCESSPERMS) | (mode & ACCESSPERMS);
 913 }
 914 #endif
 915
 916 static int set_rsync_acl(const char *fname, acl_duo *duo_item,
 917                          SMB_ACL_TYPE_T type, stat_x *sxp, mode_t mode)
 918 {
 919         if (type == SMB_ACL_TYPE_DEFAULT
 920          && duo_item->racl.user_obj == NO_ENTRY) {
 921                 int rc;
 922 #ifdef SUPPORT_XATTRS
 923                 /* --fake-super support: delete default ACL from xattrs. */
 924                 if (am_root < 0)
 925                         rc = del_def_xattr_acl(fname);
 926                 else
 927 #endif
 928                         rc = sys_acl_delete_def_file(fname);
 929                 if (rc < 0) {
 930                         rsyserr(FERROR_XFER, errno, "set_acl: sys_acl_delete_def_file(%s)",
 931                                 fname);
 932                         return -1;
 933                 }
 934 #ifdef SUPPORT_XATTRS
 935         } else if (am_root < 0) {
 936                 /* --fake-super support: store ACLs in an xattr. */
 937                 int cnt = duo_item->racl.names.count;
 938                 size_t len = 4*4 + cnt * (4+4);
 939                 char *buf = new_array(char, len);
 940                 int rc;
 941
 942                 SIVAL(buf, 0, duo_item->racl.user_obj);
 943                 SIVAL(buf, 4, duo_item->racl.group_obj);
 944                 SIVAL(buf, 8, duo_item->racl.mask_obj);
 945                 SIVAL(buf, 12, duo_item->racl.other_obj);
 946
 947                 if (cnt) {
 948                         char *bp = buf + 4*4;
 949                         id_access *ida = duo_item->racl.names.idas;
 950                         for ( ; cnt--; ida++, bp += 4+4) {
 951                                 SIVAL(bp, 0, ida->id);
 952                                 SIVAL(bp, 4, ida->access);
 953                         }
 954                 }
 955                 rc = set_xattr_acl(fname, type == SMB_ACL_TYPE_ACCESS, buf, len);
 956                 free(buf);
 957                 return rc;
 958 #endif
 959         } else {
 960                 mode_t cur_mode = sxp->st.st_mode;
 961                 if (!duo_item->sacl
 962                  && !pack_smb_acl(&duo_item->sacl, &duo_item->racl))
 963                         return -1;
 964 #ifdef HAVE_OSX_ACLS
 965                 mode = 0; /* eliminate compiler warning */
 966 #else
 967                 if (type == SMB_ACL_TYPE_ACCESS) {
 968                         cur_mode = change_sacl_perms(duo_item->sacl, &duo_item->racl,
 969                                                      cur_mode, mode);
 970                         if (cur_mode == (mode_t)~0)
 971                                 return 0;
 972                 }
 973 #endif
 974                 if (sys_acl_set_file(fname, type, duo_item->sacl) < 0) {
 975                         rsyserr(FERROR_XFER, errno, "set_acl: sys_acl_set_file(%s, %s)",
 976                                 fname, str_acl_type(type));
 977                         return -1;
 978                 }
 979                 if (type == SMB_ACL_TYPE_ACCESS)
 980                         sxp->st.st_mode = cur_mode;
 981         }
 982
 983         return 0;
 984 }
 985
 986 /* Set ACL on indicated filename.
 987  *
 988  * This sets extended access ACL entries and default ACL.  If convenient,
 989  * it sets permission bits along with the access ACL and signals having
 990  * done so by modifying sxp->st.st_mode.
 991  *
 992  * Returns 1 for unchanged, 0 for changed, -1 for failed.  Call this
 993  * with fname set to NULL to just check if the ACL is unchanged. */
 994 int set_acl(const char *fname, const struct file_struct *file, stat_x *sxp)
 995 {
 996         int unchanged = 1;
 997         int32 ndx;
 998         BOOL eq;
 999
1000         if (!dry_run && (read_only || list_only)) {
1001                 errno = EROFS;
1002                 return -1;
1003         }
1004
1005         ndx = F_ACL(file);
1006         if (ndx >= 0 && (size_t)ndx < access_acl_list.count) {
1007                 acl_duo *duo_item = access_acl_list.items;
1008                 duo_item += ndx;
1009                 eq = sxp->acc_acl
1010                   && rsync_acl_equal_enough(sxp->acc_acl, &duo_item->racl, file->mode);
1011                 if (!eq) {
1012                         unchanged = 0;
1013                         if (!dry_run && fname
1014                          && set_rsync_acl(fname, duo_item, SMB_ACL_TYPE_ACCESS,
1015                                           sxp, file->mode) < 0)
1016                                 unchanged = -1;
1017                 }
1018         }
1019
1020         if (!S_ISDIR(sxp->st.st_mode))
1021                 return unchanged;
1022
1023         ndx = F_DIR_DEFACL(file);
1024         if (ndx >= 0 && (size_t)ndx < default_acl_list.count) {
1025                 acl_duo *duo_item = default_acl_list.items;
1026                 duo_item += ndx;
1027                 eq = sxp->def_acl && rsync_acl_equal(sxp->def_acl, &duo_item->racl);
1028                 if (!eq) {
1029                         if (unchanged > 0)
1030                                 unchanged = 0;
1031                         if (!dry_run && fname
1032                          && set_rsync_acl(fname, duo_item, SMB_ACL_TYPE_DEFAULT,
1033                                           sxp, file->mode) < 0)
1034                                 unchanged = -1;
1035                 }
1036         }
1037
1038         return unchanged;
1039 }
1040
1041 /* Non-incremental recursion needs to convert all the received IDs.
1042  * This is done in a single pass after receiving the whole file-list. */
1043 static void match_racl_ids(const item_list *racl_list)
1044 {
1045         int list_cnt, name_cnt;
1046         acl_duo *duo_item = racl_list->items;
1047         for (list_cnt = racl_list->count; list_cnt--; duo_item++) {
1048                 ida_entries *idal = &duo_item->racl.names;
1049                 id_access *ida = idal->idas;
1050                 for (name_cnt = idal->count; name_cnt--; ida++) {
1051                         if (ida->access & NAME_IS_USER)
1052                                 ida->id = match_uid(ida->id);
1053                         else
1054                                 ida->id = match_gid(ida->id, NULL);
1055                 }
1056         }
1057 }
1058
1059 void match_acl_ids(void)
1060 {
1061         match_racl_ids(&access_acl_list);
1062         match_racl_ids(&default_acl_list);
1063 }
1064
1065 /* This is used by dest_mode(). */
1066 int default_perms_for_dir(const char *dir)
1067 {
1068         rsync_acl racl;
1069         SMB_ACL_T sacl;
1070         BOOL ok;
1071         int perms;
1072
1073         if (dir == NULL)
1074                 dir = ".";
1075         perms = ACCESSPERMS & ~orig_umask;
1076         /* Read the directory's default ACL.  If it has none, this will successfully return an empty ACL. */
1077         sacl = sys_acl_get_file(dir, SMB_ACL_TYPE_DEFAULT);
1078         if (sacl == NULL) {
1079                 /* Couldn't get an ACL.  Darn. */
1080                 switch (errno) {
1081 #ifdef ENOTSUP
1082                 case ENOTSUP:
1083 #endif
1084                 case ENOSYS:
1085                         /* No ACLs are available. */
1086                         break;
1087                 case ENOENT:
1088                         if (dry_run) {
1089                                 /* We're doing a dry run, so the containing directory
1090                                  * wasn't actually created.  Don't worry about it. */
1091                                 break;
1092                         }
1093                         /* Otherwise fall through. */
1094                 default:
1095                         rprintf(FWARNING,
1096                                 "default_perms_for_dir: sys_acl_get_file(%s, %s): %s, falling back on umask\n",
1097                                 dir, str_acl_type(SMB_ACL_TYPE_DEFAULT), strerror(errno));
1098                 }
1099                 return perms;
1100         }
1101
1102         /* Convert it. */
1103         racl = empty_rsync_acl;
1104         ok = unpack_smb_acl(sacl, &racl);
1105         sys_acl_free_acl(sacl);
1106         if (!ok) {
1107                 rprintf(FWARNING, "default_perms_for_dir: unpack_smb_acl failed, falling back on umask\n");
1108                 return perms;
1109         }
1110
1111         /* Apply the permission-bit entries of the default ACL, if any. */
1112         if (racl.user_obj != NO_ENTRY) {
1113                 perms = rsync_acl_get_perms(&racl);
1114                 if (verbose > 2)
1115                         rprintf(FINFO, "got ACL-based default perms %o for directory %s\n", perms, dir);
1116         }
1117
1118         rsync_acl_free(&racl);
1119         return perms;
1120 }
1121
1122 #endif /* SUPPORT_ACLS */