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 }