1 /* 2 * ext_attr.c --- extended attribute blocks 3 * 4 * Copyright (C) 2001 Andreas Gruenbacher, <a.gruenbacher (at) 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 25 #include "ext2fs.h" 26 27 #define NAME_HASH_SHIFT 5 28 #define VALUE_HASH_SHIFT 16 29 30 /* 31 * ext2_xattr_hash_entry() 32 * 33 * Compute the hash of an extended attribute. 34 */ 35 __u32 ext2fs_ext_attr_hash_entry(struct ext2_ext_attr_entry *entry, void *data) 36 { 37 __u32 hash = 0; 38 char *name = ((char *) entry) + sizeof(struct ext2_ext_attr_entry); 39 int n; 40 41 for (n = 0; n < entry->e_name_len; n++) { 42 hash = (hash << NAME_HASH_SHIFT) ^ 43 (hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^ 44 *name++; 45 } 46 47 /* The hash needs to be calculated on the data in little-endian. */ 48 if (entry->e_value_block == 0 && entry->e_value_size != 0) { 49 __u32 *value = (__u32 *)data; 50 for (n = (entry->e_value_size + EXT2_EXT_ATTR_ROUND) >> 51 EXT2_EXT_ATTR_PAD_BITS; n; n--) { 52 hash = (hash << VALUE_HASH_SHIFT) ^ 53 (hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^ 54 ext2fs_le32_to_cpu(*value++); 55 } 56 } 57 58 return hash; 59 } 60 61 static errcode_t check_ext_attr_header(struct ext2_ext_attr_header *header) 62 { 63 if ((header->h_magic != EXT2_EXT_ATTR_MAGIC_v1 && 64 header->h_magic != EXT2_EXT_ATTR_MAGIC) || 65 header->h_blocks != 1) 66 return EXT2_ET_BAD_EA_HEADER; 67 68 return 0; 69 } 70 71 #undef NAME_HASH_SHIFT 72 #undef VALUE_HASH_SHIFT 73 74 errcode_t ext2fs_read_ext_attr3(ext2_filsys fs, blk64_t block, void *buf, 75 ext2_ino_t inum) 76 { 77 int csum_failed = 0; 78 errcode_t retval; 79 80 retval = io_channel_read_blk64(fs->io, block, 1, buf); 81 if (retval) 82 return retval; 83 84 if (!(fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) && 85 !ext2fs_ext_attr_block_csum_verify(fs, inum, block, buf)) 86 csum_failed = 1; 87 88 #ifdef WORDS_BIGENDIAN 89 ext2fs_swap_ext_attr(buf, buf, fs->blocksize, 1); 90 #endif 91 92 retval = check_ext_attr_header(buf); 93 if (retval == 0 && csum_failed) 94 retval = EXT2_ET_EXT_ATTR_CSUM_INVALID; 95 96 return retval; 97 } 98 99 errcode_t ext2fs_read_ext_attr2(ext2_filsys fs, blk64_t block, void *buf) 100 { 101 return ext2fs_read_ext_attr3(fs, block, buf, 0); 102 } 103 104 errcode_t ext2fs_read_ext_attr(ext2_filsys fs, blk_t block, void *buf) 105 { 106 return ext2fs_read_ext_attr2(fs, block, buf); 107 } 108 109 errcode_t ext2fs_write_ext_attr3(ext2_filsys fs, blk64_t block, void *inbuf, 110 ext2_ino_t inum) 111 { 112 errcode_t retval; 113 char *write_buf; 114 115 #ifdef WORDS_BIGENDIAN 116 retval = ext2fs_get_mem(fs->blocksize, &write_buf); 117 if (retval) 118 return retval; 119 ext2fs_swap_ext_attr(write_buf, inbuf, fs->blocksize, 1); 120 #else 121 write_buf = (char *) inbuf; 122 #endif 123 124 retval = ext2fs_ext_attr_block_csum_set(fs, inum, block, 125 (struct ext2_ext_attr_header *)write_buf); 126 if (retval) 127 return retval; 128 129 retval = io_channel_write_blk64(fs->io, block, 1, write_buf); 130 #ifdef WORDS_BIGENDIAN 131 ext2fs_free_mem(&write_buf); 132 #endif 133 if (!retval) 134 ext2fs_mark_changed(fs); 135 return retval; 136 } 137 138 errcode_t ext2fs_write_ext_attr2(ext2_filsys fs, blk64_t block, void *inbuf) 139 { 140 return ext2fs_write_ext_attr3(fs, block, inbuf, 0); 141 } 142 143 errcode_t ext2fs_write_ext_attr(ext2_filsys fs, blk_t block, void *inbuf) 144 { 145 return ext2fs_write_ext_attr2(fs, block, inbuf); 146 } 147 148 /* 149 * This function adjusts the reference count of the EA block. 150 */ 151 errcode_t ext2fs_adjust_ea_refcount3(ext2_filsys fs, blk64_t blk, 152 char *block_buf, int adjust, 153 __u32 *newcount, ext2_ino_t inum) 154 { 155 errcode_t retval; 156 struct ext2_ext_attr_header *header; 157 char *buf = 0; 158 159 if ((blk >= ext2fs_blocks_count(fs->super)) || 160 (blk < fs->super->s_first_data_block)) 161 return EXT2_ET_BAD_EA_BLOCK_NUM; 162 163 if (!block_buf) { 164 retval = ext2fs_get_mem(fs->blocksize, &buf); 165 if (retval) 166 return retval; 167 block_buf = buf; 168 } 169 170 retval = ext2fs_read_ext_attr3(fs, blk, block_buf, inum); 171 if (retval) 172 goto errout; 173 174 header = (struct ext2_ext_attr_header *) block_buf; 175 header->h_refcount += adjust; 176 if (newcount) 177 *newcount = header->h_refcount; 178 179 retval = ext2fs_write_ext_attr3(fs, blk, block_buf, inum); 180 if (retval) 181 goto errout; 182 183 errout: 184 if (buf) 185 ext2fs_free_mem(&buf); 186 return retval; 187 } 188 189 errcode_t ext2fs_adjust_ea_refcount2(ext2_filsys fs, blk64_t blk, 190 char *block_buf, int adjust, 191 __u32 *newcount) 192 { 193 return ext2fs_adjust_ea_refcount3(fs, blk, block_buf, adjust, 194 newcount, 0); 195 } 196 197 errcode_t ext2fs_adjust_ea_refcount(ext2_filsys fs, blk_t blk, 198 char *block_buf, int adjust, 199 __u32 *newcount) 200 { 201 return ext2fs_adjust_ea_refcount2(fs, blk, block_buf, adjust, 202 newcount); 203 } 204 205 /* Manipulate the contents of extended attribute regions */ 206 struct ext2_xattr { 207 char *name; 208 void *value; 209 size_t value_len; 210 }; 211 212 struct ext2_xattr_handle { 213 errcode_t magic; 214 ext2_filsys fs; 215 struct ext2_xattr *attrs; 216 size_t length, count; 217 ext2_ino_t ino; 218 int dirty; 219 }; 220 221 static errcode_t ext2fs_xattrs_expand(struct ext2_xattr_handle *h, 222 unsigned int expandby) 223 { 224 struct ext2_xattr *new_attrs; 225 errcode_t err; 226 227 err = ext2fs_get_arrayzero(h->length + expandby, 228 sizeof(struct ext2_xattr), &new_attrs); 229 if (err) 230 return err; 231 232 memcpy(new_attrs, h->attrs, h->length * sizeof(struct ext2_xattr)); 233 ext2fs_free_mem(&h->attrs); 234 h->length += expandby; 235 h->attrs = new_attrs; 236 237 return 0; 238 } 239 240 struct ea_name_index { 241 int index; 242 const char *name; 243 }; 244 245 /* Keep these names sorted in order of decreasing specificity. */ 246 static struct ea_name_index ea_names[] = { 247 {3, "system.posix_acl_default"}, 248 {2, "system.posix_acl_access"}, 249 {8, "system.richacl"}, 250 {6, "security."}, 251 {4, "trusted."}, 252 {7, "system."}, 253 {1, "user."}, 254 {0, NULL}, 255 }; 256 257 static int find_ea_index(char *fullname, char **name, int *index); 258 259 /* Push empty attributes to the end and inlinedata to the front. */ 260 static int attr_compare(const void *a, const void *b) 261 { 262 const struct ext2_xattr *xa = a, *xb = b; 263 char *xa_suffix, *xb_suffix; 264 int xa_idx, xb_idx; 265 int cmp; 266 267 if (xa->name == NULL) 268 return +1; 269 else if (xb->name == NULL) 270 return -1; 271 else if (!strcmp(xa->name, "system.data")) 272 return -1; 273 else if (!strcmp(xb->name, "system.data")) 274 return +1; 275 276 /* 277 * Duplicate the kernel's sorting algorithm because xattr blocks 278 * require sorted keys. 279 */ 280 xa_suffix = xa->name; 281 xb_suffix = xb->name; 282 xa_idx = xb_idx = 0; 283 find_ea_index(xa->name, &xa_suffix, &xa_idx); 284 find_ea_index(xb->name, &xb_suffix, &xb_idx); 285 cmp = xa_idx - xb_idx; 286 if (cmp) 287 return cmp; 288 cmp = strlen(xa_suffix) - strlen(xb_suffix); 289 if (cmp) 290 return cmp; 291 cmp = strcmp(xa_suffix, xb_suffix); 292 return cmp; 293 } 294 295 static const char *find_ea_prefix(int index) 296 { 297 struct ea_name_index *e; 298 299 for (e = ea_names; e->name; e++) 300 if (e->index == index) 301 return e->name; 302 303 return NULL; 304 } 305 306 static int find_ea_index(char *fullname, char **name, int *index) 307 { 308 struct ea_name_index *e; 309 310 for (e = ea_names; e->name; e++) { 311 if (memcmp(fullname, e->name, strlen(e->name)) == 0) { 312 *name = (char *)fullname + strlen(e->name); 313 *index = e->index; 314 return 1; 315 } 316 } 317 return 0; 318 } 319 320 errcode_t ext2fs_free_ext_attr(ext2_filsys fs, ext2_ino_t ino, 321 struct ext2_inode_large *inode) 322 { 323 struct ext2_ext_attr_header *header; 324 void *block_buf = NULL; 325 blk64_t blk; 326 errcode_t err; 327 struct ext2_inode_large i; 328 329 /* Read inode? */ 330 if (inode == NULL) { 331 err = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)&i, 332 sizeof(struct ext2_inode_large)); 333 if (err) 334 return err; 335 inode = &i; 336 } 337 338 /* Do we already have an EA block? */ 339 blk = ext2fs_file_acl_block(fs, (struct ext2_inode *)inode); 340 if (blk == 0) 341 return 0; 342 343 /* Find block, zero it, write back */ 344 if ((blk < fs->super->s_first_data_block) || 345 (blk >= ext2fs_blocks_count(fs->super))) { 346 err = EXT2_ET_BAD_EA_BLOCK_NUM; 347 goto out; 348 } 349 350 err = ext2fs_get_mem(fs->blocksize, &block_buf); 351 if (err) 352 goto out; 353 354 err = ext2fs_read_ext_attr3(fs, blk, block_buf, ino); 355 if (err) 356 goto out2; 357 358 /* We only know how to deal with v2 EA blocks */ 359 header = (struct ext2_ext_attr_header *) block_buf; 360 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) { 361 err = EXT2_ET_BAD_EA_HEADER; 362 goto out2; 363 } 364 365 header->h_refcount--; 366 err = ext2fs_write_ext_attr3(fs, blk, block_buf, ino); 367 if (err) 368 goto out2; 369 370 /* Erase link to block */ 371 ext2fs_file_acl_block_set(fs, (struct ext2_inode *)inode, 0); 372 if (header->h_refcount == 0) 373 ext2fs_block_alloc_stats2(fs, blk, -1); 374 err = ext2fs_iblk_sub_blocks(fs, (struct ext2_inode *)inode, 1); 375 if (err) 376 goto out2; 377 378 /* Write inode? */ 379 if (inode == &i) { 380 err = ext2fs_write_inode_full(fs, ino, (struct ext2_inode *)&i, 381 sizeof(struct ext2_inode_large)); 382 if (err) 383 goto out2; 384 } 385 386 out2: 387 ext2fs_free_mem(&block_buf); 388 out: 389 return err; 390 } 391 392 static errcode_t prep_ea_block_for_write(ext2_filsys fs, ext2_ino_t ino, 393 struct ext2_inode_large *inode) 394 { 395 struct ext2_ext_attr_header *header; 396 void *block_buf = NULL; 397 blk64_t blk, goal; 398 errcode_t err; 399 400 /* Do we already have an EA block? */ 401 blk = ext2fs_file_acl_block(fs, (struct ext2_inode *)inode); 402 if (blk != 0) { 403 if ((blk < fs->super->s_first_data_block) || 404 (blk >= ext2fs_blocks_count(fs->super))) { 405 err = EXT2_ET_BAD_EA_BLOCK_NUM; 406 goto out; 407 } 408 409 err = ext2fs_get_mem(fs->blocksize, &block_buf); 410 if (err) 411 goto out; 412 413 err = ext2fs_read_ext_attr3(fs, blk, block_buf, ino); 414 if (err) 415 goto out2; 416 417 /* We only know how to deal with v2 EA blocks */ 418 header = (struct ext2_ext_attr_header *) block_buf; 419 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) { 420 err = EXT2_ET_BAD_EA_HEADER; 421 goto out2; 422 } 423 424 /* Single-user block. We're done here. */ 425 if (header->h_refcount == 1) 426 goto out2; 427 428 /* We need to CoW the block. */ 429 header->h_refcount--; 430 err = ext2fs_write_ext_attr3(fs, blk, block_buf, ino); 431 if (err) 432 goto out2; 433 } else { 434 /* No block, we must increment i_blocks */ 435 err = ext2fs_iblk_add_blocks(fs, (struct ext2_inode *)inode, 436 1); 437 if (err) 438 goto out; 439 } 440 441 /* Allocate a block */ 442 goal = ext2fs_find_inode_goal(fs, ino, (struct ext2_inode *)inode, 0); 443 err = ext2fs_alloc_block2(fs, goal, NULL, &blk); 444 if (err) 445 goto out2; 446 ext2fs_file_acl_block_set(fs, (struct ext2_inode *)inode, blk); 447 out2: 448 if (block_buf) 449 ext2fs_free_mem(&block_buf); 450 out: 451 return err; 452 } 453 454 455 static errcode_t write_xattrs_to_buffer(struct ext2_xattr_handle *handle, 456 struct ext2_xattr **pos, 457 void *entries_start, 458 unsigned int storage_size, 459 unsigned int value_offset_correction, 460 int write_hash) 461 { 462 struct ext2_xattr *x = *pos; 463 struct ext2_ext_attr_entry *e = entries_start; 464 char *end = (char *) entries_start + storage_size; 465 char *shortname; 466 unsigned int entry_size, value_size; 467 int idx, ret; 468 469 memset(entries_start, 0, storage_size); 470 /* For all remaining x... */ 471 for (; x < handle->attrs + handle->length; x++) { 472 if (!x->name) 473 continue; 474 475 /* Calculate index and shortname position */ 476 shortname = x->name; 477 ret = find_ea_index(x->name, &shortname, &idx); 478 479 /* Calculate entry and value size */ 480 entry_size = (sizeof(*e) + strlen(shortname) + 481 EXT2_EXT_ATTR_PAD - 1) & 482 ~(EXT2_EXT_ATTR_PAD - 1); 483 value_size = ((x->value_len + EXT2_EXT_ATTR_PAD - 1) / 484 EXT2_EXT_ATTR_PAD) * EXT2_EXT_ATTR_PAD; 485 486 /* 487 * Would entry collide with value? 488 * Note that we must leave sufficient room for a (u32)0 to 489 * mark the end of the entries. 490 */ 491 if ((char *)e + entry_size + sizeof(__u32) > end - value_size) 492 break; 493 494 /* Fill out e appropriately */ 495 e->e_name_len = strlen(shortname); 496 e->e_name_index = (ret ? idx : 0); 497 e->e_value_offs = end - value_size - (char *)entries_start + 498 value_offset_correction; 499 e->e_value_block = 0; 500 e->e_value_size = x->value_len; 501 502 /* Store name and value */ 503 end -= value_size; 504 memcpy((char *)e + sizeof(*e), shortname, e->e_name_len); 505 memcpy(end, x->value, e->e_value_size); 506 507 if (write_hash) 508 e->e_hash = ext2fs_ext_attr_hash_entry(e, end); 509 else 510 e->e_hash = 0; 511 512 e = EXT2_EXT_ATTR_NEXT(e); 513 *(__u32 *)e = 0; 514 } 515 *pos = x; 516 517 return 0; 518 } 519 520 errcode_t ext2fs_xattrs_write(struct ext2_xattr_handle *handle) 521 { 522 struct ext2_xattr *x; 523 struct ext2_inode_large *inode; 524 char *start, *block_buf = NULL; 525 struct ext2_ext_attr_header *header; 526 __u32 ea_inode_magic; 527 blk64_t blk; 528 unsigned int storage_size; 529 unsigned int i; 530 errcode_t err; 531 532 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE); 533 i = EXT2_INODE_SIZE(handle->fs->super); 534 if (i < sizeof(*inode)) 535 i = sizeof(*inode); 536 err = ext2fs_get_memzero(i, &inode); 537 if (err) 538 return err; 539 540 err = ext2fs_read_inode_full(handle->fs, handle->ino, 541 (struct ext2_inode *)inode, 542 EXT2_INODE_SIZE(handle->fs->super)); 543 if (err) 544 goto out; 545 546 /* If extra_isize isn't set, we need to set it now */ 547 if (inode->i_extra_isize == 0 && 548 EXT2_INODE_SIZE(handle->fs->super) > EXT2_GOOD_OLD_INODE_SIZE) { 549 char *p = (char *)inode; 550 size_t extra = handle->fs->super->s_want_extra_isize; 551 552 if (extra == 0) 553 extra = sizeof(__u32); 554 memset(p + EXT2_GOOD_OLD_INODE_SIZE, 0, extra); 555 inode->i_extra_isize = extra; 556 } 557 if (inode->i_extra_isize & 3) { 558 err = EXT2_ET_INODE_CORRUPTED; 559 goto out; 560 } 561 562 /* 563 * Force the inlinedata attr to the front and the empty entries 564 * to the end. 565 */ 566 x = handle->attrs; 567 qsort(x, handle->length, sizeof(struct ext2_xattr), attr_compare); 568 569 /* Does the inode have space for EA? */ 570 if (inode->i_extra_isize < sizeof(inode->i_extra_isize) || 571 EXT2_INODE_SIZE(handle->fs->super) <= EXT2_GOOD_OLD_INODE_SIZE + 572 inode->i_extra_isize + 573 sizeof(__u32)) 574 goto write_ea_block; 575 576 /* Write the inode EA */ 577 ea_inode_magic = EXT2_EXT_ATTR_MAGIC; 578 memcpy(((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + 579 inode->i_extra_isize, &ea_inode_magic, sizeof(__u32)); 580 storage_size = EXT2_INODE_SIZE(handle->fs->super) - 581 EXT2_GOOD_OLD_INODE_SIZE - inode->i_extra_isize - 582 sizeof(__u32); 583 start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + 584 inode->i_extra_isize + sizeof(__u32); 585 586 err = write_xattrs_to_buffer(handle, &x, start, storage_size, 0, 0); 587 if (err) 588 goto out; 589 590 write_ea_block: 591 /* Are we done? */ 592 if (x >= handle->attrs + handle->count) 593 goto skip_ea_block; 594 595 /* Write the EA block */ 596 err = ext2fs_get_memzero(handle->fs->blocksize, &block_buf); 597 if (err) 598 goto out; 599 600 storage_size = handle->fs->blocksize - 601 sizeof(struct ext2_ext_attr_header); 602 start = block_buf + sizeof(struct ext2_ext_attr_header); 603 604 err = write_xattrs_to_buffer(handle, &x, start, storage_size, 605 start - block_buf, 1); 606 if (err) 607 goto out2; 608 609 if (x < handle->attrs + handle->length) { 610 err = EXT2_ET_EA_NO_SPACE; 611 goto out2; 612 } 613 614 /* Write a header on the EA block */ 615 header = (struct ext2_ext_attr_header *) block_buf; 616 header->h_magic = EXT2_EXT_ATTR_MAGIC; 617 header->h_refcount = 1; 618 header->h_blocks = 1; 619 620 /* Get a new block for writing */ 621 err = prep_ea_block_for_write(handle->fs, handle->ino, inode); 622 if (err) 623 goto out2; 624 625 /* Finally, write the new EA block */ 626 blk = ext2fs_file_acl_block(handle->fs, 627 (struct ext2_inode *)inode); 628 err = ext2fs_write_ext_attr3(handle->fs, blk, block_buf, 629 handle->ino); 630 if (err) 631 goto out2; 632 633 skip_ea_block: 634 blk = ext2fs_file_acl_block(handle->fs, (struct ext2_inode *)inode); 635 if (!block_buf && blk) { 636 /* xattrs shrunk, free the block */ 637 err = ext2fs_free_ext_attr(handle->fs, handle->ino, inode); 638 if (err) 639 goto out; 640 } 641 642 /* Write the inode */ 643 err = ext2fs_write_inode_full(handle->fs, handle->ino, 644 (struct ext2_inode *)inode, 645 EXT2_INODE_SIZE(handle->fs->super)); 646 if (err) 647 goto out2; 648 649 out2: 650 ext2fs_free_mem(&block_buf); 651 out: 652 ext2fs_free_mem(&inode); 653 handle->dirty = 0; 654 return err; 655 } 656 657 static errcode_t read_xattrs_from_buffer(struct ext2_xattr_handle *handle, 658 struct ext2_ext_attr_entry *entries, 659 unsigned int storage_size, 660 char *value_start, 661 size_t *nr_read) 662 { 663 struct ext2_xattr *x; 664 struct ext2_ext_attr_entry *entry, *end; 665 const char *prefix; 666 unsigned int remain, prefix_len; 667 errcode_t err; 668 unsigned int values_size = storage_size + 669 ((char *)entries - value_start); 670 671 x = handle->attrs; 672 while (x->name) 673 x++; 674 675 /* find the end */ 676 end = entries; 677 remain = storage_size; 678 while (remain >= sizeof(struct ext2_ext_attr_entry) && 679 !EXT2_EXT_IS_LAST_ENTRY(end)) { 680 681 /* header eats this space */ 682 remain -= sizeof(struct ext2_ext_attr_entry); 683 684 /* is attribute name valid? */ 685 if (EXT2_EXT_ATTR_SIZE(end->e_name_len) > remain) 686 return EXT2_ET_EA_BAD_NAME_LEN; 687 688 /* attribute len eats this space */ 689 remain -= EXT2_EXT_ATTR_SIZE(end->e_name_len); 690 end = EXT2_EXT_ATTR_NEXT(end); 691 } 692 693 entry = entries; 694 remain = storage_size; 695 while (remain >= sizeof(struct ext2_ext_attr_entry) && 696 !EXT2_EXT_IS_LAST_ENTRY(entry)) { 697 __u32 hash; 698 699 /* header eats this space */ 700 remain -= sizeof(struct ext2_ext_attr_entry); 701 702 /* attribute len eats this space */ 703 remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len); 704 705 /* check value size */ 706 if (entry->e_value_size > remain) 707 return EXT2_ET_EA_BAD_VALUE_SIZE; 708 709 if (entry->e_value_offs + entry->e_value_size > values_size) 710 return EXT2_ET_EA_BAD_VALUE_OFFSET; 711 712 if (entry->e_value_size > 0 && 713 value_start + entry->e_value_offs < 714 (char *)end + sizeof(__u32)) 715 return EXT2_ET_EA_BAD_VALUE_OFFSET; 716 717 /* e_value_block must be 0 in inode's ea */ 718 if (entry->e_value_block != 0) 719 return EXT2_ET_BAD_EA_BLOCK_NUM; 720 721 hash = ext2fs_ext_attr_hash_entry(entry, value_start + 722 entry->e_value_offs); 723 724 /* e_hash may be 0 in older inode's ea */ 725 if (entry->e_hash != 0 && entry->e_hash != hash) 726 return EXT2_ET_BAD_EA_HASH; 727 728 remain -= entry->e_value_size; 729 730 /* Allocate space for more attrs? */ 731 if (x == handle->attrs + handle->length) { 732 err = ext2fs_xattrs_expand(handle, 4); 733 if (err) 734 return err; 735 x = handle->attrs + handle->length - 4; 736 } 737 738 /* Extract name/value */ 739 prefix = find_ea_prefix(entry->e_name_index); 740 prefix_len = (prefix ? strlen(prefix) : 0); 741 err = ext2fs_get_memzero(entry->e_name_len + prefix_len + 1, 742 &x->name); 743 if (err) 744 return err; 745 if (prefix) 746 memcpy(x->name, prefix, prefix_len); 747 if (entry->e_name_len) 748 memcpy(x->name + prefix_len, 749 (char *)entry + sizeof(*entry), 750 entry->e_name_len); 751 752 err = ext2fs_get_mem(entry->e_value_size, &x->value); 753 if (err) 754 return err; 755 x->value_len = entry->e_value_size; 756 memcpy(x->value, value_start + entry->e_value_offs, 757 entry->e_value_size); 758 x++; 759 (*nr_read)++; 760 entry = EXT2_EXT_ATTR_NEXT(entry); 761 } 762 763 return 0; 764 } 765 766 static void xattrs_free_keys(struct ext2_xattr_handle *h) 767 { 768 struct ext2_xattr *a = h->attrs; 769 size_t i; 770 771 for (i = 0; i < h->length; i++) { 772 if (a[i].name) 773 ext2fs_free_mem(&a[i].name); 774 if (a[i].value) 775 ext2fs_free_mem(&a[i].value); 776 } 777 h->count = 0; 778 } 779 780 errcode_t ext2fs_xattrs_read(struct ext2_xattr_handle *handle) 781 { 782 struct ext2_inode_large *inode; 783 struct ext2_ext_attr_header *header; 784 __u32 ea_inode_magic; 785 unsigned int storage_size; 786 char *start, *block_buf = NULL; 787 blk64_t blk; 788 size_t i; 789 errcode_t err; 790 791 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE); 792 i = EXT2_INODE_SIZE(handle->fs->super); 793 if (i < sizeof(*inode)) 794 i = sizeof(*inode); 795 err = ext2fs_get_memzero(i, &inode); 796 if (err) 797 return err; 798 799 err = ext2fs_read_inode_full(handle->fs, handle->ino, 800 (struct ext2_inode *)inode, 801 EXT2_INODE_SIZE(handle->fs->super)); 802 if (err) 803 goto out; 804 805 xattrs_free_keys(handle); 806 807 /* Does the inode have space for EA? */ 808 if (inode->i_extra_isize < sizeof(inode->i_extra_isize) || 809 EXT2_INODE_SIZE(handle->fs->super) <= EXT2_GOOD_OLD_INODE_SIZE + 810 inode->i_extra_isize + 811 sizeof(__u32)) 812 goto read_ea_block; 813 if (inode->i_extra_isize & 3) { 814 err = EXT2_ET_INODE_CORRUPTED; 815 goto out; 816 } 817 818 /* Look for EA in the inode */ 819 memcpy(&ea_inode_magic, ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + 820 inode->i_extra_isize, sizeof(__u32)); 821 if (ea_inode_magic == EXT2_EXT_ATTR_MAGIC) { 822 storage_size = EXT2_INODE_SIZE(handle->fs->super) - 823 EXT2_GOOD_OLD_INODE_SIZE - inode->i_extra_isize - 824 sizeof(__u32); 825 start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + 826 inode->i_extra_isize + sizeof(__u32); 827 828 err = read_xattrs_from_buffer(handle, 829 (struct ext2_ext_attr_entry *) start, storage_size, 830 start, &handle->count); 831 if (err) 832 goto out; 833 } 834 835 read_ea_block: 836 /* Look for EA in a separate EA block */ 837 blk = ext2fs_file_acl_block(handle->fs, (struct ext2_inode *)inode); 838 if (blk != 0) { 839 if ((blk < handle->fs->super->s_first_data_block) || 840 (blk >= ext2fs_blocks_count(handle->fs->super))) { 841 err = EXT2_ET_BAD_EA_BLOCK_NUM; 842 goto out; 843 } 844 845 err = ext2fs_get_mem(handle->fs->blocksize, &block_buf); 846 if (err) 847 goto out; 848 849 err = ext2fs_read_ext_attr3(handle->fs, blk, block_buf, 850 handle->ino); 851 if (err) 852 goto out3; 853 854 /* We only know how to deal with v2 EA blocks */ 855 header = (struct ext2_ext_attr_header *) block_buf; 856 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) { 857 err = EXT2_ET_BAD_EA_HEADER; 858 goto out3; 859 } 860 861 /* Read EAs */ 862 storage_size = handle->fs->blocksize - 863 sizeof(struct ext2_ext_attr_header); 864 start = block_buf + sizeof(struct ext2_ext_attr_header); 865 err = read_xattrs_from_buffer(handle, 866 (struct ext2_ext_attr_entry *) start, storage_size, 867 block_buf, &handle->count); 868 if (err) 869 goto out3; 870 871 ext2fs_free_mem(&block_buf); 872 } 873 874 ext2fs_free_mem(&block_buf); 875 ext2fs_free_mem(&inode); 876 return 0; 877 878 out3: 879 ext2fs_free_mem(&block_buf); 880 out: 881 ext2fs_free_mem(&inode); 882 return err; 883 } 884 885 errcode_t ext2fs_xattrs_iterate(struct ext2_xattr_handle *h, 886 int (*func)(char *name, char *value, 887 size_t value_len, void *data), 888 void *data) 889 { 890 struct ext2_xattr *x; 891 int ret; 892 893 EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE); 894 for (x = h->attrs; x < h->attrs + h->length; x++) { 895 if (!x->name) 896 continue; 897 898 ret = func(x->name, x->value, x->value_len, data); 899 if (ret & XATTR_CHANGED) 900 h->dirty = 1; 901 if (ret & XATTR_ABORT) 902 return 0; 903 } 904 905 return 0; 906 } 907 908 errcode_t ext2fs_xattr_get(struct ext2_xattr_handle *h, const char *key, 909 void **value, size_t *value_len) 910 { 911 struct ext2_xattr *x; 912 char *val; 913 errcode_t err; 914 915 EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE); 916 for (x = h->attrs; x < h->attrs + h->length; x++) { 917 if (!x->name) 918 continue; 919 920 if (strcmp(x->name, key) == 0) { 921 err = ext2fs_get_mem(x->value_len, &val); 922 if (err) 923 return err; 924 memcpy(val, x->value, x->value_len); 925 *value = val; 926 *value_len = x->value_len; 927 return 0; 928 } 929 } 930 931 return EXT2_ET_EA_KEY_NOT_FOUND; 932 } 933 934 errcode_t ext2fs_xattr_inode_max_size(ext2_filsys fs, ext2_ino_t ino, 935 size_t *size) 936 { 937 struct ext2_ext_attr_entry *entry; 938 struct ext2_inode_large *inode; 939 __u32 ea_inode_magic; 940 unsigned int minoff; 941 char *start; 942 size_t i; 943 errcode_t err; 944 945 i = EXT2_INODE_SIZE(fs->super); 946 if (i < sizeof(*inode)) 947 i = sizeof(*inode); 948 err = ext2fs_get_memzero(i, &inode); 949 if (err) 950 return err; 951 952 err = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)inode, 953 EXT2_INODE_SIZE(fs->super)); 954 if (err) 955 goto out; 956 957 /* Does the inode have size for EA? */ 958 if (EXT2_INODE_SIZE(fs->super) <= EXT2_GOOD_OLD_INODE_SIZE + 959 inode->i_extra_isize + 960 sizeof(__u32)) { 961 err = EXT2_ET_INLINE_DATA_NO_SPACE; 962 goto out; 963 } 964 965 minoff = EXT2_INODE_SIZE(fs->super) - sizeof(*inode) - sizeof(__u32); 966 memcpy(&ea_inode_magic, ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + 967 inode->i_extra_isize, sizeof(__u32)); 968 if (ea_inode_magic == EXT2_EXT_ATTR_MAGIC) { 969 /* has xattrs. calculate the size */ 970 start= ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + 971 inode->i_extra_isize + sizeof(__u32); 972 entry = (struct ext2_ext_attr_entry *) start; 973 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) { 974 if (!entry->e_value_block && entry->e_value_size) { 975 unsigned int offs = entry->e_value_offs; 976 if (offs < minoff) 977 minoff = offs; 978 } 979 entry = EXT2_EXT_ATTR_NEXT(entry); 980 } 981 *size = minoff - ((char *)entry - (char *)start) - sizeof(__u32); 982 } else { 983 /* no xattr. return a maximum size */ 984 *size = EXT2_EXT_ATTR_SIZE(minoff - 985 EXT2_EXT_ATTR_LEN(strlen("data")) - 986 EXT2_EXT_ATTR_ROUND - sizeof(__u32)); 987 } 988 989 out: 990 ext2fs_free_mem(&inode); 991 return err; 992 } 993 994 errcode_t ext2fs_xattr_set(struct ext2_xattr_handle *handle, 995 const char *key, 996 const void *value, 997 size_t value_len) 998 { 999 struct ext2_xattr *x, *last_empty; 1000 char *new_value; 1001 errcode_t err; 1002 1003 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE); 1004 last_empty = NULL; 1005 for (x = handle->attrs; x < handle->attrs + handle->length; x++) { 1006 if (!x->name) { 1007 last_empty = x; 1008 continue; 1009 } 1010 1011 /* Replace xattr */ 1012 if (strcmp(x->name, key) == 0) { 1013 err = ext2fs_get_mem(value_len, &new_value); 1014 if (err) 1015 return err; 1016 memcpy(new_value, value, value_len); 1017 ext2fs_free_mem(&x->value); 1018 x->value = new_value; 1019 x->value_len = value_len; 1020 handle->dirty = 1; 1021 return 0; 1022 } 1023 } 1024 1025 /* Add attr to empty slot */ 1026 if (last_empty) { 1027 err = ext2fs_get_mem(strlen(key) + 1, &last_empty->name); 1028 if (err) 1029 return err; 1030 strcpy(last_empty->name, key); 1031 1032 err = ext2fs_get_mem(value_len, &last_empty->value); 1033 if (err) 1034 return err; 1035 memcpy(last_empty->value, value, value_len); 1036 last_empty->value_len = value_len; 1037 handle->dirty = 1; 1038 handle->count++; 1039 return 0; 1040 } 1041 1042 /* Expand array, append slot */ 1043 err = ext2fs_xattrs_expand(handle, 4); 1044 if (err) 1045 return err; 1046 1047 x = handle->attrs + handle->length - 4; 1048 err = ext2fs_get_mem(strlen(key) + 1, &x->name); 1049 if (err) 1050 return err; 1051 strcpy(x->name, key); 1052 1053 err = ext2fs_get_mem(value_len, &x->value); 1054 if (err) 1055 return err; 1056 memcpy(x->value, value, value_len); 1057 x->value_len = value_len; 1058 handle->dirty = 1; 1059 handle->count++; 1060 return 0; 1061 } 1062 1063 errcode_t ext2fs_xattr_remove(struct ext2_xattr_handle *handle, 1064 const char *key) 1065 { 1066 struct ext2_xattr *x; 1067 1068 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE); 1069 for (x = handle->attrs; x < handle->attrs + handle->length; x++) { 1070 if (!x->name) 1071 continue; 1072 1073 if (strcmp(x->name, key) == 0) { 1074 ext2fs_free_mem(&x->name); 1075 ext2fs_free_mem(&x->value); 1076 x->value_len = 0; 1077 handle->dirty = 1; 1078 handle->count--; 1079 return 0; 1080 } 1081 } 1082 1083 /* no key found, success! */ 1084 return 0; 1085 } 1086 1087 errcode_t ext2fs_xattrs_open(ext2_filsys fs, ext2_ino_t ino, 1088 struct ext2_xattr_handle **handle) 1089 { 1090 struct ext2_xattr_handle *h; 1091 errcode_t err; 1092 1093 if (!ext2fs_has_feature_xattr(fs->super) && 1094 !ext2fs_has_feature_inline_data(fs->super)) 1095 return EXT2_ET_MISSING_EA_FEATURE; 1096 1097 err = ext2fs_get_memzero(sizeof(*h), &h); 1098 if (err) 1099 return err; 1100 1101 h->magic = EXT2_ET_MAGIC_EA_HANDLE; 1102 h->length = 4; 1103 err = ext2fs_get_arrayzero(h->length, sizeof(struct ext2_xattr), 1104 &h->attrs); 1105 if (err) { 1106 ext2fs_free_mem(&h); 1107 return err; 1108 } 1109 h->count = 0; 1110 h->ino = ino; 1111 h->fs = fs; 1112 *handle = h; 1113 return 0; 1114 } 1115 1116 errcode_t ext2fs_xattrs_close(struct ext2_xattr_handle **handle) 1117 { 1118 struct ext2_xattr_handle *h = *handle; 1119 errcode_t err; 1120 1121 EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE); 1122 if (h->dirty) { 1123 err = ext2fs_xattrs_write(h); 1124 if (err) 1125 return err; 1126 } 1127 1128 xattrs_free_keys(h); 1129 ext2fs_free_mem(&h->attrs); 1130 ext2fs_free_mem(handle); 1131 return 0; 1132 } 1133 1134 errcode_t ext2fs_xattrs_count(struct ext2_xattr_handle *handle, size_t *count) 1135 { 1136 EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE); 1137 *count = handle->count; 1138 return 0; 1139 } 1140
