1
2
3
4
5
6
7
8
9#include "hfsplus_fs.h"
10#include "xattr.h"
11#include "acl.h"
12
13const struct xattr_handler *hfsplus_xattr_handlers[] = {
14 &hfsplus_xattr_osx_handler,
15 &hfsplus_xattr_user_handler,
16 &hfsplus_xattr_trusted_handler,
17#ifdef CONFIG_HFSPLUS_FS_POSIX_ACL
18 &hfsplus_xattr_acl_access_handler,
19 &hfsplus_xattr_acl_default_handler,
20#endif
21 &hfsplus_xattr_security_handler,
22 NULL
23};
24
25static int strcmp_xattr_finder_info(const char *name)
26{
27 if (name) {
28 return strncmp(name, HFSPLUS_XATTR_FINDER_INFO_NAME,
29 sizeof(HFSPLUS_XATTR_FINDER_INFO_NAME));
30 }
31 return -1;
32}
33
34static int strcmp_xattr_acl(const char *name)
35{
36 if (name) {
37 return strncmp(name, HFSPLUS_XATTR_ACL_NAME,
38 sizeof(HFSPLUS_XATTR_ACL_NAME));
39 }
40 return -1;
41}
42
43static inline int is_known_namespace(const char *name)
44{
45 if (strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN) &&
46 strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) &&
47 strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) &&
48 strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN))
49 return false;
50
51 return true;
52}
53
54static int can_set_system_xattr(struct inode *inode, const char *name,
55 const void *value, size_t size)
56{
57#ifdef CONFIG_HFSPLUS_FS_POSIX_ACL
58 struct posix_acl *acl;
59 int err;
60
61 if (!inode_owner_or_capable(inode))
62 return -EPERM;
63
64
65
66
67 if (strcmp(name, POSIX_ACL_XATTR_ACCESS) == 0) {
68 acl = posix_acl_from_xattr(&init_user_ns, value, size);
69 if (IS_ERR(acl))
70 return PTR_ERR(acl);
71 if (acl) {
72 err = posix_acl_equiv_mode(acl, &inode->i_mode);
73 posix_acl_release(acl);
74 if (err < 0)
75 return err;
76 mark_inode_dirty(inode);
77 }
78
79
80
81 forget_cached_acl(inode, ACL_TYPE_ACCESS);
82
83 return 0;
84 } else if (strcmp(name, POSIX_ACL_XATTR_DEFAULT) == 0) {
85 acl = posix_acl_from_xattr(&init_user_ns, value, size);
86 if (IS_ERR(acl))
87 return PTR_ERR(acl);
88 posix_acl_release(acl);
89
90
91
92
93 forget_cached_acl(inode, ACL_TYPE_DEFAULT);
94
95 return 0;
96 }
97#endif
98 return -EOPNOTSUPP;
99}
100
101static int can_set_xattr(struct inode *inode, const char *name,
102 const void *value, size_t value_len)
103{
104 if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
105 return can_set_system_xattr(inode, name, value, value_len);
106
107 if (!strncmp(name, XATTR_MAC_OSX_PREFIX, XATTR_MAC_OSX_PREFIX_LEN)) {
108
109
110
111
112
113 if (is_known_namespace(name + XATTR_MAC_OSX_PREFIX_LEN))
114 return -EOPNOTSUPP;
115
116 return 0;
117 }
118
119
120
121
122 if (strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) &&
123 strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) &&
124 strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN))
125 return -EOPNOTSUPP;
126
127 return 0;
128}
129
130int __hfsplus_setxattr(struct inode *inode, const char *name,
131 const void *value, size_t size, int flags)
132{
133 int err = 0;
134 struct hfs_find_data cat_fd;
135 hfsplus_cat_entry entry;
136 u16 cat_entry_flags, cat_entry_type;
137 u16 folder_finderinfo_len = sizeof(struct DInfo) +
138 sizeof(struct DXInfo);
139 u16 file_finderinfo_len = sizeof(struct FInfo) +
140 sizeof(struct FXInfo);
141
142 if ((!S_ISREG(inode->i_mode) &&
143 !S_ISDIR(inode->i_mode)) ||
144 HFSPLUS_IS_RSRC(inode))
145 return -EOPNOTSUPP;
146
147 err = can_set_xattr(inode, name, value, size);
148 if (err)
149 return err;
150
151 if (strncmp(name, XATTR_MAC_OSX_PREFIX,
152 XATTR_MAC_OSX_PREFIX_LEN) == 0)
153 name += XATTR_MAC_OSX_PREFIX_LEN;
154
155 if (value == NULL) {
156 value = "";
157 size = 0;
158 }
159
160 err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &cat_fd);
161 if (err) {
162 pr_err("can't init xattr find struct\n");
163 return err;
164 }
165
166 err = hfsplus_find_cat(inode->i_sb, inode->i_ino, &cat_fd);
167 if (err) {
168 pr_err("catalog searching failed\n");
169 goto end_setxattr;
170 }
171
172 if (!strcmp_xattr_finder_info(name)) {
173 if (flags & XATTR_CREATE) {
174 pr_err("xattr exists yet\n");
175 err = -EOPNOTSUPP;
176 goto end_setxattr;
177 }
178 hfs_bnode_read(cat_fd.bnode, &entry, cat_fd.entryoffset,
179 sizeof(hfsplus_cat_entry));
180 if (be16_to_cpu(entry.type) == HFSPLUS_FOLDER) {
181 if (size == folder_finderinfo_len) {
182 memcpy(&entry.folder.user_info, value,
183 folder_finderinfo_len);
184 hfs_bnode_write(cat_fd.bnode, &entry,
185 cat_fd.entryoffset,
186 sizeof(struct hfsplus_cat_folder));
187 hfsplus_mark_inode_dirty(inode,
188 HFSPLUS_I_CAT_DIRTY);
189 } else {
190 err = -ERANGE;
191 goto end_setxattr;
192 }
193 } else if (be16_to_cpu(entry.type) == HFSPLUS_FILE) {
194 if (size == file_finderinfo_len) {
195 memcpy(&entry.file.user_info, value,
196 file_finderinfo_len);
197 hfs_bnode_write(cat_fd.bnode, &entry,
198 cat_fd.entryoffset,
199 sizeof(struct hfsplus_cat_file));
200 hfsplus_mark_inode_dirty(inode,
201 HFSPLUS_I_CAT_DIRTY);
202 } else {
203 err = -ERANGE;
204 goto end_setxattr;
205 }
206 } else {
207 err = -EOPNOTSUPP;
208 goto end_setxattr;
209 }
210 goto end_setxattr;
211 }
212
213 if (!HFSPLUS_SB(inode->i_sb)->attr_tree) {
214 err = -EOPNOTSUPP;
215 goto end_setxattr;
216 }
217
218 if (hfsplus_attr_exists(inode, name)) {
219 if (flags & XATTR_CREATE) {
220 pr_err("xattr exists yet\n");
221 err = -EOPNOTSUPP;
222 goto end_setxattr;
223 }
224 err = hfsplus_delete_attr(inode, name);
225 if (err)
226 goto end_setxattr;
227 err = hfsplus_create_attr(inode, name, value, size);
228 if (err)
229 goto end_setxattr;
230 } else {
231 if (flags & XATTR_REPLACE) {
232 pr_err("cannot replace xattr\n");
233 err = -EOPNOTSUPP;
234 goto end_setxattr;
235 }
236 err = hfsplus_create_attr(inode, name, value, size);
237 if (err)
238 goto end_setxattr;
239 }
240
241 cat_entry_type = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset);
242 if (cat_entry_type == HFSPLUS_FOLDER) {
243 cat_entry_flags = hfs_bnode_read_u16(cat_fd.bnode,
244 cat_fd.entryoffset +
245 offsetof(struct hfsplus_cat_folder, flags));
246 cat_entry_flags |= HFSPLUS_XATTR_EXISTS;
247 if (!strcmp_xattr_acl(name))
248 cat_entry_flags |= HFSPLUS_ACL_EXISTS;
249 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset +
250 offsetof(struct hfsplus_cat_folder, flags),
251 cat_entry_flags);
252 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
253 } else if (cat_entry_type == HFSPLUS_FILE) {
254 cat_entry_flags = hfs_bnode_read_u16(cat_fd.bnode,
255 cat_fd.entryoffset +
256 offsetof(struct hfsplus_cat_file, flags));
257 cat_entry_flags |= HFSPLUS_XATTR_EXISTS;
258 if (!strcmp_xattr_acl(name))
259 cat_entry_flags |= HFSPLUS_ACL_EXISTS;
260 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset +
261 offsetof(struct hfsplus_cat_file, flags),
262 cat_entry_flags);
263 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
264 } else {
265 pr_err("invalid catalog entry type\n");
266 err = -EIO;
267 goto end_setxattr;
268 }
269
270end_setxattr:
271 hfs_find_exit(&cat_fd);
272 return err;
273}
274
275static inline int is_osx_xattr(const char *xattr_name)
276{
277 return !is_known_namespace(xattr_name);
278}
279
280static int name_len(const char *xattr_name, int xattr_name_len)
281{
282 int len = xattr_name_len + 1;
283
284 if (is_osx_xattr(xattr_name))
285 len += XATTR_MAC_OSX_PREFIX_LEN;
286
287 return len;
288}
289
290static int copy_name(char *buffer, const char *xattr_name, int name_len)
291{
292 int len = name_len;
293 int offset = 0;
294
295 if (is_osx_xattr(xattr_name)) {
296 strncpy(buffer, XATTR_MAC_OSX_PREFIX, XATTR_MAC_OSX_PREFIX_LEN);
297 offset += XATTR_MAC_OSX_PREFIX_LEN;
298 len += XATTR_MAC_OSX_PREFIX_LEN;
299 }
300
301 strncpy(buffer + offset, xattr_name, name_len);
302 memset(buffer + offset + name_len, 0, 1);
303 len += 1;
304
305 return len;
306}
307
308static ssize_t hfsplus_getxattr_finder_info(struct inode *inode,
309 void *value, size_t size)
310{
311 ssize_t res = 0;
312 struct hfs_find_data fd;
313 u16 entry_type;
314 u16 folder_rec_len = sizeof(struct DInfo) + sizeof(struct DXInfo);
315 u16 file_rec_len = sizeof(struct FInfo) + sizeof(struct FXInfo);
316 u16 record_len = max(folder_rec_len, file_rec_len);
317 u8 folder_finder_info[sizeof(struct DInfo) + sizeof(struct DXInfo)];
318 u8 file_finder_info[sizeof(struct FInfo) + sizeof(struct FXInfo)];
319
320 if (size >= record_len) {
321 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
322 if (res) {
323 pr_err("can't init xattr find struct\n");
324 return res;
325 }
326 res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
327 if (res)
328 goto end_getxattr_finder_info;
329 entry_type = hfs_bnode_read_u16(fd.bnode, fd.entryoffset);
330
331 if (entry_type == HFSPLUS_FOLDER) {
332 hfs_bnode_read(fd.bnode, folder_finder_info,
333 fd.entryoffset +
334 offsetof(struct hfsplus_cat_folder, user_info),
335 folder_rec_len);
336 memcpy(value, folder_finder_info, folder_rec_len);
337 res = folder_rec_len;
338 } else if (entry_type == HFSPLUS_FILE) {
339 hfs_bnode_read(fd.bnode, file_finder_info,
340 fd.entryoffset +
341 offsetof(struct hfsplus_cat_file, user_info),
342 file_rec_len);
343 memcpy(value, file_finder_info, file_rec_len);
344 res = file_rec_len;
345 } else {
346 res = -EOPNOTSUPP;
347 goto end_getxattr_finder_info;
348 }
349 } else
350 res = size ? -ERANGE : record_len;
351
352end_getxattr_finder_info:
353 if (size >= record_len)
354 hfs_find_exit(&fd);
355 return res;
356}
357
358ssize_t __hfsplus_getxattr(struct inode *inode, const char *name,
359 void *value, size_t size)
360{
361 struct hfs_find_data fd;
362 hfsplus_attr_entry *entry;
363 __be32 xattr_record_type;
364 u32 record_type;
365 u16 record_length = 0;
366 ssize_t res = 0;
367
368 if ((!S_ISREG(inode->i_mode) &&
369 !S_ISDIR(inode->i_mode)) ||
370 HFSPLUS_IS_RSRC(inode))
371 return -EOPNOTSUPP;
372
373 if (strncmp(name, XATTR_MAC_OSX_PREFIX,
374 XATTR_MAC_OSX_PREFIX_LEN) == 0) {
375
376 name += XATTR_MAC_OSX_PREFIX_LEN;
377
378
379
380
381 if (is_known_namespace(name))
382 return -EOPNOTSUPP;
383 }
384
385 if (!strcmp_xattr_finder_info(name))
386 return hfsplus_getxattr_finder_info(inode, value, size);
387
388 if (!HFSPLUS_SB(inode->i_sb)->attr_tree)
389 return -EOPNOTSUPP;
390
391 entry = hfsplus_alloc_attr_entry();
392 if (!entry) {
393 pr_err("can't allocate xattr entry\n");
394 return -ENOMEM;
395 }
396
397 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->attr_tree, &fd);
398 if (res) {
399 pr_err("can't init xattr find struct\n");
400 goto failed_getxattr_init;
401 }
402
403 res = hfsplus_find_attr(inode->i_sb, inode->i_ino, name, &fd);
404 if (res) {
405 if (res == -ENOENT)
406 res = -ENODATA;
407 else
408 pr_err("xattr searching failed\n");
409 goto out;
410 }
411
412 hfs_bnode_read(fd.bnode, &xattr_record_type,
413 fd.entryoffset, sizeof(xattr_record_type));
414 record_type = be32_to_cpu(xattr_record_type);
415 if (record_type == HFSPLUS_ATTR_INLINE_DATA) {
416 record_length = hfs_bnode_read_u16(fd.bnode,
417 fd.entryoffset +
418 offsetof(struct hfsplus_attr_inline_data,
419 length));
420 if (record_length > HFSPLUS_MAX_INLINE_DATA_SIZE) {
421 pr_err("invalid xattr record size\n");
422 res = -EIO;
423 goto out;
424 }
425 } else if (record_type == HFSPLUS_ATTR_FORK_DATA ||
426 record_type == HFSPLUS_ATTR_EXTENTS) {
427 pr_err("only inline data xattr are supported\n");
428 res = -EOPNOTSUPP;
429 goto out;
430 } else {
431 pr_err("invalid xattr record\n");
432 res = -EIO;
433 goto out;
434 }
435
436 if (size) {
437 hfs_bnode_read(fd.bnode, entry, fd.entryoffset,
438 offsetof(struct hfsplus_attr_inline_data,
439 raw_bytes) + record_length);
440 }
441
442 if (size >= record_length) {
443 memcpy(value, entry->inline_data.raw_bytes, record_length);
444 res = record_length;
445 } else
446 res = size ? -ERANGE : record_length;
447
448out:
449 hfs_find_exit(&fd);
450
451failed_getxattr_init:
452 hfsplus_destroy_attr_entry(entry);
453 return res;
454}
455
456static inline int can_list(const char *xattr_name)
457{
458 if (!xattr_name)
459 return 0;
460
461 return strncmp(xattr_name, XATTR_TRUSTED_PREFIX,
462 XATTR_TRUSTED_PREFIX_LEN) ||
463 capable(CAP_SYS_ADMIN);
464}
465
466static ssize_t hfsplus_listxattr_finder_info(struct dentry *dentry,
467 char *buffer, size_t size)
468{
469 ssize_t res = 0;
470 struct inode *inode = dentry->d_inode;
471 struct hfs_find_data fd;
472 u16 entry_type;
473 u8 folder_finder_info[sizeof(struct DInfo) + sizeof(struct DXInfo)];
474 u8 file_finder_info[sizeof(struct FInfo) + sizeof(struct FXInfo)];
475 unsigned long len, found_bit;
476 int xattr_name_len, symbols_count;
477
478 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
479 if (res) {
480 pr_err("can't init xattr find struct\n");
481 return res;
482 }
483
484 res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
485 if (res)
486 goto end_listxattr_finder_info;
487
488 entry_type = hfs_bnode_read_u16(fd.bnode, fd.entryoffset);
489 if (entry_type == HFSPLUS_FOLDER) {
490 len = sizeof(struct DInfo) + sizeof(struct DXInfo);
491 hfs_bnode_read(fd.bnode, folder_finder_info,
492 fd.entryoffset +
493 offsetof(struct hfsplus_cat_folder, user_info),
494 len);
495 found_bit = find_first_bit((void *)folder_finder_info, len*8);
496 } else if (entry_type == HFSPLUS_FILE) {
497 len = sizeof(struct FInfo) + sizeof(struct FXInfo);
498 hfs_bnode_read(fd.bnode, file_finder_info,
499 fd.entryoffset +
500 offsetof(struct hfsplus_cat_file, user_info),
501 len);
502 found_bit = find_first_bit((void *)file_finder_info, len*8);
503 } else {
504 res = -EOPNOTSUPP;
505 goto end_listxattr_finder_info;
506 }
507
508 if (found_bit >= (len*8))
509 res = 0;
510 else {
511 symbols_count = sizeof(HFSPLUS_XATTR_FINDER_INFO_NAME) - 1;
512 xattr_name_len =
513 name_len(HFSPLUS_XATTR_FINDER_INFO_NAME, symbols_count);
514 if (!buffer || !size) {
515 if (can_list(HFSPLUS_XATTR_FINDER_INFO_NAME))
516 res = xattr_name_len;
517 } else if (can_list(HFSPLUS_XATTR_FINDER_INFO_NAME)) {
518 if (size < xattr_name_len)
519 res = -ERANGE;
520 else {
521 res = copy_name(buffer,
522 HFSPLUS_XATTR_FINDER_INFO_NAME,
523 symbols_count);
524 }
525 }
526 }
527
528end_listxattr_finder_info:
529 hfs_find_exit(&fd);
530
531 return res;
532}
533
534ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size)
535{
536 ssize_t err;
537 ssize_t res = 0;
538 struct inode *inode = dentry->d_inode;
539 struct hfs_find_data fd;
540 u16 key_len = 0;
541 struct hfsplus_attr_key attr_key;
542 char strbuf[HFSPLUS_ATTR_MAX_STRLEN +
543 XATTR_MAC_OSX_PREFIX_LEN + 1] = {0};
544 int xattr_name_len;
545
546 if ((!S_ISREG(inode->i_mode) &&
547 !S_ISDIR(inode->i_mode)) ||
548 HFSPLUS_IS_RSRC(inode))
549 return -EOPNOTSUPP;
550
551 res = hfsplus_listxattr_finder_info(dentry, buffer, size);
552 if (res < 0)
553 return res;
554 else if (!HFSPLUS_SB(inode->i_sb)->attr_tree)
555 return (res == 0) ? -EOPNOTSUPP : res;
556
557 err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->attr_tree, &fd);
558 if (err) {
559 pr_err("can't init xattr find struct\n");
560 return err;
561 }
562
563 err = hfsplus_find_attr(inode->i_sb, inode->i_ino, NULL, &fd);
564 if (err) {
565 if (err == -ENOENT) {
566 if (res == 0)
567 res = -ENODATA;
568 goto end_listxattr;
569 } else {
570 res = err;
571 goto end_listxattr;
572 }
573 }
574
575 for (;;) {
576 key_len = hfs_bnode_read_u16(fd.bnode, fd.keyoffset);
577 if (key_len == 0 || key_len > fd.tree->max_key_len) {
578 pr_err("invalid xattr key length: %d\n", key_len);
579 res = -EIO;
580 goto end_listxattr;
581 }
582
583 hfs_bnode_read(fd.bnode, &attr_key,
584 fd.keyoffset, key_len + sizeof(key_len));
585
586 if (be32_to_cpu(attr_key.cnid) != inode->i_ino)
587 goto end_listxattr;
588
589 xattr_name_len = HFSPLUS_ATTR_MAX_STRLEN;
590 if (hfsplus_uni2asc(inode->i_sb,
591 (const struct hfsplus_unistr *)&fd.key->attr.key_name,
592 strbuf, &xattr_name_len)) {
593 pr_err("unicode conversion failed\n");
594 res = -EIO;
595 goto end_listxattr;
596 }
597
598 if (!buffer || !size) {
599 if (can_list(strbuf))
600 res += name_len(strbuf, xattr_name_len);
601 } else if (can_list(strbuf)) {
602 if (size < (res + name_len(strbuf, xattr_name_len))) {
603 res = -ERANGE;
604 goto end_listxattr;
605 } else
606 res += copy_name(buffer + res,
607 strbuf, xattr_name_len);
608 }
609
610 if (hfs_brec_goto(&fd, 1))
611 goto end_listxattr;
612 }
613
614end_listxattr:
615 hfs_find_exit(&fd);
616 return res;
617}
618
619int hfsplus_removexattr(struct dentry *dentry, const char *name)
620{
621 int err = 0;
622 struct inode *inode = dentry->d_inode;
623 struct hfs_find_data cat_fd;
624 u16 flags;
625 u16 cat_entry_type;
626 int is_xattr_acl_deleted = 0;
627 int is_all_xattrs_deleted = 0;
628
629 if ((!S_ISREG(inode->i_mode) &&
630 !S_ISDIR(inode->i_mode)) ||
631 HFSPLUS_IS_RSRC(inode))
632 return -EOPNOTSUPP;
633
634 if (!HFSPLUS_SB(inode->i_sb)->attr_tree)
635 return -EOPNOTSUPP;
636
637 err = can_set_xattr(inode, name, NULL, 0);
638 if (err)
639 return err;
640
641 if (strncmp(name, XATTR_MAC_OSX_PREFIX,
642 XATTR_MAC_OSX_PREFIX_LEN) == 0)
643 name += XATTR_MAC_OSX_PREFIX_LEN;
644
645 if (!strcmp_xattr_finder_info(name))
646 return -EOPNOTSUPP;
647
648 err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &cat_fd);
649 if (err) {
650 pr_err("can't init xattr find struct\n");
651 return err;
652 }
653
654 err = hfsplus_find_cat(inode->i_sb, inode->i_ino, &cat_fd);
655 if (err) {
656 pr_err("catalog searching failed\n");
657 goto end_removexattr;
658 }
659
660 err = hfsplus_delete_attr(inode, name);
661 if (err)
662 goto end_removexattr;
663
664 is_xattr_acl_deleted = !strcmp_xattr_acl(name);
665 is_all_xattrs_deleted = !hfsplus_attr_exists(inode, NULL);
666
667 if (!is_xattr_acl_deleted && !is_all_xattrs_deleted)
668 goto end_removexattr;
669
670 cat_entry_type = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset);
671
672 if (cat_entry_type == HFSPLUS_FOLDER) {
673 flags = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset +
674 offsetof(struct hfsplus_cat_folder, flags));
675 if (is_xattr_acl_deleted)
676 flags &= ~HFSPLUS_ACL_EXISTS;
677 if (is_all_xattrs_deleted)
678 flags &= ~HFSPLUS_XATTR_EXISTS;
679 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset +
680 offsetof(struct hfsplus_cat_folder, flags),
681 flags);
682 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
683 } else if (cat_entry_type == HFSPLUS_FILE) {
684 flags = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset +
685 offsetof(struct hfsplus_cat_file, flags));
686 if (is_xattr_acl_deleted)
687 flags &= ~HFSPLUS_ACL_EXISTS;
688 if (is_all_xattrs_deleted)
689 flags &= ~HFSPLUS_XATTR_EXISTS;
690 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset +
691 offsetof(struct hfsplus_cat_file, flags),
692 flags);
693 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
694 } else {
695 pr_err("invalid catalog entry type\n");
696 err = -EIO;
697 goto end_removexattr;
698 }
699
700end_removexattr:
701 hfs_find_exit(&cat_fd);
702 return err;
703}
704
705static int hfsplus_osx_getxattr(struct dentry *dentry, const char *name,
706 void *buffer, size_t size, int type)
707{
708 char xattr_name[HFSPLUS_ATTR_MAX_STRLEN +
709 XATTR_MAC_OSX_PREFIX_LEN + 1] = {0};
710 size_t len = strlen(name);
711
712 if (!strcmp(name, ""))
713 return -EINVAL;
714
715 if (len > HFSPLUS_ATTR_MAX_STRLEN)
716 return -EOPNOTSUPP;
717
718 strcpy(xattr_name, XATTR_MAC_OSX_PREFIX);
719 strcpy(xattr_name + XATTR_MAC_OSX_PREFIX_LEN, name);
720
721 return hfsplus_getxattr(dentry, xattr_name, buffer, size);
722}
723
724static int hfsplus_osx_setxattr(struct dentry *dentry, const char *name,
725 const void *buffer, size_t size, int flags, int type)
726{
727 char xattr_name[HFSPLUS_ATTR_MAX_STRLEN +
728 XATTR_MAC_OSX_PREFIX_LEN + 1] = {0};
729 size_t len = strlen(name);
730
731 if (!strcmp(name, ""))
732 return -EINVAL;
733
734 if (len > HFSPLUS_ATTR_MAX_STRLEN)
735 return -EOPNOTSUPP;
736
737 strcpy(xattr_name, XATTR_MAC_OSX_PREFIX);
738 strcpy(xattr_name + XATTR_MAC_OSX_PREFIX_LEN, name);
739
740 return hfsplus_setxattr(dentry, xattr_name, buffer, size, flags);
741}
742
743static size_t hfsplus_osx_listxattr(struct dentry *dentry, char *list,
744 size_t list_size, const char *name, size_t name_len, int type)
745{
746
747
748
749
750 return -EOPNOTSUPP;
751}
752
753const struct xattr_handler hfsplus_xattr_osx_handler = {
754 .prefix = XATTR_MAC_OSX_PREFIX,
755 .list = hfsplus_osx_listxattr,
756 .get = hfsplus_osx_getxattr,
757 .set = hfsplus_osx_setxattr,
758};
759
