fs/hfsplus/xattr.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * linux/fs/hfsplus/xattr.c
   4  *
   5  * Vyacheslav Dubeyko <slava@dubeyko.com>
   6  *
   7  * Logic of processing extended attributes
   8  */
   9
  10 #include "hfsplus_fs.h"
  11 #include <linux/nls.h>
  12 #include "xattr.h"
  13
  14 static int hfsplus_removexattr(struct inode *inode, const char *name);
  15
  16 const struct xattr_handler *hfsplus_xattr_handlers[] = {
  17         &hfsplus_xattr_osx_handler,
  18         &hfsplus_xattr_user_handler,
  19         &hfsplus_xattr_trusted_handler,
  20         &hfsplus_xattr_security_handler,
  21         NULL
  22 };
  23
  24 static int strcmp_xattr_finder_info(const char *name)
  25 {
  26         if (name) {
  27                 return strncmp(name, HFSPLUS_XATTR_FINDER_INFO_NAME,
  28                                 sizeof(HFSPLUS_XATTR_FINDER_INFO_NAME));
  29         }
  30         return -1;
  31 }
  32
  33 static int strcmp_xattr_acl(const char *name)
  34 {
  35         if (name) {
  36                 return strncmp(name, HFSPLUS_XATTR_ACL_NAME,
  37                                 sizeof(HFSPLUS_XATTR_ACL_NAME));
  38         }
  39         return -1;
  40 }
  41
  42 static bool is_known_namespace(const char *name)
  43 {
  44         if (strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN) &&
  45             strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) &&
  46             strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) &&
  47             strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN))
  48                 return false;
  49
  50         return true;
  51 }
  52
  53 static void hfsplus_init_header_node(struct inode *attr_file,
  54                                         u32 clump_size,
  55                                         char *buf, u16 node_size)
  56 {
  57         struct hfs_bnode_desc *desc;
  58         struct hfs_btree_header_rec *head;
  59         u16 offset;
  60         __be16 *rec_offsets;
  61         u32 hdr_node_map_rec_bits;
  62         char *bmp;
  63         u32 used_nodes;
  64         u32 used_bmp_bytes;
  65         u64 tmp;
  66
  67         hfs_dbg(ATTR_MOD, "init_hdr_attr_file: clump %u, node_size %u\n",
  68                 clump_size, node_size);
  69
  70         /* The end of the node contains list of record offsets */
  71         rec_offsets = (__be16 *)(buf + node_size);
  72
  73         desc = (struct hfs_bnode_desc *)buf;
  74         desc->type = HFS_NODE_HEADER;
  75         desc->num_recs = cpu_to_be16(HFSPLUS_BTREE_HDR_NODE_RECS_COUNT);
  76         offset = sizeof(struct hfs_bnode_desc);
  77         *--rec_offsets = cpu_to_be16(offset);
  78
  79         head = (struct hfs_btree_header_rec *)(buf + offset);
  80         head->node_size = cpu_to_be16(node_size);
  81         tmp = i_size_read(attr_file);
  82         do_div(tmp, node_size);
  83         head->node_count = cpu_to_be32(tmp);
  84         head->free_nodes = cpu_to_be32(be32_to_cpu(head->node_count) - 1);
  85         head->clump_size = cpu_to_be32(clump_size);
  86         head->attributes |= cpu_to_be32(HFS_TREE_BIGKEYS | HFS_TREE_VARIDXKEYS);
  87         head->max_key_len = cpu_to_be16(HFSPLUS_ATTR_KEYLEN - sizeof(u16));
  88         offset += sizeof(struct hfs_btree_header_rec);
  89         *--rec_offsets = cpu_to_be16(offset);
  90         offset += HFSPLUS_BTREE_HDR_USER_BYTES;
  91         *--rec_offsets = cpu_to_be16(offset);
  92
  93         hdr_node_map_rec_bits = 8 * (node_size - offset - (4 * sizeof(u16)));
  94         if (be32_to_cpu(head->node_count) > hdr_node_map_rec_bits) {
  95                 u32 map_node_bits;
  96                 u32 map_nodes;
  97
  98                 desc->next = cpu_to_be32(be32_to_cpu(head->leaf_tail) + 1);
  99                 map_node_bits = 8 * (node_size - sizeof(struct hfs_bnode_desc) -
 100                                         (2 * sizeof(u16)) - 2);
 101                 map_nodes = (be32_to_cpu(head->node_count) -
 102                                 hdr_node_map_rec_bits +
 103                                 (map_node_bits - 1)) / map_node_bits;
 104                 be32_add_cpu(&head->free_nodes, 0 - map_nodes);
 105         }
 106
 107         bmp = buf + offset;
 108         used_nodes =
 109                 be32_to_cpu(head->node_count) - be32_to_cpu(head->free_nodes);
 110         used_bmp_bytes = used_nodes / 8;
 111         if (used_bmp_bytes) {
 112                 memset(bmp, 0xFF, used_bmp_bytes);
 113                 bmp += used_bmp_bytes;
 114                 used_nodes %= 8;
 115         }
 116         *bmp = ~(0xFF >> used_nodes);
 117         offset += hdr_node_map_rec_bits / 8;
 118         *--rec_offsets = cpu_to_be16(offset);
 119 }
 120
 121 static int hfsplus_create_attributes_file(struct super_block *sb)
 122 {
 123         int err = 0;
 124         struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
 125         struct inode *attr_file;
 126         struct hfsplus_inode_info *hip;
 127         u32 clump_size;
 128         u16 node_size = HFSPLUS_ATTR_TREE_NODE_SIZE;
 129         char *buf;
 130         int index, written;
 131         struct address_space *mapping;
 132         struct page *page;
 133         int old_state = HFSPLUS_EMPTY_ATTR_TREE;
 134
 135         hfs_dbg(ATTR_MOD, "create_attr_file: ino %d\n", HFSPLUS_ATTR_CNID);
 136
 137 check_attr_tree_state_again:
 138         switch (atomic_read(&sbi->attr_tree_state)) {
 139         case HFSPLUS_EMPTY_ATTR_TREE:
 140                 if (old_state != atomic_cmpxchg(&sbi->attr_tree_state,
 141                                                 old_state,
 142                                                 HFSPLUS_CREATING_ATTR_TREE))
 143                         goto check_attr_tree_state_again;
 144                 break;
 145         case HFSPLUS_CREATING_ATTR_TREE:
 146                 /*
 147                  * This state means that another thread is in process
 148                  * of AttributesFile creation. Theoretically, it is
 149                  * possible to be here. But really __setxattr() method
 150                  * first of all calls hfs_find_init() for lookup in
 151                  * B-tree of CatalogFile. This method locks mutex of
 152                  * CatalogFile's B-tree. As a result, if some thread
 153                  * is inside AttributedFile creation operation then
 154                  * another threads will be waiting unlocking of
 155                  * CatalogFile's B-tree's mutex. However, if code will
 156                  * change then we will return error code (-EAGAIN) from
 157                  * here. Really, it means that first try to set of xattr
 158                  * fails with error but second attempt will have success.
 159                  */
 160                 return -EAGAIN;
 161         case HFSPLUS_VALID_ATTR_TREE:
 162                 return 0;
 163         case HFSPLUS_FAILED_ATTR_TREE:
 164                 return -EOPNOTSUPP;
 165         default:
 166                 BUG();
 167         }
 168
 169         attr_file = hfsplus_iget(sb, HFSPLUS_ATTR_CNID);
 170         if (IS_ERR(attr_file)) {
 171                 pr_err("failed to load attributes file\n");
 172                 return PTR_ERR(attr_file);
 173         }
 174
 175         BUG_ON(i_size_read(attr_file) != 0);
 176
 177         hip = HFSPLUS_I(attr_file);
 178
 179         clump_size = hfsplus_calc_btree_clump_size(sb->s_blocksize,
 180                                                     node_size,
 181                                                     sbi->sect_count,
 182                                                     HFSPLUS_ATTR_CNID);
 183
 184         mutex_lock(&hip->extents_lock);
 185         hip->clump_blocks = clump_size >> sbi->alloc_blksz_shift;
 186         mutex_unlock(&hip->extents_lock);
 187
 188         if (sbi->free_blocks <= (hip->clump_blocks << 1)) {
 189                 err = -ENOSPC;
 190                 goto end_attr_file_creation;
 191         }
 192
 193         while (hip->alloc_blocks < hip->clump_blocks) {
 194                 err = hfsplus_file_extend(attr_file, false);
 195                 if (unlikely(err)) {
 196                         pr_err("failed to extend attributes file\n");
 197                         goto end_attr_file_creation;
 198                 }
 199                 hip->phys_size = attr_file->i_size =
 200                         (loff_t)hip->alloc_blocks << sbi->alloc_blksz_shift;
 201                 hip->fs_blocks = hip->alloc_blocks << sbi->fs_shift;
 202                 inode_set_bytes(attr_file, attr_file->i_size);
 203         }
 204
 205         buf = kzalloc(node_size, GFP_NOFS);
 206         if (!buf) {
 207                 pr_err("failed to allocate memory for header node\n");
 208                 err = -ENOMEM;
 209                 goto end_attr_file_creation;
 210         }
 211
 212         hfsplus_init_header_node(attr_file, clump_size, buf, node_size);
 213
 214         mapping = attr_file->i_mapping;
 215
 216         index = 0;
 217         written = 0;
 218         for (; written < node_size; index++, written += PAGE_SIZE) {
 219                 void *kaddr;
 220
 221                 page = read_mapping_page(mapping, index, NULL);
 222                 if (IS_ERR(page)) {
 223                         err = PTR_ERR(page);
 224                         goto failed_header_node_init;
 225                 }
 226
 227                 kaddr = kmap_atomic(page);
 228                 memcpy(kaddr, buf + written,
 229                         min_t(size_t, PAGE_SIZE, node_size - written));
 230                 kunmap_atomic(kaddr);
 231
 232                 set_page_dirty(page);
 233                 put_page(page);
 234         }
 235
 236         hfsplus_mark_inode_dirty(attr_file, HFSPLUS_I_ATTR_DIRTY);
 237
 238         sbi->attr_tree = hfs_btree_open(sb, HFSPLUS_ATTR_CNID);
 239         if (!sbi->attr_tree)
 240                 pr_err("failed to load attributes file\n");
 241
 242 failed_header_node_init:
 243         kfree(buf);
 244
 245 end_attr_file_creation:
 246         iput(attr_file);
 247
 248         if (!err)
 249                 atomic_set(&sbi->attr_tree_state, HFSPLUS_VALID_ATTR_TREE);
 250         else if (err == -ENOSPC)
 251                 atomic_set(&sbi->attr_tree_state, HFSPLUS_EMPTY_ATTR_TREE);
 252         else
 253                 atomic_set(&sbi->attr_tree_state, HFSPLUS_FAILED_ATTR_TREE);
 254
 255         return err;
 256 }
 257
 258 int __hfsplus_setxattr(struct inode *inode, const char *name,
 259                         const void *value, size_t size, int flags)
 260 {
 261         int err = 0;
 262         struct hfs_find_data cat_fd;
 263         hfsplus_cat_entry entry;
 264         u16 cat_entry_flags, cat_entry_type;
 265         u16 folder_finderinfo_len = sizeof(struct DInfo) +
 266                                         sizeof(struct DXInfo);
 267         u16 file_finderinfo_len = sizeof(struct FInfo) +
 268                                         sizeof(struct FXInfo);
 269
 270         if ((!S_ISREG(inode->i_mode) &&
 271                         !S_ISDIR(inode->i_mode)) ||
 272                                 HFSPLUS_IS_RSRC(inode))
 273                 return -EOPNOTSUPP;
 274
 275         if (value == NULL)
 276                 return hfsplus_removexattr(inode, name);
 277
 278         err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &cat_fd);
 279         if (err) {
 280                 pr_err("can't init xattr find struct\n");
 281                 return err;
 282         }
 283
 284         err = hfsplus_find_cat(inode->i_sb, inode->i_ino, &cat_fd);
 285         if (err) {
 286                 pr_err("catalog searching failed\n");
 287                 goto end_setxattr;
 288         }
 289
 290         if (!strcmp_xattr_finder_info(name)) {
 291                 if (flags & XATTR_CREATE) {
 292                         pr_err("xattr exists yet\n");
 293                         err = -EOPNOTSUPP;
 294                         goto end_setxattr;
 295                 }
 296                 hfs_bnode_read(cat_fd.bnode, &entry, cat_fd.entryoffset,
 297                                         sizeof(hfsplus_cat_entry));
 298                 if (be16_to_cpu(entry.type) == HFSPLUS_FOLDER) {
 299                         if (size == folder_finderinfo_len) {
 300                                 memcpy(&entry.folder.user_info, value,
 301                                                 folder_finderinfo_len);
 302                                 hfs_bnode_write(cat_fd.bnode, &entry,
 303                                         cat_fd.entryoffset,
 304                                         sizeof(struct hfsplus_cat_folder));
 305                                 hfsplus_mark_inode_dirty(inode,
 306                                                 HFSPLUS_I_CAT_DIRTY);
 307                         } else {
 308                                 err = -ERANGE;
 309                                 goto end_setxattr;
 310                         }
 311                 } else if (be16_to_cpu(entry.type) == HFSPLUS_FILE) {
 312                         if (size == file_finderinfo_len) {
 313                                 memcpy(&entry.file.user_info, value,
 314                                                 file_finderinfo_len);
 315                                 hfs_bnode_write(cat_fd.bnode, &entry,
 316                                         cat_fd.entryoffset,
 317                                         sizeof(struct hfsplus_cat_file));
 318                                 hfsplus_mark_inode_dirty(inode,
 319                                                 HFSPLUS_I_CAT_DIRTY);
 320                         } else {
 321                                 err = -ERANGE;
 322                                 goto end_setxattr;
 323                         }
 324                 } else {
 325                         err = -EOPNOTSUPP;
 326                         goto end_setxattr;
 327                 }
 328                 goto end_setxattr;
 329         }
 330
 331         if (!HFSPLUS_SB(inode->i_sb)->attr_tree) {
 332                 err = hfsplus_create_attributes_file(inode->i_sb);
 333                 if (unlikely(err))
 334                         goto end_setxattr;
 335         }
 336
 337         if (hfsplus_attr_exists(inode, name)) {
 338                 if (flags & XATTR_CREATE) {
 339                         pr_err("xattr exists yet\n");
 340                         err = -EOPNOTSUPP;
 341                         goto end_setxattr;
 342                 }
 343                 err = hfsplus_delete_attr(inode, name);
 344                 if (err)
 345                         goto end_setxattr;
 346                 err = hfsplus_create_attr(inode, name, value, size);
 347                 if (err)
 348                         goto end_setxattr;
 349         } else {
 350                 if (flags & XATTR_REPLACE) {
 351                         pr_err("cannot replace xattr\n");
 352                         err = -EOPNOTSUPP;
 353                         goto end_setxattr;
 354                 }
 355                 err = hfsplus_create_attr(inode, name, value, size);
 356                 if (err)
 357                         goto end_setxattr;
 358         }
 359
 360         cat_entry_type = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset);
 361         if (cat_entry_type == HFSPLUS_FOLDER) {
 362                 cat_entry_flags = hfs_bnode_read_u16(cat_fd.bnode,
 363                                     cat_fd.entryoffset +
 364                                     offsetof(struct hfsplus_cat_folder, flags));
 365                 cat_entry_flags |= HFSPLUS_XATTR_EXISTS;
 366                 if (!strcmp_xattr_acl(name))
 367                         cat_entry_flags |= HFSPLUS_ACL_EXISTS;
 368                 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset +
 369                                 offsetof(struct hfsplus_cat_folder, flags),
 370                                 cat_entry_flags);
 371                 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
 372         } else if (cat_entry_type == HFSPLUS_FILE) {
 373                 cat_entry_flags = hfs_bnode_read_u16(cat_fd.bnode,
 374                                     cat_fd.entryoffset +
 375                                     offsetof(struct hfsplus_cat_file, flags));
 376                 cat_entry_flags |= HFSPLUS_XATTR_EXISTS;
 377                 if (!strcmp_xattr_acl(name))
 378                         cat_entry_flags |= HFSPLUS_ACL_EXISTS;
 379                 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset +
 380                                     offsetof(struct hfsplus_cat_file, flags),
 381                                     cat_entry_flags);
 382                 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
 383         } else {
 384                 pr_err("invalid catalog entry type\n");
 385                 err = -EIO;
 386                 goto end_setxattr;
 387         }
 388
 389 end_setxattr:
 390         hfs_find_exit(&cat_fd);
 391         return err;
 392 }
 393
 394 static int name_len(const char *xattr_name, int xattr_name_len)
 395 {
 396         int len = xattr_name_len + 1;
 397
 398         if (!is_known_namespace(xattr_name))
 399                 len += XATTR_MAC_OSX_PREFIX_LEN;
 400
 401         return len;
 402 }
 403
 404 static int copy_name(char *buffer, const char *xattr_name, int name_len)
 405 {
 406         int len = name_len;
 407         int offset = 0;
 408
 409         if (!is_known_namespace(xattr_name)) {
 410                 strncpy(buffer, XATTR_MAC_OSX_PREFIX, XATTR_MAC_OSX_PREFIX_LEN);
 411                 offset += XATTR_MAC_OSX_PREFIX_LEN;
 412                 len += XATTR_MAC_OSX_PREFIX_LEN;
 413         }
 414
 415         strncpy(buffer + offset, xattr_name, name_len);
 416         memset(buffer + offset + name_len, 0, 1);
 417         len += 1;
 418
 419         return len;
 420 }
 421
 422 int hfsplus_setxattr(struct inode *inode, const char *name,
 423                      const void *value, size_t size, int flags,
 424                      const char *prefix, size_t prefixlen)
 425 {
 426         char *xattr_name;
 427         int res;
 428
 429         xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 1,
 430                 GFP_KERNEL);
 431         if (!xattr_name)
 432                 return -ENOMEM;
 433         strcpy(xattr_name, prefix);
 434         strcpy(xattr_name + prefixlen, name);
 435         res = __hfsplus_setxattr(inode, xattr_name, value, size, flags);
 436         kfree(xattr_name);
 437         return res;
 438 }
 439
 440 static ssize_t hfsplus_getxattr_finder_info(struct inode *inode,
 441                                                 void *value, size_t size)
 442 {
 443         ssize_t res = 0;
 444         struct hfs_find_data fd;
 445         u16 entry_type;
 446         u16 folder_rec_len = sizeof(struct DInfo) + sizeof(struct DXInfo);
 447         u16 file_rec_len = sizeof(struct FInfo) + sizeof(struct FXInfo);
 448         u16 record_len = max(folder_rec_len, file_rec_len);
 449         u8 folder_finder_info[sizeof(struct DInfo) + sizeof(struct DXInfo)];
 450         u8 file_finder_info[sizeof(struct FInfo) + sizeof(struct FXInfo)];
 451
 452         if (size >= record_len) {
 453                 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
 454                 if (res) {
 455                         pr_err("can't init xattr find struct\n");
 456                         return res;
 457                 }
 458                 res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
 459                 if (res)
 460                         goto end_getxattr_finder_info;
 461                 entry_type = hfs_bnode_read_u16(fd.bnode, fd.entryoffset);
 462
 463                 if (entry_type == HFSPLUS_FOLDER) {
 464                         hfs_bnode_read(fd.bnode, folder_finder_info,
 465                                 fd.entryoffset +
 466                                 offsetof(struct hfsplus_cat_folder, user_info),
 467                                 folder_rec_len);
 468                         memcpy(value, folder_finder_info, folder_rec_len);
 469                         res = folder_rec_len;
 470                 } else if (entry_type == HFSPLUS_FILE) {
 471                         hfs_bnode_read(fd.bnode, file_finder_info,
 472                                 fd.entryoffset +
 473                                 offsetof(struct hfsplus_cat_file, user_info),
 474                                 file_rec_len);
 475                         memcpy(value, file_finder_info, file_rec_len);
 476                         res = file_rec_len;
 477                 } else {
 478                         res = -EOPNOTSUPP;
 479                         goto end_getxattr_finder_info;
 480                 }
 481         } else
 482                 res = size ? -ERANGE : record_len;
 483
 484 end_getxattr_finder_info:
 485         if (size >= record_len)
 486                 hfs_find_exit(&fd);
 487         return res;
 488 }
 489
 490 ssize_t __hfsplus_getxattr(struct inode *inode, const char *name,
 491                          void *value, size_t size)
 492 {
 493         struct hfs_find_data fd;
 494         hfsplus_attr_entry *entry;
 495         __be32 xattr_record_type;
 496         u32 record_type;
 497         u16 record_length = 0;
 498         ssize_t res = 0;
 499
 500         if ((!S_ISREG(inode->i_mode) &&
 501                         !S_ISDIR(inode->i_mode)) ||
 502                                 HFSPLUS_IS_RSRC(inode))
 503                 return -EOPNOTSUPP;
 504
 505         if (!strcmp_xattr_finder_info(name))
 506                 return hfsplus_getxattr_finder_info(inode, value, size);
 507
 508         if (!HFSPLUS_SB(inode->i_sb)->attr_tree)
 509                 return -EOPNOTSUPP;
 510
 511         entry = hfsplus_alloc_attr_entry();
 512         if (!entry) {
 513                 pr_err("can't allocate xattr entry\n");
 514                 return -ENOMEM;
 515         }
 516
 517         res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->attr_tree, &fd);
 518         if (res) {
 519                 pr_err("can't init xattr find struct\n");
 520                 goto failed_getxattr_init;
 521         }
 522
 523         res = hfsplus_find_attr(inode->i_sb, inode->i_ino, name, &fd);
 524         if (res) {
 525                 if (res == -ENOENT)
 526                         res = -ENODATA;
 527                 else
 528                         pr_err("xattr searching failed\n");
 529                 goto out;
 530         }
 531
 532         hfs_bnode_read(fd.bnode, &xattr_record_type,
 533                         fd.entryoffset, sizeof(xattr_record_type));
 534         record_type = be32_to_cpu(xattr_record_type);
 535         if (record_type == HFSPLUS_ATTR_INLINE_DATA) {
 536                 record_length = hfs_bnode_read_u16(fd.bnode,
 537                                 fd.entryoffset +
 538                                 offsetof(struct hfsplus_attr_inline_data,
 539                                 length));
 540                 if (record_length > HFSPLUS_MAX_INLINE_DATA_SIZE) {
 541                         pr_err("invalid xattr record size\n");
 542                         res = -EIO;
 543                         goto out;
 544                 }
 545         } else if (record_type == HFSPLUS_ATTR_FORK_DATA ||
 546                         record_type == HFSPLUS_ATTR_EXTENTS) {
 547                 pr_err("only inline data xattr are supported\n");
 548                 res = -EOPNOTSUPP;
 549                 goto out;
 550         } else {
 551                 pr_err("invalid xattr record\n");
 552                 res = -EIO;
 553                 goto out;
 554         }
 555
 556         if (size) {
 557                 hfs_bnode_read(fd.bnode, entry, fd.entryoffset,
 558                                 offsetof(struct hfsplus_attr_inline_data,
 559                                         raw_bytes) + record_length);
 560         }
 561
 562         if (size >= record_length) {
 563                 memcpy(value, entry->inline_data.raw_bytes, record_length);
 564                 res = record_length;
 565         } else
 566                 res = size ? -ERANGE : record_length;
 567
 568 out:
 569         hfs_find_exit(&fd);
 570
 571 failed_getxattr_init:
 572         hfsplus_destroy_attr_entry(entry);
 573         return res;
 574 }
 575
 576 ssize_t hfsplus_getxattr(struct inode *inode, const char *name,
 577                          void *value, size_t size,
 578                          const char *prefix, size_t prefixlen)
 579 {
 580         int res;
 581         char *xattr_name;
 582
 583         xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 1,
 584                              GFP_KERNEL);
 585         if (!xattr_name)
 586                 return -ENOMEM;
 587
 588         strcpy(xattr_name, prefix);
 589         strcpy(xattr_name + prefixlen, name);
 590
 591         res = __hfsplus_getxattr(inode, xattr_name, value, size);
 592         kfree(xattr_name);
 593         return res;
 594
 595 }
 596
 597 static inline int can_list(const char *xattr_name)
 598 {
 599         if (!xattr_name)
 600                 return 0;
 601
 602         return strncmp(xattr_name, XATTR_TRUSTED_PREFIX,
 603                         XATTR_TRUSTED_PREFIX_LEN) ||
 604                                 capable(CAP_SYS_ADMIN);
 605 }
 606
 607 static ssize_t hfsplus_listxattr_finder_info(struct dentry *dentry,
 608                                                 char *buffer, size_t size)
 609 {
 610         ssize_t res = 0;
 611         struct inode *inode = d_inode(dentry);
 612         struct hfs_find_data fd;
 613         u16 entry_type;
 614         u8 folder_finder_info[sizeof(struct DInfo) + sizeof(struct DXInfo)];
 615         u8 file_finder_info[sizeof(struct FInfo) + sizeof(struct FXInfo)];
 616         unsigned long len, found_bit;
 617         int xattr_name_len, symbols_count;
 618
 619         res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
 620         if (res) {
 621                 pr_err("can't init xattr find struct\n");
 622                 return res;
 623         }
 624
 625         res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
 626         if (res)
 627                 goto end_listxattr_finder_info;
 628
 629         entry_type = hfs_bnode_read_u16(fd.bnode, fd.entryoffset);
 630         if (entry_type == HFSPLUS_FOLDER) {
 631                 len = sizeof(struct DInfo) + sizeof(struct DXInfo);
 632                 hfs_bnode_read(fd.bnode, folder_finder_info,
 633                                 fd.entryoffset +
 634                                 offsetof(struct hfsplus_cat_folder, user_info),
 635                                 len);
 636                 found_bit = find_first_bit((void *)folder_finder_info, len*8);
 637         } else if (entry_type == HFSPLUS_FILE) {
 638                 len = sizeof(struct FInfo) + sizeof(struct FXInfo);
 639                 hfs_bnode_read(fd.bnode, file_finder_info,
 640                                 fd.entryoffset +
 641                                 offsetof(struct hfsplus_cat_file, user_info),
 642                                 len);
 643                 found_bit = find_first_bit((void *)file_finder_info, len*8);
 644         } else {
 645                 res = -EOPNOTSUPP;
 646                 goto end_listxattr_finder_info;
 647         }
 648
 649         if (found_bit >= (len*8))
 650                 res = 0;
 651         else {
 652                 symbols_count = sizeof(HFSPLUS_XATTR_FINDER_INFO_NAME) - 1;
 653                 xattr_name_len =
 654                         name_len(HFSPLUS_XATTR_FINDER_INFO_NAME, symbols_count);
 655                 if (!buffer || !size) {
 656                         if (can_list(HFSPLUS_XATTR_FINDER_INFO_NAME))
 657                                 res = xattr_name_len;
 658                 } else if (can_list(HFSPLUS_XATTR_FINDER_INFO_NAME)) {
 659                         if (size < xattr_name_len)
 660                                 res = -ERANGE;
 661                         else {
 662                                 res = copy_name(buffer,
 663                                                 HFSPLUS_XATTR_FINDER_INFO_NAME,
 664                                                 symbols_count);
 665                         }
 666                 }
 667         }
 668
 669 end_listxattr_finder_info:
 670         hfs_find_exit(&fd);
 671
 672         return res;
 673 }
 674
 675 ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size)
 676 {
 677         ssize_t err;
 678         ssize_t res = 0;
 679         struct inode *inode = d_inode(dentry);
 680         struct hfs_find_data fd;
 681         u16 key_len = 0;
 682         struct hfsplus_attr_key attr_key;
 683         char *strbuf;
 684         int xattr_name_len;
 685
 686         if ((!S_ISREG(inode->i_mode) &&
 687                         !S_ISDIR(inode->i_mode)) ||
 688                                 HFSPLUS_IS_RSRC(inode))
 689                 return -EOPNOTSUPP;
 690
 691         res = hfsplus_listxattr_finder_info(dentry, buffer, size);
 692         if (res < 0)
 693                 return res;
 694         else if (!HFSPLUS_SB(inode->i_sb)->attr_tree)
 695                 return (res == 0) ? -EOPNOTSUPP : res;
 696
 697         err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->attr_tree, &fd);
 698         if (err) {
 699                 pr_err("can't init xattr find struct\n");
 700                 return err;
 701         }
 702
 703         strbuf = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN +
 704                         XATTR_MAC_OSX_PREFIX_LEN + 1, GFP_KERNEL);
 705         if (!strbuf) {
 706                 res = -ENOMEM;
 707                 goto out;
 708         }
 709
 710         err = hfsplus_find_attr(inode->i_sb, inode->i_ino, NULL, &fd);
 711         if (err) {
 712                 if (err == -ENOENT) {
 713                         if (res == 0)
 714                                 res = -ENODATA;
 715                         goto end_listxattr;
 716                 } else {
 717                         res = err;
 718                         goto end_listxattr;
 719                 }
 720         }
 721
 722         for (;;) {
 723                 key_len = hfs_bnode_read_u16(fd.bnode, fd.keyoffset);
 724                 if (key_len == 0 || key_len > fd.tree->max_key_len) {
 725                         pr_err("invalid xattr key length: %d\n", key_len);
 726                         res = -EIO;
 727                         goto end_listxattr;
 728                 }
 729
 730                 hfs_bnode_read(fd.bnode, &attr_key,
 731                                 fd.keyoffset, key_len + sizeof(key_len));
 732
 733                 if (be32_to_cpu(attr_key.cnid) != inode->i_ino)
 734                         goto end_listxattr;
 735
 736                 xattr_name_len = NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN;
 737                 if (hfsplus_uni2asc(inode->i_sb,
 738                         (const struct hfsplus_unistr *)&fd.key->attr.key_name,
 739                                         strbuf, &xattr_name_len)) {
 740                         pr_err("unicode conversion failed\n");
 741                         res = -EIO;
 742                         goto end_listxattr;
 743                 }
 744
 745                 if (!buffer || !size) {
 746                         if (can_list(strbuf))
 747                                 res += name_len(strbuf, xattr_name_len);
 748                 } else if (can_list(strbuf)) {
 749                         if (size < (res + name_len(strbuf, xattr_name_len))) {
 750                                 res = -ERANGE;
 751                                 goto end_listxattr;
 752                         } else
 753                                 res += copy_name(buffer + res,
 754                                                 strbuf, xattr_name_len);
 755                 }
 756
 757                 if (hfs_brec_goto(&fd, 1))
 758                         goto end_listxattr;
 759         }
 760
 761 end_listxattr:
 762         kfree(strbuf);
 763 out:
 764         hfs_find_exit(&fd);
 765         return res;
 766 }
 767
 768 static int hfsplus_removexattr(struct inode *inode, const char *name)
 769 {
 770         int err = 0;
 771         struct hfs_find_data cat_fd;
 772         u16 flags;
 773         u16 cat_entry_type;
 774         int is_xattr_acl_deleted = 0;
 775         int is_all_xattrs_deleted = 0;
 776
 777         if (!HFSPLUS_SB(inode->i_sb)->attr_tree)
 778                 return -EOPNOTSUPP;
 779
 780         if (!strcmp_xattr_finder_info(name))
 781                 return -EOPNOTSUPP;
 782
 783         err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &cat_fd);
 784         if (err) {
 785                 pr_err("can't init xattr find struct\n");
 786                 return err;
 787         }
 788
 789         err = hfsplus_find_cat(inode->i_sb, inode->i_ino, &cat_fd);
 790         if (err) {
 791                 pr_err("catalog searching failed\n");
 792                 goto end_removexattr;
 793         }
 794
 795         err = hfsplus_delete_attr(inode, name);
 796         if (err)
 797                 goto end_removexattr;
 798
 799         is_xattr_acl_deleted = !strcmp_xattr_acl(name);
 800         is_all_xattrs_deleted = !hfsplus_attr_exists(inode, NULL);
 801
 802         if (!is_xattr_acl_deleted && !is_all_xattrs_deleted)
 803                 goto end_removexattr;
 804
 805         cat_entry_type = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset);
 806
 807         if (cat_entry_type == HFSPLUS_FOLDER) {
 808                 flags = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset +
 809                                 offsetof(struct hfsplus_cat_folder, flags));
 810                 if (is_xattr_acl_deleted)
 811                         flags &= ~HFSPLUS_ACL_EXISTS;
 812                 if (is_all_xattrs_deleted)
 813                         flags &= ~HFSPLUS_XATTR_EXISTS;
 814                 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset +
 815                                 offsetof(struct hfsplus_cat_folder, flags),
 816                                 flags);
 817                 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
 818         } else if (cat_entry_type == HFSPLUS_FILE) {
 819                 flags = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset +
 820                                 offsetof(struct hfsplus_cat_file, flags));
 821                 if (is_xattr_acl_deleted)
 822                         flags &= ~HFSPLUS_ACL_EXISTS;
 823                 if (is_all_xattrs_deleted)
 824                         flags &= ~HFSPLUS_XATTR_EXISTS;
 825                 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset +
 826                                 offsetof(struct hfsplus_cat_file, flags),
 827                                 flags);
 828                 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
 829         } else {
 830                 pr_err("invalid catalog entry type\n");
 831                 err = -EIO;
 832                 goto end_removexattr;
 833         }
 834
 835 end_removexattr:
 836         hfs_find_exit(&cat_fd);
 837         return err;
 838 }
 839
 840 static int hfsplus_osx_getxattr(const struct xattr_handler *handler,
 841                                 struct dentry *unused, struct inode *inode,
 842                                 const char *name, void *buffer, size_t size)
 843 {
 844         /*
 845          * Don't allow retrieving properly prefixed attributes
 846          * by prepending them with "osx."
 847          */
 848         if (is_known_namespace(name))
 849                 return -EOPNOTSUPP;
 850
 851         /*
 852          * osx is the namespace we use to indicate an unprefixed
 853          * attribute on the filesystem (like the ones that OS X
 854          * creates), so we pass the name through unmodified (after
 855          * ensuring it doesn't conflict with another namespace).
 856          */
 857         return __hfsplus_getxattr(inode, name, buffer, size);
 858 }
 859
 860 static int hfsplus_osx_setxattr(const struct xattr_handler *handler,
 861                                 struct dentry *unused, struct inode *inode,
 862                                 const char *name, const void *buffer,
 863                                 size_t size, int flags)
 864 {
 865         /*
 866          * Don't allow setting properly prefixed attributes
 867          * by prepending them with "osx."
 868          */
 869         if (is_known_namespace(name))
 870                 return -EOPNOTSUPP;
 871
 872         /*
 873          * osx is the namespace we use to indicate an unprefixed
 874          * attribute on the filesystem (like the ones that OS X
 875          * creates), so we pass the name through unmodified (after
 876          * ensuring it doesn't conflict with another namespace).
 877          */
 878         return __hfsplus_setxattr(inode, name, buffer, size, flags);
 879 }
 880
 881 const struct xattr_handler hfsplus_xattr_osx_handler = {
 882         .prefix = XATTR_MAC_OSX_PREFIX,
 883         .get    = hfsplus_osx_getxattr,
 884         .set    = hfsplus_osx_setxattr,
 885 };