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 #include <errno.h>
  22 #if defined HAVE_SYS_XATTR_H
  23 #include <sys/xattr.h>
  24 #elif defined HAVE_ATTR_XATTR_H
  25 #include <attr/xattr.h>
  26 #endif
  27
  28 #include "ext2_fs.h"
  29 #include "ext2_ext_attr.h"
  30 #include "ext4_acl.h"
  31
  32 #include "ext2fs.h"
  33
  34 static errcode_t read_ea_inode_hash(ext2_filsys fs, ext2_ino_t ino, __u32 *hash)
  35 {
  36         struct ext2_inode inode;
  37         errcode_t retval;
  38
  39         retval = ext2fs_read_inode(fs, ino, &inode);
  40         if (retval)
  41                 return retval;
  42         *hash = ext2fs_get_ea_inode_hash(&inode);
  43         return 0;
  44 }
  45
  46 #define NAME_HASH_SHIFT 5
  47 #define VALUE_HASH_SHIFT 16
  48
  49 /*
  50  * ext2_xattr_hash_entry()
  51  *
  52  * Compute the hash of an extended attribute.
  53  */
  54 __u32 ext2fs_ext_attr_hash_entry(struct ext2_ext_attr_entry *entry, void *data)
  55 {
  56         __u32 hash = 0;
  57         char *name = ((char *) entry) + sizeof(struct ext2_ext_attr_entry);
  58         int n;
  59
  60         for (n = 0; n < entry->e_name_len; n++) {
  61                 hash = (hash << NAME_HASH_SHIFT) ^
  62                        (hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^
  63                        *name++;
  64         }
  65
  66         /* The hash needs to be calculated on the data in little-endian. */
  67         if (entry->e_value_inum == 0 && entry->e_value_size != 0) {
  68                 __u32 *value = (__u32 *)data;
  69                 for (n = (entry->e_value_size + EXT2_EXT_ATTR_ROUND) >>
  70                          EXT2_EXT_ATTR_PAD_BITS; n; n--) {
  71                         hash = (hash << VALUE_HASH_SHIFT) ^
  72                                (hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^
  73                                ext2fs_le32_to_cpu(*value++);
  74                 }
  75         }
  76
  77         return hash;
  78 }
  79
  80 /*
  81  * ext2fs_ext_attr_hash_entry2()
  82  *
  83  * Compute the hash of an extended attribute.
  84  * This version of the function supports hashing entries that reference
  85  * external inodes (ea_inode feature).
  86  */
  87 errcode_t ext2fs_ext_attr_hash_entry2(ext2_filsys fs,
  88                                       struct ext2_ext_attr_entry *entry,
  89                                       void *data, __u32 *hash)
  90 {
  91         *hash = ext2fs_ext_attr_hash_entry(entry, data);
  92
  93         if (entry->e_value_inum) {
  94                 __u32 ea_inode_hash;
  95                 errcode_t retval;
  96
  97                 retval = read_ea_inode_hash(fs, entry->e_value_inum,
  98                                             &ea_inode_hash);
  99                 if (retval)
 100                         return retval;
 101
 102                 *hash = (*hash << VALUE_HASH_SHIFT) ^
 103                         (*hash >> (8*sizeof(*hash) - VALUE_HASH_SHIFT)) ^
 104                         ea_inode_hash;
 105         }
 106         return 0;
 107 }
 108
 109 #undef NAME_HASH_SHIFT
 110 #undef VALUE_HASH_SHIFT
 111
 112 #define BLOCK_HASH_SHIFT 16
 113
 114 /* Mirrors ext4_xattr_rehash() implementation in kernel. */
 115 void ext2fs_ext_attr_block_rehash(struct ext2_ext_attr_header *header,
 116                                   struct ext2_ext_attr_entry *end)
 117 {
 118         struct ext2_ext_attr_entry *here;
 119         __u32 hash = 0;
 120
 121         here = (struct ext2_ext_attr_entry *)(header+1);
 122         while (here < end && !EXT2_EXT_IS_LAST_ENTRY(here)) {
 123                 if (!here->e_hash) {
 124                         /* Block is not shared if an entry's hash value == 0 */
 125                         hash = 0;
 126                         break;
 127                 }
 128                 hash = (hash << BLOCK_HASH_SHIFT) ^
 129                        (hash >> (8*sizeof(hash) - BLOCK_HASH_SHIFT)) ^
 130                        here->e_hash;
 131                 here = EXT2_EXT_ATTR_NEXT(here);
 132         }
 133         header->h_hash = hash;
 134 }
 135
 136 /*
 137  * Re-compute the extended attribute hash value after an entry has changed.
 138  */
 139 static void ext2fs_attr_rehash(struct ext2_ext_attr_header *header,
 140                                 struct ext2_ext_attr_entry *entry)
 141 {
 142         struct ext2_ext_attr_entry *here;
 143         __u32 hash = 0;
 144
 145         entry->e_hash = ext2fs_ext_attr_hash_entry(entry, (char *)header +
 146                                                    entry->e_value_offs);
 147
 148         here = ENTRY(header+1);
 149         while (!EXT2_EXT_IS_LAST_ENTRY(here)) {
 150                 if (!here->e_hash) {
 151                         /* Block is not shared if an entry's hash value == 0 */
 152                         hash = 0;
 153                         break;
 154                 }
 155                 hash = (hash << BLOCK_HASH_SHIFT) ^
 156                        (hash >> (8*sizeof(hash) - BLOCK_HASH_SHIFT)) ^
 157                        here->e_hash;
 158                 here = EXT2_EXT_ATTR_NEXT(here);
 159         }
 160         header->h_hash = hash;
 161 }
 162
 163 #undef BLOCK_HASH_SHIFT
 164
 165 __u32 ext2fs_get_ea_inode_hash(struct ext2_inode *inode)
 166 {
 167         return inode->i_atime;
 168 }
 169
 170 void ext2fs_set_ea_inode_hash(struct ext2_inode *inode, __u32 hash)
 171 {
 172         inode->i_atime = hash;
 173 }
 174
 175 __u64 ext2fs_get_ea_inode_ref(struct ext2_inode *inode)
 176 {
 177         return ((__u64)inode->i_ctime << 32) | inode->osd1.linux1.l_i_version;
 178 }
 179
 180 void ext2fs_set_ea_inode_ref(struct ext2_inode *inode, __u64 ref_count)
 181 {
 182         inode->i_ctime = (__u32)(ref_count >> 32);
 183         inode->osd1.linux1.l_i_version = (__u32)ref_count;
 184 }
 185
 186 static errcode_t check_ext_attr_header(struct ext2_ext_attr_header *header)
 187 {
 188         if ((header->h_magic != EXT2_EXT_ATTR_MAGIC_v1 &&
 189              header->h_magic != EXT2_EXT_ATTR_MAGIC) ||
 190             header->h_blocks != 1)
 191                 return EXT2_ET_BAD_EA_HEADER;
 192
 193         return 0;
 194 }
 195
 196 errcode_t ext2fs_read_ext_attr3(ext2_filsys fs, blk64_t block, void *buf,
 197                                 ext2_ino_t inum)
 198 {
 199         int             csum_failed = 0;
 200         errcode_t       retval;
 201
 202         retval = io_channel_read_blk64(fs->io, block, 1, buf);
 203         if (retval)
 204                 return retval;
 205
 206         if (!(fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) &&
 207             !ext2fs_ext_attr_block_csum_verify(fs, inum, block, buf))
 208                 csum_failed = 1;
 209
 210 #ifdef WORDS_BIGENDIAN
 211         ext2fs_swap_ext_attr(buf, buf, fs->blocksize, 1);
 212 #endif
 213
 214         retval = check_ext_attr_header(buf);
 215         if (retval == 0 && csum_failed)
 216                 retval = EXT2_ET_EXT_ATTR_CSUM_INVALID;
 217
 218         return retval;
 219 }
 220
 221 errcode_t ext2fs_read_ext_attr2(ext2_filsys fs, blk64_t block, void *buf)
 222 {
 223         return ext2fs_read_ext_attr3(fs, block, buf, 0);
 224 }
 225
 226 errcode_t ext2fs_read_ext_attr(ext2_filsys fs, blk_t block, void *buf)
 227 {
 228         return ext2fs_read_ext_attr2(fs, block, buf);
 229 }
 230
 231 errcode_t ext2fs_write_ext_attr3(ext2_filsys fs, blk64_t block, void *inbuf,
 232                                  ext2_ino_t inum)
 233 {
 234         errcode_t       retval;
 235         char            *write_buf;
 236
 237 #ifdef WORDS_BIGENDIAN
 238         retval = ext2fs_get_mem(fs->blocksize, &write_buf);
 239         if (retval)
 240                 return retval;
 241         ext2fs_swap_ext_attr(write_buf, inbuf, fs->blocksize, 1);
 242 #else
 243         write_buf = (char *) inbuf;
 244 #endif
 245
 246         retval = ext2fs_ext_attr_block_csum_set(fs, inum, block,
 247                         (struct ext2_ext_attr_header *)write_buf);
 248         if (retval)
 249                 return retval;
 250
 251         retval = io_channel_write_blk64(fs->io, block, 1, write_buf);
 252 #ifdef WORDS_BIGENDIAN
 253         ext2fs_free_mem(&write_buf);
 254 #endif
 255         if (!retval)
 256                 ext2fs_mark_changed(fs);
 257         return retval;
 258 }
 259
 260 errcode_t ext2fs_write_ext_attr2(ext2_filsys fs, blk64_t block, void *inbuf)
 261 {
 262         return ext2fs_write_ext_attr3(fs, block, inbuf, 0);
 263 }
 264
 265 errcode_t ext2fs_write_ext_attr(ext2_filsys fs, blk_t block, void *inbuf)
 266 {
 267         return ext2fs_write_ext_attr2(fs, block, inbuf);
 268 }
 269
 270 /*
 271  * This function adjusts the reference count of the EA block.
 272  */
 273 errcode_t ext2fs_adjust_ea_refcount3(ext2_filsys fs, blk64_t blk,
 274                                     char *block_buf, int adjust,
 275                                     __u32 *newcount, ext2_ino_t inum)
 276 {
 277         errcode_t       retval;
 278         struct ext2_ext_attr_header *header;
 279         char    *buf = 0;
 280
 281         if ((blk >= ext2fs_blocks_count(fs->super)) ||
 282             (blk < fs->super->s_first_data_block))
 283                 return EXT2_ET_BAD_EA_BLOCK_NUM;
 284
 285         if (!block_buf) {
 286                 retval = ext2fs_get_mem(fs->blocksize, &buf);
 287                 if (retval)
 288                         return retval;
 289                 block_buf = buf;
 290         }
 291
 292         retval = ext2fs_read_ext_attr3(fs, blk, block_buf, inum);
 293         if (retval)
 294                 goto errout;
 295
 296         header = BHDR(block_buf);
 297         if (header->h_magic != EXT2_EXT_ATTR_MAGIC)
 298                 return EXT2_ET_EA_BAD_MAGIC;
 299
 300         header->h_refcount += adjust;
 301         if (newcount)
 302                 *newcount = header->h_refcount;
 303
 304         retval = ext2fs_write_ext_attr3(fs, blk, block_buf, inum);
 305         if (retval)
 306                 goto errout;
 307
 308 errout:
 309         if (buf)
 310                 ext2fs_free_mem(&buf);
 311         return retval;
 312 }
 313
 314 errcode_t ext2fs_adjust_ea_refcount2(ext2_filsys fs, blk64_t blk,
 315                                     char *block_buf, int adjust,
 316                                     __u32 *newcount)
 317 {
 318         return ext2fs_adjust_ea_refcount3(fs, blk, block_buf, adjust,
 319                                           newcount, 0);
 320 }
 321
 322 errcode_t ext2fs_adjust_ea_refcount(ext2_filsys fs, blk_t blk,
 323                                         char *block_buf, int adjust,
 324                                         __u32 *newcount)
 325 {
 326         return ext2fs_adjust_ea_refcount2(fs, blk, block_buf, adjust,
 327                                           newcount);
 328 }
 329
 330 /* Manipulate the contents of extended attribute regions */
 331 struct ext2_xattr {
 332         int name_index;
 333         char *name;
 334         char *short_name;
 335         void *value;
 336         unsigned int value_len;
 337         ext2_ino_t ea_ino;
 338 };
 339
 340 struct ext2_xattr_handle {
 341         errcode_t magic;
 342         ext2_filsys fs;
 343         struct ext2_xattr *attrs;
 344         int capacity;
 345         int count;
 346         int ibody_count;
 347         ext2_ino_t ino;
 348         unsigned int flags;
 349 };
 350
 351 static errcode_t ext2fs_xattrs_expand(struct ext2_xattr_handle *h,
 352                                       unsigned int expandby)
 353 {
 354         struct ext2_xattr *new_attrs;
 355         errcode_t err;
 356
 357         err = ext2fs_get_arrayzero(h->capacity + expandby,
 358                                    sizeof(struct ext2_xattr), &new_attrs);
 359         if (err)
 360                 return err;
 361
 362         memcpy(new_attrs, h->attrs, h->capacity * sizeof(struct ext2_xattr));
 363         ext2fs_free_mem(&h->attrs);
 364         h->capacity += expandby;
 365         h->attrs = new_attrs;
 366
 367         return 0;
 368 }
 369
 370 struct ea_name_index {
 371         int index;
 372         const char *name;
 373 };
 374
 375 /* Keep these names sorted in order of decreasing specificity. */
 376 static struct ea_name_index ea_names[] = {
 377         {10, "gnu."},
 378         {3, "system.posix_acl_default"},
 379         {2, "system.posix_acl_access"},
 380         {8, "system.richacl"},
 381         {6, "security."},
 382         {5, "lustre."},
 383         {4, "trusted."},
 384         {7, "system."},
 385         {1, "user."},
 386         {0, NULL},
 387 };
 388
 389 static const char *find_ea_prefix(int index)
 390 {
 391         struct ea_name_index *e;
 392
 393         for (e = ea_names; e->name; e++)
 394                 if (e->index == index)
 395                         return e->name;
 396
 397         return NULL;
 398 }
 399
 400 static int find_ea_index(const char *fullname, const char **name, int *index)
 401 {
 402         struct ea_name_index *e;
 403
 404         for (e = ea_names; e->name; e++) {
 405                 if (strncmp(fullname, e->name, strlen(e->name)) == 0) {
 406                         *name = fullname + strlen(e->name);
 407                         *index = e->index;
 408                         return 1;
 409                 }
 410         }
 411         return 0;
 412 }
 413
 414 errcode_t ext2fs_free_ext_attr(ext2_filsys fs, ext2_ino_t ino,
 415                                struct ext2_inode_large *inode)
 416 {
 417         struct ext2_ext_attr_header *header;
 418         void *block_buf = NULL;
 419         blk64_t blk;
 420         errcode_t err;
 421         struct ext2_inode_large i;
 422
 423         /* Read inode? */
 424         if (inode == NULL) {
 425                 err = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)&i,
 426                                              sizeof(struct ext2_inode_large));
 427                 if (err)
 428                         return err;
 429                 inode = &i;
 430         }
 431
 432         /* Do we already have an EA block? */
 433         blk = ext2fs_file_acl_block(fs, (struct ext2_inode *)inode);
 434         if (blk == 0)
 435                 return 0;
 436
 437         /* Find block, zero it, write back */
 438         if ((blk < fs->super->s_first_data_block) ||
 439             (blk >= ext2fs_blocks_count(fs->super))) {
 440                 err = EXT2_ET_BAD_EA_BLOCK_NUM;
 441                 goto out;
 442         }
 443
 444         err = ext2fs_get_mem(fs->blocksize, &block_buf);
 445         if (err)
 446                 goto out;
 447
 448         err = ext2fs_read_ext_attr3(fs, blk, block_buf, ino);
 449         if (err)
 450                 goto out2;
 451
 452         /* We only know how to deal with v2 EA blocks */
 453         header = (struct ext2_ext_attr_header *) block_buf;
 454         if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
 455                 err = EXT2_ET_BAD_EA_HEADER;
 456                 goto out2;
 457         }
 458
 459         header->h_refcount--;
 460         err = ext2fs_write_ext_attr3(fs, blk, block_buf, ino);
 461         if (err)
 462                 goto out2;
 463
 464         /* Erase link to block */
 465         ext2fs_file_acl_block_set(fs, (struct ext2_inode *)inode, 0);
 466         if (header->h_refcount == 0)
 467                 ext2fs_block_alloc_stats2(fs, blk, -1);
 468         err = ext2fs_iblk_sub_blocks(fs, (struct ext2_inode *)inode, 1);
 469         if (err)
 470                 goto out2;
 471
 472         /* Write inode? */
 473         if (inode == &i) {
 474                 err = ext2fs_write_inode_full(fs, ino, (struct ext2_inode *)&i,
 475                                               sizeof(struct ext2_inode_large));
 476                 if (err)
 477                         goto out2;
 478         }
 479
 480 out2:
 481         ext2fs_free_mem(&block_buf);
 482 out:
 483         return err;
 484 }
 485
 486 static errcode_t prep_ea_block_for_write(ext2_filsys fs, ext2_ino_t ino,
 487                                          struct ext2_inode_large *inode)
 488 {
 489         struct ext2_ext_attr_header *header;
 490         void *block_buf = NULL;
 491         blk64_t blk, goal;
 492         errcode_t err;
 493
 494         /* Do we already have an EA block? */
 495         blk = ext2fs_file_acl_block(fs, (struct ext2_inode *)inode);
 496         if (blk != 0) {
 497                 if ((blk < fs->super->s_first_data_block) ||
 498                     (blk >= ext2fs_blocks_count(fs->super))) {
 499                         err = EXT2_ET_BAD_EA_BLOCK_NUM;
 500                         goto out;
 501                 }
 502
 503                 err = ext2fs_get_mem(fs->blocksize, &block_buf);
 504                 if (err)
 505                         goto out;
 506
 507                 err = ext2fs_read_ext_attr3(fs, blk, block_buf, ino);
 508                 if (err)
 509                         goto out2;
 510
 511                 /* We only know how to deal with v2 EA blocks */
 512                 header = (struct ext2_ext_attr_header *) block_buf;
 513                 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
 514                         err = EXT2_ET_BAD_EA_HEADER;
 515                         goto out2;
 516                 }
 517
 518                 /* Single-user block.  We're done here. */
 519                 if (header->h_refcount == 1)
 520                         goto out2;
 521
 522                 /* We need to CoW the block. */
 523                 header->h_refcount--;
 524                 err = ext2fs_write_ext_attr3(fs, blk, block_buf, ino);
 525                 if (err)
 526                         goto out2;
 527         } else {
 528                 /* No block, we must increment i_blocks */
 529                 err = ext2fs_iblk_add_blocks(fs, (struct ext2_inode *)inode,
 530                                              1);
 531                 if (err)
 532                         goto out;
 533         }
 534
 535         /* Allocate a block */
 536         goal = ext2fs_find_inode_goal(fs, ino, (struct ext2_inode *)inode, 0);
 537         err = ext2fs_alloc_block2(fs, goal, NULL, &blk);
 538         if (err)
 539                 goto out2;
 540         ext2fs_file_acl_block_set(fs, (struct ext2_inode *)inode, blk);
 541 out2:
 542         if (block_buf)
 543                 ext2fs_free_mem(&block_buf);
 544 out:
 545         return err;
 546 }
 547
 548
 549 static inline int
 550 posix_acl_xattr_count(size_t size)
 551 {
 552         if (size < sizeof(posix_acl_xattr_header))
 553                 return -1;
 554         size -= sizeof(posix_acl_xattr_header);
 555         if (size % sizeof(posix_acl_xattr_entry))
 556                 return -1;
 557         return size / sizeof(posix_acl_xattr_entry);
 558 }
 559
 560 /*
 561  * The lgetxattr function returns data formatted in the POSIX extended
 562  * attribute format.  The on-disk format uses a more compact encoding.
 563  * See the ext4_acl_to_disk in fs/ext4/acl.c.
 564  */
 565 static errcode_t convert_posix_acl_to_disk_buffer(const void *value, size_t size,
 566                                                   void *out_buf, size_t *size_out)
 567 {
 568         const posix_acl_xattr_header *header =
 569                 (const posix_acl_xattr_header*) value;
 570         const posix_acl_xattr_entry *end, *entry =
 571                 (const posix_acl_xattr_entry *)(header+1);
 572         ext4_acl_header *ext_acl;
 573         size_t s;
 574         char *e;
 575
 576         int count;
 577
 578         if (!value)
 579                 return EINVAL;
 580         if (size < sizeof(posix_acl_xattr_header))
 581                 return ENOMEM;
 582         if (header->a_version != ext2fs_cpu_to_le32(POSIX_ACL_XATTR_VERSION))
 583                 return EINVAL;
 584
 585         count = posix_acl_xattr_count(size);
 586         ext_acl = out_buf;
 587         ext_acl->a_version = ext2fs_cpu_to_le32(EXT4_ACL_VERSION);
 588
 589         if (count <= 0)
 590                 return EINVAL;
 591
 592         e = (char *) out_buf + sizeof(ext4_acl_header);
 593         s = sizeof(ext4_acl_header);
 594         for (end = entry + count; entry != end;entry++) {
 595                 ext4_acl_entry *disk_entry = (ext4_acl_entry*) e;
 596                 disk_entry->e_tag = ext2fs_cpu_to_le16(entry->e_tag);
 597                 disk_entry->e_perm = ext2fs_cpu_to_le16(entry->e_perm);
 598
 599                 switch(entry->e_tag) {
 600                         case ACL_USER_OBJ:
 601                         case ACL_GROUP_OBJ:
 602                         case ACL_MASK:
 603                         case ACL_OTHER:
 604                                 e += sizeof(ext4_acl_entry_short);
 605                                 s += sizeof(ext4_acl_entry_short);
 606                                 break;
 607                         case ACL_USER:
 608                         case ACL_GROUP:
 609                                 disk_entry->e_id =  ext2fs_cpu_to_le32(entry->e_id);
 610                                 e += sizeof(ext4_acl_entry);
 611                                 s += sizeof(ext4_acl_entry);
 612                                 break;
 613                 }
 614         }
 615         *size_out = s;
 616         return 0;
 617 }
 618
 619 static errcode_t convert_disk_buffer_to_posix_acl(const void *value, size_t size,
 620                                                   void **out_buf, size_t *size_out)
 621 {
 622         posix_acl_xattr_header *header;
 623         posix_acl_xattr_entry *entry;
 624         const ext4_acl_header *ext_acl = (const ext4_acl_header *) value;
 625         errcode_t err;
 626         const char *cp;
 627         char *out;
 628
 629         if ((!value) ||
 630             (size < sizeof(ext4_acl_header)) ||
 631             (ext_acl->a_version != ext2fs_cpu_to_le32(EXT4_ACL_VERSION)))
 632                 return EINVAL;
 633
 634         err = ext2fs_get_mem(size * 2, &out);
 635         if (err)
 636                 return err;
 637
 638         header = (posix_acl_xattr_header *) out;
 639         header->a_version = ext2fs_cpu_to_le32(POSIX_ACL_XATTR_VERSION);
 640         entry = (posix_acl_xattr_entry *) (out + sizeof(posix_acl_xattr_header));
 641
 642         cp = (const char *) value + sizeof(ext4_acl_header);
 643         size -= sizeof(ext4_acl_header);
 644
 645         while (size > 0) {
 646                 const ext4_acl_entry *disk_entry = (const ext4_acl_entry *) cp;
 647
 648                 entry->e_tag = ext2fs_le16_to_cpu(disk_entry->e_tag);
 649                 entry->e_perm = ext2fs_le16_to_cpu(disk_entry->e_perm);
 650
 651                 switch(entry->e_tag) {
 652                         case ACL_USER_OBJ:
 653                         case ACL_GROUP_OBJ:
 654                         case ACL_MASK:
 655                         case ACL_OTHER:
 656                                 entry->e_id = 0;
 657                                 cp += sizeof(ext4_acl_entry_short);
 658                                 size -= sizeof(ext4_acl_entry_short);
 659                                 break;
 660                         case ACL_USER:
 661                         case ACL_GROUP:
 662                                 entry->e_id = ext2fs_le32_to_cpu(disk_entry->e_id);
 663                                 cp += sizeof(ext4_acl_entry);
 664                                 size -= sizeof(ext4_acl_entry);
 665                                 break;
 666                 default:
 667                         ext2fs_free_mem(&out);
 668                         return EINVAL;
 669                 }
 670                 entry++;
 671         }
 672         *out_buf = out;
 673         *size_out = ((char *) entry - out);
 674         return 0;
 675 }
 676
 677 static errcode_t
 678 write_xattrs_to_buffer(ext2_filsys fs, struct ext2_xattr *attrs, int count,
 679                        void *entries_start, unsigned int storage_size,
 680                        unsigned int value_offset_correction, int write_hash)
 681 {
 682         struct ext2_xattr *x;
 683         struct ext2_ext_attr_entry *e = entries_start;
 684         char *end = (char *) entries_start + storage_size;
 685         unsigned int value_size;
 686         errcode_t err;
 687
 688         memset(entries_start, 0, storage_size);
 689         for (x = attrs; x < attrs + count; x++) {
 690                 value_size = ((x->value_len + EXT2_EXT_ATTR_PAD - 1) /
 691                               EXT2_EXT_ATTR_PAD) * EXT2_EXT_ATTR_PAD;
 692
 693                 /* Fill out e appropriately */
 694                 e->e_name_len = strlen(x->short_name);
 695                 e->e_name_index = x->name_index;
 696
 697                 e->e_value_size = x->value_len;
 698                 e->e_value_inum = x->ea_ino;
 699
 700                 /* Store name */
 701                 memcpy((char *)e + sizeof(*e), x->short_name, e->e_name_len);
 702                 if (x->ea_ino) {
 703                         e->e_value_offs = 0;
 704                 } else {
 705                         end -= value_size;
 706                         e->e_value_offs = end - (char *) entries_start +
 707                                                 value_offset_correction;
 708                         memcpy(end, x->value, e->e_value_size);
 709                 }
 710
 711                 if (write_hash || x->ea_ino) {
 712                         err = ext2fs_ext_attr_hash_entry2(fs, e,
 713                                                           x->ea_ino ? 0 : end,
 714                                                           &e->e_hash);
 715                         if (err)
 716                                 return err;
 717                 } else
 718                         e->e_hash = 0;
 719
 720                 e = EXT2_EXT_ATTR_NEXT(e);
 721                 *(__u32 *)e = 0;
 722         }
 723         return 0;
 724 }
 725
 726 errcode_t ext2fs_xattrs_write(struct ext2_xattr_handle *handle)
 727 {
 728         ext2_filsys fs = handle->fs;
 729         const unsigned int inode_size = EXT2_INODE_SIZE(fs->super);
 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 = inode_size;
 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(fs, handle->ino, EXT2_INODE(inode),
 748                                      inode_size);
 749         if (err)
 750                 goto out;
 751
 752         /* If extra_isize isn't set, we need to set it now */
 753         if (inode->i_extra_isize == 0 &&
 754             inode_size > EXT2_GOOD_OLD_INODE_SIZE) {
 755                 char *p = (char *)inode;
 756                 size_t extra = fs->super->s_want_extra_isize;
 757
 758                 if (extra == 0)
 759                         extra = sizeof(__u32);
 760                 memset(p + EXT2_GOOD_OLD_INODE_SIZE, 0, extra);
 761                 inode->i_extra_isize = extra;
 762         }
 763         if (inode->i_extra_isize & 3) {
 764                 err = EXT2_ET_INODE_CORRUPTED;
 765                 goto out;
 766         }
 767
 768         /* Does the inode have space for EA? */
 769         if (inode->i_extra_isize < sizeof(inode->i_extra_isize) ||
 770             inode_size <= EXT2_GOOD_OLD_INODE_SIZE + inode->i_extra_isize +
 771                                                                 sizeof(__u32))
 772                 goto write_ea_block;
 773
 774         /* Write the inode EA */
 775         ea_inode_magic = EXT2_EXT_ATTR_MAGIC;
 776         memcpy(((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
 777                inode->i_extra_isize, &ea_inode_magic, sizeof(__u32));
 778         storage_size = inode_size - EXT2_GOOD_OLD_INODE_SIZE -
 779                                 inode->i_extra_isize - sizeof(__u32);
 780         start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
 781                                 inode->i_extra_isize + sizeof(__u32);
 782
 783         err = write_xattrs_to_buffer(fs, handle->attrs, handle->ibody_count,
 784                                      start, storage_size, 0, 0);
 785         if (err)
 786                 goto out;
 787 write_ea_block:
 788         /* Are we done? */
 789         if (handle->ibody_count == handle->count &&
 790             !ext2fs_file_acl_block(fs, EXT2_INODE(inode)))
 791                 goto skip_ea_block;
 792
 793         /* Write the EA block */
 794         err = ext2fs_get_memzero(fs->blocksize, &block_buf);
 795         if (err)
 796                 goto out;
 797
 798         storage_size = fs->blocksize - sizeof(struct ext2_ext_attr_header);
 799         start = block_buf + sizeof(struct ext2_ext_attr_header);
 800
 801         err = write_xattrs_to_buffer(fs, handle->attrs + handle->ibody_count,
 802                                      handle->count - handle->ibody_count, start,
 803                                      storage_size, start - block_buf, 1);
 804         if (err)
 805                 goto out2;
 806
 807         /* Write a header on the EA block */
 808         header = (struct ext2_ext_attr_header *) block_buf;
 809         header->h_magic = EXT2_EXT_ATTR_MAGIC;
 810         header->h_refcount = 1;
 811         header->h_blocks = 1;
 812
 813         /* Get a new block for writing */
 814         err = prep_ea_block_for_write(fs, handle->ino, inode);
 815         if (err)
 816                 goto out2;
 817
 818         /* Finally, write the new EA block */
 819         blk = ext2fs_file_acl_block(fs, EXT2_INODE(inode));
 820         err = ext2fs_write_ext_attr3(fs, blk, block_buf, handle->ino);
 821         if (err)
 822                 goto out2;
 823
 824 skip_ea_block:
 825         blk = ext2fs_file_acl_block(fs, (struct ext2_inode *)inode);
 826         if (!block_buf && blk) {
 827                 /* xattrs shrunk, free the block */
 828                 err = ext2fs_free_ext_attr(fs, handle->ino, inode);
 829                 if (err)
 830                         goto out;
 831         }
 832
 833         /* Write the inode */
 834         err = ext2fs_write_inode_full(fs, handle->ino, EXT2_INODE(inode),
 835                                       inode_size);
 836         if (err)
 837                 goto out2;
 838
 839 out2:
 840         ext2fs_free_mem(&block_buf);
 841 out:
 842         ext2fs_free_mem(&inode);
 843         return err;
 844 }
 845
 846 static errcode_t read_xattrs_from_buffer(struct ext2_xattr_handle *handle,
 847                                          struct ext2_inode_large *inode,
 848                                          struct ext2_ext_attr_entry *entries,
 849                                          unsigned int storage_size,
 850                                          char *value_start)
 851 {
 852         struct ext2_xattr *x;
 853         struct ext2_ext_attr_entry *entry, *end;
 854         const char *prefix;
 855         unsigned int remain, prefix_len;
 856         errcode_t err;
 857         unsigned int values_size = storage_size +
 858                         ((char *)entries - value_start);
 859
 860         /* find the end */
 861         end = entries;
 862         remain = storage_size;
 863         while (remain >= sizeof(struct ext2_ext_attr_entry) &&
 864                !EXT2_EXT_IS_LAST_ENTRY(end)) {
 865
 866                 /* header eats this space */
 867                 remain -= sizeof(struct ext2_ext_attr_entry);
 868
 869                 /* is attribute name valid? */
 870                 if (EXT2_EXT_ATTR_SIZE(end->e_name_len) > remain)
 871                         return EXT2_ET_EA_BAD_NAME_LEN;
 872
 873                 /* attribute len eats this space */
 874                 remain -= EXT2_EXT_ATTR_SIZE(end->e_name_len);
 875                 end = EXT2_EXT_ATTR_NEXT(end);
 876         }
 877
 878         entry = entries;
 879         remain = storage_size;
 880         while (remain >= sizeof(struct ext2_ext_attr_entry) &&
 881                !EXT2_EXT_IS_LAST_ENTRY(entry)) {
 882
 883                 /* Allocate space for more attrs? */
 884                 if (handle->count == handle->capacity) {
 885                         err = ext2fs_xattrs_expand(handle, 4);
 886                         if (err)
 887                                 return err;
 888                 }
 889
 890                 x = handle->attrs + handle->count;
 891
 892                 /* header eats this space */
 893                 remain -= sizeof(struct ext2_ext_attr_entry);
 894
 895                 /* attribute len eats this space */
 896                 remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len);
 897
 898                 /* Extract name */
 899                 prefix = find_ea_prefix(entry->e_name_index);
 900                 prefix_len = (prefix ? strlen(prefix) : 0);
 901                 err = ext2fs_get_memzero(entry->e_name_len + prefix_len + 1,
 902                                          &x->name);
 903                 if (err)
 904                         return err;
 905                 if (prefix)
 906                         memcpy(x->name, prefix, prefix_len);
 907                 if (entry->e_name_len)
 908                         memcpy(x->name + prefix_len,
 909                                (char *)entry + sizeof(*entry),
 910                                entry->e_name_len);
 911                 x->short_name = x->name + prefix_len;
 912                 x->name_index = entry->e_name_index;
 913
 914                 /* Check & copy value */
 915                 if (!ext2fs_has_feature_ea_inode(handle->fs->super) &&
 916                     entry->e_value_inum != 0)
 917                         return EXT2_ET_BAD_EA_BLOCK_NUM;
 918
 919                 if (entry->e_value_inum == 0) {
 920                         if (entry->e_value_size > remain)
 921                                 return EXT2_ET_EA_BAD_VALUE_SIZE;
 922
 923                         if (entry->e_value_offs + entry->e_value_size > values_size)
 924                                 return EXT2_ET_EA_BAD_VALUE_OFFSET;
 925
 926                         if (entry->e_value_size > 0 &&
 927                             value_start + entry->e_value_offs <
 928                             (char *)end + sizeof(__u32))
 929                                 return EXT2_ET_EA_BAD_VALUE_OFFSET;
 930
 931                         remain -= entry->e_value_size;
 932
 933                         err = ext2fs_get_mem(entry->e_value_size, &x->value);
 934                         if (err)
 935                                 return err;
 936                         memcpy(x->value, value_start + entry->e_value_offs,
 937                                entry->e_value_size);
 938                 } else {
 939                         struct ext2_inode *ea_inode;
 940                         ext2_file_t ea_file;
 941
 942                         if (entry->e_value_offs != 0)
 943                                 return EXT2_ET_EA_BAD_VALUE_OFFSET;
 944
 945                         if (entry->e_value_size > (64 * 1024))
 946                                 return EXT2_ET_EA_BAD_VALUE_SIZE;
 947
 948                         err = ext2fs_get_mem(entry->e_value_size, &x->value);
 949                         if (err)
 950                                 return err;
 951
 952                         err = ext2fs_file_open(handle->fs, entry->e_value_inum,
 953                                                0, &ea_file);
 954                         if (err)
 955                                 return err;
 956
 957                         ea_inode = ext2fs_file_get_inode(ea_file);
 958                         if ((ea_inode->i_flags & EXT4_INLINE_DATA_FL) ||
 959                             !(ea_inode->i_flags & EXT4_EA_INODE_FL) ||
 960                             ea_inode->i_links_count == 0)
 961                                 err = EXT2_ET_EA_INODE_CORRUPTED;
 962                         else if ((__u64) ext2fs_file_get_size(ea_file) !=
 963                                  entry->e_value_size)
 964                                 err = EXT2_ET_EA_BAD_VALUE_SIZE;
 965                         else
 966                                 err = ext2fs_file_read(ea_file, x->value,
 967                                                        entry->e_value_size, 0);
 968                         ext2fs_file_close(ea_file);
 969                         if (err)
 970                                 return err;
 971                 }
 972
 973                 x->ea_ino = entry->e_value_inum;
 974                 x->value_len = entry->e_value_size;
 975
 976                 /* e_hash may be 0 in older inode's ea */
 977                 if (entry->e_hash != 0) {
 978                         __u32 hash;
 979                         void *data = (entry->e_value_inum != 0) ?
 980                                         0 : value_start + entry->e_value_offs;
 981
 982                         err = ext2fs_ext_attr_hash_entry2(handle->fs, entry,
 983                                                           data, &hash);
 984                         if (err)
 985                                 return err;
 986                         if (entry->e_hash != hash) {
 987                                 struct ext2_inode child;
 988
 989                                 /* Check whether this is an old Lustre-style
 990                                  * ea_inode reference.
 991                                  */
 992                                 err = ext2fs_read_inode(handle->fs,
 993                                                         entry->e_value_inum,
 994                                                         &child);
 995                                 if (err)
 996                                         return err;
 997                                 if (child.i_mtime != handle->ino ||
 998                                     child.i_generation != inode->i_generation)
 999                                         return EXT2_ET_BAD_EA_HASH;
1000                         }
1001                 }
1002
1003                 handle->count++;
1004                 entry = EXT2_EXT_ATTR_NEXT(entry);
1005         }
1006
1007         return 0;
1008 }
1009
1010 static void xattrs_free_keys(struct ext2_xattr_handle *h)
1011 {
1012         struct ext2_xattr *a = h->attrs;
1013         int i;
1014
1015         for (i = 0; i < h->capacity; i++) {
1016                 if (a[i].name)
1017                         ext2fs_free_mem(&a[i].name);
1018                 if (a[i].value)
1019                         ext2fs_free_mem(&a[i].value);
1020         }
1021         h->count = 0;
1022         h->ibody_count = 0;
1023 }
1024
1025 /* fetch xattrs from an already-loaded inode */
1026 errcode_t ext2fs_xattrs_read_inode(struct ext2_xattr_handle *handle,
1027                                    struct ext2_inode_large *inode)
1028 {
1029
1030         struct ext2_ext_attr_header *header;
1031         __u32 ea_inode_magic;
1032         unsigned int storage_size;
1033         char *start, *block_buf = NULL;
1034         blk64_t blk;
1035         errcode_t err;
1036
1037         EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1038
1039         xattrs_free_keys(handle);
1040
1041         /* Does the inode have space for EA? */
1042         if (inode->i_extra_isize < sizeof(inode->i_extra_isize) ||
1043             EXT2_INODE_SIZE(handle->fs->super) <= EXT2_GOOD_OLD_INODE_SIZE +
1044                                                   inode->i_extra_isize +
1045                                                   sizeof(__u32))
1046                 goto read_ea_block;
1047         if (inode->i_extra_isize & 3) {
1048                 err = EXT2_ET_INODE_CORRUPTED;
1049                 goto out;
1050         }
1051
1052         /* Look for EA in the inode */
1053         memcpy(&ea_inode_magic, ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
1054                inode->i_extra_isize, sizeof(__u32));
1055         if (ea_inode_magic == EXT2_EXT_ATTR_MAGIC) {
1056                 storage_size = EXT2_INODE_SIZE(handle->fs->super) -
1057                         EXT2_GOOD_OLD_INODE_SIZE - inode->i_extra_isize -
1058                         sizeof(__u32);
1059                 start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
1060                         inode->i_extra_isize + sizeof(__u32);
1061
1062                 err = read_xattrs_from_buffer(handle, inode,
1063                                         (struct ext2_ext_attr_entry *) start,
1064                                         storage_size, start);
1065                 if (err)
1066                         goto out;
1067
1068                 handle->ibody_count = handle->count;
1069         }
1070
1071 read_ea_block:
1072         /* Look for EA in a separate EA block */
1073         blk = ext2fs_file_acl_block(handle->fs, EXT2_INODE(inode));
1074         if (blk != 0) {
1075                 if ((blk < handle->fs->super->s_first_data_block) ||
1076                     (blk >= ext2fs_blocks_count(handle->fs->super))) {
1077                         err = EXT2_ET_BAD_EA_BLOCK_NUM;
1078                         goto out;
1079                 }
1080
1081                 err = ext2fs_get_mem(handle->fs->blocksize, &block_buf);
1082                 if (err)
1083                         goto out;
1084
1085                 err = ext2fs_read_ext_attr3(handle->fs, blk, block_buf,
1086                                             handle->ino);
1087                 if (err)
1088                         goto out3;
1089
1090                 /* We only know how to deal with v2 EA blocks */
1091                 header = (struct ext2_ext_attr_header *) block_buf;
1092                 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
1093                         err = EXT2_ET_BAD_EA_HEADER;
1094                         goto out3;
1095                 }
1096
1097                 /* Read EAs */
1098                 storage_size = handle->fs->blocksize -
1099                         sizeof(struct ext2_ext_attr_header);
1100                 start = block_buf + sizeof(struct ext2_ext_attr_header);
1101                 err = read_xattrs_from_buffer(handle, inode,
1102                                         (struct ext2_ext_attr_entry *) start,
1103                                         storage_size, block_buf);
1104         }
1105
1106 out3:
1107         if (block_buf)
1108                 ext2fs_free_mem(&block_buf);
1109 out:
1110         return err;
1111 }
1112
1113 errcode_t ext2fs_xattrs_read(struct ext2_xattr_handle *handle)
1114 {
1115         struct ext2_inode_large *inode;
1116         size_t inode_size = EXT2_INODE_SIZE(handle->fs->super);
1117         errcode_t err;
1118
1119         EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1120
1121         if (inode_size < sizeof(*inode))
1122                 inode_size = sizeof(*inode);
1123         err = ext2fs_get_memzero(inode_size, &inode);
1124         if (err)
1125                 return err;
1126
1127         err = ext2fs_read_inode_full(handle->fs, handle->ino, EXT2_INODE(inode),
1128                                      EXT2_INODE_SIZE(handle->fs->super));
1129         if (err)
1130                 goto out;
1131
1132         err = ext2fs_xattrs_read_inode(handle, inode);
1133
1134 out:
1135         ext2fs_free_mem(&inode);
1136
1137         return err;
1138 }
1139
1140 errcode_t ext2fs_xattrs_iterate(struct ext2_xattr_handle *h,
1141                                 int (*func)(char *name, char *value,
1142                                             size_t value_len,
1143                                             ext2_ino_t inode_num, void *data),
1144                                 void *data)
1145 {
1146         struct ext2_xattr *x;
1147         int dirty = 0;
1148         int ret;
1149
1150         EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE);
1151         for (x = h->attrs; x < h->attrs + h->count; x++) {
1152                 ret = func(x->name, x->value, x->value_len, x->ea_ino, data);
1153                 if (ret & XATTR_CHANGED)
1154                         dirty = 1;
1155                 if (ret & XATTR_ABORT)
1156                         break;
1157         }
1158
1159         if (dirty)
1160                 return ext2fs_xattrs_write(h);
1161         return 0;
1162 }
1163
1164 errcode_t ext2fs_xattr_get(struct ext2_xattr_handle *h, const char *key,
1165                            void **value, size_t *value_len)
1166 {
1167         struct ext2_xattr *x;
1168         char *val;
1169         errcode_t err;
1170
1171         EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE);
1172         for (x = h->attrs; x < h->attrs + h->count; x++) {
1173                 if (strcmp(x->name, key))
1174                         continue;
1175
1176                 if (!(h->flags & XATTR_HANDLE_FLAG_RAW) &&
1177                     ((strcmp(key, "system.posix_acl_default") == 0) ||
1178                      (strcmp(key, "system.posix_acl_access") == 0))) {
1179                         err = convert_disk_buffer_to_posix_acl(x->value, x->value_len,
1180                                                                value, value_len);
1181                         return err;
1182                 } else {
1183                         err = ext2fs_get_mem(x->value_len, &val);
1184                         if (err)
1185                                 return err;
1186                         memcpy(val, x->value, x->value_len);
1187                         *value = val;
1188                         *value_len = x->value_len;
1189                         return 0;
1190                 }
1191         }
1192
1193         return EXT2_ET_EA_KEY_NOT_FOUND;
1194 }
1195
1196 errcode_t ext2fs_xattr_inode_max_size(ext2_filsys fs, ext2_ino_t ino,
1197                                       size_t *size)
1198 {
1199         struct ext2_ext_attr_entry *entry;
1200         struct ext2_inode_large *inode;
1201         __u32 ea_inode_magic;
1202         unsigned int minoff;
1203         char *start;
1204         size_t i;
1205         errcode_t err;
1206
1207         i = EXT2_INODE_SIZE(fs->super);
1208         if (i < sizeof(*inode))
1209                 i = sizeof(*inode);
1210         err = ext2fs_get_memzero(i, &inode);
1211         if (err)
1212                 return err;
1213
1214         err = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)inode,
1215                                      EXT2_INODE_SIZE(fs->super));
1216         if (err)
1217                 goto out;
1218
1219         /* Does the inode have size for EA? */
1220         if (EXT2_INODE_SIZE(fs->super) <= EXT2_GOOD_OLD_INODE_SIZE +
1221                                                   inode->i_extra_isize +
1222                                                   sizeof(__u32)) {
1223                 err = EXT2_ET_INLINE_DATA_NO_SPACE;
1224                 goto out;
1225         }
1226
1227         minoff = EXT2_INODE_SIZE(fs->super) - sizeof(*inode) - sizeof(__u32);
1228         memcpy(&ea_inode_magic, ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
1229                inode->i_extra_isize, sizeof(__u32));
1230         if (ea_inode_magic == EXT2_EXT_ATTR_MAGIC) {
1231                 /* has xattrs.  calculate the size */
1232                 start= ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
1233                         inode->i_extra_isize + sizeof(__u32);
1234                 entry = (struct ext2_ext_attr_entry *) start;
1235                 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
1236                         if (!entry->e_value_inum && entry->e_value_size) {
1237                                 unsigned int offs = entry->e_value_offs;
1238                                 if (offs < minoff)
1239                                         minoff = offs;
1240                         }
1241                         entry = EXT2_EXT_ATTR_NEXT(entry);
1242                 }
1243                 *size = minoff - ((char *)entry - (char *)start) - sizeof(__u32);
1244         } else {
1245                 /* no xattr.  return a maximum size */
1246                 *size = EXT2_EXT_ATTR_SIZE(minoff -
1247                                            EXT2_EXT_ATTR_LEN(strlen("data")) -
1248                                            EXT2_EXT_ATTR_ROUND - sizeof(__u32));
1249         }
1250
1251 out:
1252         ext2fs_free_mem(&inode);
1253         return err;
1254 }
1255
1256 static errcode_t xattr_create_ea_inode(ext2_filsys fs, const void *value,
1257                                        size_t value_len, ext2_ino_t *ea_ino)
1258 {
1259         struct ext2_inode inode;
1260         ext2_ino_t ino;
1261         ext2_file_t file;
1262         __u32 hash;
1263         errcode_t ret;
1264
1265         ret = ext2fs_new_inode(fs, 0, 0, 0, &ino);
1266         if (ret)
1267                 return ret;
1268
1269         memset(&inode, 0, sizeof(inode));
1270         inode.i_flags |= EXT4_EA_INODE_FL;
1271         if (ext2fs_has_feature_extents(fs->super))
1272                 inode.i_flags |= EXT4_EXTENTS_FL;
1273         inode.i_size = 0;
1274         inode.i_mode = LINUX_S_IFREG | 0600;
1275         inode.i_links_count = 1;
1276         ret = ext2fs_write_new_inode(fs, ino, &inode);
1277         if (ret)
1278                 return ret;
1279         /*
1280          * ref_count and hash utilize inode's i_*time fields.
1281          * ext2fs_write_new_inode() call above initializes these fields with
1282          * current time. That's why ref count and hash updates are done
1283          * separately below.
1284          */
1285         ext2fs_set_ea_inode_ref(&inode, 1);
1286         hash = ext2fs_crc32c_le(fs->csum_seed, value, value_len);
1287         ext2fs_set_ea_inode_hash(&inode, hash);
1288
1289         ret = ext2fs_write_inode(fs, ino, &inode);
1290         if (ret)
1291                 return ret;
1292
1293         ret = ext2fs_file_open(fs, ino, EXT2_FILE_WRITE, &file);
1294         if (ret)
1295                 return ret;
1296         ret = ext2fs_file_write(file, value, value_len, NULL);
1297         ext2fs_file_close(file);
1298         if (ret)
1299                 return ret;
1300
1301         ext2fs_inode_alloc_stats2(fs, ino, 1 /* inuse */, 0 /* isdir */);
1302
1303         *ea_ino = ino;
1304         return 0;
1305 }
1306
1307 static errcode_t xattr_inode_dec_ref(ext2_filsys fs, ext2_ino_t ino)
1308 {
1309         struct ext2_inode_large inode;
1310         __u64 ref_count;
1311         errcode_t ret;
1312
1313         ret = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)&inode,
1314                                      sizeof(inode));
1315         if (ret)
1316                 goto out;
1317
1318         ref_count = ext2fs_get_ea_inode_ref(EXT2_INODE(&inode));
1319         ref_count--;
1320         ext2fs_set_ea_inode_ref(EXT2_INODE(&inode), ref_count);
1321
1322         if (ref_count)
1323                 goto write_out;
1324
1325         inode.i_links_count = 0;
1326         inode.i_dtime = fs->now ? fs->now : time(0);
1327
1328         ret = ext2fs_free_ext_attr(fs, ino, &inode);
1329         if (ret)
1330                 goto write_out;
1331
1332         if (ext2fs_inode_has_valid_blocks2(fs, (struct ext2_inode *)&inode)) {
1333                 ret = ext2fs_punch(fs, ino, (struct ext2_inode *)&inode, NULL,
1334                                    0, ~0ULL);
1335                 if (ret)
1336                         goto out;
1337         }
1338
1339         ext2fs_inode_alloc_stats2(fs, ino, -1 /* inuse */, 0 /* is_dir */);
1340
1341 write_out:
1342         ret = ext2fs_write_inode_full(fs, ino, (struct ext2_inode *)&inode,
1343                                       sizeof(inode));
1344 out:
1345         return ret;
1346 }
1347
1348 static errcode_t xattr_update_entry(ext2_filsys fs, struct ext2_xattr *x,
1349                                     const char *name, const char *short_name,
1350                                     int index, const void *value,
1351                                     size_t value_len, int in_inode)
1352 {
1353         ext2_ino_t ea_ino = 0;
1354         void *new_value = NULL;
1355         char *new_name = NULL;
1356         int name_len;
1357         errcode_t ret;
1358
1359         if (!x->name) {
1360                 name_len = strlen(name);
1361                 ret = ext2fs_get_mem(name_len + 1, &new_name);
1362                 if (ret)
1363                         goto fail;
1364                 memcpy(new_name, name, name_len + 1);
1365         }
1366
1367         ret = ext2fs_get_mem(value_len, &new_value);
1368         if (ret)
1369                 goto fail;
1370         memcpy(new_value, value, value_len);
1371
1372         if (in_inode) {
1373                 ret = xattr_create_ea_inode(fs, value, value_len, &ea_ino);
1374                 if (ret)
1375                         goto fail;
1376         }
1377
1378         if (x->ea_ino) {
1379                 ret = xattr_inode_dec_ref(fs, x->ea_ino);
1380                 if (ret)
1381                         goto fail;
1382         }
1383
1384         if (!x->name) {
1385                 x->name = new_name;
1386                 x->short_name = new_name + (short_name  - name);
1387         }
1388         x->name_index = index;
1389
1390         if (x->value)
1391                 ext2fs_free_mem(&x->value);
1392         x->value = new_value;
1393         x->value_len = value_len;
1394         x->ea_ino = ea_ino;
1395         return 0;
1396 fail:
1397         if (new_name)
1398                 ext2fs_free_mem(&new_name);
1399         if (new_value)
1400                 ext2fs_free_mem(&new_value);
1401         if (ea_ino)
1402                 xattr_inode_dec_ref(fs, ea_ino);
1403         return ret;
1404 }
1405
1406 static int xattr_find_position(struct ext2_xattr *attrs, int count,
1407                                const char *shortname, int name_idx)
1408 {
1409         struct ext2_xattr *x;
1410         int i;
1411         int shortname_len, x_shortname_len;
1412
1413         shortname_len = strlen(shortname);
1414
1415         for (i = 0, x = attrs; i < count; i++, x++) {
1416                 if (name_idx < x->name_index)
1417                         break;
1418                 if (name_idx > x->name_index)
1419                         continue;
1420
1421                 x_shortname_len = strlen(x->short_name);
1422                 if (shortname_len < x_shortname_len)
1423                         break;
1424                 if (shortname_len > x_shortname_len)
1425                         continue;
1426
1427                 if (memcmp(shortname, x->short_name, shortname_len) <= 0)
1428                         break;
1429         }
1430         return i;
1431 }
1432
1433 static errcode_t xattr_array_update(struct ext2_xattr_handle *h,
1434                                     const char *name,
1435                                     const void *value, size_t value_len,
1436                                     int ibody_free, int block_free,
1437                                     int old_idx, int in_inode)
1438 {
1439         struct ext2_xattr tmp;
1440         int add_to_ibody;
1441         int needed;
1442         int name_len, name_idx = 0;
1443         const char *shortname = name;
1444         int new_idx;
1445         int ret;
1446
1447         find_ea_index(name, &shortname, &name_idx);
1448         name_len = strlen(shortname);
1449
1450         needed = EXT2_EXT_ATTR_LEN(name_len);
1451         if (!in_inode)
1452                 needed += EXT2_EXT_ATTR_SIZE(value_len);
1453
1454         if (old_idx >= 0 && old_idx < h->ibody_count) {
1455                 ibody_free += EXT2_EXT_ATTR_LEN(name_len);
1456                 if (!h->attrs[old_idx].ea_ino)
1457                         ibody_free += EXT2_EXT_ATTR_SIZE(
1458                                                 h->attrs[old_idx].value_len);
1459         }
1460
1461         if (needed <= ibody_free) {
1462                 if (old_idx < 0) {
1463                         new_idx = h->ibody_count;
1464                         add_to_ibody = 1;
1465                         goto add_new;
1466                 }
1467
1468                 /* Update the existing entry. */
1469                 ret = xattr_update_entry(h->fs, &h->attrs[old_idx], name,
1470                                          shortname, name_idx, value,
1471                                          value_len, in_inode);
1472                 if (ret)
1473                         return ret;
1474                 if (h->ibody_count <= old_idx) {
1475                         /* Move entry from block to the end of ibody. */
1476                         tmp = h->attrs[old_idx];
1477                         memmove(h->attrs + h->ibody_count + 1,
1478                                 h->attrs + h->ibody_count,
1479                                 (old_idx - h->ibody_count) * sizeof(*h->attrs));
1480                         h->attrs[h->ibody_count] = tmp;
1481                         h->ibody_count++;
1482                 }
1483                 return 0;
1484         }
1485
1486         if (h->ibody_count <= old_idx) {
1487                 block_free += EXT2_EXT_ATTR_LEN(name_len);
1488                 if (!h->attrs[old_idx].ea_ino)
1489                         block_free +=
1490                                 EXT2_EXT_ATTR_SIZE(h->attrs[old_idx].value_len);
1491         }
1492
1493         if (needed > block_free)
1494                 return EXT2_ET_EA_NO_SPACE;
1495
1496         if (old_idx >= 0) {
1497                 /* Update the existing entry. */
1498                 ret = xattr_update_entry(h->fs, &h->attrs[old_idx], name,
1499                                          shortname, name_idx, value,
1500                                          value_len, in_inode);
1501                 if (ret)
1502                         return ret;
1503                 if (old_idx < h->ibody_count) {
1504                         /*
1505                          * Move entry from ibody to the block. Note that
1506                          * entries in the block are sorted.
1507                          */
1508                         new_idx = xattr_find_position(h->attrs + h->ibody_count,
1509                                                       h->count - h->ibody_count,
1510                                                       shortname, name_idx);
1511                         new_idx += h->ibody_count - 1;
1512                         tmp = h->attrs[old_idx];
1513                         memmove(h->attrs + old_idx, h->attrs + old_idx + 1,
1514                                 (new_idx - old_idx) * sizeof(*h->attrs));
1515                         h->attrs[new_idx] = tmp;
1516                         h->ibody_count--;
1517                 }
1518                 return 0;
1519         }
1520
1521         new_idx = xattr_find_position(h->attrs + h->ibody_count,
1522                                       h->count - h->ibody_count,
1523                                       shortname, name_idx);
1524         new_idx += h->ibody_count;
1525         add_to_ibody = 0;
1526
1527 add_new:
1528         if (h->count == h->capacity) {
1529                 ret = ext2fs_xattrs_expand(h, 4);
1530                 if (ret)
1531                         return ret;
1532         }
1533
1534         ret = xattr_update_entry(h->fs, &h->attrs[h->count], name, shortname,
1535                                  name_idx, value, value_len, in_inode);
1536         if (ret)
1537                 return ret;
1538
1539         tmp = h->attrs[h->count];
1540         memmove(h->attrs + new_idx + 1, h->attrs + new_idx,
1541                 (h->count - new_idx)*sizeof(*h->attrs));
1542         h->attrs[new_idx] = tmp;
1543         if (add_to_ibody)
1544                 h->ibody_count++;
1545         h->count++;
1546         return 0;
1547 }
1548
1549 static int space_used(struct ext2_xattr *attrs, int count)
1550 {
1551         int total = 0;
1552         struct ext2_xattr *x;
1553         int i, len;
1554
1555         for (i = 0, x = attrs; i < count; i++, x++) {
1556                 len = strlen(x->short_name);
1557                 total += EXT2_EXT_ATTR_LEN(len);
1558                 if (!x->ea_ino)
1559                         total += EXT2_EXT_ATTR_SIZE(x->value_len);
1560         }
1561         return total;
1562 }
1563
1564 /*
1565  * The minimum size of EA value when you start storing it in an external inode
1566  * size of block - size of header - size of 1 entry - 4 null bytes
1567  */
1568 #define EXT4_XATTR_MIN_LARGE_EA_SIZE(b) \
1569         ((b) - EXT2_EXT_ATTR_LEN(3) - sizeof(struct ext2_ext_attr_header) - 4)
1570
1571 errcode_t ext2fs_xattr_set(struct ext2_xattr_handle *h,
1572                            const char *name,
1573                            const void *value,
1574                            size_t value_len)
1575 {
1576         ext2_filsys fs = h->fs;
1577         const int inode_size = EXT2_INODE_SIZE(fs->super);
1578         struct ext2_inode_large *inode = NULL;
1579         struct ext2_xattr *x;
1580         char *new_value;
1581         int ibody_free, block_free;
1582         int in_inode = 0;
1583         int old_idx = -1;
1584         int extra_isize;
1585         errcode_t ret;
1586
1587         EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE);
1588
1589         ret = ext2fs_get_mem(value_len, &new_value);
1590         if (ret)
1591                 return ret;
1592         if (!(h->flags & XATTR_HANDLE_FLAG_RAW) &&
1593             ((strcmp(name, "system.posix_acl_default") == 0) ||
1594              (strcmp(name, "system.posix_acl_access") == 0))) {
1595                 ret = convert_posix_acl_to_disk_buffer(value, value_len,
1596                                                        new_value, &value_len);
1597                 if (ret)
1598                         goto out;
1599         } else if (value_len)
1600                 memcpy(new_value, value, value_len);
1601
1602         /* Imitate kernel behavior by skipping update if value is the same. */
1603         for (x = h->attrs; x < h->attrs + h->count; x++) {
1604                 if (!strcmp(x->name, name)) {
1605                         if (!x->ea_ino && x->value_len == value_len &&
1606                             (!value_len ||
1607                              !memcmp(x->value, new_value, value_len))) {
1608                                 ret = 0;
1609                                 goto out;
1610                         }
1611                         old_idx = x - h->attrs;
1612                         break;
1613                 }
1614         }
1615
1616         ret = ext2fs_get_memzero(inode_size, &inode);
1617         if (ret)
1618                 goto out;
1619         ret = ext2fs_read_inode_full(fs, h->ino,
1620                                      (struct ext2_inode *)inode,
1621                                      inode_size);
1622         if (ret)
1623                 goto out;
1624         if (inode_size > EXT2_GOOD_OLD_INODE_SIZE) {
1625                 extra_isize = inode->i_extra_isize;
1626                 if (extra_isize == 0) {
1627                         extra_isize = fs->super->s_want_extra_isize;
1628                         if (extra_isize == 0)
1629                                 extra_isize = sizeof(__u32);
1630                 }
1631                 ibody_free = inode_size - EXT2_GOOD_OLD_INODE_SIZE;
1632                 ibody_free -= extra_isize;
1633                 /* Extended attribute magic and final null entry. */
1634                 ibody_free -= sizeof(__u32) * 2;
1635                 ibody_free -= space_used(h->attrs, h->ibody_count);
1636         } else
1637                 ibody_free = 0;
1638
1639         /* Inline data can only go to ibody. */
1640         if (strcmp(name, "system.data") == 0) {
1641                 if (h->ibody_count <= old_idx) {
1642                         ret = EXT2_ET_FILESYSTEM_CORRUPTED;
1643                         goto out;
1644                 }
1645                 ret = xattr_array_update(h, name, new_value, value_len,
1646                                          ibody_free,
1647                                          0 /* block_free */, old_idx,
1648                                          0 /* in_inode */);
1649                 if (ret)
1650                         goto out;
1651                 goto write_out;
1652         }
1653
1654         block_free = fs->blocksize;
1655         block_free -= sizeof(struct ext2_ext_attr_header);
1656         /* Final null entry. */
1657         block_free -= sizeof(__u32);
1658         block_free -= space_used(h->attrs + h->ibody_count,
1659                                  h->count - h->ibody_count);
1660
1661         if (ext2fs_has_feature_ea_inode(fs->super) &&
1662             value_len > EXT4_XATTR_MIN_LARGE_EA_SIZE(fs->blocksize))
1663                 in_inode = 1;
1664
1665         ret = xattr_array_update(h, name, new_value, value_len, ibody_free,
1666                                  block_free, old_idx, in_inode);
1667         if (ret == EXT2_ET_EA_NO_SPACE && !in_inode &&
1668             ext2fs_has_feature_ea_inode(fs->super))
1669                 ret = xattr_array_update(h, name, new_value, value_len,
1670                         ibody_free, block_free, old_idx, 1 /* in_inode */);
1671         if (ret)
1672                 goto out;
1673
1674 write_out:
1675         ret = ext2fs_xattrs_write(h);
1676 out:
1677         if (inode)
1678                 ext2fs_free_mem(&inode);
1679         ext2fs_free_mem(&new_value);
1680         return ret;
1681 }
1682
1683 errcode_t ext2fs_xattr_remove(struct ext2_xattr_handle *handle,
1684                               const char *key)
1685 {
1686         struct ext2_xattr *x;
1687         struct ext2_xattr *end = handle->attrs + handle->count;
1688
1689         EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1690         for (x = handle->attrs; x < end; x++) {
1691                 if (strcmp(x->name, key) == 0) {
1692                         ext2fs_free_mem(&x->name);
1693                         ext2fs_free_mem(&x->value);
1694                         if (x->ea_ino)
1695                                 xattr_inode_dec_ref(handle->fs, x->ea_ino);
1696                         memmove(x, x + 1, (end - x - 1)*sizeof(*x));
1697                         memset(end - 1, 0, sizeof(*end));
1698                         if (x < handle->attrs + handle->ibody_count)
1699                                 handle->ibody_count--;
1700                         handle->count--;
1701                         return ext2fs_xattrs_write(handle);
1702                 }
1703         }
1704
1705         /* no key found, success! */
1706         return 0;
1707 }
1708
1709 errcode_t ext2fs_xattrs_open(ext2_filsys fs, ext2_ino_t ino,
1710                              struct ext2_xattr_handle **handle)
1711 {
1712         struct ext2_xattr_handle *h;
1713         errcode_t err;
1714
1715         if (!ext2fs_has_feature_xattr(fs->super) &&
1716             !ext2fs_has_feature_inline_data(fs->super))
1717                 return EXT2_ET_MISSING_EA_FEATURE;
1718
1719         err = ext2fs_get_memzero(sizeof(*h), &h);
1720         if (err)
1721                 return err;
1722
1723         h->magic = EXT2_ET_MAGIC_EA_HANDLE;
1724         h->capacity = 4;
1725         err = ext2fs_get_arrayzero(h->capacity, sizeof(struct ext2_xattr),
1726                                    &h->attrs);
1727         if (err) {
1728                 ext2fs_free_mem(&h);
1729                 return err;
1730         }
1731         h->count = 0;
1732         h->ino = ino;
1733         h->fs = fs;
1734         *handle = h;
1735         return 0;
1736 }
1737
1738 errcode_t ext2fs_xattrs_close(struct ext2_xattr_handle **handle)
1739 {
1740         struct ext2_xattr_handle *h = *handle;
1741
1742         EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE);
1743         xattrs_free_keys(h);
1744         ext2fs_free_mem(&h->attrs);
1745         ext2fs_free_mem(handle);
1746         return 0;
1747 }
1748
1749 errcode_t ext2fs_xattrs_count(struct ext2_xattr_handle *handle, size_t *count)
1750 {
1751         EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1752         *count = handle->count;
1753         return 0;
1754 }
1755
1756 errcode_t ext2fs_xattrs_flags(struct ext2_xattr_handle *handle,
1757                               unsigned int *new_flags, unsigned int *old_flags)
1758 {
1759         EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
1760         if (old_flags)
1761                 *old_flags = handle->flags;
1762         if (new_flags)
1763                 handle->flags = *new_flags;
1764         return 0;
1765 }
1766
1767 struct ext2_attr_info {
1768         int name_index;
1769         const char *name;
1770         const char *value;
1771         int value_len;
1772 };
1773
1774 struct ext2_attr_search {
1775         struct ext2_ext_attr_entry *first;
1776         char *base;
1777         char *end;
1778         struct ext2_ext_attr_entry *here;
1779         int not_found;
1780 };
1781
1782 struct ext2_attr_ibody_find {
1783         ext2_ino_t ino;
1784         struct ext2_attr_search s;
1785 };
1786
1787 struct ext2_attr_block_find {
1788         struct ext2_attr_search s;
1789         char *block;
1790 };
1791
1792 void ext2fs_attr_shift_entries(struct ext2_ext_attr_entry *entry,
1793                                int value_offs_shift, char *to,
1794                                char *from, int n)
1795 {
1796         struct ext2_ext_attr_entry *last = entry;
1797
1798         /* Adjust the value offsets of the entries */
1799         for (; !EXT2_EXT_IS_LAST_ENTRY(last); last = EXT2_EXT_ATTR_NEXT(last)) {
1800                 if (!last->e_value_inum && last->e_value_size) {
1801                         last->e_value_offs = last->e_value_offs +
1802                                                         value_offs_shift;
1803                 }
1804         }
1805         /* Shift the entries by n bytes and zero freed space in inode */
1806         memmove(to, from, n);
1807         if (to > from)
1808                 memset(from, 0, to - from);
1809 }
1810
1811 /*
1812  * This function returns the free space present in the inode or the EA block.
1813  * total is number of bytes taken up by the EA entries and is used to shift
1814  * the EAs in ext2fs_expand_extra_isize().
1815  */
1816 int ext2fs_attr_free_space(struct ext2_ext_attr_entry *last,
1817                            int *min_offs, char *base, int *total)
1818 {
1819         for (; !EXT2_EXT_IS_LAST_ENTRY(last); last = EXT2_EXT_ATTR_NEXT(last)) {
1820                 *total += EXT2_EXT_ATTR_LEN(last->e_name_len);
1821                 if (!last->e_value_inum && last->e_value_size) {
1822                         int offs = last->e_value_offs;
1823                         if (offs < *min_offs)
1824                                 *min_offs = offs;
1825                 }
1826         }
1827
1828         return *min_offs - ((char *)last - base) - sizeof(__u32);
1829 }
1830
1831 static errcode_t ext2fs_attr_check_names(struct ext2_ext_attr_entry *entry,
1832                                          char *end)
1833 {
1834         while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
1835                 struct ext2_ext_attr_entry *next = EXT2_EXT_ATTR_NEXT(entry);
1836                 if ((char *)next >= end)
1837                         return EXT2_ET_EA_BAD_ENTRIES;
1838                 entry = next;
1839         }
1840         return 0;
1841 }
1842
1843 /* The unused parameter used to be the blocksize, but with in-inode xattrs
1844  * the xattr storage area size depends on where the xattrs are kept.  Keep
1845  * this parameter for API/ABI compatibility, but it is not needed. */
1846 static errcode_t ext2fs_attr_find_entry(struct ext2_ext_attr_entry **pentry,
1847                                         int name_index, const char *name,
1848                                         int unused, int sorted)
1849 {
1850         struct ext2_ext_attr_entry *entry;
1851         int name_len;
1852         int cmp = 1;
1853
1854         if (name == NULL)
1855                 return EXT2_ET_EA_BAD_NAME;
1856
1857         name_len = strlen(name);
1858         entry = *pentry;
1859         for (; !EXT2_EXT_IS_LAST_ENTRY(entry);
1860                 entry = EXT2_EXT_ATTR_NEXT(entry)) {
1861                 cmp = name_index - entry->e_name_index;
1862                 if (!cmp)
1863                         cmp = name_len - entry->e_name_len;
1864                 if (!cmp)
1865                         cmp = memcmp(name, entry->e_name, name_len);
1866                 if (cmp <= 0 && (sorted || cmp == 0))
1867                         break;
1868         }
1869         *pentry = entry;
1870
1871         return cmp ? EXT2_ET_EA_NAME_NOT_FOUND : 0;
1872 }
1873
1874 static errcode_t ext2fs_attr_block_find(ext2_filsys fs,struct ext2_inode *inode,
1875                                         struct ext2_attr_info *i,
1876                                         struct ext2_attr_block_find *bs)
1877 {
1878         struct ext2_ext_attr_header *header;
1879         errcode_t error;
1880
1881         if (inode->i_file_acl) {
1882                 /* The inode already has an extended attribute block. */
1883                 error = ext2fs_get_mem(fs->blocksize, &bs->block);
1884                 if (error)
1885                         return error;
1886                 error = ext2fs_read_ext_attr(fs, inode->i_file_acl, bs->block);
1887                 if (error)
1888                         goto cleanup;
1889
1890                 header = BHDR(bs->block);
1891                 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
1892                         error = EXT2_ET_EA_BAD_MAGIC;
1893                         goto cleanup;
1894                 }
1895
1896                 /* Find the named attribute. */
1897                 bs->s.base = bs->block;
1898                 bs->s.first = (struct ext2_ext_attr_entry *)(header + 1);
1899                 bs->s.end = bs->block + fs->blocksize;
1900                 bs->s.here = bs->s.first;
1901                 error = ext2fs_attr_find_entry(&bs->s.here, i->name_index,
1902                                                i->name, fs->blocksize, 1);
1903                 if (error && error != EXT2_ET_EA_NAME_NOT_FOUND)
1904                         goto cleanup;
1905                 bs->s.not_found = error;
1906         }
1907         error = 0;
1908
1909 cleanup:
1910         if (error && bs->block)
1911                 ext2fs_free_mem(&bs->block);
1912         return error;
1913 }
1914
1915 static errcode_t ext2fs_attr_ibody_find(ext2_filsys fs,
1916                                         struct ext2_inode_large *inode,
1917                                         struct ext2_attr_info *i,
1918                                         struct ext2_attr_ibody_find *is)
1919 {
1920         errcode_t error;
1921
1922         if (EXT2_INODE_SIZE(fs->super) == EXT2_GOOD_OLD_INODE_SIZE)
1923                 return 0;
1924
1925         if (inode->i_extra_isize == 0)
1926                 return 0;
1927
1928         is->s.first = &IHDR(inode)->h_first_entry[0];
1929         is->s.base = (char *)is->s.first;
1930         is->s.here = is->s.first;
1931         is->s.end = (char *)inode + EXT2_INODE_SIZE(fs->super);
1932         if (IHDR(inode)->h_magic == EXT2_EXT_ATTR_MAGIC) {
1933                 error = ext2fs_attr_check_names(is->s.first, is->s.end);
1934                 if (error)
1935                         return error;
1936                 /* Find the named attribute. */
1937                 error = ext2fs_attr_find_entry(&is->s.here, i->name_index,
1938                                                i->name, is->s.end -
1939                                                (char *)is->s.base, 0);
1940                 if (error && error != EXT2_ET_EA_NAME_NOT_FOUND)
1941                         return error;
1942                 is->s.not_found = error;
1943         }
1944
1945         return 0;
1946 }
1947
1948 static errcode_t ext2fs_attr_set_entry(ext2_filsys fs, struct ext2_attr_info *i,
1949                                        struct ext2_attr_search *s)
1950 {
1951         struct ext2_ext_attr_entry *last;
1952         int free, min_offs = s->end - s->base, name_len = strlen(i->name);
1953
1954         /* Compute min_offs and last. */
1955         for (last = s->first; !EXT2_EXT_IS_LAST_ENTRY(last);
1956              last = EXT2_EXT_ATTR_NEXT(last)) {
1957                 if (!last->e_value_inum && last->e_value_size) {
1958                         int offs = last->e_value_offs;
1959
1960                         if (offs < min_offs)
1961                                 min_offs = offs;
1962                 }
1963         }
1964         free = min_offs - ((char *)last - s->base) - sizeof(__u32);
1965
1966         if (!s->not_found) {
1967                 if (!s->here->e_value_inum && s->here->e_value_size) {
1968                         int size = s->here->e_value_size;
1969                         free += EXT2_EXT_ATTR_SIZE(size);
1970                 }
1971                 free += EXT2_EXT_ATTR_LEN(name_len);
1972         }
1973         if (i->value) {
1974                 if (free < EXT2_EXT_ATTR_LEN(name_len) +
1975                            EXT2_EXT_ATTR_SIZE(i->value_len))
1976                         return EXT2_ET_EA_NO_SPACE;
1977         }
1978
1979         if (i->value && s->not_found) {
1980                 /* Insert the new name. */
1981                 int size = EXT2_EXT_ATTR_LEN(name_len);
1982                 int rest = (char *)last - (char *)s->here + sizeof(__u32);
1983
1984                 memmove((char *)s->here + size, s->here, rest);
1985                 memset(s->here, 0, size);
1986                 s->here->e_name_index = i->name_index;
1987                 s->here->e_name_len = name_len;
1988                 memcpy(s->here->e_name, i->name, name_len);
1989         } else {
1990                 if (!s->here->e_value_inum && s->here->e_value_size) {
1991                         char *first_val = s->base + min_offs;
1992                         int offs = s->here->e_value_offs;
1993                         char *val = s->base + offs;
1994                         int size = EXT2_EXT_ATTR_SIZE(s->here->e_value_size);
1995
1996                         if (i->value &&
1997                             size == EXT2_EXT_ATTR_SIZE(i->value_len)) {
1998                                 /* The old and the new value have the same
1999                                    size. Just replace. */
2000                                 s->here->e_value_size = i->value_len;
2001                                 memset(val + size - EXT2_EXT_ATTR_PAD, 0,
2002                                        EXT2_EXT_ATTR_PAD); /* Clear pad bytes */
2003                                 memcpy(val, i->value, i->value_len);
2004                                 return 0;
2005                         }
2006
2007                         /* Remove the old value. */
2008                         memmove(first_val + size, first_val, val - first_val);
2009                         memset(first_val, 0, size);
2010                         s->here->e_value_size = 0;
2011                         s->here->e_value_offs = 0;
2012                         min_offs += size;
2013
2014                         /* Adjust all value offsets. */
2015                         last = s->first;
2016                         while (!EXT2_EXT_IS_LAST_ENTRY(last)) {
2017                                 int o = last->e_value_offs;
2018
2019                                 if (!last->e_value_inum &&
2020                                     last->e_value_size && o < offs)
2021                                         last->e_value_offs = o + size;
2022                                 last = EXT2_EXT_ATTR_NEXT(last);
2023                         }
2024                 }
2025                 if (!i->value) {
2026                         /* Remove the old name. */
2027                         int size = EXT2_EXT_ATTR_LEN(name_len);
2028
2029                         last = ENTRY((char *)last - size);
2030                         memmove((char *)s->here, (char *)s->here + size,
2031                                 (char *)last - (char *)s->here + sizeof(__u32));
2032                         memset(last, 0, size);
2033                 }
2034         }
2035
2036         if (i->value) {
2037                 /* Insert the new value. */
2038                 s->here->e_value_size = i->value_len;
2039                 if (i->value_len) {
2040                         int size = EXT2_EXT_ATTR_SIZE(i->value_len);
2041                         char *val = s->base + min_offs - size;
2042
2043                         s->here->e_value_offs = min_offs - size;
2044                         memset(val + size - EXT2_EXT_ATTR_PAD, 0,
2045                                EXT2_EXT_ATTR_PAD); /* Clear the pad bytes. */
2046                         memcpy(val, i->value, i->value_len);
2047                 }
2048         }
2049
2050         return 0;
2051 }
2052
2053 static errcode_t ext2fs_attr_block_set(ext2_filsys fs, struct ext2_inode *inode,
2054                                        struct ext2_attr_info *i,
2055                                        struct ext2_attr_block_find *bs)
2056 {
2057         struct ext2_attr_search *s = &bs->s;
2058         char *new_buf = NULL, *old_block = NULL;
2059         blk_t blk;
2060         int clear_flag = 0;
2061         errcode_t error;
2062
2063         if (i->value && i->value_len > fs->blocksize)
2064                 return EXT2_ET_EA_NO_SPACE;
2065
2066         if (s->base) {
2067                 if (BHDR(s->base)->h_refcount != 1) {
2068                         int offset = (char *)s->here - bs->block;
2069
2070                         /* Decrement the refcount of the shared block */
2071                         old_block = s->base;
2072                         BHDR(s->base)->h_refcount -= 1;
2073
2074                         error = ext2fs_get_mem(fs->blocksize, &s->base);
2075                         if (error)
2076                                 goto cleanup;
2077                         clear_flag = 1;
2078                         memcpy(s->base, bs->block, fs->blocksize);
2079                         s->first = ENTRY(BHDR(s->base)+1);
2080                         BHDR(s->base)->h_refcount = 1;
2081                         s->here = ENTRY(s->base + offset);
2082                         s->end = s->base + fs->blocksize;
2083                 }
2084         } else {
2085                 error = ext2fs_get_mem(fs->blocksize, &s->base);
2086                 if (error)
2087                         goto cleanup;
2088                 clear_flag = 1;
2089                 memset(s->base, 0, fs->blocksize);
2090                 BHDR(s->base)->h_magic = EXT2_EXT_ATTR_MAGIC;
2091                 BHDR(s->base)->h_blocks = 1;
2092                 BHDR(s->base)->h_refcount = 1;
2093                 s->first = ENTRY(BHDR(s->base)+1);
2094                 s->here = ENTRY(BHDR(s->base)+1);
2095                 s->end = s->base + fs->blocksize;
2096         }
2097
2098         error = ext2fs_attr_set_entry(fs, i, s);
2099         if (error)
2100                 goto cleanup;
2101
2102         if (!EXT2_EXT_IS_LAST_ENTRY(s->first))
2103                 ext2fs_attr_rehash(BHDR(s->base), s->here);
2104
2105         if (!EXT2_EXT_IS_LAST_ENTRY(s->first)) {
2106                 if (bs->block && bs->block == s->base) {
2107                         /* We are modifying this block in-place */
2108                         new_buf = bs->block;
2109                         blk = inode->i_file_acl;
2110                         error = ext2fs_write_ext_attr(fs, blk, s->base);
2111                         if (error)
2112                                 goto cleanup;
2113                 } else {
2114                         /* We need to allocate a new block */
2115                         error = ext2fs_new_block(fs, 0, 0, &blk);
2116                         if (error)
2117                                 goto cleanup;
2118                         ext2fs_block_alloc_stats(fs, blk, 1);
2119                         error = ext2fs_write_ext_attr(fs, blk, s->base);
2120                         if (error)
2121                                 goto cleanup;
2122                         new_buf = s->base;
2123                         if (old_block) {
2124                                 BHDR(s->base)->h_refcount -= 1;
2125                                 error = ext2fs_write_ext_attr(fs,
2126                                                               inode->i_file_acl,
2127                                                               s->base);
2128                                 if (error)
2129                                         goto cleanup;
2130                         }
2131                 }
2132         }
2133
2134         /* Update the i_blocks if we added a new EA block */
2135         if (!inode->i_file_acl && new_buf)
2136                 inode->i_blocks += fs->blocksize / 512;
2137         /* Update the inode. */
2138         inode->i_file_acl = new_buf ? blk : 0;
2139
2140 cleanup:
2141         if (clear_flag)
2142                 ext2fs_free_mem(&s->base);
2143         return 0;
2144 }
2145
2146 static errcode_t ext2fs_attr_ibody_set(ext2_filsys fs,
2147                                        struct ext2_inode_large *inode,
2148                                        struct ext2_attr_info *i,
2149                                        struct ext2_attr_ibody_find *is)
2150 {
2151         struct ext2_attr_search *s = &is->s;
2152         errcode_t error;
2153
2154         if (EXT2_INODE_SIZE(fs->super) == EXT2_GOOD_OLD_INODE_SIZE)
2155                 return EXT2_ET_EA_NO_SPACE;
2156
2157         error = ext2fs_attr_set_entry(fs, i, s);
2158         if (error)
2159                 return error;
2160
2161         if (!EXT2_EXT_IS_LAST_ENTRY(s->first))
2162                 IHDR(inode)->h_magic = EXT2_EXT_ATTR_MAGIC;
2163         else
2164                 IHDR(inode)->h_magic = 0;
2165
2166         return ext2fs_write_inode_full(fs, is->ino, (struct ext2_inode *)inode,
2167                                        EXT2_INODE_SIZE(fs->super));
2168 }
2169
2170 static struct {
2171         char str[28];
2172         int len;
2173 } ext2_attr_index_prefix[] = {
2174         [EXT2_ATTR_INDEX_USER] = { EXT2_ATTR_INDEX_USER_PREFIX,
2175                                    sizeof(EXT2_ATTR_INDEX_USER_PREFIX) },
2176         [EXT2_ATTR_INDEX_POSIX_ACL_ACCESS] = {
2177                 EXT2_ATTR_INDEX_POSIX_ACL_ACCESS_PREFIX,
2178                 sizeof(EXT2_ATTR_INDEX_POSIX_ACL_ACCESS_PREFIX) },
2179         [EXT2_ATTR_INDEX_POSIX_ACL_DEFAULT] = {
2180                 EXT2_ATTR_INDEX_POSIX_ACL_DEFAULT_PREFIX,
2181                 sizeof(EXT2_ATTR_INDEX_POSIX_ACL_DEFAULT_PREFIX) },
2182         [EXT2_ATTR_INDEX_TRUSTED] = { EXT2_ATTR_INDEX_TRUSTED_PREFIX,
2183                                       sizeof(EXT2_ATTR_INDEX_TRUSTED_PREFIX) },
2184         [EXT2_ATTR_INDEX_LUSTRE] = { EXT2_ATTR_INDEX_LUSTRE_PREFIX,
2185                                      sizeof(EXT2_ATTR_INDEX_LUSTRE_PREFIX) },
2186         [EXT2_ATTR_INDEX_SECURITY] = { EXT2_ATTR_INDEX_SECURITY_PREFIX,
2187                                        sizeof(EXT2_ATTR_INDEX_SECURITY_PREFIX)},
2188         { "", 0 }
2189 };
2190
2191 errcode_t ext2fs_attr_set(ext2_filsys fs, ext2_ino_t ino,
2192                           struct ext2_inode *inode,
2193                           int name_index, const char *name, const char *value,
2194                           int value_len, int flags)
2195 {
2196         struct ext2_inode_large *inode_large = NULL;
2197         struct ext2_attr_info i = {
2198                 .name_index = name_index,
2199                 .name = name,
2200                 .value = value,
2201                 .value_len = value_len,
2202         };
2203         struct ext2_attr_ibody_find is = {
2204                 .ino = ino,
2205                 .s = { .not_found = -ENODATA, },
2206         };
2207         struct ext2_attr_block_find bs = {
2208                 .s = { .not_found = -ENODATA, },
2209         };
2210         errcode_t error;
2211
2212         if (!name)
2213                 return EXT2_ET_EA_BAD_NAME;
2214         if (strlen(name) > 255)
2215                 return EXT2_ET_EA_NAME_TOO_BIG;
2216
2217         /* If the prefix is still present, skip it */
2218         if (strncmp(name, ext2_attr_index_prefix[name_index].str,
2219                     ext2_attr_index_prefix[name_index].len) == 0)
2220                 i.name += ext2_attr_index_prefix[name_index].len;
2221
2222         if (EXT2_INODE_SIZE(fs->super) > EXT2_GOOD_OLD_INODE_SIZE) {
2223                 inode_large = (struct ext2_inode_large *)inode;
2224
2225                 error = ext2fs_attr_ibody_find(fs, inode_large, &i, &is);
2226                 if (error)
2227                         goto cleanup;
2228         }
2229         if (is.s.not_found) {
2230                 error = ext2fs_attr_block_find(fs, inode, &i, &bs);
2231                 if (error)
2232                         goto cleanup;
2233         }
2234
2235         if (is.s.not_found && bs.s.not_found) {
2236                 error = EXT2_ET_EA_NAME_NOT_FOUND;
2237                 if (flags & XATTR_REPLACE)
2238                         goto cleanup;
2239                 error = 0;
2240                 if (!value)
2241                         goto cleanup;
2242         } else {
2243                 error = EXT2_ET_EA_NAME_EXISTS;
2244                 if (flags & XATTR_CREATE)
2245                         goto cleanup;
2246         }
2247
2248         if (!value) {
2249                 if (!is.s.not_found &&
2250                     (EXT2_INODE_SIZE(fs->super) > EXT2_GOOD_OLD_INODE_SIZE))
2251                         error = ext2fs_attr_ibody_set(fs, inode_large, &i, &is);
2252                 else if (!bs.s.not_found)
2253                         error = ext2fs_attr_block_set(fs, inode, &i, &bs);
2254         } else {
2255                 if (EXT2_INODE_SIZE(fs->super) > EXT2_GOOD_OLD_INODE_SIZE)
2256                         error = ext2fs_attr_ibody_set(fs, inode_large, &i, &is);
2257                 if (!error && !bs.s.not_found) {
2258                         i.value = NULL;
2259                         error = ext2fs_attr_block_set(fs, inode, &i, &bs);
2260                 } else if (error == EXT2_ET_EA_NO_SPACE) {
2261                         error = ext2fs_attr_block_set(fs, inode, &i, &bs);
2262                         if (error)
2263                                 goto cleanup;
2264                         if (!is.s.not_found) {
2265                                 i.value = NULL;
2266                                 if (EXT2_INODE_SIZE(fs->super) >
2267                                     EXT2_GOOD_OLD_INODE_SIZE)
2268                                         error = ext2fs_attr_ibody_set(fs,
2269                                                         inode_large, &i, &is);
2270                         }
2271                 }
2272         }
2273
2274 cleanup:
2275         return error;
2276 }
2277
2278 static errcode_t ext2fs_attr_check_block(ext2_filsys fs, char *buffer)
2279 {
2280         if (BHDR(buffer)->h_magic != (EXT2_EXT_ATTR_MAGIC) ||
2281             BHDR(buffer)->h_blocks != 1)
2282                 return EXT2_ET_EA_BAD_MAGIC;
2283
2284         return ext2fs_attr_check_names((struct ext2_ext_attr_entry *)
2285                                        (BHDR(buffer) + 1),
2286                                        buffer + fs->blocksize);
2287 }
2288
2289 static errcode_t ext2fs_attr_block_get(ext2_filsys fs, struct ext2_inode *inode,
2290                                        int name_index, const char *name,
2291                                        void *buffer, size_t buffer_size,
2292                                        int *easize)
2293 {
2294         struct ext2_ext_attr_header *header = NULL;
2295         struct ext2_ext_attr_entry *entry;
2296         char *block_buf = NULL;
2297         errcode_t error;
2298
2299         error = EXT2_ET_EA_NAME_NOT_FOUND;
2300         if (!inode->i_file_acl)
2301                 goto cleanup;
2302
2303         error = ext2fs_get_mem(fs->blocksize, &block_buf);
2304         if (error)
2305                 return error;
2306         error = ext2fs_read_ext_attr(fs, inode->i_file_acl, block_buf);
2307         if (error)
2308                 goto cleanup;
2309
2310         error = ext2fs_attr_check_block(fs, block_buf);
2311         if (error)
2312                 goto cleanup;
2313
2314         header = BHDR(block_buf);
2315         entry = (struct ext2_ext_attr_entry *)(header + 1);
2316         error = ext2fs_attr_find_entry(&entry, name_index, name,
2317                                        fs->blocksize, 1);
2318         if (error)
2319                 goto cleanup;
2320         if (easize)
2321                 *easize = entry->e_value_size;
2322         if (buffer) {
2323                 if (entry->e_value_size > buffer_size) {
2324                         error = EXT2_ET_EA_TOO_BIG;
2325                         goto cleanup;
2326                 }
2327                 memcpy(buffer, block_buf + entry->e_value_offs,
2328                        entry->e_value_size);
2329                 error = 0;
2330         }
2331
2332 cleanup:
2333         if (block_buf)
2334                 ext2fs_free_mem(&block_buf);
2335         return error;
2336 }
2337
2338 static errcode_t ext2fs_attr_check_ibody(ext2_filsys fs,
2339                                          struct ext2_inode_large *inode)
2340 {
2341         const int inode_size = EXT2_INODE_SIZE(fs->super);
2342
2343         if (inode_size == EXT2_GOOD_OLD_INODE_SIZE)
2344                 return EXT2_ET_EA_NAME_NOT_FOUND;
2345
2346         if (IHDR(inode)->h_magic != EXT2_EXT_ATTR_MAGIC)
2347                 return EXT2_ET_EA_BAD_MAGIC;
2348
2349         return ext2fs_attr_check_names(&IHDR(inode)->h_first_entry[0],
2350                                        (char *)inode + inode_size);
2351 }
2352
2353
2354 static errcode_t ext2fs_attr_ibody_get(ext2_filsys fs,
2355                                        struct ext2_inode_large *inode,
2356                                        int name_index, const char *name,
2357                                        void *buffer, size_t buffer_size,
2358                                        int *easize)
2359 {
2360         struct ext2_ext_attr_entry *entry;
2361         int error;
2362
2363         error = ext2fs_attr_check_ibody(fs, inode);
2364         if (error)
2365                 return error;
2366
2367         entry = &IHDR(inode)->h_first_entry[0];
2368
2369         error = ext2fs_attr_find_entry(&entry, name_index, name,
2370                                 (char *)inode + EXT2_INODE_SIZE(fs->super) -
2371                                 (char *)entry, 0);
2372         if (error)
2373                 goto cleanup;
2374         if (easize)
2375                 *easize = entry->e_value_size;
2376         if (buffer) {
2377                 if (entry->e_value_size > buffer_size) {
2378                         error = EXT2_ET_EA_TOO_BIG;
2379                         goto cleanup;
2380                 }
2381                 memcpy(buffer, (char *)&IHDR(inode)->h_first_entry[0] +
2382                                entry->e_value_offs, entry->e_value_size);
2383         }
2384
2385 cleanup:
2386         return error;
2387 }
2388
2389
2390 errcode_t ext2fs_attr_get(ext2_filsys fs, struct ext2_inode *inode,
2391                           int name_index, const char *name, char *buffer,
2392                           size_t buffer_size, int *easize)
2393 {
2394         errcode_t error;
2395
2396         error = ext2fs_attr_ibody_get(fs, (struct ext2_inode_large *)inode,
2397                                       name_index, name, buffer, buffer_size,
2398                                       easize);
2399         if (error == EXT2_ET_EA_NAME_NOT_FOUND || error == EXT2_ET_EA_BAD_MAGIC)
2400                 error = ext2fs_attr_block_get(fs, inode, name_index, name,
2401                                               buffer, buffer_size, easize);
2402
2403         return error;
2404 }
2405
2406 int ext2fs_attr_get_next_attr(struct ext2_ext_attr_entry *entry, int name_index,
2407                               char *buffer, int buffer_size, int start)
2408 {
2409         const int prefix_len = ext2_attr_index_prefix[name_index].len;
2410         int total_len;
2411
2412         if (!start && !EXT2_EXT_IS_LAST_ENTRY(entry))
2413                 entry = EXT2_EXT_ATTR_NEXT(entry);
2414
2415         for (; !EXT2_EXT_IS_LAST_ENTRY(entry);
2416              entry = EXT2_EXT_ATTR_NEXT(entry)) {
2417                 if (!name_index)
2418                         break;
2419                 if (name_index == entry->e_name_index)
2420                         break;
2421         }
2422         if (EXT2_EXT_IS_LAST_ENTRY(entry))
2423                 return 0;
2424
2425         total_len = prefix_len + entry->e_name_len + 1;
2426         if (buffer && total_len <= buffer_size) {
2427                 memcpy(buffer, ext2_attr_index_prefix[name_index].str,
2428                        prefix_len);
2429                 memcpy(buffer + prefix_len, entry->e_name, entry->e_name_len);
2430                 buffer[prefix_len + entry->e_name_len] = '\0';
2431         }
2432
2433         return total_len;
2434 }
2435
2436 errcode_t ext2fs_expand_extra_isize(ext2_filsys fs, ext2_ino_t ino,
2437                                     struct ext2_inode_large *inode,
2438                                     int new_extra_isize, int *ret,
2439                                     int *needed_size)
2440 {
2441         struct ext2_inode *inode_buf = NULL;
2442         struct ext2_ext_attr_header *header = NULL;
2443         struct ext2_ext_attr_entry *entry = NULL, *last = NULL;
2444         struct ext2_attr_ibody_find is = {
2445                 .ino = ino,
2446                 .s = { .not_found = EXT2_ET_EA_NO_SPACE, },
2447         };
2448         struct ext2_attr_block_find bs = {
2449                 .s = { .not_found = EXT2_ET_EA_NO_SPACE, },
2450         };
2451         char *start, *end, *block_buf = NULL, *buffer =NULL, *b_entry_name=NULL;
2452         int total_ino = 0, total_blk, free, offs, tried_min_extra_isize = 0;
2453         int s_min_extra_isize = fs->super->s_min_extra_isize;
2454         errcode_t error = 0;
2455
2456         if (needed_size)
2457                 *needed_size = new_extra_isize;
2458         error = ext2fs_get_mem(fs->blocksize, &block_buf);
2459         if (error)
2460                 return error;
2461
2462         if (inode == NULL) {
2463                 error = ext2fs_get_mem(EXT2_INODE_SIZE(fs->super), &inode_buf);
2464                 if (error)
2465                         goto cleanup;
2466
2467                 error = ext2fs_read_inode_full(fs, ino, inode_buf,
2468                                                EXT2_INODE_SIZE(fs->super));
2469                 if (error)
2470                         goto cleanup;
2471
2472                 inode = (struct ext2_inode_large *)inode_buf;
2473         }
2474
2475 retry:
2476         if (inode->i_extra_isize >= new_extra_isize)
2477                 goto cleanup;
2478
2479         start = (char *)inode + EXT2_GOOD_OLD_INODE_SIZE + inode->i_extra_isize;
2480         /* No extended attributes present */
2481         if (IHDR(inode)->h_magic != EXT2_EXT_ATTR_MAGIC) {
2482                 memset(start, 0,
2483                        EXT2_INODE_SIZE(fs->super) - EXT2_GOOD_OLD_INODE_SIZE -
2484                        inode->i_extra_isize);
2485                 inode->i_extra_isize = new_extra_isize;
2486                 if (needed_size)
2487                         *needed_size = 0;
2488                 goto write_inode;
2489         }
2490
2491         start += sizeof(__u32);
2492         end = (char *)inode + EXT2_INODE_SIZE(fs->super);
2493         last = entry = (struct ext2_ext_attr_entry *)start;
2494         offs = end - start;
2495         /* Consider space takenup by magic number */
2496         total_ino = sizeof(__u32);
2497         free = ext2fs_attr_free_space(last, &offs, start, &total_ino);
2498
2499         /* Enough free space available in the inode for expansion */
2500         if (free >= new_extra_isize) {
2501                 ext2fs_attr_shift_entries(entry,
2502                                         inode->i_extra_isize - new_extra_isize,
2503                                         (char *)inode +
2504                                         EXT2_GOOD_OLD_INODE_SIZE +
2505                                         new_extra_isize,
2506                                         start - sizeof(__u32), total_ino);
2507                 inode->i_extra_isize = new_extra_isize;
2508                 if (needed_size)
2509                         *needed_size = 0;
2510                 goto write_inode;
2511         }
2512
2513         if (inode->i_file_acl) {
2514                 error = ext2fs_read_ext_attr(fs, inode->i_file_acl, block_buf);
2515                 if (error)
2516                         goto cleanup;
2517
2518                 header = BHDR(block_buf);
2519                 if (header->h_magic != EXT2_EXT_ATTR_MAGIC) {
2520                         error = EXT2_ET_EA_BAD_MAGIC;
2521                         goto cleanup;
2522                 }
2523                 end = block_buf + fs->blocksize;
2524                 last = entry = (struct ext2_ext_attr_entry *)(header+1);
2525                 start = (char *)entry;
2526                 offs = end - start;
2527                 free = ext2fs_attr_free_space(last, &offs, start, &total_blk);
2528                 if (free < new_extra_isize) {
2529                         if (!tried_min_extra_isize && s_min_extra_isize) {
2530                                 tried_min_extra_isize++;
2531                                 new_extra_isize = s_min_extra_isize;
2532                                 goto retry;
2533                         }
2534                         if (ret)
2535                                 *ret = EXT2_EXPAND_EISIZE_NOSPC;
2536                         error = EXT2_ET_EA_NO_SPACE;
2537                         goto cleanup;
2538                 }
2539         } else {
2540                 if (ret && *ret == EXT2_EXPAND_EISIZE_UNSAFE) {
2541                         *ret = EXT2_EXPAND_EISIZE_NEW_BLOCK;
2542                         error = 0;
2543                         goto cleanup;
2544                 }
2545                 free = fs->blocksize;
2546         }
2547
2548         while (new_extra_isize > 0) {
2549                 int offs, size, entry_size;
2550                 struct ext2_ext_attr_entry *small_entry = NULL;
2551                 struct ext2_attr_info i = {
2552                         .value = NULL,
2553                         .value_len = 0,
2554                 };
2555                 unsigned int total_size, shift_bytes, temp = ~0U, extra_isize=0;
2556
2557                 start = (char *)inode + EXT2_GOOD_OLD_INODE_SIZE +
2558                                 inode->i_extra_isize + sizeof(__u32);
2559                 end = (char *)inode + EXT2_INODE_SIZE(fs->super);
2560                 last = (struct ext2_ext_attr_entry *)start;
2561
2562                 /* Find the entry best suited to be pushed into EA block */
2563                 entry = NULL;
2564                 for (; !EXT2_EXT_IS_LAST_ENTRY(last);
2565                         last = EXT2_EXT_ATTR_NEXT(last)) {
2566                         total_size = EXT2_EXT_ATTR_SIZE(last->e_value_size) +
2567                                         EXT2_EXT_ATTR_LEN(last->e_name_len);
2568                         if (total_size <= free && total_size < temp) {
2569                                 if (total_size < new_extra_isize) {
2570                                         small_entry = last;
2571                                 } else {
2572                                         entry = last;
2573                                         temp = total_size;
2574                                 }
2575                         }
2576                 }
2577
2578                 if (entry == NULL) {
2579                         if (small_entry) {
2580                                 entry = small_entry;
2581                         } else {
2582                                 if (!tried_min_extra_isize &&
2583                                     s_min_extra_isize) {
2584                                         tried_min_extra_isize++;
2585                                         new_extra_isize = s_min_extra_isize;
2586                                         goto retry;
2587                                 }
2588                                 if (ret)
2589                                         *ret = EXT2_EXPAND_EISIZE_NOSPC;
2590                                 error = EXT2_ET_EA_NO_SPACE;
2591                                 goto cleanup;
2592                         }
2593                 }
2594                 offs = entry->e_value_offs;
2595                 size = entry->e_value_size;
2596                 entry_size = EXT2_EXT_ATTR_LEN(entry->e_name_len);
2597                 i.name_index = entry->e_name_index;
2598                 error = ext2fs_get_mem(EXT2_EXT_ATTR_SIZE(size), &buffer);
2599                 if (error)
2600                         goto cleanup;
2601                 error = ext2fs_get_mem(entry->e_name_len + 1, &b_entry_name);
2602                 if (error)
2603                         goto cleanup;
2604                 /* Save the entry name and the entry value */
2605                 memcpy((char *)buffer, (char *)start + offs,
2606                        EXT2_EXT_ATTR_SIZE(size));
2607                 memcpy((char *)b_entry_name, (char *)entry->e_name,
2608                        entry->e_name_len);
2609                 b_entry_name[entry->e_name_len] = '\0';
2610                 i.name = b_entry_name;
2611
2612                 error = ext2fs_attr_ibody_find(fs, inode, &i, &is);
2613                 if (error)
2614                         goto cleanup;
2615
2616                 error = ext2fs_attr_set_entry(fs, &i, &is.s);
2617                 if (error)
2618                         goto cleanup;
2619
2620                 entry = (struct ext2_ext_attr_entry *)start;
2621                 if (entry_size + EXT2_EXT_ATTR_SIZE(size) >= new_extra_isize)
2622                         shift_bytes = new_extra_isize;
2623                 else
2624                         shift_bytes = entry_size + EXT2_EXT_ATTR_SIZE(size);
2625                 ext2fs_attr_shift_entries(entry,
2626                                         inode->i_extra_isize - shift_bytes,
2627                                         (char *)inode +EXT2_GOOD_OLD_INODE_SIZE+
2628                                         extra_isize + shift_bytes,
2629                                         start - sizeof(__u32),
2630                                         total_ino - entry_size);
2631
2632                 extra_isize += shift_bytes;
2633                 new_extra_isize -= shift_bytes;
2634                 if (needed_size)
2635                         *needed_size = new_extra_isize;
2636                 inode->i_extra_isize = extra_isize;
2637
2638                 i.name = b_entry_name;
2639                 i.value = buffer;
2640                 i.value_len = size;
2641                 error = ext2fs_attr_block_find(fs, (struct ext2_inode *)inode,
2642                                                &i, &bs);
2643                 if (error)
2644                         goto cleanup;
2645
2646                 /* Add entry which was removed from the inode into the block */
2647                 error = ext2fs_attr_block_set(fs, (struct ext2_inode *)inode,
2648                                               &i, &bs);
2649                 if (error)
2650                         goto cleanup;
2651         }
2652
2653 write_inode:
2654         error = ext2fs_write_inode_full(fs, ino, (struct ext2_inode *)inode,
2655                                         EXT2_INODE_SIZE(fs->super));
2656 cleanup:
2657         if (inode_buf)
2658                 ext2fs_free_mem(&inode_buf);
2659         if (block_buf)
2660                 ext2fs_free_mem(&block_buf);
2661         if (buffer)
2662                 ext2fs_free_mem(&buffer);
2663         if (b_entry_name)
2664                 ext2fs_free_mem(&b_entry_name);
2665
2666         return error;
2667 }