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