Import libarchive-3.0.4.
[dragonfly.git] / contrib / libarchive / libarchive / archive_acl.c
1 /*-
2  * Copyright (c) 2003-2010 Tim Kientzle
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "archive_platform.h"
27 __FBSDID("$FreeBSD$");
28
29 #ifdef HAVE_ERRNO_H
30 #include <errno.h>
31 #endif
32 #ifdef HAVE_LIMITS_H
33 #include <limits.h>
34 #endif
35 #ifdef HAVE_WCHAR_H
36 #include <wchar.h>
37 #endif
38
39 #include "archive_acl_private.h"
40 #include "archive_entry.h"
41 #include "archive_private.h"
42
43 #undef max
44 #define max(a, b)       ((a)>(b)?(a):(b))
45
46 #ifndef HAVE_WMEMCMP
47 /* Good enough for simple equality testing, but not for sorting. */
48 #define wmemcmp(a,b,i)  memcmp((a), (b), (i) * sizeof(wchar_t))
49 #endif
50
51 static int      acl_special(struct archive_acl *acl,
52                     int type, int permset, int tag);
53 static struct archive_acl_entry *acl_new_entry(struct archive_acl *acl,
54                     int type, int permset, int tag, int id);
55 static int      archive_acl_add_entry_len_l(struct archive_acl *acl,
56                     int type, int permset, int tag, int id, const char *name,
57                     size_t len, struct archive_string_conv *sc);
58 static int      isint_w(const wchar_t *start, const wchar_t *end, int *result);
59 static int      ismode_w(const wchar_t *start, const wchar_t *end, int *result);
60 static void     next_field_w(const wchar_t **wp, const wchar_t **start,
61                     const wchar_t **end, wchar_t *sep);
62 static int      prefix_w(const wchar_t *start, const wchar_t *end,
63                     const wchar_t *test);
64 static void     append_entry_w(wchar_t **wp, const wchar_t *prefix, int tag,
65                     const wchar_t *wname, int perm, int id);
66 static void     append_id_w(wchar_t **wp, int id);
67 static int      isint(const char *start, const char *end, int *result);
68 static int      ismode(const char *start, const char *end, int *result);
69 static void     next_field(const char **p, const char **start,
70                     const char **end, char *sep);
71 static int      prefix_c(const char *start, const char *end,
72                     const char *test);
73 static void     append_entry(char **p, const char *prefix, int tag,
74                     const char *name, int perm, int id);
75 static void     append_id(char **p, int id);
76
77 void
78 archive_acl_clear(struct archive_acl *acl)
79 {
80         struct archive_acl_entry *ap;
81
82         while (acl->acl_head != NULL) {
83                 ap = acl->acl_head->next;
84                 archive_mstring_clean(&acl->acl_head->name);
85                 free(acl->acl_head);
86                 acl->acl_head = ap;
87         }
88         if (acl->acl_text_w != NULL) {
89                 free(acl->acl_text_w);
90                 acl->acl_text_w = NULL;
91         }
92         if (acl->acl_text != NULL) {
93                 free(acl->acl_text);
94                 acl->acl_text = NULL;
95         }
96         acl->acl_p = NULL;
97         acl->acl_state = 0; /* Not counting. */
98 }
99
100 void
101 archive_acl_copy(struct archive_acl *dest, struct archive_acl *src)
102 {
103         struct archive_acl_entry *ap, *ap2;
104
105         archive_acl_clear(dest);
106
107         dest->mode = src->mode;
108         ap = src->acl_head;
109         while (ap != NULL) {
110                 ap2 = acl_new_entry(dest,
111                     ap->type, ap->permset, ap->tag, ap->id);
112                 if (ap2 != NULL)
113                         archive_mstring_copy(&ap2->name, &ap->name);
114                 ap = ap->next;
115         }
116 }
117
118 int
119 archive_acl_add_entry(struct archive_acl *acl,
120     int type, int permset, int tag, int id, const char *name)
121 {
122         struct archive_acl_entry *ap;
123
124         if (acl_special(acl, type, permset, tag) == 0)
125                 return ARCHIVE_OK;
126         ap = acl_new_entry(acl, type, permset, tag, id);
127         if (ap == NULL) {
128                 /* XXX Error XXX */
129                 return ARCHIVE_FAILED;
130         }
131         if (name != NULL  &&  *name != '\0')
132                 archive_mstring_copy_mbs(&ap->name, name);
133         else
134                 archive_mstring_clean(&ap->name);
135         return ARCHIVE_OK;
136 }
137
138 int
139 archive_acl_add_entry_w_len(struct archive_acl *acl,
140     int type, int permset, int tag, int id, const wchar_t *name, size_t len)
141 {
142         struct archive_acl_entry *ap;
143
144         if (acl_special(acl, type, permset, tag) == 0)
145                 return ARCHIVE_OK;
146         ap = acl_new_entry(acl, type, permset, tag, id);
147         if (ap == NULL) {
148                 /* XXX Error XXX */
149                 return ARCHIVE_FAILED;
150         }
151         if (name != NULL  &&  *name != L'\0' && len > 0)
152                 archive_mstring_copy_wcs_len(&ap->name, name, len);
153         else
154                 archive_mstring_clean(&ap->name);
155         return ARCHIVE_OK;
156 }
157
158 static int
159 archive_acl_add_entry_len_l(struct archive_acl *acl,
160     int type, int permset, int tag, int id, const char *name, size_t len,
161     struct archive_string_conv *sc)
162 {
163         struct archive_acl_entry *ap;
164         int r;
165
166         if (acl_special(acl, type, permset, tag) == 0)
167                 return ARCHIVE_OK;
168         ap = acl_new_entry(acl, type, permset, tag, id);
169         if (ap == NULL) {
170                 /* XXX Error XXX */
171                 return ARCHIVE_FAILED;
172         }
173         if (name != NULL  &&  *name != '\0' && len > 0) {
174                 r = archive_mstring_copy_mbs_len_l(&ap->name, name, len, sc);
175         } else {
176                 r = 0;
177                 archive_mstring_clean(&ap->name);
178         }
179         if (r == 0)
180                 return (ARCHIVE_OK);
181         else if (errno == ENOMEM)
182                 return (ARCHIVE_FATAL);
183         else
184                 return (ARCHIVE_WARN);
185 }
186
187 /*
188  * If this ACL entry is part of the standard POSIX permissions set,
189  * store the permissions in the stat structure and return zero.
190  */
191 static int
192 acl_special(struct archive_acl *acl, int type, int permset, int tag)
193 {
194         if (type == ARCHIVE_ENTRY_ACL_TYPE_ACCESS
195             && ((permset & ~007) == 0)) {
196                 switch (tag) {
197                 case ARCHIVE_ENTRY_ACL_USER_OBJ:
198                         acl->mode &= ~0700;
199                         acl->mode |= (permset & 7) << 6;
200                         return (0);
201                 case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
202                         acl->mode &= ~0070;
203                         acl->mode |= (permset & 7) << 3;
204                         return (0);
205                 case ARCHIVE_ENTRY_ACL_OTHER:
206                         acl->mode &= ~0007;
207                         acl->mode |= permset & 7;
208                         return (0);
209                 }
210         }
211         return (1);
212 }
213
214 /*
215  * Allocate and populate a new ACL entry with everything but the
216  * name.
217  */
218 static struct archive_acl_entry *
219 acl_new_entry(struct archive_acl *acl,
220     int type, int permset, int tag, int id)
221 {
222         struct archive_acl_entry *ap, *aq;
223
224         /* Type argument must be a valid NFS4 or POSIX.1e type.
225          * The type must agree with anything already set and
226          * the permset must be compatible. */
227         if (type & ARCHIVE_ENTRY_ACL_TYPE_NFS4) {
228                 if (acl->acl_types & ~ARCHIVE_ENTRY_ACL_TYPE_NFS4) {
229                         return (NULL);
230                 }
231                 if (permset &
232                     ~(ARCHIVE_ENTRY_ACL_PERMS_NFS4
233                         | ARCHIVE_ENTRY_ACL_INHERITANCE_NFS4)) {
234                         return (NULL);
235                 }
236         } else  if (type & ARCHIVE_ENTRY_ACL_TYPE_POSIX1E) {
237                 if (acl->acl_types & ~ARCHIVE_ENTRY_ACL_TYPE_POSIX1E) {
238                         return (NULL);
239                 }
240                 if (permset & ~ARCHIVE_ENTRY_ACL_PERMS_POSIX1E) {
241                         return (NULL);
242                 }
243         } else {
244                 return (NULL);
245         }
246
247         /* Verify the tag is valid and compatible with NFS4 or POSIX.1e. */
248         switch (tag) {
249         case ARCHIVE_ENTRY_ACL_USER:
250         case ARCHIVE_ENTRY_ACL_USER_OBJ:
251         case ARCHIVE_ENTRY_ACL_GROUP:
252         case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
253                 /* Tags valid in both NFS4 and POSIX.1e */
254                 break;
255         case ARCHIVE_ENTRY_ACL_MASK:
256         case ARCHIVE_ENTRY_ACL_OTHER:
257                 /* Tags valid only in POSIX.1e. */
258                 if (type & ~ARCHIVE_ENTRY_ACL_TYPE_POSIX1E) {
259                         return (NULL);
260                 }
261                 break;
262         case ARCHIVE_ENTRY_ACL_EVERYONE:
263                 /* Tags valid only in NFS4. */
264                 if (type & ~ARCHIVE_ENTRY_ACL_TYPE_NFS4) {
265                         return (NULL);
266                 }
267                 break;
268         default:
269                 /* No other values are valid. */
270                 return (NULL);
271         }
272
273         if (acl->acl_text_w != NULL) {
274                 free(acl->acl_text_w);
275                 acl->acl_text_w = NULL;
276         }
277         if (acl->acl_text != NULL) {
278                 free(acl->acl_text);
279                 acl->acl_text = NULL;
280         }
281
282         /* If there's a matching entry already in the list, overwrite it. */
283         ap = acl->acl_head;
284         aq = NULL;
285         while (ap != NULL) {
286                 if (ap->type == type && ap->tag == tag && ap->id == id) {
287                         ap->permset = permset;
288                         return (ap);
289                 }
290                 aq = ap;
291                 ap = ap->next;
292         }
293
294         /* Add a new entry to the end of the list. */
295         ap = (struct archive_acl_entry *)malloc(sizeof(*ap));
296         if (ap == NULL)
297                 return (NULL);
298         memset(ap, 0, sizeof(*ap));
299         if (aq == NULL)
300                 acl->acl_head = ap;
301         else
302                 aq->next = ap;
303         ap->type = type;
304         ap->tag = tag;
305         ap->id = id;
306         ap->permset = permset;
307         acl->acl_types |= type;
308         return (ap);
309 }
310
311 /*
312  * Return a count of entries matching "want_type".
313  */
314 int
315 archive_acl_count(struct archive_acl *acl, int want_type)
316 {
317         int count;
318         struct archive_acl_entry *ap;
319
320         count = 0;
321         ap = acl->acl_head;
322         while (ap != NULL) {
323                 if ((ap->type & want_type) != 0)
324                         count++;
325                 ap = ap->next;
326         }
327
328         if (count > 0 && ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0))
329                 count += 3;
330         return (count);
331 }
332
333 /*
334  * Prepare for reading entries from the ACL data.  Returns a count
335  * of entries matching "want_type", or zero if there are no
336  * non-extended ACL entries of that type.
337  */
338 int
339 archive_acl_reset(struct archive_acl *acl, int want_type)
340 {
341         int count, cutoff;
342
343         count = archive_acl_count(acl, want_type);
344
345         /*
346          * If the only entries are the three standard ones,
347          * then don't return any ACL data.  (In this case,
348          * client can just use chmod(2) to set permissions.)
349          */
350         if ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0)
351                 cutoff = 3;
352         else
353                 cutoff = 0;
354
355         if (count > cutoff)
356                 acl->acl_state = ARCHIVE_ENTRY_ACL_USER_OBJ;
357         else
358                 acl->acl_state = 0;
359         acl->acl_p = acl->acl_head;
360         return (count);
361 }
362
363
364 /*
365  * Return the next ACL entry in the list.  Fake entries for the
366  * standard permissions and include them in the returned list.
367  */
368 int
369 archive_acl_next(struct archive *a, struct archive_acl *acl, int want_type, int *type,
370     int *permset, int *tag, int *id, const char **name)
371 {
372         *name = NULL;
373         *id = -1;
374
375         /*
376          * The acl_state is either zero (no entries available), -1
377          * (reading from list), or an entry type (retrieve that type
378          * from ae_stat.aest_mode).
379          */
380         if (acl->acl_state == 0)
381                 return (ARCHIVE_WARN);
382
383         /* The first three access entries are special. */
384         if ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0) {
385                 switch (acl->acl_state) {
386                 case ARCHIVE_ENTRY_ACL_USER_OBJ:
387                         *permset = (acl->mode >> 6) & 7;
388                         *type = ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
389                         *tag = ARCHIVE_ENTRY_ACL_USER_OBJ;
390                         acl->acl_state = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
391                         return (ARCHIVE_OK);
392                 case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
393                         *permset = (acl->mode >> 3) & 7;
394                         *type = ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
395                         *tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
396                         acl->acl_state = ARCHIVE_ENTRY_ACL_OTHER;
397                         return (ARCHIVE_OK);
398                 case ARCHIVE_ENTRY_ACL_OTHER:
399                         *permset = acl->mode & 7;
400                         *type = ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
401                         *tag = ARCHIVE_ENTRY_ACL_OTHER;
402                         acl->acl_state = -1;
403                         acl->acl_p = acl->acl_head;
404                         return (ARCHIVE_OK);
405                 default:
406                         break;
407                 }
408         }
409
410         while (acl->acl_p != NULL && (acl->acl_p->type & want_type) == 0)
411                 acl->acl_p = acl->acl_p->next;
412         if (acl->acl_p == NULL) {
413                 acl->acl_state = 0;
414                 *type = 0;
415                 *permset = 0;
416                 *tag = 0;
417                 *id = -1;
418                 *name = NULL;
419                 return (ARCHIVE_EOF); /* End of ACL entries. */
420         }
421         *type = acl->acl_p->type;
422         *permset = acl->acl_p->permset;
423         *tag = acl->acl_p->tag;
424         *id = acl->acl_p->id;
425         if (archive_mstring_get_mbs(a, &acl->acl_p->name, name) != 0) {
426                 if (errno == ENOMEM)
427                         return (ARCHIVE_FATAL);
428                 *name = NULL;
429         }
430         acl->acl_p = acl->acl_p->next;
431         return (ARCHIVE_OK);
432 }
433
434 /*
435  * Generate a text version of the ACL.  The flags parameter controls
436  * the style of the generated ACL.
437  */
438 const wchar_t *
439 archive_acl_text_w(struct archive *a, struct archive_acl *acl, int flags)
440 {
441         int count;
442         size_t length;
443         const wchar_t *wname;
444         const wchar_t *prefix;
445         wchar_t separator;
446         struct archive_acl_entry *ap;
447         int id, r;
448         wchar_t *wp;
449
450         if (acl->acl_text_w != NULL) {
451                 free (acl->acl_text_w);
452                 acl->acl_text_w = NULL;
453         }
454
455         separator = L',';
456         count = 0;
457         length = 0;
458         ap = acl->acl_head;
459         while (ap != NULL) {
460                 if ((ap->type & flags) != 0) {
461                         count++;
462                         if ((flags & ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT) &&
463                             (ap->type & ARCHIVE_ENTRY_ACL_TYPE_DEFAULT))
464                                 length += 8; /* "default:" */
465                         length += 5; /* tag name */
466                         length += 1; /* colon */
467                         r = archive_mstring_get_wcs(a, &ap->name, &wname);
468                         if (r == 0 && wname != NULL)
469                                 length += wcslen(wname);
470                         else if (r < 0 && errno == ENOMEM)
471                                 return (NULL);
472                         else
473                                 length += sizeof(uid_t) * 3 + 1;
474                         length ++; /* colon */
475                         length += 3; /* rwx */
476                         length += 1; /* colon */
477                         length += max(sizeof(uid_t), sizeof(gid_t)) * 3 + 1;
478                         length ++; /* newline */
479                 }
480                 ap = ap->next;
481         }
482
483         if (count > 0 && ((flags & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0)) {
484                 length += 10; /* "user::rwx\n" */
485                 length += 11; /* "group::rwx\n" */
486                 length += 11; /* "other::rwx\n" */
487         }
488
489         if (count == 0)
490                 return (NULL);
491
492         /* Now, allocate the string and actually populate it. */
493         wp = acl->acl_text_w = (wchar_t *)malloc(length * sizeof(wchar_t));
494         if (wp == NULL)
495                 return (NULL);
496         count = 0;
497         if ((flags & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0) {
498                 append_entry_w(&wp, NULL, ARCHIVE_ENTRY_ACL_USER_OBJ, NULL,
499                     acl->mode & 0700, -1);
500                 *wp++ = ',';
501                 append_entry_w(&wp, NULL, ARCHIVE_ENTRY_ACL_GROUP_OBJ, NULL,
502                     acl->mode & 0070, -1);
503                 *wp++ = ',';
504                 append_entry_w(&wp, NULL, ARCHIVE_ENTRY_ACL_OTHER, NULL,
505                     acl->mode & 0007, -1);
506                 count += 3;
507
508                 ap = acl->acl_head;
509                 while (ap != NULL) {
510                         if ((ap->type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0) {
511                                 r = archive_mstring_get_wcs(a, &ap->name, &wname);
512                                 if (r == 0) {
513                                         *wp++ = separator;
514                                         if (flags & ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID)
515                                                 id = ap->id;
516                                         else
517                                                 id = -1;
518                                         append_entry_w(&wp, NULL, ap->tag, wname,
519                                             ap->permset, id);
520                                         count++;
521                                 } else if (r < 0 && errno == ENOMEM)
522                                         return (NULL);
523                         }
524                         ap = ap->next;
525                 }
526         }
527
528
529         if ((flags & ARCHIVE_ENTRY_ACL_TYPE_DEFAULT) != 0) {
530                 if (flags & ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT)
531                         prefix = L"default:";
532                 else
533                         prefix = NULL;
534                 ap = acl->acl_head;
535                 count = 0;
536                 while (ap != NULL) {
537                         if ((ap->type & ARCHIVE_ENTRY_ACL_TYPE_DEFAULT) != 0) {
538                                 r = archive_mstring_get_wcs(a, &ap->name, &wname);
539                                 if (r == 0) {
540                                         if (count > 0)
541                                                 *wp++ = separator;
542                                         if (flags & ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID)
543                                                 id = ap->id;
544                                         else
545                                                 id = -1;
546                                         append_entry_w(&wp, prefix, ap->tag,
547                                             wname, ap->permset, id);
548                                         count ++;
549                                 } else if (r < 0 && errno == ENOMEM)
550                                         return (NULL);
551                         }
552                         ap = ap->next;
553                 }
554         }
555
556         return (acl->acl_text_w);
557 }
558
559
560 static void
561 append_id_w(wchar_t **wp, int id)
562 {
563         if (id < 0)
564                 id = 0;
565         if (id > 9)
566                 append_id_w(wp, id / 10);
567         *(*wp)++ = L"0123456789"[id % 10];
568 }
569
570 static void
571 append_entry_w(wchar_t **wp, const wchar_t *prefix, int tag,
572     const wchar_t *wname, int perm, int id)
573 {
574         if (prefix != NULL) {
575                 wcscpy(*wp, prefix);
576                 *wp += wcslen(*wp);
577         }
578         switch (tag) {
579         case ARCHIVE_ENTRY_ACL_USER_OBJ:
580                 wname = NULL;
581                 id = -1;
582                 /* FALLTHROUGH */
583         case ARCHIVE_ENTRY_ACL_USER:
584                 wcscpy(*wp, L"user");
585                 break;
586         case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
587                 wname = NULL;
588                 id = -1;
589                 /* FALLTHROUGH */
590         case ARCHIVE_ENTRY_ACL_GROUP:
591                 wcscpy(*wp, L"group");
592                 break;
593         case ARCHIVE_ENTRY_ACL_MASK:
594                 wcscpy(*wp, L"mask");
595                 wname = NULL;
596                 id = -1;
597                 break;
598         case ARCHIVE_ENTRY_ACL_OTHER:
599                 wcscpy(*wp, L"other");
600                 wname = NULL;
601                 id = -1;
602                 break;
603         }
604         *wp += wcslen(*wp);
605         *(*wp)++ = L':';
606         if (wname != NULL) {
607                 wcscpy(*wp, wname);
608                 *wp += wcslen(*wp);
609         } else if (tag == ARCHIVE_ENTRY_ACL_USER
610             || tag == ARCHIVE_ENTRY_ACL_GROUP) {
611                 append_id_w(wp, id);
612                 id = -1;
613         }
614         *(*wp)++ = L':';
615         *(*wp)++ = (perm & 0444) ? L'r' : L'-';
616         *(*wp)++ = (perm & 0222) ? L'w' : L'-';
617         *(*wp)++ = (perm & 0111) ? L'x' : L'-';
618         if (id != -1) {
619                 *(*wp)++ = L':';
620                 append_id_w(wp, id);
621         }
622         **wp = L'\0';
623 }
624
625 int
626 archive_acl_text_l(struct archive_acl *acl, int flags,
627     const char **acl_text, size_t *acl_text_len,
628     struct archive_string_conv *sc)
629 {
630         int count;
631         size_t length;
632         const char *name;
633         const char *prefix;
634         char separator;
635         struct archive_acl_entry *ap;
636         size_t len;
637         int id, r;
638         char *p;
639
640         if (acl->acl_text != NULL) {
641                 free (acl->acl_text);
642                 acl->acl_text = NULL;
643         }
644
645         *acl_text = NULL;
646         if (acl_text_len != NULL)
647                 *acl_text_len = 0;
648         separator = ',';
649         count = 0;
650         length = 0;
651         ap = acl->acl_head;
652         while (ap != NULL) {
653                 if ((ap->type & flags) != 0) {
654                         count++;
655                         if ((flags & ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT) &&
656                             (ap->type & ARCHIVE_ENTRY_ACL_TYPE_DEFAULT))
657                                 length += 8; /* "default:" */
658                         length += 5; /* tag name */
659                         length += 1; /* colon */
660                         r = archive_mstring_get_mbs_l(
661                             &ap->name, &name, &len, sc);
662                         if (r != 0)
663                                 return (-1);
664                         if (len > 0 && name != NULL)
665                                 length += len;
666                         else
667                                 length += sizeof(uid_t) * 3 + 1;
668                         length ++; /* colon */
669                         length += 3; /* rwx */
670                         length += 1; /* colon */
671                         length += max(sizeof(uid_t), sizeof(gid_t)) * 3 + 1;
672                         length ++; /* newline */
673                 }
674                 ap = ap->next;
675         }
676
677         if (count > 0 && ((flags & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0)) {
678                 length += 10; /* "user::rwx\n" */
679                 length += 11; /* "group::rwx\n" */
680                 length += 11; /* "other::rwx\n" */
681         }
682
683         if (count == 0)
684                 return (0);
685
686         /* Now, allocate the string and actually populate it. */
687         p = acl->acl_text = (char *)malloc(length);
688         if (p == NULL)
689                 return (-1);
690         count = 0;
691         if ((flags & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0) {
692                 append_entry(&p, NULL, ARCHIVE_ENTRY_ACL_USER_OBJ, NULL,
693                     acl->mode & 0700, -1);
694                 *p++ = ',';
695                 append_entry(&p, NULL, ARCHIVE_ENTRY_ACL_GROUP_OBJ, NULL,
696                     acl->mode & 0070, -1);
697                 *p++ = ',';
698                 append_entry(&p, NULL, ARCHIVE_ENTRY_ACL_OTHER, NULL,
699                     acl->mode & 0007, -1);
700                 count += 3;
701
702                 for (ap = acl->acl_head; ap != NULL; ap = ap->next) {
703                         if ((ap->type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) == 0)
704                                 continue;
705                         r = archive_mstring_get_mbs_l(
706                             &ap->name, &name, &len, sc);
707                         if (r != 0)
708                                 return (-1);
709                         *p++ = separator;
710                         if (flags & ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID)
711                                 id = ap->id;
712                         else
713                                 id = -1;
714                         append_entry(&p, NULL, ap->tag, name,
715                             ap->permset, id);
716                         count++;
717                 }
718         }
719
720
721         if ((flags & ARCHIVE_ENTRY_ACL_TYPE_DEFAULT) != 0) {
722                 if (flags & ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT)
723                         prefix = "default:";
724                 else
725                         prefix = NULL;
726                 count = 0;
727                 for (ap = acl->acl_head; ap != NULL; ap = ap->next) {
728                         if ((ap->type & ARCHIVE_ENTRY_ACL_TYPE_DEFAULT) == 0)
729                                 continue;
730                         r = archive_mstring_get_mbs_l(
731                             &ap->name, &name, &len, sc);
732                         if (r != 0)
733                                 return (-1);
734                         if (count > 0)
735                                 *p++ = separator;
736                         if (flags & ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID)
737                                 id = ap->id;
738                         else
739                                 id = -1;
740                         append_entry(&p, prefix, ap->tag,
741                             name, ap->permset, id);
742                         count ++;
743                 }
744         }
745
746         *acl_text = acl->acl_text;
747         if (acl_text_len != NULL)
748                 *acl_text_len = strlen(acl->acl_text);
749         return (0);
750 }
751
752 static void
753 append_id(char **p, int id)
754 {
755         if (id < 0)
756                 id = 0;
757         if (id > 9)
758                 append_id(p, id / 10);
759         *(*p)++ = "0123456789"[id % 10];
760 }
761
762 static void
763 append_entry(char **p, const char *prefix, int tag,
764     const char *name, int perm, int id)
765 {
766         if (prefix != NULL) {
767                 strcpy(*p, prefix);
768                 *p += strlen(*p);
769         }
770         switch (tag) {
771         case ARCHIVE_ENTRY_ACL_USER_OBJ:
772                 name = NULL;
773                 id = -1;
774                 /* FALLTHROUGH */
775         case ARCHIVE_ENTRY_ACL_USER:
776                 strcpy(*p, "user");
777                 break;
778         case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
779                 name = NULL;
780                 id = -1;
781                 /* FALLTHROUGH */
782         case ARCHIVE_ENTRY_ACL_GROUP:
783                 strcpy(*p, "group");
784                 break;
785         case ARCHIVE_ENTRY_ACL_MASK:
786                 strcpy(*p, "mask");
787                 name = NULL;
788                 id = -1;
789                 break;
790         case ARCHIVE_ENTRY_ACL_OTHER:
791                 strcpy(*p, "other");
792                 name = NULL;
793                 id = -1;
794                 break;
795         }
796         *p += strlen(*p);
797         *(*p)++ = ':';
798         if (name != NULL) {
799                 strcpy(*p, name);
800                 *p += strlen(*p);
801         } else if (tag == ARCHIVE_ENTRY_ACL_USER
802             || tag == ARCHIVE_ENTRY_ACL_GROUP) {
803                 append_id(p, id);
804                 id = -1;
805         }
806         *(*p)++ = ':';
807         *(*p)++ = (perm & 0444) ? 'r' : '-';
808         *(*p)++ = (perm & 0222) ? 'w' : '-';
809         *(*p)++ = (perm & 0111) ? 'x' : '-';
810         if (id != -1) {
811                 *(*p)++ = ':';
812                 append_id(p, id);
813         }
814         **p = '\0';
815 }
816
817 /*
818  * Parse a textual ACL.  This automatically recognizes and supports
819  * extensions described above.  The 'type' argument is used to
820  * indicate the type that should be used for any entries not
821  * explicitly marked as "default:".
822  */
823 int
824 archive_acl_parse_w(struct archive_acl *acl,
825     const wchar_t *text, int default_type)
826 {
827         struct {
828                 const wchar_t *start;
829                 const wchar_t *end;
830         } field[4], name;
831
832         int fields, n;
833         int type, tag, permset, id;
834         wchar_t sep;
835
836         while (text != NULL  &&  *text != L'\0') {
837                 /*
838                  * Parse the fields out of the next entry,
839                  * advance 'text' to start of next entry.
840                  */
841                 fields = 0;
842                 do {
843                         const wchar_t *start, *end;
844                         next_field_w(&text, &start, &end, &sep);
845                         if (fields < 4) {
846                                 field[fields].start = start;
847                                 field[fields].end = end;
848                         }
849                         ++fields;
850                 } while (sep == L':');
851
852                 /* Set remaining fields to blank. */
853                 for (n = fields; n < 4; ++n)
854                         field[n].start = field[n].end = NULL;
855
856                 /* Check for a numeric ID in field 1 or 3. */
857                 id = -1;
858                 isint_w(field[1].start, field[1].end, &id);
859                 /* Field 3 is optional. */
860                 if (id == -1 && fields > 3)
861                         isint_w(field[3].start, field[3].end, &id);
862
863                 /*
864                  * Solaris extension:  "defaultuser::rwx" is the
865                  * default ACL corresponding to "user::rwx", etc.
866                  */
867                 if (field[0].end - field[0].start > 7
868                     && wmemcmp(field[0].start, L"default", 7) == 0) {
869                         type = ARCHIVE_ENTRY_ACL_TYPE_DEFAULT;
870                         field[0].start += 7;
871                 } else
872                         type = default_type;
873
874                 name.start = name.end = NULL;
875                 if (prefix_w(field[0].start, field[0].end, L"user")) {
876                         if (!ismode_w(field[2].start, field[2].end, &permset))
877                                 return (ARCHIVE_WARN);
878                         if (id != -1 || field[1].start < field[1].end) {
879                                 tag = ARCHIVE_ENTRY_ACL_USER;
880                                 name = field[1];
881                         } else
882                                 tag = ARCHIVE_ENTRY_ACL_USER_OBJ;
883                 } else if (prefix_w(field[0].start, field[0].end, L"group")) {
884                         if (!ismode_w(field[2].start, field[2].end, &permset))
885                                 return (ARCHIVE_WARN);
886                         if (id != -1 || field[1].start < field[1].end) {
887                                 tag = ARCHIVE_ENTRY_ACL_GROUP;
888                                 name = field[1];
889                         } else
890                                 tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
891                 } else if (prefix_w(field[0].start, field[0].end, L"other")) {
892                         if (fields == 2
893                             && field[1].start < field[1].end
894                             && ismode_w(field[1].start, field[1].end, &permset)) {
895                                 /* This is Solaris-style "other:rwx" */
896                         } else if (fields == 3
897                             && field[1].start == field[1].end
898                             && field[2].start < field[2].end
899                             && ismode_w(field[2].start, field[2].end, &permset)) {
900                                 /* This is FreeBSD-style "other::rwx" */
901                         } else
902                                 return (ARCHIVE_WARN);
903                         tag = ARCHIVE_ENTRY_ACL_OTHER;
904                 } else if (prefix_w(field[0].start, field[0].end, L"mask")) {
905                         if (fields == 2
906                             && field[1].start < field[1].end
907                             && ismode_w(field[1].start, field[1].end, &permset)) {
908                                 /* This is Solaris-style "mask:rwx" */
909                         } else if (fields == 3
910                             && field[1].start == field[1].end
911                             && field[2].start < field[2].end
912                             && ismode_w(field[2].start, field[2].end, &permset)) {
913                                 /* This is FreeBSD-style "mask::rwx" */
914                         } else
915                                 return (ARCHIVE_WARN);
916                         tag = ARCHIVE_ENTRY_ACL_MASK;
917                 } else
918                         return (ARCHIVE_WARN);
919
920                 /* Add entry to the internal list. */
921                 archive_acl_add_entry_w_len(acl, type, permset,
922                     tag, id, name.start, name.end - name.start);
923         }
924         return (ARCHIVE_OK);
925 }
926
927 /*
928  * Parse a string to a positive decimal integer.  Returns true if
929  * the string is non-empty and consists only of decimal digits,
930  * false otherwise.
931  */
932 static int
933 isint_w(const wchar_t *start, const wchar_t *end, int *result)
934 {
935         int n = 0;
936         if (start >= end)
937                 return (0);
938         while (start < end) {
939                 if (*start < '0' || *start > '9')
940                         return (0);
941                 if (n > (INT_MAX / 10) ||
942                     (n == INT_MAX / 10 && (*start - '0') > INT_MAX % 10)) {
943                         n = INT_MAX;
944                 } else {
945                         n *= 10;
946                         n += *start - '0';
947                 }
948                 start++;
949         }
950         *result = n;
951         return (1);
952 }
953
954 /*
955  * Parse a string as a mode field.  Returns true if
956  * the string is non-empty and consists only of mode characters,
957  * false otherwise.
958  */
959 static int
960 ismode_w(const wchar_t *start, const wchar_t *end, int *permset)
961 {
962         const wchar_t *p;
963
964         if (start >= end)
965                 return (0);
966         p = start;
967         *permset = 0;
968         while (p < end) {
969                 switch (*p++) {
970                 case 'r': case 'R':
971                         *permset |= ARCHIVE_ENTRY_ACL_READ;
972                         break;
973                 case 'w': case 'W':
974                         *permset |= ARCHIVE_ENTRY_ACL_WRITE;
975                         break;
976                 case 'x': case 'X':
977                         *permset |= ARCHIVE_ENTRY_ACL_EXECUTE;
978                         break;
979                 case '-':
980                         break;
981                 default:
982                         return (0);
983                 }
984         }
985         return (1);
986 }
987
988 /*
989  * Match "[:whitespace:]*(.*)[:whitespace:]*[:,\n]".  *wp is updated
990  * to point to just after the separator.  *start points to the first
991  * character of the matched text and *end just after the last
992  * character of the matched identifier.  In particular *end - *start
993  * is the length of the field body, not including leading or trailing
994  * whitespace.
995  */
996 static void
997 next_field_w(const wchar_t **wp, const wchar_t **start,
998     const wchar_t **end, wchar_t *sep)
999 {
1000         /* Skip leading whitespace to find start of field. */
1001         while (**wp == L' ' || **wp == L'\t' || **wp == L'\n') {
1002                 (*wp)++;
1003         }
1004         *start = *wp;
1005
1006         /* Scan for the separator. */
1007         while (**wp != L'\0' && **wp != L',' && **wp != L':' &&
1008             **wp != L'\n') {
1009                 (*wp)++;
1010         }
1011         *sep = **wp;
1012
1013         /* Trim trailing whitespace to locate end of field. */
1014         *end = *wp - 1;
1015         while (**end == L' ' || **end == L'\t' || **end == L'\n') {
1016                 (*end)--;
1017         }
1018         (*end)++;
1019
1020         /* Adjust scanner location. */
1021         if (**wp != L'\0')
1022                 (*wp)++;
1023 }
1024
1025 /*
1026  * Return true if the characters [start...end) are a prefix of 'test'.
1027  * This makes it easy to handle the obvious abbreviations: 'u' for 'user', etc.
1028  */
1029 static int
1030 prefix_w(const wchar_t *start, const wchar_t *end, const wchar_t *test)
1031 {
1032         if (start == end)
1033                 return (0);
1034
1035         if (*start++ != *test++)
1036                 return (0);
1037
1038         while (start < end  &&  *start++ == *test++)
1039                 ;
1040
1041         if (start < end)
1042                 return (0);
1043
1044         return (1);
1045 }
1046
1047 /*
1048  * Parse a textual ACL.  This automatically recognizes and supports
1049  * extensions described above.  The 'type' argument is used to
1050  * indicate the type that should be used for any entries not
1051  * explicitly marked as "default:".
1052  */
1053 int
1054 archive_acl_parse_l(struct archive_acl *acl,
1055     const char *text, int default_type, struct archive_string_conv *sc)
1056 {
1057         struct {
1058                 const char *start;
1059                 const char *end;
1060         } field[4], name;
1061
1062         int fields, n, r, ret = ARCHIVE_OK;
1063         int type, tag, permset, id;
1064         char sep;
1065
1066         while (text != NULL  &&  *text != '\0') {
1067                 /*
1068                  * Parse the fields out of the next entry,
1069                  * advance 'text' to start of next entry.
1070                  */
1071                 fields = 0;
1072                 do {
1073                         const char *start, *end;
1074                         next_field(&text, &start, &end, &sep);
1075                         if (fields < 4) {
1076                                 field[fields].start = start;
1077                                 field[fields].end = end;
1078                         }
1079                         ++fields;
1080                 } while (sep == ':');
1081
1082                 /* Set remaining fields to blank. */
1083                 for (n = fields; n < 4; ++n)
1084                         field[n].start = field[n].end = NULL;
1085
1086                 /* Check for a numeric ID in field 1 or 3. */
1087                 id = -1;
1088                 isint(field[1].start, field[1].end, &id);
1089                 /* Field 3 is optional. */
1090                 if (id == -1 && fields > 3)
1091                         isint(field[3].start, field[3].end, &id);
1092
1093                 /*
1094                  * Solaris extension:  "defaultuser::rwx" is the
1095                  * default ACL corresponding to "user::rwx", etc.
1096                  */
1097                 if (field[0].end - field[0].start > 7
1098                     && memcmp(field[0].start, "default", 7) == 0) {
1099                         type = ARCHIVE_ENTRY_ACL_TYPE_DEFAULT;
1100                         field[0].start += 7;
1101                 } else
1102                         type = default_type;
1103
1104                 name.start = name.end = NULL;
1105                 if (prefix_c(field[0].start, field[0].end, "user")) {
1106                         if (!ismode(field[2].start, field[2].end, &permset))
1107                                 return (ARCHIVE_WARN);
1108                         if (id != -1 || field[1].start < field[1].end) {
1109                                 tag = ARCHIVE_ENTRY_ACL_USER;
1110                                 name = field[1];
1111                         } else
1112                                 tag = ARCHIVE_ENTRY_ACL_USER_OBJ;
1113                 } else if (prefix_c(field[0].start, field[0].end, "group")) {
1114                         if (!ismode(field[2].start, field[2].end, &permset))
1115                                 return (ARCHIVE_WARN);
1116                         if (id != -1 || field[1].start < field[1].end) {
1117                                 tag = ARCHIVE_ENTRY_ACL_GROUP;
1118                                 name = field[1];
1119                         } else
1120                                 tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
1121                 } else if (prefix_c(field[0].start, field[0].end, "other")) {
1122                         if (fields == 2
1123                             && field[1].start < field[1].end
1124                             && ismode(field[1].start, field[1].end, &permset)) {
1125                                 /* This is Solaris-style "other:rwx" */
1126                         } else if (fields == 3
1127                             && field[1].start == field[1].end
1128                             && field[2].start < field[2].end
1129                             && ismode(field[2].start, field[2].end, &permset)) {
1130                                 /* This is FreeBSD-style "other::rwx" */
1131                         } else
1132                                 return (ARCHIVE_WARN);
1133                         tag = ARCHIVE_ENTRY_ACL_OTHER;
1134                 } else if (prefix_c(field[0].start, field[0].end, "mask")) {
1135                         if (fields == 2
1136                             && field[1].start < field[1].end
1137                             && ismode(field[1].start, field[1].end, &permset)) {
1138                                 /* This is Solaris-style "mask:rwx" */
1139                         } else if (fields == 3
1140                             && field[1].start == field[1].end
1141                             && field[2].start < field[2].end
1142                             && ismode(field[2].start, field[2].end, &permset)) {
1143                                 /* This is FreeBSD-style "mask::rwx" */
1144                         } else
1145                                 return (ARCHIVE_WARN);
1146                         tag = ARCHIVE_ENTRY_ACL_MASK;
1147                 } else
1148                         return (ARCHIVE_WARN);
1149
1150                 /* Add entry to the internal list. */
1151                 r = archive_acl_add_entry_len_l(acl, type, permset,
1152                     tag, id, name.start, name.end - name.start, sc);
1153                 if (r < ARCHIVE_WARN)
1154                         return (r);
1155                 if (r != ARCHIVE_OK)
1156                         ret = ARCHIVE_WARN;
1157         }
1158         return (ret);
1159 }
1160
1161 /*
1162  * Parse a string to a positive decimal integer.  Returns true if
1163  * the string is non-empty and consists only of decimal digits,
1164  * false otherwise.
1165  */
1166 static int
1167 isint(const char *start, const char *end, int *result)
1168 {
1169         int n = 0;
1170         if (start >= end)
1171                 return (0);
1172         while (start < end) {
1173                 if (*start < '0' || *start > '9')
1174                         return (0);
1175                 if (n > (INT_MAX / 10) ||
1176                     (n == INT_MAX / 10 && (*start - '0') > INT_MAX % 10)) {
1177                         n = INT_MAX;
1178                 } else {
1179                         n *= 10;
1180                         n += *start - '0';
1181                 }
1182                 start++;
1183         }
1184         *result = n;
1185         return (1);
1186 }
1187
1188 /*
1189  * Parse a string as a mode field.  Returns true if
1190  * the string is non-empty and consists only of mode characters,
1191  * false otherwise.
1192  */
1193 static int
1194 ismode(const char *start, const char *end, int *permset)
1195 {
1196         const char *p;
1197
1198         if (start >= end)
1199                 return (0);
1200         p = start;
1201         *permset = 0;
1202         while (p < end) {
1203                 switch (*p++) {
1204                 case 'r': case 'R':
1205                         *permset |= ARCHIVE_ENTRY_ACL_READ;
1206                         break;
1207                 case 'w': case 'W':
1208                         *permset |= ARCHIVE_ENTRY_ACL_WRITE;
1209                         break;
1210                 case 'x': case 'X':
1211                         *permset |= ARCHIVE_ENTRY_ACL_EXECUTE;
1212                         break;
1213                 case '-':
1214                         break;
1215                 default:
1216                         return (0);
1217                 }
1218         }
1219         return (1);
1220 }
1221
1222 /*
1223  * Match "[:whitespace:]*(.*)[:whitespace:]*[:,\n]".  *wp is updated
1224  * to point to just after the separator.  *start points to the first
1225  * character of the matched text and *end just after the last
1226  * character of the matched identifier.  In particular *end - *start
1227  * is the length of the field body, not including leading or trailing
1228  * whitespace.
1229  */
1230 static void
1231 next_field(const char **p, const char **start,
1232     const char **end, char *sep)
1233 {
1234         /* Skip leading whitespace to find start of field. */
1235         while (**p == ' ' || **p == '\t' || **p == '\n') {
1236                 (*p)++;
1237         }
1238         *start = *p;
1239
1240         /* Scan for the separator. */
1241         while (**p != '\0' && **p != ',' && **p != ':' && **p != '\n') {
1242                 (*p)++;
1243         }
1244         *sep = **p;
1245
1246         /* Trim trailing whitespace to locate end of field. */
1247         *end = *p - 1;
1248         while (**end == ' ' || **end == '\t' || **end == '\n') {
1249                 (*end)--;
1250         }
1251         (*end)++;
1252
1253         /* Adjust scanner location. */
1254         if (**p != '\0')
1255                 (*p)++;
1256 }
1257
1258 /*
1259  * Return true if the characters [start...end) are a prefix of 'test'.
1260  * This makes it easy to handle the obvious abbreviations: 'u' for 'user', etc.
1261  */
1262 static int
1263 prefix_c(const char *start, const char *end, const char *test)
1264 {
1265         if (start == end)
1266                 return (0);
1267
1268         if (*start++ != *test++)
1269                 return (0);
1270
1271         while (start < end  &&  *start++ == *test++)
1272                 ;
1273
1274         if (start < end)
1275                 return (0);
1276
1277         return (1);
1278 }