1/** 2 * xattrs.c : common functions to deal with system extended attributes 3 * 4 * Copyright (c) 2010 Jean-Pierre Andre 5 * 6 * This program/include file is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License as published 8 * by the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program/include file is distributed in the hope that it will be 12 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty 13 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program (in the main directory of the NTFS-3G 18 * distribution in the file COPYING); if not, write to the Free Software 19 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 */ 21 22#ifdef HAVE_CONFIG_H 23#include "config.h" 24#endif 25 26#ifdef HAVE_SETXATTR /* extended attributes support required */ 27 28#ifdef HAVE_STDIO_H 29#include <stdio.h> 30#endif 31#ifdef HAVE_STDLIB_H 32#include <stdlib.h> 33#endif 34#ifdef HAVE_STRING_H 35#include <string.h> 36#endif 37#ifdef HAVE_FCNTL_H 38#include <fcntl.h> 39#endif 40#ifdef HAVE_UNISTD_H 41#include <unistd.h> 42#endif 43#ifdef HAVE_ERRNO_H 44#include <errno.h> 45#endif 46 47#include "types.h" 48#include "param.h" 49#include "layout.h" 50#include "attrib.h" 51#include "index.h" 52#include "dir.h" 53#include "security.h" 54#include "acls.h" 55#include "efs.h" 56#include "reparse.h" 57#include "object_id.h" 58#include "misc.h" 59#include "logging.h" 60#include "xattrs.h" 61 62#if POSIXACLS 63#if __BYTE_ORDER == __BIG_ENDIAN 64 65/* 66 * Posix ACL structures 67 */ 68 69struct LE_POSIX_ACE { 70 le16 tag; 71 le16 perms; 72 le32 id; 73} __attribute__((__packed__)); 74 75struct LE_POSIX_ACL { 76 u8 version; 77 u8 flags; 78 le16 filler; 79 struct LE_POSIX_ACE ace[0]; 80} __attribute__((__packed__)); 81 82#endif 83#endif 84 85static const char xattr_ntfs_3g[] = "ntfs-3g."; 86static const char nf_ns_user_prefix[] = "user."; 87static const int nf_ns_user_prefix_len = sizeof(nf_ns_user_prefix) - 1; 88 89static const char nf_ns_xattr_ntfs_acl[] = "system.ntfs_acl"; 90static const char nf_ns_xattr_attrib[] = "system.ntfs_attrib"; 91static const char nf_ns_xattr_attrib_be[] = "system.ntfs_attrib_be"; 92static const char nf_ns_xattr_efsinfo[] = "system.ntfs_efsinfo"; 93static const char nf_ns_xattr_reparse[] = "system.ntfs_reparse_data"; 94static const char nf_ns_xattr_object_id[] = "system.ntfs_object_id"; 95static const char nf_ns_xattr_dos_name[] = "system.ntfs_dos_name"; 96static const char nf_ns_xattr_times[] = "system.ntfs_times"; 97static const char nf_ns_xattr_times_be[] = "system.ntfs_times_be"; 98static const char nf_ns_xattr_crtime[] = "system.ntfs_crtime"; 99static const char nf_ns_xattr_crtime_be[] = "system.ntfs_crtime_be"; 100static const char nf_ns_xattr_posix_access[] = "system.posix_acl_access"; 101static const char nf_ns_xattr_posix_default[] = "system.posix_acl_default"; 102 103static const char nf_ns_alt_xattr_efsinfo[] = "user.ntfs.efsinfo"; 104 105struct XATTRNAME { 106 enum SYSTEMXATTRS xattr; 107 const char *name; 108} ; 109 110static struct XATTRNAME nf_ns_xattr_names[] = { 111 { XATTR_NTFS_ACL, nf_ns_xattr_ntfs_acl }, 112 { XATTR_NTFS_ATTRIB, nf_ns_xattr_attrib }, 113 { XATTR_NTFS_ATTRIB_BE, nf_ns_xattr_attrib_be }, 114 { XATTR_NTFS_EFSINFO, nf_ns_xattr_efsinfo }, 115 { XATTR_NTFS_REPARSE_DATA, nf_ns_xattr_reparse }, 116 { XATTR_NTFS_OBJECT_ID, nf_ns_xattr_object_id }, 117 { XATTR_NTFS_DOS_NAME, nf_ns_xattr_dos_name }, 118 { XATTR_NTFS_TIMES, nf_ns_xattr_times }, 119 { XATTR_NTFS_TIMES_BE, nf_ns_xattr_times_be }, 120 { XATTR_NTFS_CRTIME, nf_ns_xattr_crtime }, 121 { XATTR_NTFS_CRTIME_BE, nf_ns_xattr_crtime_be }, 122 { XATTR_POSIX_ACC, nf_ns_xattr_posix_access }, 123 { XATTR_POSIX_DEF, nf_ns_xattr_posix_default }, 124 { XATTR_UNMAPPED, (char*)NULL } /* terminator */ 125}; 126 127/* 128 * Make an integer big-endian 129 * 130 * Swap bytes on a small-endian computer and does nothing on a 131 * big-endian computer. 132 */ 133 134static void fix_big_endian(char *p, int size) 135{ 136#if __BYTE_ORDER == __LITTLE_ENDIAN 137 int i,j; 138 int c; 139 140 i = 0; 141 j = size - 1; 142 while (i < j) { 143 c = p[i]; 144 p[i++] = p[j]; 145 p[j--] = c; 146 } 147#endif 148} 149 150#if POSIXACLS 151#if __BYTE_ORDER == __BIG_ENDIAN 152 153/* 154 * Make a Posix ACL CPU endian 155 */ 156 157static int le_acl_to_cpu(const struct LE_POSIX_ACL *le_acl, size_t size, 158 struct POSIX_ACL *acl) 159{ 160 int i; 161 int cnt; 162 163 acl->version = le_acl->version; 164 acl->flags = le_acl->flags; 165 acl->filler = 0; 166 cnt = (size - sizeof(struct LE_POSIX_ACL)) / sizeof(struct LE_POSIX_ACE); 167 for (i=0; i<cnt; i++) { 168 acl->ace[i].tag = le16_to_cpu(le_acl->ace[i].tag); 169 acl->ace[i].perms = le16_to_cpu(le_acl->ace[i].perms); 170 acl->ace[i].id = le32_to_cpu(le_acl->ace[i].id); 171 } 172 return (0); 173} 174 175/* 176 * Make a Posix ACL little endian 177 */ 178 179int cpu_to_le_acl(const struct POSIX_ACL *acl, size_t size, 180 struct LE_POSIX_ACL *le_acl) 181{ 182 int i; 183 int cnt; 184 185 le_acl->version = acl->version; 186 le_acl->flags = acl->flags; 187 le_acl->filler = const_cpu_to_le16(0); 188 cnt = (size - sizeof(struct POSIX_ACL)) / sizeof(struct POSIX_ACE); 189 for (i=0; i<cnt; i++) { 190 le_acl->ace[i].tag = cpu_to_le16(acl->ace[i].tag); 191 le_acl->ace[i].perms = cpu_to_le16(acl->ace[i].perms); 192 le_acl->ace[i].id = cpu_to_le32(acl->ace[i].id); 193 } 194 return (0); 195} 196 197#endif 198#endif 199 200/* 201 * Determine whether an extended attribute is mapped to 202 * internal data (original name in system namespace, or renamed) 203 */ 204 205enum SYSTEMXATTRS ntfs_xattr_system_type(const char *name, 206 ntfs_volume *vol) 207{ 208 struct XATTRNAME *p; 209 enum SYSTEMXATTRS ret; 210#ifdef XATTR_MAPPINGS 211 const struct XATTRMAPPING *q; 212#endif /* XATTR_MAPPINGS */ 213 214 p = nf_ns_xattr_names; 215 while (p->name && strcmp(p->name,name)) 216 p++; 217 ret = p->xattr; 218#ifdef XATTR_MAPPINGS 219 if (!p->name && vol && vol->xattr_mapping) { 220 q = vol->xattr_mapping; 221 while (q && strcmp(q->name,name)) 222 q = q->next; 223 if (q) 224 ret = q->xattr; 225 } 226#else /* XATTR_MAPPINGS */ 227 if (!p->name 228 && vol 229 && vol->efs_raw 230 && !strcmp(nf_ns_alt_xattr_efsinfo,name)) 231 ret = XATTR_NTFS_EFSINFO; 232#endif /* XATTR_MAPPINGS */ 233 return (ret); 234} 235 236#ifdef XATTR_MAPPINGS 237 238/* 239 * Basic read from a user mapping file on another volume 240 */ 241 242static int basicread(void *fileid, char *buf, size_t size, off_t offs __attribute__((unused))) 243{ 244 return (read(*(int*)fileid, buf, size)); 245} 246 247 248/* 249 * Read from a user mapping file on current NTFS partition 250 */ 251 252static int localread(void *fileid, char *buf, size_t size, off_t offs) 253{ 254 return (ntfs_attr_data_read((ntfs_inode*)fileid, 255 AT_UNNAMED, 0, buf, size, offs)); 256} 257 258/* 259 * Get a single mapping item from buffer 260 * 261 * Always reads a full line, truncating long lines 262 * Refills buffer when exhausted 263 * Returns pointer to item, or NULL when there is no more 264 * Note : errors are logged, but not returned 265// TODO partially share with acls.c 266 */ 267 268static struct XATTRMAPPING *getmappingitem(FILEREADER reader, void *fileid, 269 off_t *poffs, char *buf, int *psrc, s64 *psize) 270{ 271 int src; 272 int dst; 273 char *pe; 274 char *ps; 275 char *pu; 276 enum SYSTEMXATTRS xattr; 277 int gotend; 278 char maptext[LINESZ]; 279 struct XATTRMAPPING *item; 280 281 src = *psrc; 282 dst = 0; 283 do { 284 gotend = 0; 285 while ((src < *psize) 286 && (buf[src] != '\n')) { 287 /* ignore spaces */ 288 if ((dst < LINESZ) 289 && (buf[src] != '\r') 290 && (buf[src] != '\t') 291 && (buf[src] != ' ')) 292 maptext[dst++] = buf[src]; 293 src++; 294 } 295 if (src >= *psize) { 296 *poffs += *psize; 297 *psize = reader(fileid, buf, (size_t)BUFSZ, *poffs); 298 src = 0; 299 } else { 300 gotend = 1; 301 src++; 302 maptext[dst] = '\0'; 303 dst = 0; 304 } 305 } while (*psize && ((maptext[0] == '#') || !gotend)); 306 item = (struct XATTRMAPPING*)NULL; 307 if (gotend) { 308 /* decompose into system name and user name */ 309 ps = maptext; 310 pu = strchr(maptext,':'); 311 if (pu) { 312 *pu++ = 0; 313 pe = strchr(pu,':'); 314 if (pe) 315 *pe = 0; 316 /* check name validity */ 317 if ((strlen(pu) < 6) || strncmp(pu,"user.",5)) 318 pu = (char*)NULL; 319 xattr = ntfs_xattr_system_type(ps, 320 (ntfs_volume*)NULL); 321 if (xattr == XATTR_UNMAPPED) 322 pu = (char*)NULL; 323 } 324 if (pu) { 325 item = (struct XATTRMAPPING*)ntfs_malloc( 326 sizeof(struct XATTRMAPPING) 327 + strlen(pu)); 328 if (item) { 329 item->xattr = xattr; 330 strcpy(item->name,pu); 331 item->next = (struct XATTRMAPPING*)NULL; 332 } 333 } else { 334 ntfs_log_early_error("Bad xattr mapping item, aborting\n"); 335 } 336 } 337 *psrc = src; 338 return (item); 339} 340 341/* 342 * Read xattr mapping file and split into their attribute. 343 * Parameters are kept in a chained list. 344 * Returns the head of list, if any 345 * Errors are logged, but not returned 346 * 347 * If an absolute path is provided, the mapping file is assumed 348 * to be located in another mounted file system, and plain read() 349 * are used to get its contents. 350 * If a relative path is provided, the mapping file is assumed 351 * to be located on the current file system, and internal IO 352 * have to be used since we are still mounting and we have not 353 * entered the fuse loop yet. 354 */ 355 356static struct XATTRMAPPING *ntfs_read_xattr_mapping(FILEREADER reader, 357 void *fileid) 358{ 359 char buf[BUFSZ]; 360 struct XATTRMAPPING *item; 361 struct XATTRMAPPING *current; 362 struct XATTRMAPPING *firstitem; 363 struct XATTRMAPPING *lastitem; 364 BOOL duplicated; 365 int src; 366 off_t offs; 367 s64 size; 368 369 firstitem = (struct XATTRMAPPING*)NULL; 370 lastitem = (struct XATTRMAPPING*)NULL; 371 offs = 0; 372 size = reader(fileid, buf, (size_t)BUFSZ, (off_t)0); 373 if (size > 0) { 374 src = 0; 375 do { 376 item = getmappingitem(reader, fileid, &offs, 377 buf, &src, &size); 378 if (item) { 379 /* check no double mapping */ 380 duplicated = FALSE; 381 for (current=firstitem; current; current=current->next) 382 if ((current->xattr == item->xattr) 383 || !strcmp(current->name,item->name)) 384 duplicated = TRUE; 385 if (duplicated) { 386 free(item); 387 ntfs_log_early_error("Conflicting xattr mapping ignored\n"); 388 } else { 389 item->next = (struct XATTRMAPPING*)NULL; 390 if (lastitem) 391 lastitem->next = item; 392 else 393 firstitem = item; 394 lastitem = item; 395 } 396 } 397 } while (item); 398 } 399 return (firstitem); 400} 401 402/* 403 * Build the extended attribute mappings to user namespace 404 * 405 * Note : no error is returned. If we refused mounting when there 406 * is an error it would be too difficult to fix the offending file 407 */ 408 409struct XATTRMAPPING *ntfs_xattr_build_mapping(ntfs_volume *vol, 410 const char *xattrmap_path) 411{ 412 struct XATTRMAPPING *firstmapping; 413 struct XATTRMAPPING *mapping; 414 BOOL user_efs; 415 BOOL notfound; 416 ntfs_inode *ni; 417 int fd; 418 419 firstmapping = (struct XATTRMAPPING*)NULL; 420 notfound = FALSE; 421 if (!xattrmap_path) 422 xattrmap_path = XATTRMAPPINGFILE; 423 if (xattrmap_path[0] == '/') { 424 fd = open(xattrmap_path,O_RDONLY); 425 if (fd > 0) { 426 firstmapping = ntfs_read_xattr_mapping(basicread, (void*)&fd); 427 close(fd); 428 } else 429 notfound = TRUE; 430 } else { 431 ni = ntfs_pathname_to_inode(vol, NULL, xattrmap_path); 432 if (ni) { 433 firstmapping = ntfs_read_xattr_mapping(localread, ni); 434 ntfs_inode_close(ni); 435 } else 436 notfound = TRUE; 437 } 438 if (notfound && strcmp(xattrmap_path, XATTRMAPPINGFILE)) { 439 ntfs_log_early_error("Could not open \"%s\"\n",xattrmap_path); 440 } 441 if (vol->efs_raw) { 442 user_efs = TRUE; 443 for (mapping=firstmapping; mapping; mapping=mapping->next) 444 if (mapping->xattr == XATTR_NTFS_EFSINFO) 445 user_efs = FALSE; 446 } else 447 user_efs = FALSE; 448 if (user_efs) { 449 mapping = (struct XATTRMAPPING*)ntfs_malloc( 450 sizeof(struct XATTRMAPPING) 451 + strlen(nf_ns_alt_xattr_efsinfo)); 452 if (mapping) { 453 mapping->next = firstmapping; 454 mapping->xattr = XATTR_NTFS_EFSINFO; 455 strcpy(mapping->name,nf_ns_alt_xattr_efsinfo); 456 firstmapping = mapping; 457 } 458 } 459 return (firstmapping); 460} 461 462void ntfs_xattr_free_mapping(struct XATTRMAPPING *mapping) 463{ 464 struct XATTRMAPPING *p, *q; 465 466 p = mapping; 467 while (p) { 468 q = p->next; 469 free(p); 470 p = q; 471 } 472} 473 474#endif /* XATTR_MAPPINGS */ 475 476 477int ntfs_xattr_system_getxattr(struct SECURITY_CONTEXT *scx, 478 enum SYSTEMXATTRS attr, 479 ntfs_inode *ni, ntfs_inode *dir_ni, 480 char *value, size_t size) 481{ 482 int res; 483 int i; 484#if POSIXACLS 485#if __BYTE_ORDER == __BIG_ENDIAN 486 struct POSIX_ACL *acl; 487#endif 488#endif 489 490 /* 491 * the returned value is the needed 492 * size. If it is too small, no copy 493 * is done, and the caller has to 494 * issue a new call with correct size. 495 */ 496 switch (attr) { 497 case XATTR_NTFS_ACL : 498 res = ntfs_get_ntfs_acl(scx, ni, value, size); 499 break; 500#if POSIXACLS 501#if __BYTE_ORDER == __BIG_ENDIAN 502 case XATTR_POSIX_ACC : 503 acl = (struct POSIX_ACL*)ntfs_malloc(size); 504 if (acl) { 505 res = ntfs_get_posix_acl(scx, ni, 506 nf_ns_xattr_posix_access, (char*)acl, size); 507 if (res > 0) { 508 if (cpu_to_le_acl(acl,res, 509 (struct LE_POSIX_ACL*)value)) 510 res = -errno; 511 } 512 free(acl); 513 } else 514 res = -errno; 515 break; 516 case XATTR_POSIX_DEF : 517 acl = (struct POSIX_ACL*)ntfs_malloc(size); 518 if (acl) { 519 res = ntfs_get_posix_acl(scx, ni, 520 nf_ns_xattr_posix_default, (char*)acl, size); 521 if (res > 0) { 522 if (cpu_to_le_acl(acl,res, 523 (struct LE_POSIX_ACL*)value)) 524 res = -errno; 525 } 526 free(acl); 527 } else 528 res = -errno; 529 break; 530#else 531 case XATTR_POSIX_ACC : 532 res = ntfs_get_posix_acl(scx, ni, nf_ns_xattr_posix_access, 533 value, size); 534 break; 535 case XATTR_POSIX_DEF : 536 res = ntfs_get_posix_acl(scx, ni, nf_ns_xattr_posix_default, 537 value, size); 538 break; 539#endif 540#endif 541 case XATTR_NTFS_ATTRIB : 542 res = ntfs_get_ntfs_attrib(ni, value, size); 543 break; 544 case XATTR_NTFS_ATTRIB_BE : 545 res = ntfs_get_ntfs_attrib(ni, value, size); 546 if ((res == 4) && value) { 547 if (size >= 4) 548 fix_big_endian(value,4); 549 else 550 res = -EINVAL; 551 } 552 break; 553 case XATTR_NTFS_EFSINFO : 554 if (ni->vol->efs_raw) 555 res = ntfs_get_efs_info(ni, value, size); 556 else 557 res = -EPERM; 558 break; 559 case XATTR_NTFS_REPARSE_DATA : 560 res = ntfs_get_ntfs_reparse_data(ni, value, size); 561 break; 562 case XATTR_NTFS_OBJECT_ID : 563 res = ntfs_get_ntfs_object_id(ni, value, size); 564 break; 565 case XATTR_NTFS_DOS_NAME: 566 if (dir_ni) 567 res = ntfs_get_ntfs_dos_name(ni, dir_ni, value, size); 568 else 569 res = -errno; 570 break; 571 case XATTR_NTFS_TIMES: 572 res = ntfs_inode_get_times(ni, value, size); 573 break; 574 case XATTR_NTFS_TIMES_BE: 575 res = ntfs_inode_get_times(ni, value, size); 576 if ((res > 0) && value) { 577 for (i=0; (i+1)*sizeof(u64)<=(unsigned int)res; i++) 578 fix_big_endian(&value[i*sizeof(u64)], 579 sizeof(u64)); 580 } 581 break; 582 case XATTR_NTFS_CRTIME: 583 res = ntfs_inode_get_times(ni, value, 584 (size >= sizeof(u64) ? sizeof(u64) : size)); 585 break; 586 case XATTR_NTFS_CRTIME_BE: 587 res = ntfs_inode_get_times(ni, value, 588 (size >= sizeof(u64) ? sizeof(u64) : size)); 589 if ((res >= (int)sizeof(u64)) && value) 590 fix_big_endian(value,sizeof(u64)); 591 break; 592 default : 593 errno = EOPNOTSUPP; 594 res = -errno; 595 break; 596 } 597 return (res); 598} 599 600int ntfs_xattr_system_setxattr(struct SECURITY_CONTEXT *scx, 601 enum SYSTEMXATTRS attr, 602 ntfs_inode *ni, ntfs_inode *dir_ni, 603 const char *value, size_t size, int flags) 604{ 605 int res; 606 int i; 607 char buf[4*sizeof(u64)]; 608#if POSIXACLS 609#if __BYTE_ORDER == __BIG_ENDIAN 610 struct POSIX_ACL *acl; 611#endif 612#endif 613 614 switch (attr) { 615 case XATTR_NTFS_ACL : 616 res = ntfs_set_ntfs_acl(scx, ni, value, size, flags); 617 break; 618#if POSIXACLS 619#if __BYTE_ORDER == __BIG_ENDIAN 620 case XATTR_POSIX_ACC : 621 acl = (struct POSIX_ACL*)ntfs_malloc(size); 622 if (acl) { 623 if (!le_acl_to_cpu((const struct LE_POSIX_ACL*)value, 624 size, acl)) { 625 res = ntfs_set_posix_acl(scx ,ni , 626 nf_ns_xattr_posix_access, 627 (char*)acl, size, flags); 628 } else 629 res = -errno; 630 free(acl); 631 } else 632 res = -errno; 633 break; 634 case XATTR_POSIX_DEF : 635 acl = (struct POSIX_ACL*)ntfs_malloc(size); 636 if (acl) { 637 if (!le_acl_to_cpu((const struct LE_POSIX_ACL*)value, 638 size, acl)) { 639 res = ntfs_set_posix_acl(scx ,ni , 640 nf_ns_xattr_posix_default, 641 (char*)acl, size, flags); 642 } else 643 res = -errno; 644 free(acl); 645 } else 646 res = -errno; 647 break; 648#else 649 case XATTR_POSIX_ACC : 650 res = ntfs_set_posix_acl(scx ,ni , nf_ns_xattr_posix_access, 651 value, size, flags); 652 break; 653 case XATTR_POSIX_DEF : 654 res = ntfs_set_posix_acl(scx, ni, nf_ns_xattr_posix_default, 655 value, size, flags); 656 break; 657#endif 658#endif 659 case XATTR_NTFS_ATTRIB : 660 res = ntfs_set_ntfs_attrib(ni, value, size, flags); 661 break; 662 case XATTR_NTFS_ATTRIB_BE : 663 if (value && (size >= 4)) { 664 memcpy(buf,value,4); 665 fix_big_endian(buf,4); 666 res = ntfs_set_ntfs_attrib(ni, buf, 4, flags); 667 } else 668 res = ntfs_set_ntfs_attrib(ni, value, size, flags); 669 break; 670 case XATTR_NTFS_EFSINFO : 671 if (ni->vol->efs_raw) 672 res = ntfs_set_efs_info(ni, value, size, flags); 673 else 674 res = -EPERM; 675 break; 676 case XATTR_NTFS_REPARSE_DATA : 677 res = ntfs_set_ntfs_reparse_data(ni, value, size, flags); 678 break; 679 case XATTR_NTFS_OBJECT_ID : 680 res = ntfs_set_ntfs_object_id(ni, value, size, flags); 681 break; 682 case XATTR_NTFS_DOS_NAME: 683 if (dir_ni) 684 /* warning : this closes both inodes */ 685 res = ntfs_set_ntfs_dos_name(ni, dir_ni, value, 686 size, flags); 687 else 688 res = -errno; 689 break; 690 case XATTR_NTFS_TIMES: 691 res = ntfs_inode_set_times(ni, value, size, flags); 692 break; 693 case XATTR_NTFS_TIMES_BE: 694 if (value && (size > 0) && (size <= 4*sizeof(u64))) { 695 memcpy(buf,value,size); 696 for (i=0; (i+1)*sizeof(u64)<=size; i++) 697 fix_big_endian(&buf[i*sizeof(u64)], 698 sizeof(u64)); 699 res = ntfs_inode_set_times(ni, buf, size, flags); 700 } else 701 res = ntfs_inode_set_times(ni, value, size, flags); 702 break; 703 case XATTR_NTFS_CRTIME: 704 res = ntfs_inode_set_times(ni, value, 705 (size >= sizeof(u64) ? sizeof(u64) : size), flags); 706 break; 707 case XATTR_NTFS_CRTIME_BE: 708 if (value && (size >= sizeof(u64))) { 709 memcpy(buf,value,sizeof(u64)); 710 fix_big_endian(buf,sizeof(u64)); 711 res = ntfs_inode_set_times(ni, buf, sizeof(u64), flags); 712 } else 713 res = ntfs_inode_set_times(ni, value, size, flags); 714 break; 715 default : 716 errno = EOPNOTSUPP; 717 res = -errno; 718 break; 719 } 720 return (res); 721} 722 723int ntfs_xattr_system_removexattr(struct SECURITY_CONTEXT *scx, 724 enum SYSTEMXATTRS attr, 725 ntfs_inode *ni, ntfs_inode *dir_ni) 726{ 727 int res; 728 729 res = 0; 730 switch (attr) { 731 /* 732 * Removal of NTFS ACL, ATTRIB, EFSINFO or TIMES 733 * is never allowed 734 */ 735 case XATTR_NTFS_ACL : 736 case XATTR_NTFS_ATTRIB : 737 case XATTR_NTFS_ATTRIB_BE : 738 case XATTR_NTFS_EFSINFO : 739 case XATTR_NTFS_TIMES : 740 case XATTR_NTFS_TIMES_BE : 741 case XATTR_NTFS_CRTIME : 742 case XATTR_NTFS_CRTIME_BE : 743 res = -EPERM; 744 break; 745#if POSIXACLS 746 case XATTR_POSIX_ACC : 747 case XATTR_POSIX_DEF : 748 if (ni) { 749 if (!ntfs_allowed_as_owner(scx, ni) 750 || ntfs_remove_posix_acl(scx, ni, 751 (attr == XATTR_POSIX_ACC ? 752 nf_ns_xattr_posix_access : 753 nf_ns_xattr_posix_default))) 754 res = -errno; 755 } else 756 res = -errno; 757 break; 758#endif 759 case XATTR_NTFS_REPARSE_DATA : 760 if (ni) { 761 if (!ntfs_allowed_as_owner(scx, ni) 762 || ntfs_remove_ntfs_reparse_data(ni)) 763 res = -errno; 764 } else 765 res = -errno; 766 break; 767 case XATTR_NTFS_OBJECT_ID : 768 if (ni) { 769 if (!ntfs_allowed_as_owner(scx, ni) 770 || ntfs_remove_ntfs_object_id(ni)) 771 res = -errno; 772 } else 773 res = -errno; 774 break; 775 case XATTR_NTFS_DOS_NAME: 776 if (ni && dir_ni) { 777 if (ntfs_remove_ntfs_dos_name(ni,dir_ni)) 778 res = -errno; 779 /* ni and dir_ni have been closed */ 780 } else 781 res = -errno; 782 break; 783 default : 784 errno = EOPNOTSUPP; 785 res = -errno; 786 break; 787 } 788 return (res); 789} 790 791#endif /* HAVE_SETXATTR */ 792