]> 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
e2fsck: ea_inode hash validation
[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 = inode.i_atime;
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 static errcode_t check_ext_attr_header(struct ext2_ext_attr_header *header)
104 {
105 if ((header->h_magic != EXT2_EXT_ATTR_MAGIC_v1 &&
106 header->h_magic != EXT2_EXT_ATTR_MAGIC) ||
107 header->h_blocks != 1)
108 return EXT2_ET_BAD_EA_HEADER;
109
110 return 0;
111 }
112
113 #undef NAME_HASH_SHIFT
114 #undef VALUE_HASH_SHIFT
115
116 errcode_t ext2fs_read_ext_attr3(ext2_filsys fs, blk64_t block, void *buf,
117 ext2_ino_t inum)
118 {
119 int csum_failed = 0;
120 errcode_t retval;
121
122 retval = io_channel_read_blk64(fs->io, block, 1, buf);
123 if (retval)
124 return retval;
125
126 if (!(fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) &&
127 !ext2fs_ext_attr_block_csum_verify(fs, inum, block, buf))
128 csum_failed = 1;
129
130 #ifdef WORDS_BIGENDIAN
131 ext2fs_swap_ext_attr(buf, buf, fs->blocksize, 1);
132 #endif
133
134 retval = check_ext_attr_header(buf);
135 if (retval == 0 && csum_failed)
136 retval = EXT2_ET_EXT_ATTR_CSUM_INVALID;
137
138 return retval;
139 }
140
141 errcode_t ext2fs_read_ext_attr2(ext2_filsys fs, blk64_t block, void *buf)
142 {
143 return ext2fs_read_ext_attr3(fs, block, buf, 0);
144 }
145
146 errcode_t ext2fs_read_ext_attr(ext2_filsys fs, blk_t block, void *buf)
147 {
148 return ext2fs_read_ext_attr2(fs, block, buf);
149 }
150
151 errcode_t ext2fs_write_ext_attr3(ext2_filsys fs, blk64_t block, void *inbuf,
152 ext2_ino_t inum)
153 {
154 errcode_t retval;
155 char *write_buf;
156
157 #ifdef WORDS_BIGENDIAN
158 retval = ext2fs_get_mem(fs->blocksize, &write_buf);
159 if (retval)
160 return retval;
161 ext2fs_swap_ext_attr(write_buf, inbuf, fs->blocksize, 1);
162 #else
163 write_buf = (char *) inbuf;
164 #endif
165
166 retval = ext2fs_ext_attr_block_csum_set(fs, inum, block,
167 (struct ext2_ext_attr_header *)write_buf);
168 if (retval)
169 return retval;
170
171 retval = io_channel_write_blk64(fs->io, block, 1, write_buf);
172 #ifdef WORDS_BIGENDIAN
173 ext2fs_free_mem(&write_buf);
174 #endif
175 if (!retval)
176 ext2fs_mark_changed(fs);
177 return retval;
178 }
179
180 errcode_t ext2fs_write_ext_attr2(ext2_filsys fs, blk64_t block, void *inbuf)
181 {
182 return ext2fs_write_ext_attr3(fs, block, inbuf, 0);
183 }
184
185 errcode_t ext2fs_write_ext_attr(ext2_filsys fs, blk_t block, void *inbuf)
186 {
187 return ext2fs_write_ext_attr2(fs, block, inbuf);
188 }
189
190 /*
191 * This function adjusts the reference count of the EA block.
192 */
193 errcode_t ext2fs_adjust_ea_refcount3(ext2_filsys fs, blk64_t blk,
194 char *block_buf, int adjust,
195 __u32 *newcount, ext2_ino_t inum)
196 {
197 errcode_t retval;
198 struct ext2_ext_attr_header *header;
199 char *buf = 0;
200
201 if ((blk >= ext2fs_blocks_count(fs->super)) ||
202 (blk < fs->super->s_first_data_block))
203 return EXT2_ET_BAD_EA_BLOCK_NUM;
204
205 if (!block_buf) {
206 retval = ext2fs_get_mem(fs->blocksize, &buf);
207 if (retval)
208 return retval;
209 block_buf = buf;
210 }
211
212 retval = ext2fs_read_ext_attr3(fs, blk, block_buf, inum);
213 if (retval)
214 goto errout;
215
216 header = (struct ext2_ext_attr_header *) block_buf;
217 header->h_refcount += adjust;
218 if (newcount)
219 *newcount = header->h_refcount;
220
221 retval = ext2fs_write_ext_attr3(fs, blk, block_buf, inum);
222 if (retval)
223 goto errout;
224
225 errout:
226 if (buf)
227 ext2fs_free_mem(&buf);
228 return retval;
229 }
230
231 errcode_t ext2fs_adjust_ea_refcount2(ext2_filsys fs, blk64_t blk,
232 char *block_buf, int adjust,
233 __u32 *newcount)
234 {
235 return ext2fs_adjust_ea_refcount3(fs, blk, block_buf, adjust,
236 newcount, 0);
237 }
238
239 errcode_t ext2fs_adjust_ea_refcount(ext2_filsys fs, blk_t blk,
240 char *block_buf, int adjust,
241 __u32 *newcount)
242 {
243 return ext2fs_adjust_ea_refcount2(fs, blk, block_buf, adjust,
244 newcount);
245 }
246
247 /* Manipulate the contents of extended attribute regions */
248 struct ext2_xattr {
249 char *name;
250 void *value;
251 size_t value_len;
252 };
253
254 struct ext2_xattr_handle {
255 errcode_t magic;
256 ext2_filsys fs;
257 struct ext2_xattr *attrs;
258 size_t length, count;
259 ext2_ino_t ino;
260 unsigned int flags;
261 int dirty;
262 };
263
264 static errcode_t ext2fs_xattrs_expand(struct ext2_xattr_handle *h,
265 unsigned int expandby)
266 {
267 struct ext2_xattr *new_attrs;
268 errcode_t err;
269
270 err = ext2fs_get_arrayzero(h->length + expandby,
271 sizeof(struct ext2_xattr), &new_attrs);
272 if (err)
273 return err;
274
275 memcpy(new_attrs, h->attrs, h->length * sizeof(struct ext2_xattr));
276 ext2fs_free_mem(&h->attrs);
277 h->length += expandby;
278 h->attrs = new_attrs;
279
280 return 0;
281 }
282
283 struct ea_name_index {
284 int index;
285 const char *name;
286 };
287
288 /* Keep these names sorted in order of decreasing specificity. */
289 static struct ea_name_index ea_names[] = {
290 {3, "system.posix_acl_default"},
291 {2, "system.posix_acl_access"},
292 {8, "system.richacl"},
293 {6, "security."},
294 {4, "trusted."},
295 {7, "system."},
296 {1, "user."},
297 {0, NULL},
298 };
299
300 static int find_ea_index(char *fullname, char **name, int *index);
301
302 /* Push empty attributes to the end and inlinedata to the front. */
303 static int attr_compare(const void *a, const void *b)
304 {
305 const struct ext2_xattr *xa = a, *xb = b;
306 char *xa_suffix, *xb_suffix;
307 int xa_idx, xb_idx;
308 int cmp;
309
310 if (xa->name == NULL)
311 return +1;
312 else if (xb->name == NULL)
313 return -1;
314 else if (!strcmp(xa->name, "system.data"))
315 return -1;
316 else if (!strcmp(xb->name, "system.data"))
317 return +1;
318
319 /*
320 * Duplicate the kernel's sorting algorithm because xattr blocks
321 * require sorted keys.
322 */
323 xa_suffix = xa->name;
324 xb_suffix = xb->name;
325 xa_idx = xb_idx = 0;
326 find_ea_index(xa->name, &xa_suffix, &xa_idx);
327 find_ea_index(xb->name, &xb_suffix, &xb_idx);
328 cmp = xa_idx - xb_idx;
329 if (cmp)
330 return cmp;
331 cmp = strlen(xa_suffix) - strlen(xb_suffix);
332 if (cmp)
333 return cmp;
334 cmp = strcmp(xa_suffix, xb_suffix);
335 return cmp;
336 }
337
338 static const char *find_ea_prefix(int index)
339 {
340 struct ea_name_index *e;
341
342 for (e = ea_names; e->name; e++)
343 if (e->index == index)
344 return e->name;
345
346 return NULL;
347 }
348
349 static int find_ea_index(char *fullname, char **name, int *index)
350 {
351 struct ea_name_index *e;
352
353 for (e = ea_names; e->name; e++) {
354 if (strncmp(fullname, e->name, strlen(e->name)) == 0) {
355 *name = (char *)fullname + strlen(e->name);
356 *index = e->index;
357 return 1;
358 }
359 }
360 return 0;
361 }
362
363 errcode_t ext2fs_free_ext_attr(ext2_filsys fs, ext2_ino_t ino,
364 struct ext2_inode_large *inode)
365 {
366 struct ext2_ext_attr_header *header;
367 void *block_buf = NULL;
368 blk64_t blk;
369 errcode_t err;
370 struct ext2_inode_large i;
371
372 /* Read inode? */
373 if (inode == NULL) {
374 err = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)&i,
375 sizeof(struct ext2_inode_large));
376 if (err)
377 return err;
378 inode = &i;
379 }
380
381 /* Do we already have an EA block? */
382 blk = ext2fs_file_acl_block(fs, (struct ext2_inode *)inode);
383 if (blk == 0)
384 return 0;
385
386 /* Find block, zero it, write back */
387 if ((blk < fs->super->s_first_data_block) ||
388 (blk >= ext2fs_blocks_count(fs->super))) {
389 err = EXT2_ET_BAD_EA_BLOCK_NUM;
390 goto out;
391 }
392
393 err = ext2fs_get_mem(fs->blocksize, &block_buf);
394 if (err)
395 goto out;
396
397 err = ext2fs_read_ext_attr3(fs, blk, block_buf, ino);
398 if (err)
399 goto out2;
400
401 /* We only know how to deal with v2 EA blocks */
402 header = (struct ext2_ext_attr_header *) block_buf;
403 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
404 err = EXT2_ET_BAD_EA_HEADER;
405 goto out2;
406 }
407
408 header->h_refcount--;
409 err = ext2fs_write_ext_attr3(fs, blk, block_buf, ino);
410 if (err)
411 goto out2;
412
413 /* Erase link to block */
414 ext2fs_file_acl_block_set(fs, (struct ext2_inode *)inode, 0);
415 if (header->h_refcount == 0)
416 ext2fs_block_alloc_stats2(fs, blk, -1);
417 err = ext2fs_iblk_sub_blocks(fs, (struct ext2_inode *)inode, 1);
418 if (err)
419 goto out2;
420
421 /* Write inode? */
422 if (inode == &i) {
423 err = ext2fs_write_inode_full(fs, ino, (struct ext2_inode *)&i,
424 sizeof(struct ext2_inode_large));
425 if (err)
426 goto out2;
427 }
428
429 out2:
430 ext2fs_free_mem(&block_buf);
431 out:
432 return err;
433 }
434
435 static errcode_t prep_ea_block_for_write(ext2_filsys fs, ext2_ino_t ino,
436 struct ext2_inode_large *inode)
437 {
438 struct ext2_ext_attr_header *header;
439 void *block_buf = NULL;
440 blk64_t blk, goal;
441 errcode_t err;
442
443 /* Do we already have an EA block? */
444 blk = ext2fs_file_acl_block(fs, (struct ext2_inode *)inode);
445 if (blk != 0) {
446 if ((blk < fs->super->s_first_data_block) ||
447 (blk >= ext2fs_blocks_count(fs->super))) {
448 err = EXT2_ET_BAD_EA_BLOCK_NUM;
449 goto out;
450 }
451
452 err = ext2fs_get_mem(fs->blocksize, &block_buf);
453 if (err)
454 goto out;
455
456 err = ext2fs_read_ext_attr3(fs, blk, block_buf, ino);
457 if (err)
458 goto out2;
459
460 /* We only know how to deal with v2 EA blocks */
461 header = (struct ext2_ext_attr_header *) block_buf;
462 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
463 err = EXT2_ET_BAD_EA_HEADER;
464 goto out2;
465 }
466
467 /* Single-user block. We're done here. */
468 if (header->h_refcount == 1)
469 goto out2;
470
471 /* We need to CoW the block. */
472 header->h_refcount--;
473 err = ext2fs_write_ext_attr3(fs, blk, block_buf, ino);
474 if (err)
475 goto out2;
476 } else {
477 /* No block, we must increment i_blocks */
478 err = ext2fs_iblk_add_blocks(fs, (struct ext2_inode *)inode,
479 1);
480 if (err)
481 goto out;
482 }
483
484 /* Allocate a block */
485 goal = ext2fs_find_inode_goal(fs, ino, (struct ext2_inode *)inode, 0);
486 err = ext2fs_alloc_block2(fs, goal, NULL, &blk);
487 if (err)
488 goto out2;
489 ext2fs_file_acl_block_set(fs, (struct ext2_inode *)inode, blk);
490 out2:
491 if (block_buf)
492 ext2fs_free_mem(&block_buf);
493 out:
494 return err;
495 }
496
497
498 static inline int
499 posix_acl_xattr_count(size_t size)
500 {
501 if (size < sizeof(posix_acl_xattr_header))
502 return -1;
503 size -= sizeof(posix_acl_xattr_header);
504 if (size % sizeof(posix_acl_xattr_entry))
505 return -1;
506 return size / sizeof(posix_acl_xattr_entry);
507 }
508
509 /*
510 * The lgetxattr function returns data formatted in the POSIX extended
511 * attribute format. The on-disk format uses a more compact encoding.
512 * See the ext4_acl_to_disk in fs/ext4/acl.c.
513 */
514 static errcode_t convert_posix_acl_to_disk_buffer(const void *value, size_t size,
515 void *out_buf, size_t *size_out)
516 {
517 posix_acl_xattr_header *header = (posix_acl_xattr_header*) value;
518 posix_acl_xattr_entry *entry = (posix_acl_xattr_entry *)(header+1), *end;
519 ext4_acl_header *ext_acl;
520 size_t s;
521 void *e;
522
523 int count;
524
525 if (!value)
526 return EINVAL;
527 if (size < sizeof(posix_acl_xattr_header))
528 return ENOMEM;
529 if (header->a_version != ext2fs_cpu_to_le32(POSIX_ACL_XATTR_VERSION))
530 return EINVAL;
531
532 count = posix_acl_xattr_count(size);
533 ext_acl = out_buf;
534 ext_acl->a_version = ext2fs_cpu_to_le32(EXT4_ACL_VERSION);
535
536 if (count <= 0)
537 return EINVAL;
538
539 e = (char *) out_buf + sizeof(ext4_acl_header);
540 s = sizeof(ext4_acl_header);
541 for (end = entry + count; entry != end;entry++) {
542 ext4_acl_entry *disk_entry = (ext4_acl_entry*) e;
543 disk_entry->e_tag = ext2fs_cpu_to_le16(entry->e_tag);
544 disk_entry->e_perm = ext2fs_cpu_to_le16(entry->e_perm);
545
546 switch(entry->e_tag) {
547 case ACL_USER_OBJ:
548 case ACL_GROUP_OBJ:
549 case ACL_MASK:
550 case ACL_OTHER:
551 e += sizeof(ext4_acl_entry_short);
552 s += sizeof(ext4_acl_entry_short);
553 break;
554 case ACL_USER:
555 case ACL_GROUP:
556 disk_entry->e_id = ext2fs_cpu_to_le32(entry->e_id);
557 e += sizeof(ext4_acl_entry);
558 s += sizeof(ext4_acl_entry);
559 break;
560 }
561 }
562 *size_out = s;
563 return 0;
564 }
565
566 static errcode_t convert_disk_buffer_to_posix_acl(const void *value, size_t size,
567 void **out_buf, size_t *size_out)
568 {
569 posix_acl_xattr_header *header;
570 posix_acl_xattr_entry *entry;
571 ext4_acl_header *ext_acl = (ext4_acl_header *) value;
572 errcode_t err;
573 const char *cp;
574 char *out;
575
576 if ((!value) ||
577 (size < sizeof(ext4_acl_header)) ||
578 (ext_acl->a_version != ext2fs_cpu_to_le32(EXT4_ACL_VERSION)))
579 return EINVAL;
580
581 err = ext2fs_get_mem(size * 2, &out);
582 if (err)
583 return err;
584
585 header = (posix_acl_xattr_header *) out;
586 header->a_version = ext2fs_cpu_to_le32(POSIX_ACL_XATTR_VERSION);
587 entry = (posix_acl_xattr_entry *) (out + sizeof(posix_acl_xattr_header));
588
589 cp = value + sizeof(ext4_acl_header);
590 size -= sizeof(ext4_acl_header);
591
592 while (size > 0) {
593 const ext4_acl_entry *disk_entry = (const ext4_acl_entry *) cp;
594
595 entry->e_tag = ext2fs_le16_to_cpu(disk_entry->e_tag);
596 entry->e_perm = ext2fs_le16_to_cpu(disk_entry->e_perm);
597
598 switch(entry->e_tag) {
599 case ACL_USER_OBJ:
600 case ACL_GROUP_OBJ:
601 case ACL_MASK:
602 case ACL_OTHER:
603 entry->e_id = 0;
604 cp += sizeof(ext4_acl_entry_short);
605 size -= sizeof(ext4_acl_entry_short);
606 break;
607 case ACL_USER:
608 case ACL_GROUP:
609 entry->e_id = ext2fs_le32_to_cpu(disk_entry->e_id);
610 cp += sizeof(ext4_acl_entry);
611 size -= sizeof(ext4_acl_entry);
612 break;
613 default:
614 ext2fs_free_mem(&out);
615 return EINVAL;
616 break;
617 }
618 entry++;
619 }
620 *out_buf = out;
621 *size_out = ((char *) entry - out);
622 return 0;
623 }
624
625
626 static errcode_t write_xattrs_to_buffer(struct ext2_xattr_handle *handle,
627 struct ext2_xattr **pos,
628 void *entries_start,
629 unsigned int storage_size,
630 unsigned int value_offset_correction,
631 int write_hash)
632 {
633 struct ext2_xattr *x = *pos;
634 struct ext2_ext_attr_entry *e = entries_start;
635 char *end = (char *) entries_start + storage_size;
636 char *shortname;
637 unsigned int entry_size, value_size;
638 int idx, ret;
639
640 memset(entries_start, 0, storage_size);
641 /* For all remaining x... */
642 for (; x < handle->attrs + handle->length; x++) {
643 if (!x->name)
644 continue;
645
646 /* Calculate index and shortname position */
647 shortname = x->name;
648 ret = find_ea_index(x->name, &shortname, &idx);
649
650 /* Calculate entry and value size */
651 entry_size = (sizeof(*e) + strlen(shortname) +
652 EXT2_EXT_ATTR_PAD - 1) &
653 ~(EXT2_EXT_ATTR_PAD - 1);
654 value_size = ((x->value_len + EXT2_EXT_ATTR_PAD - 1) /
655 EXT2_EXT_ATTR_PAD) * EXT2_EXT_ATTR_PAD;
656
657 /*
658 * Would entry collide with value?
659 * Note that we must leave sufficient room for a (u32)0 to
660 * mark the end of the entries.
661 */
662 if ((char *)e + entry_size + sizeof(__u32) > end - value_size)
663 break;
664
665 /* Fill out e appropriately */
666 e->e_name_len = strlen(shortname);
667 e->e_name_index = (ret ? idx : 0);
668 e->e_value_offs = end - value_size - (char *)entries_start +
669 value_offset_correction;
670 e->e_value_inum = 0;
671 e->e_value_size = x->value_len;
672
673 /* Store name and value */
674 end -= value_size;
675 memcpy((char *)e + sizeof(*e), shortname, e->e_name_len);
676 memcpy(end, x->value, e->e_value_size);
677
678 if (write_hash)
679 e->e_hash = ext2fs_ext_attr_hash_entry(e, end);
680 else
681 e->e_hash = 0;
682
683 e = EXT2_EXT_ATTR_NEXT(e);
684 *(__u32 *)e = 0;
685 }
686 *pos = x;
687
688 return 0;
689 }
690
691 errcode_t ext2fs_xattrs_write(struct ext2_xattr_handle *handle)
692 {
693 struct ext2_xattr *x;
694 struct ext2_inode_large *inode;
695 char *start, *block_buf = NULL;
696 struct ext2_ext_attr_header *header;
697 __u32 ea_inode_magic;
698 blk64_t blk;
699 unsigned int storage_size;
700 unsigned int i;
701 errcode_t err;
702
703 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
704 i = EXT2_INODE_SIZE(handle->fs->super);
705 if (i < sizeof(*inode))
706 i = sizeof(*inode);
707 err = ext2fs_get_memzero(i, &inode);
708 if (err)
709 return err;
710
711 err = ext2fs_read_inode_full(handle->fs, handle->ino,
712 (struct ext2_inode *)inode,
713 EXT2_INODE_SIZE(handle->fs->super));
714 if (err)
715 goto out;
716
717 /* If extra_isize isn't set, we need to set it now */
718 if (inode->i_extra_isize == 0 &&
719 EXT2_INODE_SIZE(handle->fs->super) > EXT2_GOOD_OLD_INODE_SIZE) {
720 char *p = (char *)inode;
721 size_t extra = handle->fs->super->s_want_extra_isize;
722
723 if (extra == 0)
724 extra = sizeof(__u32);
725 memset(p + EXT2_GOOD_OLD_INODE_SIZE, 0, extra);
726 inode->i_extra_isize = extra;
727 }
728 if (inode->i_extra_isize & 3) {
729 err = EXT2_ET_INODE_CORRUPTED;
730 goto out;
731 }
732
733 /*
734 * Force the inlinedata attr to the front and the empty entries
735 * to the end.
736 */
737 x = handle->attrs;
738 qsort(x, handle->length, sizeof(struct ext2_xattr), attr_compare);
739
740 /* Does the inode have space for EA? */
741 if (inode->i_extra_isize < sizeof(inode->i_extra_isize) ||
742 EXT2_INODE_SIZE(handle->fs->super) <= EXT2_GOOD_OLD_INODE_SIZE +
743 inode->i_extra_isize +
744 sizeof(__u32))
745 goto write_ea_block;
746
747 /* Write the inode EA */
748 ea_inode_magic = EXT2_EXT_ATTR_MAGIC;
749 memcpy(((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
750 inode->i_extra_isize, &ea_inode_magic, sizeof(__u32));
751 storage_size = EXT2_INODE_SIZE(handle->fs->super) -
752 EXT2_GOOD_OLD_INODE_SIZE - inode->i_extra_isize -
753 sizeof(__u32);
754 start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
755 inode->i_extra_isize + sizeof(__u32);
756
757 err = write_xattrs_to_buffer(handle, &x, start, storage_size, 0, 0);
758 if (err)
759 goto out;
760
761 write_ea_block:
762 /* Are we done? */
763 if (x >= handle->attrs + handle->count)
764 goto skip_ea_block;
765
766 /* Write the EA block */
767 err = ext2fs_get_memzero(handle->fs->blocksize, &block_buf);
768 if (err)
769 goto out;
770
771 storage_size = handle->fs->blocksize -
772 sizeof(struct ext2_ext_attr_header);
773 start = block_buf + sizeof(struct ext2_ext_attr_header);
774
775 err = write_xattrs_to_buffer(handle, &x, start, storage_size,
776 start - block_buf, 1);
777 if (err)
778 goto out2;
779
780 if (x < handle->attrs + handle->length) {
781 err = EXT2_ET_EA_NO_SPACE;
782 goto out2;
783 }
784
785 /* Write a header on the EA block */
786 header = (struct ext2_ext_attr_header *) block_buf;
787 header->h_magic = EXT2_EXT_ATTR_MAGIC;
788 header->h_refcount = 1;
789 header->h_blocks = 1;
790
791 /* Get a new block for writing */
792 err = prep_ea_block_for_write(handle->fs, handle->ino, inode);
793 if (err)
794 goto out2;
795
796 /* Finally, write the new EA block */
797 blk = ext2fs_file_acl_block(handle->fs,
798 (struct ext2_inode *)inode);
799 err = ext2fs_write_ext_attr3(handle->fs, blk, block_buf,
800 handle->ino);
801 if (err)
802 goto out2;
803
804 skip_ea_block:
805 blk = ext2fs_file_acl_block(handle->fs, (struct ext2_inode *)inode);
806 if (!block_buf && blk) {
807 /* xattrs shrunk, free the block */
808 err = ext2fs_free_ext_attr(handle->fs, handle->ino, inode);
809 if (err)
810 goto out;
811 }
812
813 /* Write the inode */
814 err = ext2fs_write_inode_full(handle->fs, handle->ino,
815 (struct ext2_inode *)inode,
816 EXT2_INODE_SIZE(handle->fs->super));
817 if (err)
818 goto out2;
819
820 out2:
821 ext2fs_free_mem(&block_buf);
822 out:
823 ext2fs_free_mem(&inode);
824 handle->dirty = 0;
825 return err;
826 }
827
828 static errcode_t read_xattrs_from_buffer(struct ext2_xattr_handle *handle,
829 struct ext2_inode_large *inode,
830 struct ext2_ext_attr_entry *entries,
831 unsigned int storage_size,
832 char *value_start,
833 size_t *nr_read)
834 {
835 struct ext2_xattr *x;
836 struct ext2_ext_attr_entry *entry, *end;
837 const char *prefix;
838 unsigned int remain, prefix_len;
839 errcode_t err;
840 unsigned int values_size = storage_size +
841 ((char *)entries - value_start);
842
843 x = handle->attrs;
844 while (x->name)
845 x++;
846
847 /* find the end */
848 end = entries;
849 remain = storage_size;
850 while (remain >= sizeof(struct ext2_ext_attr_entry) &&
851 !EXT2_EXT_IS_LAST_ENTRY(end)) {
852
853 /* header eats this space */
854 remain -= sizeof(struct ext2_ext_attr_entry);
855
856 /* is attribute name valid? */
857 if (EXT2_EXT_ATTR_SIZE(end->e_name_len) > remain)
858 return EXT2_ET_EA_BAD_NAME_LEN;
859
860 /* attribute len eats this space */
861 remain -= EXT2_EXT_ATTR_SIZE(end->e_name_len);
862 end = EXT2_EXT_ATTR_NEXT(end);
863 }
864
865 entry = entries;
866 remain = storage_size;
867 while (remain >= sizeof(struct ext2_ext_attr_entry) &&
868 !EXT2_EXT_IS_LAST_ENTRY(entry)) {
869
870 /* Allocate space for more attrs? */
871 if (x == handle->attrs + handle->length) {
872 err = ext2fs_xattrs_expand(handle, 4);
873 if (err)
874 return err;
875 x = handle->attrs + handle->length - 4;
876 }
877
878 /* header eats this space */
879 remain -= sizeof(struct ext2_ext_attr_entry);
880
881 /* attribute len eats this space */
882 remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len);
883
884 /* Extract name */
885 prefix = find_ea_prefix(entry->e_name_index);
886 prefix_len = (prefix ? strlen(prefix) : 0);
887 err = ext2fs_get_memzero(entry->e_name_len + prefix_len + 1,
888 &x->name);
889 if (err)
890 return err;
891 if (prefix)
892 memcpy(x->name, prefix, prefix_len);
893 if (entry->e_name_len)
894 memcpy(x->name + prefix_len,
895 (char *)entry + sizeof(*entry),
896 entry->e_name_len);
897
898 /* Check & copy value */
899 if (!ext2fs_has_feature_ea_inode(handle->fs->super) &&
900 entry->e_value_inum != 0)
901 return EXT2_ET_BAD_EA_BLOCK_NUM;
902
903 if (entry->e_value_inum == 0) {
904 if (entry->e_value_size > remain)
905 return EXT2_ET_EA_BAD_VALUE_SIZE;
906
907 if (entry->e_value_offs + entry->e_value_size > values_size)
908 return EXT2_ET_EA_BAD_VALUE_OFFSET;
909
910 if (entry->e_value_size > 0 &&
911 value_start + entry->e_value_offs <
912 (char *)end + sizeof(__u32))
913 return EXT2_ET_EA_BAD_VALUE_OFFSET;
914
915 remain -= entry->e_value_size;
916
917 err = ext2fs_get_mem(entry->e_value_size, &x->value);
918 if (err)
919 return err;
920 memcpy(x->value, value_start + entry->e_value_offs,
921 entry->e_value_size);
922 } else {
923 ext2_file_t ea_file;
924
925 if (entry->e_value_offs != 0)
926 return EXT2_ET_EA_BAD_VALUE_OFFSET;
927
928 if (entry->e_value_size > (64 * 1024))
929 return EXT2_ET_EA_BAD_VALUE_SIZE;
930
931 err = ext2fs_get_mem(entry->e_value_size, &x->value);
932 if (err)
933 return err;
934
935 err = ext2fs_file_open(handle->fs, entry->e_value_inum,
936 0, &ea_file);
937 if (err)
938 return err;
939
940 if (ext2fs_file_get_size(ea_file) !=
941 entry->e_value_size)
942 err = EXT2_ET_EA_BAD_VALUE_SIZE;
943 else
944 err = ext2fs_file_read(ea_file, x->value,
945 entry->e_value_size, 0);
946 ext2fs_file_close(ea_file);
947 if (err)
948 return err;
949 }
950
951 x->value_len = entry->e_value_size;
952
953 /* e_hash may be 0 in older inode's ea */
954 if (entry->e_hash != 0) {
955 __u32 hash;
956 void *data = (entry->e_value_inum != 0) ?
957 0 : value_start + entry->e_value_offs;
958
959 err = ext2fs_ext_attr_hash_entry2(handle->fs, entry,
960 data, &hash);
961 if (err)
962 return err;
963 if (entry->e_hash != hash) {
964 struct ext2_inode child;
965
966 /* Check whether this is an old Lustre-style
967 * ea_inode reference.
968 */
969 err = ext2fs_read_inode(handle->fs,
970 entry->e_value_inum,
971 &child);
972 if (err)
973 return err;
974 if (child.i_mtime != handle->ino ||
975 child.i_generation != inode->i_generation)
976 return EXT2_ET_BAD_EA_HASH;
977 }
978 }
979
980 x++;
981 (*nr_read)++;
982 entry = EXT2_EXT_ATTR_NEXT(entry);
983 }
984
985 return 0;
986 }
987
988 static void xattrs_free_keys(struct ext2_xattr_handle *h)
989 {
990 struct ext2_xattr *a = h->attrs;
991 size_t i;
992
993 for (i = 0; i < h->length; i++) {
994 if (a[i].name)
995 ext2fs_free_mem(&a[i].name);
996 if (a[i].value)
997 ext2fs_free_mem(&a[i].value);
998 }
999 h->count = 0;
1000 }
1001
1002 errcode_t ext2fs_xattrs_read(struct ext2_xattr_handle *handle)
1003 {
1004 struct ext2_inode_large *inode;
1005 struct ext2_ext_attr_header *header;
1006 __u32 ea_inode_magic;
1007 unsigned int storage_size;
1008 char *start, *block_buf = NULL;
1009 blk64_t blk;
1010 size_t i;
1011 errcode_t err;
1012
1013 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1014 i = EXT2_INODE_SIZE(handle->fs->super);
1015 if (i < sizeof(*inode))
1016 i = sizeof(*inode);
1017 err = ext2fs_get_memzero(i, &inode);
1018 if (err)
1019 return err;
1020
1021 err = ext2fs_read_inode_full(handle->fs, handle->ino,
1022 (struct ext2_inode *)inode,
1023 EXT2_INODE_SIZE(handle->fs->super));
1024 if (err)
1025 goto out;
1026
1027 xattrs_free_keys(handle);
1028
1029 /* Does the inode have space for EA? */
1030 if (inode->i_extra_isize < sizeof(inode->i_extra_isize) ||
1031 EXT2_INODE_SIZE(handle->fs->super) <= EXT2_GOOD_OLD_INODE_SIZE +
1032 inode->i_extra_isize +
1033 sizeof(__u32))
1034 goto read_ea_block;
1035 if (inode->i_extra_isize & 3) {
1036 err = EXT2_ET_INODE_CORRUPTED;
1037 goto out;
1038 }
1039
1040 /* Look for EA in the inode */
1041 memcpy(&ea_inode_magic, ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
1042 inode->i_extra_isize, sizeof(__u32));
1043 if (ea_inode_magic == EXT2_EXT_ATTR_MAGIC) {
1044 storage_size = EXT2_INODE_SIZE(handle->fs->super) -
1045 EXT2_GOOD_OLD_INODE_SIZE - inode->i_extra_isize -
1046 sizeof(__u32);
1047 start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
1048 inode->i_extra_isize + sizeof(__u32);
1049
1050 err = read_xattrs_from_buffer(handle, inode,
1051 (struct ext2_ext_attr_entry *) start, storage_size,
1052 start, &handle->count);
1053 if (err)
1054 goto out;
1055 }
1056
1057 read_ea_block:
1058 /* Look for EA in a separate EA block */
1059 blk = ext2fs_file_acl_block(handle->fs, (struct ext2_inode *)inode);
1060 if (blk != 0) {
1061 if ((blk < handle->fs->super->s_first_data_block) ||
1062 (blk >= ext2fs_blocks_count(handle->fs->super))) {
1063 err = EXT2_ET_BAD_EA_BLOCK_NUM;
1064 goto out;
1065 }
1066
1067 err = ext2fs_get_mem(handle->fs->blocksize, &block_buf);
1068 if (err)
1069 goto out;
1070
1071 err = ext2fs_read_ext_attr3(handle->fs, blk, block_buf,
1072 handle->ino);
1073 if (err)
1074 goto out3;
1075
1076 /* We only know how to deal with v2 EA blocks */
1077 header = (struct ext2_ext_attr_header *) block_buf;
1078 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
1079 err = EXT2_ET_BAD_EA_HEADER;
1080 goto out3;
1081 }
1082
1083 /* Read EAs */
1084 storage_size = handle->fs->blocksize -
1085 sizeof(struct ext2_ext_attr_header);
1086 start = block_buf + sizeof(struct ext2_ext_attr_header);
1087 err = read_xattrs_from_buffer(handle, inode,
1088 (struct ext2_ext_attr_entry *) start, storage_size,
1089 block_buf, &handle->count);
1090 if (err)
1091 goto out3;
1092
1093 ext2fs_free_mem(&block_buf);
1094 }
1095
1096 ext2fs_free_mem(&block_buf);
1097 ext2fs_free_mem(&inode);
1098 return 0;
1099
1100 out3:
1101 ext2fs_free_mem(&block_buf);
1102 out:
1103 ext2fs_free_mem(&inode);
1104 return err;
1105 }
1106
1107 errcode_t ext2fs_xattrs_iterate(struct ext2_xattr_handle *h,
1108 int (*func)(char *name, char *value,
1109 size_t value_len, void *data),
1110 void *data)
1111 {
1112 struct ext2_xattr *x;
1113 int ret;
1114
1115 EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE);
1116 for (x = h->attrs; x < h->attrs + h->length; x++) {
1117 if (!x->name)
1118 continue;
1119
1120 ret = func(x->name, x->value, x->value_len, data);
1121 if (ret & XATTR_CHANGED)
1122 h->dirty = 1;
1123 if (ret & XATTR_ABORT)
1124 return 0;
1125 }
1126
1127 return 0;
1128 }
1129
1130 errcode_t ext2fs_xattr_get(struct ext2_xattr_handle *h, const char *key,
1131 void **value, size_t *value_len)
1132 {
1133 struct ext2_xattr *x;
1134 char *val;
1135 errcode_t err;
1136
1137 EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE);
1138 for (x = h->attrs; x < h->attrs + h->length; x++) {
1139 if (!x->name || strcmp(x->name, key))
1140 continue;
1141
1142 if (!(h->flags & XATTR_HANDLE_FLAG_RAW) &&
1143 ((strcmp(key, "system.posix_acl_default") == 0) ||
1144 (strcmp(key, "system.posix_acl_access") == 0))) {
1145 err = convert_disk_buffer_to_posix_acl(x->value, x->value_len,
1146 value, value_len);
1147 return err;
1148 } else {
1149 err = ext2fs_get_mem(x->value_len, &val);
1150 if (err)
1151 return err;
1152 memcpy(val, x->value, x->value_len);
1153 *value = val;
1154 *value_len = x->value_len;
1155 return 0;
1156 }
1157 }
1158
1159 return EXT2_ET_EA_KEY_NOT_FOUND;
1160 }
1161
1162 errcode_t ext2fs_xattr_inode_max_size(ext2_filsys fs, ext2_ino_t ino,
1163 size_t *size)
1164 {
1165 struct ext2_ext_attr_entry *entry;
1166 struct ext2_inode_large *inode;
1167 __u32 ea_inode_magic;
1168 unsigned int minoff;
1169 char *start;
1170 size_t i;
1171 errcode_t err;
1172
1173 i = EXT2_INODE_SIZE(fs->super);
1174 if (i < sizeof(*inode))
1175 i = sizeof(*inode);
1176 err = ext2fs_get_memzero(i, &inode);
1177 if (err)
1178 return err;
1179
1180 err = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)inode,
1181 EXT2_INODE_SIZE(fs->super));
1182 if (err)
1183 goto out;
1184
1185 /* Does the inode have size for EA? */
1186 if (EXT2_INODE_SIZE(fs->super) <= EXT2_GOOD_OLD_INODE_SIZE +
1187 inode->i_extra_isize +
1188 sizeof(__u32)) {
1189 err = EXT2_ET_INLINE_DATA_NO_SPACE;
1190 goto out;
1191 }
1192
1193 minoff = EXT2_INODE_SIZE(fs->super) - sizeof(*inode) - sizeof(__u32);
1194 memcpy(&ea_inode_magic, ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
1195 inode->i_extra_isize, sizeof(__u32));
1196 if (ea_inode_magic == EXT2_EXT_ATTR_MAGIC) {
1197 /* has xattrs. calculate the size */
1198 start= ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
1199 inode->i_extra_isize + sizeof(__u32);
1200 entry = (struct ext2_ext_attr_entry *) start;
1201 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
1202 if (!entry->e_value_inum && entry->e_value_size) {
1203 unsigned int offs = entry->e_value_offs;
1204 if (offs < minoff)
1205 minoff = offs;
1206 }
1207 entry = EXT2_EXT_ATTR_NEXT(entry);
1208 }
1209 *size = minoff - ((char *)entry - (char *)start) - sizeof(__u32);
1210 } else {
1211 /* no xattr. return a maximum size */
1212 *size = EXT2_EXT_ATTR_SIZE(minoff -
1213 EXT2_EXT_ATTR_LEN(strlen("data")) -
1214 EXT2_EXT_ATTR_ROUND - sizeof(__u32));
1215 }
1216
1217 out:
1218 ext2fs_free_mem(&inode);
1219 return err;
1220 }
1221
1222 errcode_t ext2fs_xattr_set(struct ext2_xattr_handle *handle,
1223 const char *key,
1224 const void *value,
1225 size_t value_len)
1226 {
1227 struct ext2_xattr *x, *last_empty;
1228 char *new_value;
1229 errcode_t err;
1230
1231 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1232 last_empty = NULL;
1233
1234 err = ext2fs_get_mem(value_len, &new_value);
1235 if (err)
1236 return err;
1237 if (!(handle->flags & XATTR_HANDLE_FLAG_RAW) &&
1238 ((strcmp(key, "system.posix_acl_default") == 0) ||
1239 (strcmp(key, "system.posix_acl_access") == 0))) {
1240 err = convert_posix_acl_to_disk_buffer(value, value_len,
1241 new_value, &value_len);
1242 if (err)
1243 goto errout;
1244 } else
1245 memcpy(new_value, value, value_len);
1246
1247 for (x = handle->attrs; x < handle->attrs + handle->length; x++) {
1248 if (!x->name) {
1249 last_empty = x;
1250 continue;
1251 }
1252
1253 /* Replace xattr */
1254 if (strcmp(x->name, key) == 0) {
1255 ext2fs_free_mem(&x->value);
1256 x->value = new_value;
1257 x->value_len = value_len;
1258 handle->dirty = 1;
1259 return 0;
1260 }
1261 }
1262
1263 /* Add attr to empty slot */
1264 if (last_empty) {
1265 err = ext2fs_get_mem(strlen(key) + 1, &last_empty->name);
1266 if (err)
1267 goto errout;
1268 strcpy(last_empty->name, key);
1269 last_empty->value = new_value;
1270 last_empty->value_len = value_len;
1271 handle->dirty = 1;
1272 handle->count++;
1273 return 0;
1274 }
1275
1276 /* Expand array, append slot */
1277 err = ext2fs_xattrs_expand(handle, 4);
1278 if (err)
1279 goto errout;
1280
1281 x = handle->attrs + handle->length - 4;
1282 err = ext2fs_get_mem(strlen(key) + 1, &x->name);
1283 if (err)
1284 goto errout;
1285 strcpy(x->name, key);
1286
1287 err = ext2fs_get_mem(value_len, &x->value);
1288 if (err)
1289 goto errout;
1290 memcpy(x->value, value, value_len);
1291 x->value_len = value_len;
1292 handle->dirty = 1;
1293 handle->count++;
1294 return 0;
1295 errout:
1296 ext2fs_free_mem(&new_value);
1297 return err;
1298 }
1299
1300 errcode_t ext2fs_xattr_remove(struct ext2_xattr_handle *handle,
1301 const char *key)
1302 {
1303 struct ext2_xattr *x;
1304
1305 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1306 for (x = handle->attrs; x < handle->attrs + handle->length; x++) {
1307 if (!x->name)
1308 continue;
1309
1310 if (strcmp(x->name, key) == 0) {
1311 ext2fs_free_mem(&x->name);
1312 ext2fs_free_mem(&x->value);
1313 x->value_len = 0;
1314 handle->dirty = 1;
1315 handle->count--;
1316 return 0;
1317 }
1318 }
1319
1320 /* no key found, success! */
1321 return 0;
1322 }
1323
1324 errcode_t ext2fs_xattrs_open(ext2_filsys fs, ext2_ino_t ino,
1325 struct ext2_xattr_handle **handle)
1326 {
1327 struct ext2_xattr_handle *h;
1328 errcode_t err;
1329
1330 if (!ext2fs_has_feature_xattr(fs->super) &&
1331 !ext2fs_has_feature_inline_data(fs->super))
1332 return EXT2_ET_MISSING_EA_FEATURE;
1333
1334 err = ext2fs_get_memzero(sizeof(*h), &h);
1335 if (err)
1336 return err;
1337
1338 h->magic = EXT2_ET_MAGIC_EA_HANDLE;
1339 h->length = 4;
1340 err = ext2fs_get_arrayzero(h->length, sizeof(struct ext2_xattr),
1341 &h->attrs);
1342 if (err) {
1343 ext2fs_free_mem(&h);
1344 return err;
1345 }
1346 h->count = 0;
1347 h->ino = ino;
1348 h->fs = fs;
1349 *handle = h;
1350 return 0;
1351 }
1352
1353 errcode_t ext2fs_xattrs_close(struct ext2_xattr_handle **handle)
1354 {
1355 struct ext2_xattr_handle *h = *handle;
1356 errcode_t err;
1357
1358 EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE);
1359 if (h->dirty) {
1360 err = ext2fs_xattrs_write(h);
1361 if (err)
1362 return err;
1363 }
1364
1365 xattrs_free_keys(h);
1366 ext2fs_free_mem(&h->attrs);
1367 ext2fs_free_mem(handle);
1368 return 0;
1369 }
1370
1371 errcode_t ext2fs_xattrs_count(struct ext2_xattr_handle *handle, size_t *count)
1372 {
1373 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1374 *count = handle->count;
1375 return 0;
1376 }
1377
1378 errcode_t ext2fs_xattrs_flags(struct ext2_xattr_handle *handle,
1379 unsigned int *new_flags, unsigned int *old_flags)
1380 {
1381 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1382 if (old_flags)
1383 *old_flags = handle->flags;
1384 if (new_flags)
1385 handle->flags = *new_flags;
1386 return 0;
1387 }
Unnamed repository; edit this file 'description' to name the repository.