290f8b9694f56a26b734c90f3a4a554a44b1f95f
[dump.git] / restore / xattr.c
1 /*
2 * Copyright (c) 1999-2004
3 * Stelian Pop <stelian@popies.net>, 1999-2004
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 * 3. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 */
29
30 #ifndef lint
31 static const char rcsid[] =
32 "$Id: xattr.c,v 1.3 2005/06/08 13:24:12 stelian Exp $";
33 #endif /* not lint */
34
35 #include <config.h>
36 #include <compatlfs.h>
37 #include <compaterr.h>
38 #include <sys/types.h>
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <string.h>
42 #include <unistd.h>
43 #include <errno.h>
44 #include <bsdcompat.h>
45 #include <protocols/dumprestore.h>
46 #include "restore.h"
47 #include "extern.h"
48 #include "pathnames.h"
49
50 /*
51 * Data structures below taken from the kernel
52 */
53
54 /* Maximum number of references to one attribute block */
55 #define EXT2_XATTR_REFCOUNT_MAX 1024
56
57 /* Name indexes */
58 #define EXT2_XATTR_INDEX_MAX 10
59 #define EXT2_XATTR_INDEX_USER 1
60 #define EXT2_XATTR_INDEX_POSIX_ACL_ACCESS 2
61 #define EXT2_XATTR_INDEX_POSIX_ACL_DEFAULT 3
62 #define EXT2_XATTR_INDEX_TRUSTED 4
63 #define EXT2_XATTR_INDEX_LUSTRE 5
64 #define EXT2_XATTR_INDEX_SECURITY 6
65
66 struct ext2_xattr_header {
67 u_int32_t h_magic; /* magic number for identification */
68 u_int32_t h_refcount; /* reference count */
69 u_int32_t h_blocks; /* number of disk blocks used */
70 u_int32_t h_hash; /* hash value of all attributes */
71 u_int32_t h_reserved[4]; /* zero right now */
72 };
73
74 struct ext3_xattr_ibody_header {
75 u_int32_t h_magic; /* magic number for identification */
76 };
77
78 struct ext2_xattr_entry {
79 u_char e_name_len; /* length of name */
80 u_char e_name_index; /* attribute name index */
81 u_int16_t e_value_offs; /* offset in disk block of value */
82 u_int32_t e_value_block; /* disk block attribute is stored on (n/i) */
83 u_int32_t e_value_size; /* size of attribute value */
84 u_int32_t e_hash; /* hash value of name and value */
85 char e_name[0]; /* attribute name */
86 };
87
88 #define EXT2_XATTR_PAD_BITS 2
89 #define EXT2_XATTR_PAD (1<<EXT2_XATTR_PAD_BITS)
90 #define EXT2_XATTR_ROUND (EXT2_XATTR_PAD-1)
91 #define EXT2_XATTR_LEN(name_len) \
92 (((name_len) + EXT2_XATTR_ROUND + \
93 sizeof(struct ext2_xattr_entry)) & ~EXT2_XATTR_ROUND)
94 #define EXT2_XATTR_NEXT(entry) \
95 ( (struct ext2_xattr_entry *)( \
96 (char *)(entry) + EXT2_XATTR_LEN((entry)->e_name_len)) )
97 #define EXT3_XATTR_SIZE(size) \
98 (((size) + EXT2_XATTR_ROUND) & ~EXT2_XATTR_ROUND)
99
100 #define HDR(buffer) ((struct ext2_xattr_header *)(buffer))
101 #define ENTRY(ptr) ((struct ext2_xattr_entry *)(ptr))
102 #define IS_LAST_ENTRY(entry) (*(__u32 *)(entry) == 0)
103
104 #define BFIRST(buffer) ENTRY(HDR(buffer)+1)
105 #define IFIRST(buffer) ENTRY(((struct ext3_xattr_ibody_header *)(buffer))+1)
106
107 #define FIRST_ENTRY(buffer) \
108 ((HDR(buffer)->h_magic == EXT2_XATTR_MAGIC2) ? \
109 IFIRST(buffer) : \
110 BFIRST(buffer))
111
112 /*
113 * On-block xattr value offsets start at the beginning of the block, but
114 * on-inode xattr value offsets start after the initial header
115 * (ext3_xattr_ibody_header).
116 */
117 #define VALUE_OFFSET(buffer, entry) \
118 (((HDR(buffer)->h_magic == EXT2_XATTR_MAGIC2) ? \
119 (entry)->e_value_offs + sizeof(struct ext3_xattr_ibody_header) : \
120 (entry)->e_value_offs))
121
122 /*
123 * xattr syscalls do not exist yet in libc, get our own copy here,
124 * taken from libattr.
125 */
126 #if defined (__i386__)
127 # define HAVE_XATTR_SYSCALLS 1
128 # define __NR_lsetxattr 227
129 # define __NR_lgetxattr 230
130 # define __NR_llistxattr 233
131 #elif defined (__sparc__)
132 # define HAVE_XATTR_SYSCALLS 1
133 # define __NR_lsetxattr 170
134 # define __NR_lgetxattr 173
135 # define __NR_llistxattr 179
136 #elif defined (__ia64__)
137 # define HAVE_XATTR_SYSCALLS 1
138 # define __NR_lsetxattr 1218
139 # define __NR_lgetxattr 1221
140 # define __NR_llistxattr 1224
141 #elif defined (__powerpc__)
142 # define HAVE_XATTR_SYSCALLS 1
143 # define __NR_lsetxattr 210
144 # define __NR_lgetxattr 213
145 # define __NR_llistxattr 216
146 #elif defined (__x86_64__)
147 # define HAVE_XATTR_SYSCALLS 1
148 # define __NR_lsetxattr 189
149 # define __NR_lgetxattr 192
150 # define __NR_llistxattr 195
151 #elif defined (__s390__)
152 # define HAVE_XATTR_SYSCALLS 1
153 # define __NR_lsetxattr 225
154 # define __NR_lgetxattr 228
155 # define __NR_llistxattr 231
156 #elif defined (__arm__)
157 # define HAVE_XATTR_SYSCALLS 1
158 # define __NR_SYSCALL_BASE 0x900000
159 # define __NR_lsetxattr (__NR_SYSCALL_BASE+227)
160 # define __NR_lgetxattr (__NR_SYSCALL_BASE+230)
161 # define __NR_llistxattr (__NR_SYSCALL_BASE+233)
162 #elif defined (__mips64__)
163 # define HAVE_XATTR_SYSCALLS 1
164 # define __NR_Linux 5000
165 # define __NR_lsetxattr (__NR_Linux + 218)
166 # define __NR_lgetxattr (__NR_Linux + 221)
167 # define __NR_llistxattr (__NR_Linux + 224)
168 #elif defined (__mips__)
169 # define HAVE_XATTR_SYSCALLS 1
170 # define __NR_Linux 4000
171 # define __NR_lsetxattr (__NR_Linux + 225)
172 # define __NR_lgetxattr (__NR_Linux + 228)
173 # define __NR_llistxattr (__NR_Linux + 231)
174 #elif defined (__alpha__)
175 # define HAVE_XATTR_SYSCALLS 1
176 # define __NR_lsetxattr 383
177 # define __NR_lgetxattr 386
178 # define __NR_llistxattr 389
179 #elif defined (__mc68000__)
180 # define HAVE_XATTR_SYSCALLS 1
181 # define __NR_lsetxattr 224
182 # define __NR_lgetxattr 227
183 # define __NR_llistxattr 230
184 #else
185 # warning "Extended attribute syscalls undefined for this architecture"
186 # define HAVE_XATTR_SYSCALLS 0
187 #endif
188
189 #if HAVE_XATTR_SYSCALLS
190 # define SYSCALL(args...) syscall(args)
191 #else
192 # define SYSCALL(args...) ( errno = ENOSYS, -1 )
193 #endif
194
195 static int lsetxattr __P((const char *, const char *, void *, size_t, int));
196 static ssize_t lgetxattr __P((const char *, const char *, void *, size_t));
197 static ssize_t llistxattr __P((const char *, char *, size_t));
198 static int xattr_cb_list __P((char *, char *, int, void *));
199 static int xattr_cb_set __P((char *, char *, int, void *));
200 static int xattr_cb_compare __P((char *, char *, int, void *));
201 static int xattr_verify __P((char *));
202 static int xattr_count __P((char *, int *));
203 static int xattr_walk __P((char *, int (*)(char *, char *, int, void *), void *));
204
205 static int
206 lsetxattr(const char *path, const char *name, void *value, size_t size, int flags)
207 {
208 return SYSCALL(__NR_lsetxattr, path, name, value, size, flags);
209 }
210
211 static ssize_t
212 lgetxattr(const char *path, const char *name, void *value, size_t size)
213 {
214 return SYSCALL(__NR_lgetxattr, path, name, value, size);
215 }
216
217 static ssize_t
218 llistxattr(const char *path, char *list, size_t size)
219 {
220 return SYSCALL(__NR_llistxattr, path, list, size);
221 }
222
223 #define POSIX_ACL_XATTR_VERSION 0x0002
224
225 #define ACL_UNDEFINED_ID (-1)
226
227 #define ACL_USER_OBJ (0x01)
228 #define ACL_USER (0x02)
229 #define ACL_GROUP_OBJ (0x04)
230 #define ACL_GROUP (0x08)
231 #define ACL_MASK (0x10)
232 #define ACL_OTHER (0x20)
233
234 typedef struct {
235 u_int16_t e_tag;
236 u_int16_t e_perm;
237 u_int32_t e_id;
238 } posix_acl_xattr_entry;
239
240 typedef struct {
241 u_int32_t a_version;
242 posix_acl_xattr_entry a_entries[0];
243 } posix_acl_xattr_header;
244
245 static inline size_t
246 posix_acl_xattr_size(int count)
247 {
248 return (sizeof(posix_acl_xattr_header) +
249 (count * sizeof(posix_acl_xattr_entry)));
250 }
251
252 struct posix_acl_entry {
253 short e_tag;
254 unsigned short e_perm;
255 unsigned int e_id;
256 };
257
258 struct posix_acl {
259 unsigned int a_count;
260 struct posix_acl_entry a_entries[0];
261 };
262
263 #define EXT3_ACL_VERSION 0x0001
264
265 typedef struct {
266 u_int16_t e_tag;
267 u_int16_t e_perm;
268 u_int32_t e_id;
269 } ext3_acl_entry;
270
271 typedef struct {
272 u_int16_t e_tag;
273 u_int16_t e_perm;
274 } ext3_acl_entry_short;
275
276 typedef struct {
277 u_int32_t a_version;
278 } ext3_acl_header;
279
280 static inline int ext3_acl_count(size_t size)
281 {
282 ssize_t s;
283 size -= sizeof(ext3_acl_header);
284 s = size - 4 * sizeof(ext3_acl_entry_short);
285 if (s < 0) {
286 if (size % sizeof(ext3_acl_entry_short))
287 return -1;
288 return size / sizeof(ext3_acl_entry_short);
289 } else {
290 if (s % sizeof(ext3_acl_entry))
291 return -1;
292 return s / sizeof(ext3_acl_entry) + 4;
293 }
294 }
295
296 int
297 posix_acl_to_xattr(const struct posix_acl *acl, void *buffer, size_t size) {
298 posix_acl_xattr_header *ext_acl = (posix_acl_xattr_header *)buffer;
299 posix_acl_xattr_entry *ext_entry = ext_acl->a_entries;
300 int real_size, n;
301
302 real_size = posix_acl_xattr_size(acl->a_count);
303 if (!buffer)
304 return real_size;
305 if (real_size > size) {
306 fprintf(stderr, "ACL: not enough space to convert (%d %d)\n", real_size, size);
307 return -1;
308 }
309
310 ext_acl->a_version = POSIX_ACL_XATTR_VERSION;
311 #if BYTE_ORDER == BIG_ENDIAN
312 swabst("1i", (u_char *)ext_acl);
313 #endif
314
315 for (n=0; n < acl->a_count; n++, ext_entry++) {
316 ext_entry->e_tag = acl->a_entries[n].e_tag;
317 ext_entry->e_perm = acl->a_entries[n].e_perm;
318 ext_entry->e_id = acl->a_entries[n].e_id;
319 #if BYTE_ORDER == BIG_ENDIAN
320 swabst("2s1i", (u_char *)ext_entry);
321 #endif
322 }
323 return real_size;
324 }
325
326 static struct posix_acl *
327 ext3_acl_from_disk(const void *value, size_t size)
328 {
329 const char *end = (char *)value + size;
330 int n, count;
331 struct posix_acl *acl;
332
333 if (!value)
334 return NULL;
335 if (size < sizeof(ext3_acl_header)) {
336 fprintf(stderr, "ACL size too little\n");
337 return NULL;
338 }
339 #if BYTE_ORDER == BIG_ENDIAN
340 swabst("1i", (u_char *)value);
341 #endif
342 if (((ext3_acl_header *)value)->a_version != EXT3_ACL_VERSION) {
343 fprintf(stderr, "ACL version unknown\n");
344 return NULL;
345 }
346 value = (char *)value + sizeof(ext3_acl_header);
347 count = ext3_acl_count(size);
348 if (count < 0) {
349 fprintf(stderr, "ACL bad count\n");
350 return NULL;
351 }
352 if (count == 0)
353 return NULL;
354 acl = malloc(sizeof(struct posix_acl) + count * sizeof(struct posix_acl_entry));
355 if (!acl) {
356 fprintf(stderr, "ACL malloc failed\n");
357 return NULL;
358 }
359 acl->a_count = count;
360
361 for (n=0; n < count; n++) {
362 ext3_acl_entry *entry = (ext3_acl_entry *)value;
363 #if BYTE_ORDER == BIG_ENDIAN
364 swabst("2s", (u_char *)entry);
365 #endif
366 if ((char *)value + sizeof(ext3_acl_entry_short) > end)
367 goto fail;
368 acl->a_entries[n].e_tag = entry->e_tag;
369 acl->a_entries[n].e_perm = entry->e_perm;
370 switch(acl->a_entries[n].e_tag) {
371 case ACL_USER_OBJ:
372 case ACL_GROUP_OBJ:
373 case ACL_MASK:
374 case ACL_OTHER:
375 value = (char *)value + sizeof(ext3_acl_entry_short);
376 acl->a_entries[n].e_id = ACL_UNDEFINED_ID;
377 break;
378
379 case ACL_USER:
380 case ACL_GROUP:
381 #if BYTE_ORDER == BIG_ENDIAN
382 swabst("4b1i", (u_char *)entry);
383 #endif
384 value = (char *)value + sizeof(ext3_acl_entry);
385 if ((char *)value > end)
386 goto fail;
387 acl->a_entries[n].e_id = entry->e_id;
388 break;
389
390 default:
391 goto fail;
392 }
393 }
394 if (value != end)
395 goto fail;
396 return acl;
397
398 fail:
399 fprintf(stderr, "ACL bad entry\n");
400 free(acl);
401 return NULL;
402 }
403
404 /*
405 * Dump code starts here :)
406 */
407
408 static int
409 xattr_cb_list(char *name, char *value, int valuelen, void *private)
410 {
411 value[valuelen] = '\0';
412 printf("EA: %s:%s\n", name, value);
413
414 return GOOD;
415 }
416
417 static int
418 xattr_cb_set(char *name, char *value, int valuelen, void *private)
419 {
420 char *path = (char *)private;
421
422 if (lsetxattr(path, name, value, valuelen, 0) < 0) {
423 warn("lsetxattr %s failed", path);
424 return FAIL;
425 }
426 return GOOD;
427 }
428
429 static int
430 xattr_cb_compare(char *name, char *value, int valuelen, void *private)
431 {
432 char *path = (char *)private;
433 char valuef[XATTR_MAXSIZE];
434 int valuesz;
435
436 valuesz = lgetxattr(path, name, valuef, XATTR_MAXSIZE);
437 if (valuesz < 0) {
438 warn("%s: lgetxattr failed\n", path);
439 return FAIL;
440 }
441
442 if (valuesz != valuelen) {
443 fprintf(stderr, "%s: EA %s value changed\n", path, value);
444 return FAIL;
445 }
446
447 if (memcmp(value, valuef, valuelen)) {
448 fprintf(stderr, "%s: EA %s value changed\n", path, value);
449 return FAIL;
450 }
451
452 return GOOD;
453 }
454
455 static int
456 xattr_verify(char *buffer)
457 {
458 struct ext2_xattr_entry *entry;
459 char *end;
460
461 end = buffer + XATTR_MAXSIZE;
462
463 #if BYTE_ORDER == BIG_ENDIAN
464 swabst("4i", (u_char *)buffer);
465 #endif
466
467 if (HDR(buffer)->h_magic != EXT2_XATTR_MAGIC &&
468 HDR(buffer)->h_magic != EXT2_XATTR_MAGIC2) {
469 fprintf(stderr, "error in EA block 1\n");
470 fprintf(stderr, "magic = %x\n", HDR(buffer)->h_magic);
471
472 return FAIL;
473 }
474
475 /* check the on-disk data structure */
476 entry = FIRST_ENTRY(buffer);
477 #if BYTE_ORDER == BIG_ENDIAN
478 swabst("2b1s3i", (u_char *)entry);
479 #endif
480 while (!IS_LAST_ENTRY(entry)) {
481 struct ext2_xattr_entry *next = EXT2_XATTR_NEXT(entry);
482
483 if ((char *)next >= end) {
484 fprintf(stderr, "error in EA block\n");
485 return FAIL;
486 }
487 entry = next;
488 #if BYTE_ORDER == BIG_ENDIAN
489 swabst("2b1s3i", (u_char *)entry);
490 #endif
491 }
492 return GOOD;
493 }
494
495 static int
496 xattr_count(char *buffer, int *count)
497 {
498 struct ext2_xattr_entry *entry;
499 int result = 0;
500
501 /* list the attribute names */
502 for (entry = FIRST_ENTRY(buffer); !IS_LAST_ENTRY(entry);
503 entry = EXT2_XATTR_NEXT(entry))
504 result++;
505
506 *count = result;
507 return GOOD;
508 }
509
510 static int
511 xattr_walk(char *buffer, int (*xattr_cb)(char *, char *, int, void *), void *private)
512 {
513 struct ext2_xattr_entry *entry;
514
515 /* list the attribute names */
516 for (entry = FIRST_ENTRY(buffer); !IS_LAST_ENTRY(entry);
517 entry = EXT2_XATTR_NEXT(entry)) {
518 char name[XATTR_MAXSIZE], value[XATTR_MAXSIZE];
519 int off;
520 int convertacl = 0;
521
522 switch (entry->e_name_index) {
523 case EXT2_XATTR_INDEX_USER:
524 strcpy(name, "user.");
525 break;
526 case EXT2_XATTR_INDEX_POSIX_ACL_ACCESS:
527 strcpy(name, "system.posix_acl_access");
528 convertacl = 1;
529 break;
530 case EXT2_XATTR_INDEX_POSIX_ACL_DEFAULT:
531 strcpy(name, "system.posix_acl_default");
532 convertacl = 1;
533 break;
534 case EXT2_XATTR_INDEX_TRUSTED:
535 strcpy(name, "trusted.");
536 break;
537 case EXT2_XATTR_INDEX_LUSTRE:
538 strcpy(name, "lustre.");
539 break;
540 case EXT2_XATTR_INDEX_SECURITY:
541 strcpy(name, "security.");
542 break;
543 default:
544 fprintf(stderr, "Unknown EA index\n");
545 return FAIL;
546 }
547
548 off = strlen(name);
549 memcpy(name + off, entry->e_name, entry->e_name_len);
550 name[off + entry->e_name_len] = '\0';
551
552 memcpy(value, buffer + VALUE_OFFSET(buffer, entry), entry->e_value_size);
553
554 if (convertacl) {
555 struct posix_acl *acl;
556 int size;
557
558 acl = ext3_acl_from_disk(value, entry->e_value_size);
559 if (!acl)
560 return FAIL;
561 size = posix_acl_to_xattr(acl, value, XATTR_MAXSIZE);
562 if (size < 0)
563 return FAIL;
564 entry->e_value_size = size;
565 free(acl);
566 }
567
568 if (xattr_cb(name, value, entry->e_value_size, private) != GOOD)
569 return FAIL;
570 }
571
572 return GOOD;
573 }
574
575 int
576 xattr_compare(char *path, char *buffer)
577 {
578 int countf, countt;
579 char *names = NULL, *end_names, *name;
580
581 countf = llistxattr(path, NULL, 0);
582 if (countf < 0) {
583 warn("%s: llistxattr failed", path);
584 return FAIL;
585 }
586
587 names = malloc(countf + 1);
588 if (!names) {
589 warn("%s: llistxattr failed", path);
590 return FAIL;
591 }
592
593 countf = llistxattr(path, names, countf);
594 if (countf < 0) {
595 warn("%s: llistxattr failed", path);
596 free(names);
597 return FAIL;
598 }
599
600 names[countf] = '\0';
601 end_names = names + countf;
602
603 countf = 0;
604 for (name = names; name != end_names; name = strchr(name, '\0') + 1) {
605 if (!*name)
606 continue;
607 countf++;
608 }
609
610 free(names);
611
612 if (buffer) {
613 if (xattr_verify(buffer) == FAIL)
614 return FAIL;
615
616 if (xattr_count(buffer, &countt) == FAIL)
617 return FAIL;
618 }
619 else
620 countt = 0;
621
622 if (countf != countt) {
623 fprintf(stderr, "%s: EA count changed from %d to %d\n", path, countt, countf);
624 return FAIL;
625 }
626
627 if (!buffer)
628 return GOOD;
629
630 return xattr_walk(buffer, xattr_cb_compare, path);
631 }
632
633 int
634 xattr_extract(char *path, char *buffer)
635 {
636 if (dflag) {
637 fprintf(stderr, "xattr_extract(%s)\n", path);
638 xattr_walk(buffer, xattr_cb_list, NULL);
639 }
640
641 if (xattr_verify(buffer) == FAIL)
642 return FAIL;
643
644 return xattr_walk(buffer, xattr_cb_set, path);
645 }
646