lib/ext2fs/ext_attr.c

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