lib/ext2fs/ext_attr.c

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