]> git.ipfire.org Git - thirdparty/e2fsprogs.git/blob - lib/ext2fs/ext_attr.c
projects / thirdparty / e2fsprogs.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
libext2fs: fix regression so we are correctly translating Posix ACL's
[thirdparty/e2fsprogs.git] / lib / ext2fs / ext_attr.c
1 /*
2 * ext_attr.c --- extended attribute blocks
3 *
4 * Copyright (C) 2001 Andreas Gruenbacher, <a.gruenbacher@computer.org>
5 *
6 * Copyright (C) 2002 Theodore Ts'o.
7 *
8 * %Begin-Header%
9 * This file may be redistributed under the terms of the GNU Library
10 * General Public License, version 2.
11 * %End-Header%
12 */
13
14 #include "config.h"
15 #include <stdio.h>
16 #if HAVE_UNISTD_H
17 #include <unistd.h>
18 #endif
19 #include <string.h>
20 #include <time.h>
21
22 #include "ext2_fs.h"
23 #include "ext2_ext_attr.h"
24 #include "ext4_acl.h"
25
26 #include "ext2fs.h"
27
28 static errcode_t read_ea_inode_hash(ext2_filsys fs, ext2_ino_t ino, __u32 *hash)
29 {
30 struct ext2_inode inode;
31 errcode_t retval;
32
33 retval = ext2fs_read_inode(fs, ino, &inode);
34 if (retval)
35 return retval;
36 *hash = ext2fs_get_ea_inode_hash(&inode);
37 return 0;
38 }
39
40 #define NAME_HASH_SHIFT 5
41 #define VALUE_HASH_SHIFT 16
42
43 /*
44 * ext2_xattr_hash_entry()
45 *
46 * Compute the hash of an extended attribute.
47 */
48 __u32 ext2fs_ext_attr_hash_entry(struct ext2_ext_attr_entry *entry, void *data)
49 {
50 __u32 hash = 0;
51 char *name = ((char *) entry) + sizeof(struct ext2_ext_attr_entry);
52 int n;
53
54 for (n = 0; n < entry->e_name_len; n++) {
55 hash = (hash << NAME_HASH_SHIFT) ^
56 (hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^
57 *name++;
58 }
59
60 /* The hash needs to be calculated on the data in little-endian. */
61 if (entry->e_value_inum == 0 && entry->e_value_size != 0) {
62 __u32 *value = (__u32 *)data;
63 for (n = (entry->e_value_size + EXT2_EXT_ATTR_ROUND) >>
64 EXT2_EXT_ATTR_PAD_BITS; n; n--) {
65 hash = (hash << VALUE_HASH_SHIFT) ^
66 (hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^
67 ext2fs_le32_to_cpu(*value++);
68 }
69 }
70
71 return hash;
72 }
73
74 /*
75 * ext2fs_ext_attr_hash_entry2()
76 *
77 * Compute the hash of an extended attribute.
78 * This version of the function supports hashing entries that reference
79 * external inodes (ea_inode feature).
80 */
81 errcode_t ext2fs_ext_attr_hash_entry2(ext2_filsys fs,
82 struct ext2_ext_attr_entry *entry,
83 void *data, __u32 *hash)
84 {
85 *hash = ext2fs_ext_attr_hash_entry(entry, data);
86
87 if (entry->e_value_inum) {
88 __u32 ea_inode_hash;
89 errcode_t retval;
90
91 retval = read_ea_inode_hash(fs, entry->e_value_inum,
92 &ea_inode_hash);
93 if (retval)
94 return retval;
95
96 *hash = (*hash << VALUE_HASH_SHIFT) ^
97 (*hash >> (8*sizeof(*hash) - VALUE_HASH_SHIFT)) ^
98 ea_inode_hash;
99 }
100 return 0;
101 }
102
103 #undef NAME_HASH_SHIFT
104 #undef VALUE_HASH_SHIFT
105
106 #define BLOCK_HASH_SHIFT 16
107
108 /* Mirrors ext4_xattr_rehash() implementation in kernel. */
109 void ext2fs_ext_attr_block_rehash(struct ext2_ext_attr_header *header,
110 struct ext2_ext_attr_entry *end)
111 {
112 struct ext2_ext_attr_entry *here;
113 __u32 hash = 0;
114
115 here = (struct ext2_ext_attr_entry *)(header+1);
116 while (here < end && !EXT2_EXT_IS_LAST_ENTRY(here)) {
117 if (!here->e_hash) {
118 /* Block is not shared if an entry's hash value == 0 */
119 hash = 0;
120 break;
121 }
122 hash = (hash << BLOCK_HASH_SHIFT) ^
123 (hash >> (8*sizeof(hash) - BLOCK_HASH_SHIFT)) ^
124 here->e_hash;
125 here = EXT2_EXT_ATTR_NEXT(here);
126 }
127 header->h_hash = hash;
128 }
129
130 #undef BLOCK_HASH_SHIFT
131
132 __u32 ext2fs_get_ea_inode_hash(struct ext2_inode *inode)
133 {
134 return inode->i_atime;
135 }
136
137 void ext2fs_set_ea_inode_hash(struct ext2_inode *inode, __u32 hash)
138 {
139 inode->i_atime = hash;
140 }
141
142 __u64 ext2fs_get_ea_inode_ref(struct ext2_inode *inode)
143 {
144 return ((__u64)inode->i_ctime << 32) | inode->osd1.linux1.l_i_version;
145 }
146
147 void ext2fs_set_ea_inode_ref(struct ext2_inode *inode, __u64 ref_count)
148 {
149 inode->i_ctime = (__u32)(ref_count >> 32);
150 inode->osd1.linux1.l_i_version = (__u32)ref_count;
151 }
152
153 static errcode_t check_ext_attr_header(struct ext2_ext_attr_header *header)
154 {
155 if ((header->h_magic != EXT2_EXT_ATTR_MAGIC_v1 &&
156 header->h_magic != EXT2_EXT_ATTR_MAGIC) ||
157 header->h_blocks != 1)
158 return EXT2_ET_BAD_EA_HEADER;
159
160 return 0;
161 }
162
163 errcode_t ext2fs_read_ext_attr3(ext2_filsys fs, blk64_t block, void *buf,
164 ext2_ino_t inum)
165 {
166 int csum_failed = 0;
167 errcode_t retval;
168
169 retval = io_channel_read_blk64(fs->io, block, 1, buf);
170 if (retval)
171 return retval;
172
173 if (!(fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) &&
174 !ext2fs_ext_attr_block_csum_verify(fs, inum, block, buf))
175 csum_failed = 1;
176
177 #ifdef WORDS_BIGENDIAN
178 ext2fs_swap_ext_attr(buf, buf, fs->blocksize, 1);
179 #endif
180
181 retval = check_ext_attr_header(buf);
182 if (retval == 0 && csum_failed)
183 retval = EXT2_ET_EXT_ATTR_CSUM_INVALID;
184
185 return retval;
186 }
187
188 errcode_t ext2fs_read_ext_attr2(ext2_filsys fs, blk64_t block, void *buf)
189 {
190 return ext2fs_read_ext_attr3(fs, block, buf, 0);
191 }
192
193 errcode_t ext2fs_read_ext_attr(ext2_filsys fs, blk_t block, void *buf)
194 {
195 return ext2fs_read_ext_attr2(fs, block, buf);
196 }
197
198 errcode_t ext2fs_write_ext_attr3(ext2_filsys fs, blk64_t block, void *inbuf,
199 ext2_ino_t inum)
200 {
201 errcode_t retval;
202 char *write_buf;
203
204 #ifdef WORDS_BIGENDIAN
205 retval = ext2fs_get_mem(fs->blocksize, &write_buf);
206 if (retval)
207 return retval;
208 ext2fs_swap_ext_attr(write_buf, inbuf, fs->blocksize, 1);
209 #else
210 write_buf = (char *) inbuf;
211 #endif
212
213 retval = ext2fs_ext_attr_block_csum_set(fs, inum, block,
214 (struct ext2_ext_attr_header *)write_buf);
215 if (retval)
216 return retval;
217
218 retval = io_channel_write_blk64(fs->io, block, 1, write_buf);
219 #ifdef WORDS_BIGENDIAN
220 ext2fs_free_mem(&write_buf);
221 #endif
222 if (!retval)
223 ext2fs_mark_changed(fs);
224 return retval;
225 }
226
227 errcode_t ext2fs_write_ext_attr2(ext2_filsys fs, blk64_t block, void *inbuf)
228 {
229 return ext2fs_write_ext_attr3(fs, block, inbuf, 0);
230 }
231
232 errcode_t ext2fs_write_ext_attr(ext2_filsys fs, blk_t block, void *inbuf)
233 {
234 return ext2fs_write_ext_attr2(fs, block, inbuf);
235 }
236
237 /*
238 * This function adjusts the reference count of the EA block.
239 */
240 errcode_t ext2fs_adjust_ea_refcount3(ext2_filsys fs, blk64_t blk,
241 char *block_buf, int adjust,
242 __u32 *newcount, ext2_ino_t inum)
243 {
244 errcode_t retval;
245 struct ext2_ext_attr_header *header;
246 char *buf = 0;
247
248 if ((blk >= ext2fs_blocks_count(fs->super)) ||
249 (blk < fs->super->s_first_data_block))
250 return EXT2_ET_BAD_EA_BLOCK_NUM;
251
252 if (!block_buf) {
253 retval = ext2fs_get_mem(fs->blocksize, &buf);
254 if (retval)
255 return retval;
256 block_buf = buf;
257 }
258
259 retval = ext2fs_read_ext_attr3(fs, blk, block_buf, inum);
260 if (retval)
261 goto errout;
262
263 header = (struct ext2_ext_attr_header *) block_buf;
264 header->h_refcount += adjust;
265 if (newcount)
266 *newcount = header->h_refcount;
267
268 retval = ext2fs_write_ext_attr3(fs, blk, block_buf, inum);
269 if (retval)
270 goto errout;
271
272 errout:
273 if (buf)
274 ext2fs_free_mem(&buf);
275 return retval;
276 }
277
278 errcode_t ext2fs_adjust_ea_refcount2(ext2_filsys fs, blk64_t blk,
279 char *block_buf, int adjust,
280 __u32 *newcount)
281 {
282 return ext2fs_adjust_ea_refcount3(fs, blk, block_buf, adjust,
283 newcount, 0);
284 }
285
286 errcode_t ext2fs_adjust_ea_refcount(ext2_filsys fs, blk_t blk,
287 char *block_buf, int adjust,
288 __u32 *newcount)
289 {
290 return ext2fs_adjust_ea_refcount2(fs, blk, block_buf, adjust,
291 newcount);
292 }
293
294 /* Manipulate the contents of extended attribute regions */
295 struct ext2_xattr {
296 char *name;
297 void *value;
298 unsigned int value_len;
299 ext2_ino_t ea_ino;
300 };
301
302 struct ext2_xattr_handle {
303 errcode_t magic;
304 ext2_filsys fs;
305 struct ext2_xattr *attrs;
306 int capacity;
307 int count;
308 int ibody_count;
309 ext2_ino_t ino;
310 unsigned int flags;
311 };
312
313 static errcode_t ext2fs_xattrs_expand(struct ext2_xattr_handle *h,
314 unsigned int expandby)
315 {
316 struct ext2_xattr *new_attrs;
317 errcode_t err;
318
319 err = ext2fs_get_arrayzero(h->capacity + expandby,
320 sizeof(struct ext2_xattr), &new_attrs);
321 if (err)
322 return err;
323
324 memcpy(new_attrs, h->attrs, h->capacity * sizeof(struct ext2_xattr));
325 ext2fs_free_mem(&h->attrs);
326 h->capacity += expandby;
327 h->attrs = new_attrs;
328
329 return 0;
330 }
331
332 struct ea_name_index {
333 int index;
334 const char *name;
335 };
336
337 /* Keep these names sorted in order of decreasing specificity. */
338 static struct ea_name_index ea_names[] = {
339 {3, "system.posix_acl_default"},
340 {2, "system.posix_acl_access"},
341 {8, "system.richacl"},
342 {6, "security."},
343 {4, "trusted."},
344 {7, "system."},
345 {1, "user."},
346 {0, NULL},
347 };
348
349 static const char *find_ea_prefix(int index)
350 {
351 struct ea_name_index *e;
352
353 for (e = ea_names; e->name; e++)
354 if (e->index == index)
355 return e->name;
356
357 return NULL;
358 }
359
360 static int find_ea_index(const char *fullname, const char **name, int *index)
361 {
362 struct ea_name_index *e;
363
364 for (e = ea_names; e->name; e++) {
365 if (strncmp(fullname, e->name, strlen(e->name)) == 0) {
366 *name = fullname + strlen(e->name);
367 *index = e->index;
368 return 1;
369 }
370 }
371 return 0;
372 }
373
374 errcode_t ext2fs_free_ext_attr(ext2_filsys fs, ext2_ino_t ino,
375 struct ext2_inode_large *inode)
376 {
377 struct ext2_ext_attr_header *header;
378 void *block_buf = NULL;
379 blk64_t blk;
380 errcode_t err;
381 struct ext2_inode_large i;
382
383 /* Read inode? */
384 if (inode == NULL) {
385 err = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)&i,
386 sizeof(struct ext2_inode_large));
387 if (err)
388 return err;
389 inode = &i;
390 }
391
392 /* Do we already have an EA block? */
393 blk = ext2fs_file_acl_block(fs, (struct ext2_inode *)inode);
394 if (blk == 0)
395 return 0;
396
397 /* Find block, zero it, write back */
398 if ((blk < fs->super->s_first_data_block) ||
399 (blk >= ext2fs_blocks_count(fs->super))) {
400 err = EXT2_ET_BAD_EA_BLOCK_NUM;
401 goto out;
402 }
403
404 err = ext2fs_get_mem(fs->blocksize, &block_buf);
405 if (err)
406 goto out;
407
408 err = ext2fs_read_ext_attr3(fs, blk, block_buf, ino);
409 if (err)
410 goto out2;
411
412 /* We only know how to deal with v2 EA blocks */
413 header = (struct ext2_ext_attr_header *) block_buf;
414 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
415 err = EXT2_ET_BAD_EA_HEADER;
416 goto out2;
417 }
418
419 header->h_refcount--;
420 err = ext2fs_write_ext_attr3(fs, blk, block_buf, ino);
421 if (err)
422 goto out2;
423
424 /* Erase link to block */
425 ext2fs_file_acl_block_set(fs, (struct ext2_inode *)inode, 0);
426 if (header->h_refcount == 0)
427 ext2fs_block_alloc_stats2(fs, blk, -1);
428 err = ext2fs_iblk_sub_blocks(fs, (struct ext2_inode *)inode, 1);
429 if (err)
430 goto out2;
431
432 /* Write inode? */
433 if (inode == &i) {
434 err = ext2fs_write_inode_full(fs, ino, (struct ext2_inode *)&i,
435 sizeof(struct ext2_inode_large));
436 if (err)
437 goto out2;
438 }
439
440 out2:
441 ext2fs_free_mem(&block_buf);
442 out:
443 return err;
444 }
445
446 static errcode_t prep_ea_block_for_write(ext2_filsys fs, ext2_ino_t ino,
447 struct ext2_inode_large *inode)
448 {
449 struct ext2_ext_attr_header *header;
450 void *block_buf = NULL;
451 blk64_t blk, goal;
452 errcode_t err;
453
454 /* Do we already have an EA block? */
455 blk = ext2fs_file_acl_block(fs, (struct ext2_inode *)inode);
456 if (blk != 0) {
457 if ((blk < fs->super->s_first_data_block) ||
458 (blk >= ext2fs_blocks_count(fs->super))) {
459 err = EXT2_ET_BAD_EA_BLOCK_NUM;
460 goto out;
461 }
462
463 err = ext2fs_get_mem(fs->blocksize, &block_buf);
464 if (err)
465 goto out;
466
467 err = ext2fs_read_ext_attr3(fs, blk, block_buf, ino);
468 if (err)
469 goto out2;
470
471 /* We only know how to deal with v2 EA blocks */
472 header = (struct ext2_ext_attr_header *) block_buf;
473 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
474 err = EXT2_ET_BAD_EA_HEADER;
475 goto out2;
476 }
477
478 /* Single-user block. We're done here. */
479 if (header->h_refcount == 1)
480 goto out2;
481
482 /* We need to CoW the block. */
483 header->h_refcount--;
484 err = ext2fs_write_ext_attr3(fs, blk, block_buf, ino);
485 if (err)
486 goto out2;
487 } else {
488 /* No block, we must increment i_blocks */
489 err = ext2fs_iblk_add_blocks(fs, (struct ext2_inode *)inode,
490 1);
491 if (err)
492 goto out;
493 }
494
495 /* Allocate a block */
496 goal = ext2fs_find_inode_goal(fs, ino, (struct ext2_inode *)inode, 0);
497 err = ext2fs_alloc_block2(fs, goal, NULL, &blk);
498 if (err)
499 goto out2;
500 ext2fs_file_acl_block_set(fs, (struct ext2_inode *)inode, blk);
501 out2:
502 if (block_buf)
503 ext2fs_free_mem(&block_buf);
504 out:
505 return err;
506 }
507
508
509 static inline int
510 posix_acl_xattr_count(size_t size)
511 {
512 if (size < sizeof(posix_acl_xattr_header))
513 return -1;
514 size -= sizeof(posix_acl_xattr_header);
515 if (size % sizeof(posix_acl_xattr_entry))
516 return -1;
517 return size / sizeof(posix_acl_xattr_entry);
518 }
519
520 /*
521 * The lgetxattr function returns data formatted in the POSIX extended
522 * attribute format. The on-disk format uses a more compact encoding.
523 * See the ext4_acl_to_disk in fs/ext4/acl.c.
524 */
525 static errcode_t convert_posix_acl_to_disk_buffer(const void *value, size_t size,
526 void *out_buf, size_t *size_out)
527 {
528 const posix_acl_xattr_header *header =
529 (const posix_acl_xattr_header*) value;
530 const posix_acl_xattr_entry *end, *entry =
531 (const posix_acl_xattr_entry *)(header+1);
532 ext4_acl_header *ext_acl;
533 size_t s;
534 char *e;
535
536 int count;
537
538 if (!value)
539 return EINVAL;
540 if (size < sizeof(posix_acl_xattr_header))
541 return ENOMEM;
542 if (header->a_version != ext2fs_cpu_to_le32(POSIX_ACL_XATTR_VERSION))
543 return EINVAL;
544
545 count = posix_acl_xattr_count(size);
546 ext_acl = out_buf;
547 ext_acl->a_version = ext2fs_cpu_to_le32(EXT4_ACL_VERSION);
548
549 if (count <= 0)
550 return EINVAL;
551
552 e = (char *) out_buf + sizeof(ext4_acl_header);
553 s = sizeof(ext4_acl_header);
554 for (end = entry + count; entry != end;entry++) {
555 ext4_acl_entry *disk_entry = (ext4_acl_entry*) e;
556 disk_entry->e_tag = ext2fs_cpu_to_le16(entry->e_tag);
557 disk_entry->e_perm = ext2fs_cpu_to_le16(entry->e_perm);
558
559 switch(entry->e_tag) {
560 case ACL_USER_OBJ:
561 case ACL_GROUP_OBJ:
562 case ACL_MASK:
563 case ACL_OTHER:
564 e += sizeof(ext4_acl_entry_short);
565 s += sizeof(ext4_acl_entry_short);
566 break;
567 case ACL_USER:
568 case ACL_GROUP:
569 disk_entry->e_id = ext2fs_cpu_to_le32(entry->e_id);
570 e += sizeof(ext4_acl_entry);
571 s += sizeof(ext4_acl_entry);
572 break;
573 }
574 }
575 *size_out = s;
576 return 0;
577 }
578
579 static errcode_t convert_disk_buffer_to_posix_acl(const void *value, size_t size,
580 void **out_buf, size_t *size_out)
581 {
582 posix_acl_xattr_header *header;
583 posix_acl_xattr_entry *entry;
584 const ext4_acl_header *ext_acl = (const ext4_acl_header *) value;
585 errcode_t err;
586 const char *cp;
587 char *out;
588
589 if ((!value) ||
590 (size < sizeof(ext4_acl_header)) ||
591 (ext_acl->a_version != ext2fs_cpu_to_le32(EXT4_ACL_VERSION)))
592 return EINVAL;
593
594 err = ext2fs_get_mem(size * 2, &out);
595 if (err)
596 return err;
597
598 header = (posix_acl_xattr_header *) out;
599 header->a_version = ext2fs_cpu_to_le32(POSIX_ACL_XATTR_VERSION);
600 entry = (posix_acl_xattr_entry *) (out + sizeof(posix_acl_xattr_header));
601
602 cp = (const char *) value + sizeof(ext4_acl_header);
603 size -= sizeof(ext4_acl_header);
604
605 while (size > 0) {
606 const ext4_acl_entry *disk_entry = (const ext4_acl_entry *) cp;
607
608 entry->e_tag = ext2fs_le16_to_cpu(disk_entry->e_tag);
609 entry->e_perm = ext2fs_le16_to_cpu(disk_entry->e_perm);
610
611 switch(entry->e_tag) {
612 case ACL_USER_OBJ:
613 case ACL_GROUP_OBJ:
614 case ACL_MASK:
615 case ACL_OTHER:
616 entry->e_id = 0;
617 cp += sizeof(ext4_acl_entry_short);
618 size -= sizeof(ext4_acl_entry_short);
619 break;
620 case ACL_USER:
621 case ACL_GROUP:
622 entry->e_id = ext2fs_le32_to_cpu(disk_entry->e_id);
623 cp += sizeof(ext4_acl_entry);
624 size -= sizeof(ext4_acl_entry);
625 break;
626 default:
627 ext2fs_free_mem(&out);
628 return EINVAL;
629 break;
630 }
631 entry++;
632 }
633 *out_buf = out;
634 *size_out = ((char *) entry - out);
635 return 0;
636 }
637
638 static errcode_t
639 write_xattrs_to_buffer(ext2_filsys fs, struct ext2_xattr *attrs, int count,
640 void *entries_start, unsigned int storage_size,
641 unsigned int value_offset_correction, int write_hash)
642 {
643 struct ext2_xattr *x;
644 struct ext2_ext_attr_entry *e = entries_start;
645 char *end = (char *) entries_start + storage_size;
646 const char *shortname;
647 unsigned int value_size;
648 int idx, ret;
649 errcode_t err;
650
651 memset(entries_start, 0, storage_size);
652 for (x = attrs; x < attrs + count; x++) {
653 /* Calculate index and shortname position */
654 shortname = x->name;
655 ret = find_ea_index(x->name, &shortname, &idx);
656
657 value_size = ((x->value_len + EXT2_EXT_ATTR_PAD - 1) /
658 EXT2_EXT_ATTR_PAD) * EXT2_EXT_ATTR_PAD;
659
660 /* Fill out e appropriately */
661 e->e_name_len = strlen(shortname);
662 e->e_name_index = (ret ? idx : 0);
663
664 e->e_value_size = x->value_len;
665 e->e_value_inum = x->ea_ino;
666
667 /* Store name */
668 memcpy((char *)e + sizeof(*e), shortname, e->e_name_len);
669 if (x->ea_ino) {
670 e->e_value_offs = 0;
671 } else {
672 end -= value_size;
673 e->e_value_offs = end - (char *) entries_start +
674 value_offset_correction;
675 memcpy(end, x->value, e->e_value_size);
676 }
677
678 if (write_hash || x->ea_ino) {
679 err = ext2fs_ext_attr_hash_entry2(fs, e,
680 x->ea_ino ? 0 : end,
681 &e->e_hash);
682 if (err)
683 return err;
684 } else
685 e->e_hash = 0;
686
687 e = EXT2_EXT_ATTR_NEXT(e);
688 *(__u32 *)e = 0;
689 }
690 return 0;
691 }
692
693 errcode_t ext2fs_xattrs_write(struct ext2_xattr_handle *handle)
694 {
695 ext2_filsys fs = handle->fs;
696 const unsigned int inode_size = EXT2_INODE_SIZE(fs->super);
697 struct ext2_inode_large *inode;
698 char *start, *block_buf = NULL;
699 struct ext2_ext_attr_header *header;
700 __u32 ea_inode_magic;
701 blk64_t blk;
702 unsigned int storage_size;
703 unsigned int i;
704 errcode_t err;
705
706 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
707 i = inode_size;
708 if (i < sizeof(*inode))
709 i = sizeof(*inode);
710 err = ext2fs_get_memzero(i, &inode);
711 if (err)
712 return err;
713
714 err = ext2fs_read_inode_full(fs, handle->ino, EXT2_INODE(inode),
715 inode_size);
716 if (err)
717 goto out;
718
719 /* If extra_isize isn't set, we need to set it now */
720 if (inode->i_extra_isize == 0 &&
721 inode_size > EXT2_GOOD_OLD_INODE_SIZE) {
722 char *p = (char *)inode;
723 size_t extra = fs->super->s_want_extra_isize;
724
725 if (extra == 0)
726 extra = sizeof(__u32);
727 memset(p + EXT2_GOOD_OLD_INODE_SIZE, 0, extra);
728 inode->i_extra_isize = extra;
729 }
730 if (inode->i_extra_isize & 3) {
731 err = EXT2_ET_INODE_CORRUPTED;
732 goto out;
733 }
734
735 /* Does the inode have space for EA? */
736 if (inode->i_extra_isize < sizeof(inode->i_extra_isize) ||
737 inode_size <= EXT2_GOOD_OLD_INODE_SIZE + inode->i_extra_isize +
738 sizeof(__u32))
739 goto write_ea_block;
740
741 /* Write the inode EA */
742 ea_inode_magic = EXT2_EXT_ATTR_MAGIC;
743 memcpy(((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
744 inode->i_extra_isize, &ea_inode_magic, sizeof(__u32));
745 storage_size = inode_size - EXT2_GOOD_OLD_INODE_SIZE -
746 inode->i_extra_isize - sizeof(__u32);
747 start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
748 inode->i_extra_isize + sizeof(__u32);
749
750 err = write_xattrs_to_buffer(fs, handle->attrs, handle->ibody_count,
751 start, storage_size, 0, 0);
752 if (err)
753 goto out;
754 write_ea_block:
755 /* Are we done? */
756 if (handle->ibody_count == handle->count &&
757 !ext2fs_file_acl_block(fs, EXT2_INODE(inode)))
758 goto skip_ea_block;
759
760 /* Write the EA block */
761 err = ext2fs_get_memzero(fs->blocksize, &block_buf);
762 if (err)
763 goto out;
764
765 storage_size = fs->blocksize - sizeof(struct ext2_ext_attr_header);
766 start = block_buf + sizeof(struct ext2_ext_attr_header);
767
768 err = write_xattrs_to_buffer(fs, handle->attrs + handle->ibody_count,
769 handle->count - handle->ibody_count, start,
770 storage_size, start - block_buf, 1);
771 if (err)
772 goto out2;
773
774 /* Write a header on the EA block */
775 header = (struct ext2_ext_attr_header *) block_buf;
776 header->h_magic = EXT2_EXT_ATTR_MAGIC;
777 header->h_refcount = 1;
778 header->h_blocks = 1;
779
780 /* Get a new block for writing */
781 err = prep_ea_block_for_write(fs, handle->ino, inode);
782 if (err)
783 goto out2;
784
785 /* Finally, write the new EA block */
786 blk = ext2fs_file_acl_block(fs, EXT2_INODE(inode));
787 err = ext2fs_write_ext_attr3(fs, blk, block_buf, handle->ino);
788 if (err)
789 goto out2;
790
791 skip_ea_block:
792 blk = ext2fs_file_acl_block(fs, (struct ext2_inode *)inode);
793 if (!block_buf && blk) {
794 /* xattrs shrunk, free the block */
795 err = ext2fs_free_ext_attr(fs, handle->ino, inode);
796 if (err)
797 goto out;
798 }
799
800 /* Write the inode */
801 err = ext2fs_write_inode_full(fs, handle->ino, EXT2_INODE(inode),
802 inode_size);
803 if (err)
804 goto out2;
805
806 out2:
807 ext2fs_free_mem(&block_buf);
808 out:
809 ext2fs_free_mem(&inode);
810 return err;
811 }
812
813 static errcode_t read_xattrs_from_buffer(struct ext2_xattr_handle *handle,
814 struct ext2_inode_large *inode,
815 struct ext2_ext_attr_entry *entries,
816 unsigned int storage_size,
817 char *value_start)
818 {
819 struct ext2_xattr *x;
820 struct ext2_ext_attr_entry *entry, *end;
821 const char *prefix;
822 unsigned int remain, prefix_len;
823 errcode_t err;
824 unsigned int values_size = storage_size +
825 ((char *)entries - value_start);
826
827 /* find the end */
828 end = entries;
829 remain = storage_size;
830 while (remain >= sizeof(struct ext2_ext_attr_entry) &&
831 !EXT2_EXT_IS_LAST_ENTRY(end)) {
832
833 /* header eats this space */
834 remain -= sizeof(struct ext2_ext_attr_entry);
835
836 /* is attribute name valid? */
837 if (EXT2_EXT_ATTR_SIZE(end->e_name_len) > remain)
838 return EXT2_ET_EA_BAD_NAME_LEN;
839
840 /* attribute len eats this space */
841 remain -= EXT2_EXT_ATTR_SIZE(end->e_name_len);
842 end = EXT2_EXT_ATTR_NEXT(end);
843 }
844
845 entry = entries;
846 remain = storage_size;
847 while (remain >= sizeof(struct ext2_ext_attr_entry) &&
848 !EXT2_EXT_IS_LAST_ENTRY(entry)) {
849
850 /* Allocate space for more attrs? */
851 if (handle->count == handle->capacity) {
852 err = ext2fs_xattrs_expand(handle, 4);
853 if (err)
854 return err;
855 }
856
857 x = handle->attrs + handle->count;
858
859 /* header eats this space */
860 remain -= sizeof(struct ext2_ext_attr_entry);
861
862 /* attribute len eats this space */
863 remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len);
864
865 /* Extract name */
866 prefix = find_ea_prefix(entry->e_name_index);
867 prefix_len = (prefix ? strlen(prefix) : 0);
868 err = ext2fs_get_memzero(entry->e_name_len + prefix_len + 1,
869 &x->name);
870 if (err)
871 return err;
872 if (prefix)
873 memcpy(x->name, prefix, prefix_len);
874 if (entry->e_name_len)
875 memcpy(x->name + prefix_len,
876 (char *)entry + sizeof(*entry),
877 entry->e_name_len);
878
879 /* Check & copy value */
880 if (!ext2fs_has_feature_ea_inode(handle->fs->super) &&
881 entry->e_value_inum != 0)
882 return EXT2_ET_BAD_EA_BLOCK_NUM;
883
884 if (entry->e_value_inum == 0) {
885 if (entry->e_value_size > remain)
886 return EXT2_ET_EA_BAD_VALUE_SIZE;
887
888 if (entry->e_value_offs + entry->e_value_size > values_size)
889 return EXT2_ET_EA_BAD_VALUE_OFFSET;
890
891 if (entry->e_value_size > 0 &&
892 value_start + entry->e_value_offs <
893 (char *)end + sizeof(__u32))
894 return EXT2_ET_EA_BAD_VALUE_OFFSET;
895
896 remain -= entry->e_value_size;
897
898 err = ext2fs_get_mem(entry->e_value_size, &x->value);
899 if (err)
900 return err;
901 memcpy(x->value, value_start + entry->e_value_offs,
902 entry->e_value_size);
903 } else {
904 struct ext2_inode *ea_inode;
905 ext2_file_t ea_file;
906
907 if (entry->e_value_offs != 0)
908 return EXT2_ET_EA_BAD_VALUE_OFFSET;
909
910 if (entry->e_value_size > (64 * 1024))
911 return EXT2_ET_EA_BAD_VALUE_SIZE;
912
913 err = ext2fs_get_mem(entry->e_value_size, &x->value);
914 if (err)
915 return err;
916
917 err = ext2fs_file_open(handle->fs, entry->e_value_inum,
918 0, &ea_file);
919 if (err)
920 return err;
921
922 ea_inode = ext2fs_file_get_inode(ea_file);
923 if ((ea_inode->i_flags & EXT4_INLINE_DATA_FL) ||
924 !(ea_inode->i_flags & EXT4_EA_INODE_FL) ||
925 ea_inode->i_links_count == 0)
926 err = EXT2_ET_EA_INODE_CORRUPTED;
927 else if (ext2fs_file_get_size(ea_file) !=
928 entry->e_value_size)
929 err = EXT2_ET_EA_BAD_VALUE_SIZE;
930 else
931 err = ext2fs_file_read(ea_file, x->value,
932 entry->e_value_size, 0);
933 ext2fs_file_close(ea_file);
934 if (err)
935 return err;
936 }
937
938 x->ea_ino = entry->e_value_inum;
939 x->value_len = entry->e_value_size;
940
941 /* e_hash may be 0 in older inode's ea */
942 if (entry->e_hash != 0) {
943 __u32 hash;
944 void *data = (entry->e_value_inum != 0) ?
945 0 : value_start + entry->e_value_offs;
946
947 err = ext2fs_ext_attr_hash_entry2(handle->fs, entry,
948 data, &hash);
949 if (err)
950 return err;
951 if (entry->e_hash != hash) {
952 struct ext2_inode child;
953
954 /* Check whether this is an old Lustre-style
955 * ea_inode reference.
956 */
957 err = ext2fs_read_inode(handle->fs,
958 entry->e_value_inum,
959 &child);
960 if (err)
961 return err;
962 if (child.i_mtime != handle->ino ||
963 child.i_generation != inode->i_generation)
964 return EXT2_ET_BAD_EA_HASH;
965 }
966 }
967
968 handle->count++;
969 entry = EXT2_EXT_ATTR_NEXT(entry);
970 }
971
972 return 0;
973 }
974
975 static void xattrs_free_keys(struct ext2_xattr_handle *h)
976 {
977 struct ext2_xattr *a = h->attrs;
978 int i;
979
980 for (i = 0; i < h->capacity; i++) {
981 if (a[i].name)
982 ext2fs_free_mem(&a[i].name);
983 if (a[i].value)
984 ext2fs_free_mem(&a[i].value);
985 }
986 h->count = 0;
987 h->ibody_count = 0;
988 }
989
990 errcode_t ext2fs_xattrs_read(struct ext2_xattr_handle *handle)
991 {
992 struct ext2_inode_large *inode;
993 struct ext2_ext_attr_header *header;
994 __u32 ea_inode_magic;
995 unsigned int storage_size;
996 char *start, *block_buf = NULL;
997 blk64_t blk;
998 size_t i;
999 errcode_t err;
1000
1001 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1002 i = EXT2_INODE_SIZE(handle->fs->super);
1003 if (i < sizeof(*inode))
1004 i = sizeof(*inode);
1005 err = ext2fs_get_memzero(i, &inode);
1006 if (err)
1007 return err;
1008
1009 err = ext2fs_read_inode_full(handle->fs, handle->ino,
1010 (struct ext2_inode *)inode,
1011 EXT2_INODE_SIZE(handle->fs->super));
1012 if (err)
1013 goto out;
1014
1015 xattrs_free_keys(handle);
1016
1017 /* Does the inode have space for EA? */
1018 if (inode->i_extra_isize < sizeof(inode->i_extra_isize) ||
1019 EXT2_INODE_SIZE(handle->fs->super) <= EXT2_GOOD_OLD_INODE_SIZE +
1020 inode->i_extra_isize +
1021 sizeof(__u32))
1022 goto read_ea_block;
1023 if (inode->i_extra_isize & 3) {
1024 err = EXT2_ET_INODE_CORRUPTED;
1025 goto out;
1026 }
1027
1028 /* Look for EA in the inode */
1029 memcpy(&ea_inode_magic, ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
1030 inode->i_extra_isize, sizeof(__u32));
1031 if (ea_inode_magic == EXT2_EXT_ATTR_MAGIC) {
1032 storage_size = EXT2_INODE_SIZE(handle->fs->super) -
1033 EXT2_GOOD_OLD_INODE_SIZE - inode->i_extra_isize -
1034 sizeof(__u32);
1035 start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
1036 inode->i_extra_isize + sizeof(__u32);
1037
1038 err = read_xattrs_from_buffer(handle, inode,
1039 (struct ext2_ext_attr_entry *) start,
1040 storage_size, start);
1041 if (err)
1042 goto out;
1043
1044 handle->ibody_count = handle->count;
1045 }
1046
1047 read_ea_block:
1048 /* Look for EA in a separate EA block */
1049 blk = ext2fs_file_acl_block(handle->fs, (struct ext2_inode *)inode);
1050 if (blk != 0) {
1051 if ((blk < handle->fs->super->s_first_data_block) ||
1052 (blk >= ext2fs_blocks_count(handle->fs->super))) {
1053 err = EXT2_ET_BAD_EA_BLOCK_NUM;
1054 goto out;
1055 }
1056
1057 err = ext2fs_get_mem(handle->fs->blocksize, &block_buf);
1058 if (err)
1059 goto out;
1060
1061 err = ext2fs_read_ext_attr3(handle->fs, blk, block_buf,
1062 handle->ino);
1063 if (err)
1064 goto out3;
1065
1066 /* We only know how to deal with v2 EA blocks */
1067 header = (struct ext2_ext_attr_header *) block_buf;
1068 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
1069 err = EXT2_ET_BAD_EA_HEADER;
1070 goto out3;
1071 }
1072
1073 /* Read EAs */
1074 storage_size = handle->fs->blocksize -
1075 sizeof(struct ext2_ext_attr_header);
1076 start = block_buf + sizeof(struct ext2_ext_attr_header);
1077 err = read_xattrs_from_buffer(handle, inode,
1078 (struct ext2_ext_attr_entry *) start,
1079 storage_size, block_buf);
1080 if (err)
1081 goto out3;
1082
1083 ext2fs_free_mem(&block_buf);
1084 }
1085
1086 ext2fs_free_mem(&block_buf);
1087 ext2fs_free_mem(&inode);
1088 return 0;
1089
1090 out3:
1091 ext2fs_free_mem(&block_buf);
1092 out:
1093 ext2fs_free_mem(&inode);
1094 return err;
1095 }
1096
1097 errcode_t ext2fs_xattrs_iterate(struct ext2_xattr_handle *h,
1098 int (*func)(char *name, char *value,
1099 size_t value_len, void *data),
1100 void *data)
1101 {
1102 struct ext2_xattr *x;
1103 int dirty = 0;
1104 int ret;
1105
1106 EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE);
1107 for (x = h->attrs; x < h->attrs + h->count; x++) {
1108 ret = func(x->name, x->value, x->value_len, data);
1109 if (ret & XATTR_CHANGED)
1110 dirty = 1;
1111 if (ret & XATTR_ABORT)
1112 break;
1113 }
1114
1115 if (dirty)
1116 return ext2fs_xattrs_write(h);
1117 return 0;
1118 }
1119
1120 errcode_t ext2fs_xattr_get(struct ext2_xattr_handle *h, const char *key,
1121 void **value, size_t *value_len)
1122 {
1123 struct ext2_xattr *x;
1124 char *val;
1125 errcode_t err;
1126
1127 EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE);
1128 for (x = h->attrs; x < h->attrs + h->count; x++) {
1129 if (strcmp(x->name, key))
1130 continue;
1131
1132 if (!(h->flags & XATTR_HANDLE_FLAG_RAW) &&
1133 ((strcmp(key, "system.posix_acl_default") == 0) ||
1134 (strcmp(key, "system.posix_acl_access") == 0))) {
1135 err = convert_disk_buffer_to_posix_acl(x->value, x->value_len,
1136 value, value_len);
1137 return err;
1138 } else {
1139 err = ext2fs_get_mem(x->value_len, &val);
1140 if (err)
1141 return err;
1142 memcpy(val, x->value, x->value_len);
1143 *value = val;
1144 *value_len = x->value_len;
1145 return 0;
1146 }
1147 }
1148
1149 return EXT2_ET_EA_KEY_NOT_FOUND;
1150 }
1151
1152 errcode_t ext2fs_xattr_inode_max_size(ext2_filsys fs, ext2_ino_t ino,
1153 size_t *size)
1154 {
1155 struct ext2_ext_attr_entry *entry;
1156 struct ext2_inode_large *inode;
1157 __u32 ea_inode_magic;
1158 unsigned int minoff;
1159 char *start;
1160 size_t i;
1161 errcode_t err;
1162
1163 i = EXT2_INODE_SIZE(fs->super);
1164 if (i < sizeof(*inode))
1165 i = sizeof(*inode);
1166 err = ext2fs_get_memzero(i, &inode);
1167 if (err)
1168 return err;
1169
1170 err = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)inode,
1171 EXT2_INODE_SIZE(fs->super));
1172 if (err)
1173 goto out;
1174
1175 /* Does the inode have size for EA? */
1176 if (EXT2_INODE_SIZE(fs->super) <= EXT2_GOOD_OLD_INODE_SIZE +
1177 inode->i_extra_isize +
1178 sizeof(__u32)) {
1179 err = EXT2_ET_INLINE_DATA_NO_SPACE;
1180 goto out;
1181 }
1182
1183 minoff = EXT2_INODE_SIZE(fs->super) - sizeof(*inode) - sizeof(__u32);
1184 memcpy(&ea_inode_magic, ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
1185 inode->i_extra_isize, sizeof(__u32));
1186 if (ea_inode_magic == EXT2_EXT_ATTR_MAGIC) {
1187 /* has xattrs. calculate the size */
1188 start= ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
1189 inode->i_extra_isize + sizeof(__u32);
1190 entry = (struct ext2_ext_attr_entry *) start;
1191 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
1192 if (!entry->e_value_inum && entry->e_value_size) {
1193 unsigned int offs = entry->e_value_offs;
1194 if (offs < minoff)
1195 minoff = offs;
1196 }
1197 entry = EXT2_EXT_ATTR_NEXT(entry);
1198 }
1199 *size = minoff - ((char *)entry - (char *)start) - sizeof(__u32);
1200 } else {
1201 /* no xattr. return a maximum size */
1202 *size = EXT2_EXT_ATTR_SIZE(minoff -
1203 EXT2_EXT_ATTR_LEN(strlen("data")) -
1204 EXT2_EXT_ATTR_ROUND - sizeof(__u32));
1205 }
1206
1207 out:
1208 ext2fs_free_mem(&inode);
1209 return err;
1210 }
1211
1212 static errcode_t xattr_create_ea_inode(ext2_filsys fs, const void *value,
1213 size_t value_len, ext2_ino_t *ea_ino)
1214 {
1215 struct ext2_inode inode;
1216 ext2_ino_t ino;
1217 ext2_file_t file;
1218 __u32 hash;
1219 errcode_t ret;
1220
1221 ret = ext2fs_new_inode(fs, 0, 0, 0, &ino);
1222 if (ret)
1223 return ret;
1224
1225 memset(&inode, 0, sizeof(inode));
1226 inode.i_flags |= EXT4_EA_INODE_FL;
1227 if (ext2fs_has_feature_extents(fs->super))
1228 inode.i_flags |= EXT4_EXTENTS_FL;
1229 inode.i_size = 0;
1230 inode.i_mode = LINUX_S_IFREG | 0600;
1231 inode.i_links_count = 1;
1232 ret = ext2fs_write_new_inode(fs, ino, &inode);
1233 if (ret)
1234 return ret;
1235 /*
1236 * ref_count and hash utilize inode's i_*time fields.
1237 * ext2fs_write_new_inode() call above initializes these fields with
1238 * current time. That's why ref count and hash updates are done
1239 * separately below.
1240 */
1241 ext2fs_set_ea_inode_ref(&inode, 1);
1242 hash = ext2fs_crc32c_le(fs->csum_seed, value, value_len);
1243 ext2fs_set_ea_inode_hash(&inode, hash);
1244
1245 ret = ext2fs_write_inode(fs, ino, &inode);
1246 if (ret)
1247 return ret;
1248
1249 ret = ext2fs_file_open(fs, ino, EXT2_FILE_WRITE, &file);
1250 if (ret)
1251 return ret;
1252 ret = ext2fs_file_write(file, value, value_len, NULL);
1253 ext2fs_file_close(file);
1254 if (ret)
1255 return ret;
1256
1257 ext2fs_inode_alloc_stats2(fs, ino, 1 /* inuse */, 0 /* isdir */);
1258
1259 *ea_ino = ino;
1260 return 0;
1261 }
1262
1263 static errcode_t xattr_inode_dec_ref(ext2_filsys fs, ext2_ino_t ino)
1264 {
1265 struct ext2_inode_large inode;
1266 __u64 ref_count;
1267 errcode_t ret;
1268
1269 ret = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)&inode,
1270 sizeof(inode));
1271 if (ret)
1272 goto out;
1273
1274 ref_count = ext2fs_get_ea_inode_ref(EXT2_INODE(&inode));
1275 ref_count--;
1276 ext2fs_set_ea_inode_ref(EXT2_INODE(&inode), ref_count);
1277
1278 if (ref_count)
1279 goto write_out;
1280
1281 inode.i_links_count = 0;
1282 inode.i_dtime = fs->now ? fs->now : time(0);
1283
1284 ret = ext2fs_free_ext_attr(fs, ino, &inode);
1285 if (ret)
1286 goto write_out;
1287
1288 if (ext2fs_inode_has_valid_blocks2(fs, (struct ext2_inode *)&inode)) {
1289 ret = ext2fs_punch(fs, ino, (struct ext2_inode *)&inode, NULL,
1290 0, ~0ULL);
1291 if (ret)
1292 goto out;
1293 }
1294
1295 ext2fs_inode_alloc_stats2(fs, ino, -1 /* inuse */, 0 /* is_dir */);
1296
1297 write_out:
1298 ret = ext2fs_write_inode_full(fs, ino, (struct ext2_inode *)&inode,
1299 sizeof(inode));
1300 out:
1301 return ret;
1302 }
1303
1304 static errcode_t xattr_update_entry(ext2_filsys fs, struct ext2_xattr *x,
1305 const char *name, const void *value,
1306 size_t value_len, int in_inode)
1307 {
1308 ext2_ino_t ea_ino = 0;
1309 void *new_value = NULL;
1310 char *new_name = NULL;
1311 int name_len;
1312 errcode_t ret;
1313
1314 if (!x->name) {
1315 name_len = strlen(name);
1316 ret = ext2fs_get_mem(name_len + 1, &new_name);
1317 if (ret)
1318 goto fail;
1319 memcpy(new_name, name, name_len + 1);
1320 }
1321
1322 ret = ext2fs_get_mem(value_len, &new_value);
1323 if (ret)
1324 goto fail;
1325 memcpy(new_value, value, value_len);
1326
1327 if (in_inode) {
1328 ret = xattr_create_ea_inode(fs, value, value_len, &ea_ino);
1329 if (ret)
1330 goto fail;
1331 }
1332
1333 if (x->ea_ino) {
1334 ret = xattr_inode_dec_ref(fs, x->ea_ino);
1335 if (ret)
1336 goto fail;
1337 }
1338
1339 if (!x->name)
1340 x->name = new_name;
1341
1342 if (x->value)
1343 ext2fs_free_mem(&x->value);
1344 x->value = new_value;
1345 x->value_len = value_len;
1346 x->ea_ino = ea_ino;
1347 return 0;
1348 fail:
1349 if (new_name)
1350 ext2fs_free_mem(&new_name);
1351 if (new_value)
1352 ext2fs_free_mem(&new_value);
1353 if (ea_ino)
1354 xattr_inode_dec_ref(fs, ea_ino);
1355 return ret;
1356 }
1357
1358 static int xattr_find_position(struct ext2_xattr *attrs, int count,
1359 const char *name)
1360 {
1361 struct ext2_xattr *x;
1362 int i;
1363 const char *shortname, *x_shortname;
1364 int name_idx, x_name_idx;
1365 int shortname_len, x_shortname_len;
1366
1367 find_ea_index(name, &shortname, &name_idx);
1368 shortname_len = strlen(shortname);
1369
1370 for (i = 0, x = attrs; i < count; i++, x++) {
1371 find_ea_index(x->name, &x_shortname, &x_name_idx);
1372 if (name_idx < x_name_idx)
1373 break;
1374 if (name_idx > x_name_idx)
1375 continue;
1376
1377 x_shortname_len = strlen(x_shortname);
1378 if (shortname_len < x_shortname_len)
1379 break;
1380 if (shortname_len > x_shortname_len)
1381 continue;
1382
1383 if (memcmp(shortname, x_shortname, shortname_len) <= 0)
1384 break;
1385 }
1386 return i;
1387 }
1388
1389 static errcode_t xattr_array_update(struct ext2_xattr_handle *h,
1390 const char *name,
1391 const void *value, size_t value_len,
1392 int ibody_free, int block_free,
1393 int old_idx, int in_inode)
1394 {
1395 struct ext2_xattr tmp;
1396 int add_to_ibody;
1397 int needed;
1398 int name_len, name_idx;
1399 const char *shortname;
1400 int new_idx;
1401 int ret;
1402
1403 find_ea_index(name, &shortname, &name_idx);
1404 name_len = strlen(shortname);
1405
1406 needed = EXT2_EXT_ATTR_LEN(name_len);
1407 if (!in_inode)
1408 needed += EXT2_EXT_ATTR_SIZE(value_len);
1409
1410 if (old_idx >= 0 && old_idx < h->ibody_count) {
1411 ibody_free += EXT2_EXT_ATTR_LEN(name_len);
1412 if (!h->attrs[old_idx].ea_ino)
1413 ibody_free += EXT2_EXT_ATTR_SIZE(
1414 h->attrs[old_idx].value_len);
1415 }
1416
1417 if (needed <= ibody_free) {
1418 if (old_idx < 0) {
1419 new_idx = h->ibody_count;
1420 add_to_ibody = 1;
1421 goto add_new;
1422 }
1423
1424 /* Update the existing entry. */
1425 ret = xattr_update_entry(h->fs, &h->attrs[old_idx], name,
1426 value, value_len, in_inode);
1427 if (ret)
1428 return ret;
1429 if (h->ibody_count <= old_idx) {
1430 /* Move entry from block to the end of ibody. */
1431 tmp = h->attrs[old_idx];
1432 memmove(h->attrs + h->ibody_count + 1,
1433 h->attrs + h->ibody_count,
1434 (old_idx - h->ibody_count) * sizeof(*h->attrs));
1435 h->attrs[h->ibody_count] = tmp;
1436 h->ibody_count++;
1437 }
1438 return 0;
1439 }
1440
1441 if (h->ibody_count <= old_idx) {
1442 block_free += EXT2_EXT_ATTR_LEN(name_len);
1443 if (!h->attrs[old_idx].ea_ino)
1444 block_free +=
1445 EXT2_EXT_ATTR_SIZE(h->attrs[old_idx].value_len);
1446 }
1447
1448 if (needed > block_free)
1449 return EXT2_ET_EA_NO_SPACE;
1450
1451 if (old_idx >= 0) {
1452 /* Update the existing entry. */
1453 ret = xattr_update_entry(h->fs, &h->attrs[old_idx], name,
1454 value, value_len, in_inode);
1455 if (ret)
1456 return ret;
1457 if (old_idx < h->ibody_count) {
1458 /*
1459 * Move entry from ibody to the block. Note that
1460 * entries in the block are sorted.
1461 */
1462 new_idx = xattr_find_position(h->attrs + h->ibody_count,
1463 h->count - h->ibody_count, name);
1464 new_idx += h->ibody_count - 1;
1465 tmp = h->attrs[old_idx];
1466 memmove(h->attrs + old_idx, h->attrs + old_idx + 1,
1467 (new_idx - old_idx) * sizeof(*h->attrs));
1468 h->attrs[new_idx] = tmp;
1469 h->ibody_count--;
1470 }
1471 return 0;
1472 }
1473
1474 new_idx = xattr_find_position(h->attrs + h->ibody_count,
1475 h->count - h->ibody_count, name);
1476 new_idx += h->ibody_count;
1477 add_to_ibody = 0;
1478
1479 add_new:
1480 if (h->count == h->capacity) {
1481 ret = ext2fs_xattrs_expand(h, 4);
1482 if (ret)
1483 return ret;
1484 }
1485
1486 ret = xattr_update_entry(h->fs, &h->attrs[h->count], name, value,
1487 value_len, in_inode);
1488 if (ret)
1489 return ret;
1490
1491 tmp = h->attrs[h->count];
1492 memmove(h->attrs + new_idx + 1, h->attrs + new_idx,
1493 (h->count - new_idx)*sizeof(*h->attrs));
1494 h->attrs[new_idx] = tmp;
1495 if (add_to_ibody)
1496 h->ibody_count++;
1497 h->count++;
1498 return 0;
1499 }
1500
1501 static int space_used(struct ext2_xattr *attrs, int count)
1502 {
1503 int total = 0;
1504 struct ext2_xattr *x;
1505 const char *shortname;
1506 int i, len, name_idx;
1507
1508 for (i = 0, x = attrs; i < count; i++, x++) {
1509 find_ea_index(x->name, &shortname, &name_idx);
1510 len = strlen(shortname);
1511 total += EXT2_EXT_ATTR_LEN(len);
1512 if (!x->ea_ino)
1513 total += EXT2_EXT_ATTR_SIZE(x->value_len);
1514 }
1515 return total;
1516 }
1517
1518 /*
1519 * The minimum size of EA value when you start storing it in an external inode
1520 * size of block - size of header - size of 1 entry - 4 null bytes
1521 */
1522 #define EXT4_XATTR_MIN_LARGE_EA_SIZE(b) \
1523 ((b) - EXT2_EXT_ATTR_LEN(3) - sizeof(struct ext2_ext_attr_header) - 4)
1524
1525 errcode_t ext2fs_xattr_set(struct ext2_xattr_handle *h,
1526 const char *name,
1527 const void *value,
1528 size_t value_len)
1529 {
1530 ext2_filsys fs = h->fs;
1531 const int inode_size = EXT2_INODE_SIZE(fs->super);
1532 struct ext2_inode_large *inode = NULL;
1533 struct ext2_xattr *x;
1534 char *new_value;
1535 int ibody_free, block_free;
1536 int in_inode = 0;
1537 int old_idx = -1;
1538 int extra_isize;
1539 errcode_t ret;
1540
1541 EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE);
1542
1543 ret = ext2fs_get_mem(value_len, &new_value);
1544 if (ret)
1545 return ret;
1546 if (!(h->flags & XATTR_HANDLE_FLAG_RAW) &&
1547 ((strcmp(name, "system.posix_acl_default") == 0) ||
1548 (strcmp(name, "system.posix_acl_access") == 0))) {
1549 ret = convert_posix_acl_to_disk_buffer(value, value_len,
1550 new_value, &value_len);
1551 if (ret)
1552 goto out;
1553 } else
1554 memcpy(new_value, value, value_len);
1555
1556 /* Imitate kernel behavior by skipping update if value is the same. */
1557 for (x = h->attrs; x < h->attrs + h->count; x++) {
1558 if (!strcmp(x->name, name)) {
1559 if (!x->ea_ino && x->value_len == value_len &&
1560 !memcmp(x->value, new_value, value_len)) {
1561 ret = 0;
1562 goto out;
1563 }
1564 old_idx = x - h->attrs;
1565 break;
1566 }
1567 }
1568
1569 ret = ext2fs_get_memzero(inode_size, &inode);
1570 if (ret)
1571 goto out;
1572 ret = ext2fs_read_inode_full(fs, h->ino,
1573 (struct ext2_inode *)inode,
1574 inode_size);
1575 if (ret)
1576 goto out;
1577 if (inode_size > EXT2_GOOD_OLD_INODE_SIZE) {
1578 extra_isize = inode->i_extra_isize;
1579 if (extra_isize == 0) {
1580 extra_isize = fs->super->s_want_extra_isize;
1581 if (extra_isize == 0)
1582 extra_isize = sizeof(__u32);
1583 }
1584 ibody_free = inode_size - EXT2_GOOD_OLD_INODE_SIZE;
1585 ibody_free -= extra_isize;
1586 /* Extended attribute magic and final null entry. */
1587 ibody_free -= sizeof(__u32) * 2;
1588 ibody_free -= space_used(h->attrs, h->ibody_count);
1589 } else
1590 ibody_free = 0;
1591
1592 /* Inline data can only go to ibody. */
1593 if (strcmp(name, "system.data") == 0) {
1594 if (h->ibody_count <= old_idx) {
1595 ret = EXT2_ET_FILESYSTEM_CORRUPTED;
1596 goto out;
1597 }
1598 ret = xattr_array_update(h, name, new_value, value_len,
1599 ibody_free,
1600 0 /* block_free */, old_idx,
1601 0 /* in_inode */);
1602 if (ret)
1603 goto out;
1604 goto write_out;
1605 }
1606
1607 block_free = fs->blocksize;
1608 block_free -= sizeof(struct ext2_ext_attr_header);
1609 /* Final null entry. */
1610 block_free -= sizeof(__u32);
1611 block_free -= space_used(h->attrs + h->ibody_count,
1612 h->count - h->ibody_count);
1613
1614 if (ext2fs_has_feature_ea_inode(fs->super) &&
1615 value_len > EXT4_XATTR_MIN_LARGE_EA_SIZE(fs->blocksize))
1616 in_inode = 1;
1617
1618 ret = xattr_array_update(h, name, new_value, value_len, ibody_free,
1619 block_free, old_idx, in_inode);
1620 if (ret == EXT2_ET_EA_NO_SPACE && !in_inode &&
1621 ext2fs_has_feature_ea_inode(fs->super))
1622 ret = xattr_array_update(h, name, new_value, value_len,
1623 ibody_free, block_free, old_idx, 1 /* in_inode */);
1624 if (ret)
1625 goto out;
1626
1627 write_out:
1628 ret = ext2fs_xattrs_write(h);
1629 out:
1630 if (inode)
1631 ext2fs_free_mem(&inode);
1632 ext2fs_free_mem(&new_value);
1633 return ret;
1634 }
1635
1636 errcode_t ext2fs_xattr_remove(struct ext2_xattr_handle *handle,
1637 const char *key)
1638 {
1639 struct ext2_xattr *x;
1640 struct ext2_xattr *end = handle->attrs + handle->count;
1641
1642 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1643 for (x = handle->attrs; x < end; x++) {
1644 if (strcmp(x->name, key) == 0) {
1645 ext2fs_free_mem(&x->name);
1646 ext2fs_free_mem(&x->value);
1647 if (x->ea_ino)
1648 xattr_inode_dec_ref(handle->fs, x->ea_ino);
1649 memmove(x, x + 1, (end - x - 1)*sizeof(*x));
1650 memset(end - 1, 0, sizeof(*end));
1651 if (x < handle->attrs + handle->ibody_count)
1652 handle->ibody_count--;
1653 handle->count--;
1654 return ext2fs_xattrs_write(handle);
1655 }
1656 }
1657
1658 /* no key found, success! */
1659 return 0;
1660 }
1661
1662 errcode_t ext2fs_xattrs_open(ext2_filsys fs, ext2_ino_t ino,
1663 struct ext2_xattr_handle **handle)
1664 {
1665 struct ext2_xattr_handle *h;
1666 errcode_t err;
1667
1668 if (!ext2fs_has_feature_xattr(fs->super) &&
1669 !ext2fs_has_feature_inline_data(fs->super))
1670 return EXT2_ET_MISSING_EA_FEATURE;
1671
1672 err = ext2fs_get_memzero(sizeof(*h), &h);
1673 if (err)
1674 return err;
1675
1676 h->magic = EXT2_ET_MAGIC_EA_HANDLE;
1677 h->capacity = 4;
1678 err = ext2fs_get_arrayzero(h->capacity, sizeof(struct ext2_xattr),
1679 &h->attrs);
1680 if (err) {
1681 ext2fs_free_mem(&h);
1682 return err;
1683 }
1684 h->count = 0;
1685 h->ino = ino;
1686 h->fs = fs;
1687 *handle = h;
1688 return 0;
1689 }
1690
1691 errcode_t ext2fs_xattrs_close(struct ext2_xattr_handle **handle)
1692 {
1693 struct ext2_xattr_handle *h = *handle;
1694
1695 EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE);
1696 xattrs_free_keys(h);
1697 ext2fs_free_mem(&h->attrs);
1698 ext2fs_free_mem(handle);
1699 return 0;
1700 }
1701
1702 errcode_t ext2fs_xattrs_count(struct ext2_xattr_handle *handle, size_t *count)
1703 {
1704 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1705 *count = handle->count;
1706 return 0;
1707 }
1708
1709 errcode_t ext2fs_xattrs_flags(struct ext2_xattr_handle *handle,
1710 unsigned int *new_flags, unsigned int *old_flags)
1711 {
1712 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1713 if (old_flags)
1714 *old_flags = handle->flags;
1715 if (new_flags)
1716 handle->flags = *new_flags;
1717 return 0;
1718 }
Unnamed repository; edit this file 'description' to name the repository.