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