opengnsys
/
ntfs-3g
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Replace all le32 "or" calculations with le32_or(...).

edge.strict_endians
Erik Larsson 2016-01-28 08:28:54 +01:00
parent b61e7ff449
commit 1500a77676
18 changed files with 234 additions and 232 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
include/ntfs-3g/acls.h
View File

@ -57,35 +57,35 @@
/* flags which are set to mean exec, write or read */
#define FILE_READ (FILE_READ_DATA)
#define FILE_WRITE (FILE_WRITE_DATA | FILE_APPEND_DATA \
| READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_WRITE_EA)
#define FILE_WRITE le32_or(FILE_WRITE_DATA, le32_or(FILE_APPEND_DATA, \
le32_or(READ_CONTROL, le32_or(FILE_WRITE_ATTRIBUTES, FILE_WRITE_EA))))
#define FILE_EXEC (FILE_EXECUTE)
#define DIR_READ FILE_LIST_DIRECTORY
#define DIR_WRITE (FILE_ADD_FILE | FILE_ADD_SUBDIRECTORY | FILE_DELETE_CHILD \
| READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_WRITE_EA)
#define DIR_WRITE le32_or(FILE_ADD_FILE, le32_or(FILE_ADD_SUBDIRECTORY, le32_or(FILE_DELETE_CHILD, \
le32_or(READ_CONTROL, le32_or(FILE_WRITE_ATTRIBUTES, FILE_WRITE_EA)))))
#define DIR_EXEC (FILE_TRAVERSE)
/* flags tested for meaning exec, write or read */
/* tests for write allow for interpretation of a sticky bit */
#define FILE_GREAD (FILE_READ_DATA | GENERIC_READ)
#define FILE_GWRITE (FILE_WRITE_DATA | FILE_APPEND_DATA | GENERIC_WRITE)
#define FILE_GEXEC (FILE_EXECUTE | GENERIC_EXECUTE)
#define DIR_GREAD (FILE_LIST_DIRECTORY | GENERIC_READ)
#define DIR_GWRITE (FILE_ADD_FILE | FILE_ADD_SUBDIRECTORY | GENERIC_WRITE)
#define DIR_GEXEC (FILE_TRAVERSE | GENERIC_EXECUTE)
#define FILE_GREAD le32_or(FILE_READ_DATA, GENERIC_READ)
#define FILE_GWRITE le32_or(FILE_WRITE_DATA, le32_or(FILE_APPEND_DATA, GENERIC_WRITE))
#define FILE_GEXEC le32_or(FILE_EXECUTE, GENERIC_EXECUTE)
#define DIR_GREAD le32_or(FILE_LIST_DIRECTORY, GENERIC_READ)
#define DIR_GWRITE le32_or(FILE_ADD_FILE, le32_or(FILE_ADD_SUBDIRECTORY, GENERIC_WRITE))
#define DIR_GEXEC le32_or(FILE_TRAVERSE, GENERIC_EXECUTE)
/* standard owner (and administrator) rights */
#define OWNER_RIGHTS (DELETE | READ_CONTROL | WRITE_DAC | WRITE_OWNER \
| SYNCHRONIZE \
| FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES \
| FILE_READ_EA | FILE_WRITE_EA)
#define OWNER_RIGHTS le32_or(DELETE, le32_or(READ_CONTROL, le32_or(WRITE_DAC, le32_or(WRITE_OWNER, \
le32_or(SYNCHRONIZE, \
le32_or(FILE_READ_ATTRIBUTES, le32_or(FILE_WRITE_ATTRIBUTES, \
le32_or(FILE_READ_EA, FILE_WRITE_EA))))))))
/* standard world rights */
#define WORLD_RIGHTS (READ_CONTROL | FILE_READ_ATTRIBUTES | FILE_READ_EA \
| SYNCHRONIZE)
#define WORLD_RIGHTS le32_or(READ_CONTROL, le32_or(FILE_READ_ATTRIBUTES, le32_or(FILE_READ_EA, \
SYNCHRONIZE)))
/* inheritance flags for files and directories */

2
include/ntfs-3g/endians.h
View File

@ -332,4 +332,6 @@
#define le16_or(a, b) ((a) | (b))
#define le32_or(a, b) ((a) | (b))
#endif /* defined _NTFS_ENDIANS_H */

216
libntfs-3g/acls.c
View File

@ -766,8 +766,8 @@ int ntfs_inherit_acl(const ACL *oldacl, ACL *newacl,
if ((poldace->flags & selection)
&& (!fordir
|| (poldace->flags & NO_PROPAGATE_INHERIT_ACE)
|| !le32_andz(poldace->mask, GENERIC_ALL | GENERIC_READ
| GENERIC_WRITE | GENERIC_EXECUTE))
|| !le32_andz(poldace->mask, le32_or(GENERIC_ALL, le32_or(GENERIC_READ,
le32_or(GENERIC_WRITE, GENERIC_EXECUTE)))))
&& !ntfs_same_sid(&poldace->sid, ownersid)
&& !ntfs_same_sid(&poldace->sid, groupsid)) {
pnewace = (ACCESS_ALLOWED_ACE*)
@ -777,50 +777,50 @@ int ntfs_inherit_acl(const ACL *oldacl, ACL *newacl,
if (!le32_andz(pnewace->mask, GENERIC_ALL)) {
pnewace->mask = le32_and(pnewace->mask, ~GENERIC_ALL);
if (fordir)
pnewace->mask |= OWNER_RIGHTS
| DIR_READ
| DIR_WRITE
| DIR_EXEC;
pnewace->mask = le32_or(pnewace->mask, le32_or(OWNER_RIGHTS,
le32_or(DIR_READ,
le32_or(DIR_WRITE,
DIR_EXEC))));
else
/*
* The last flag is not defined for a file,
* however Windows sets it, so do the same
*/
pnewace->mask |= OWNER_RIGHTS
| FILE_READ
| FILE_WRITE
| FILE_EXEC
| const_cpu_to_le32(0x40);
pnewace->mask = le32_or(pnewace->mask, le32_or(OWNER_RIGHTS,
le32_or(FILE_READ,
le32_or(FILE_WRITE,
le32_or(FILE_EXEC,
const_cpu_to_le32(0x40))))));
}
/* reencode GENERIC_READ (+ EXECUTE) */
if (!le32_andz(pnewace->mask, GENERIC_READ)) {
if (fordir)
pnewace->mask |= OWNER_RIGHTS
| DIR_READ
| DIR_EXEC;
pnewace->mask = le32_or(pnewace->mask, le32_or(OWNER_RIGHTS,
le32_or(DIR_READ,
DIR_EXEC)));
else
pnewace->mask |= OWNER_RIGHTS
| FILE_READ
| FILE_EXEC;
pnewace->mask = le32_and(pnewace->mask, ~(GENERIC_READ
| GENERIC_EXECUTE
| WRITE_DAC
| WRITE_OWNER
| DELETE | FILE_WRITE_EA
| FILE_WRITE_ATTRIBUTES));
pnewace->mask = le32_or(pnewace->mask, le32_or(OWNER_RIGHTS,
le32_or(FILE_READ,
FILE_EXEC)));
pnewace->mask = le32_and(pnewace->mask, ~(le32_or(GENERIC_READ,
le32_or(GENERIC_EXECUTE,
le32_or(WRITE_DAC,
le32_or(WRITE_OWNER,
le32_or(DELETE, le32_or(FILE_WRITE_EA,
FILE_WRITE_ATTRIBUTES))))))));
}
/* reencode GENERIC_WRITE */
if (!le32_andz(pnewace->mask, GENERIC_WRITE)) {
if (fordir)
pnewace->mask |= OWNER_RIGHTS
| DIR_WRITE;
pnewace->mask = le32_or(pnewace->mask, le32_or(OWNER_RIGHTS,
DIR_WRITE));
else
pnewace->mask |= OWNER_RIGHTS
| FILE_WRITE;
pnewace->mask = le32_and(pnewace->mask, ~(GENERIC_WRITE
| WRITE_DAC
| WRITE_OWNER
| FILE_DELETE_CHILD));
pnewace->mask = le32_or(pnewace->mask, le32_or(OWNER_RIGHTS,
FILE_WRITE));
pnewace->mask = le32_and(pnewace->mask, ~(le32_or(GENERIC_WRITE,
le32_or(WRITE_DAC,
le32_or(WRITE_OWNER,
FILE_DELETE_CHILD)))));
}
/* remove inheritance flags */
pnewace->flags &= ~(OBJECT_INHERIT_ACE
@ -834,7 +834,7 @@ int ntfs_inherit_acl(const ACL *oldacl, ACL *newacl,
&& ntfs_same_sid(&poldace->sid, authsid)) {
if (pauthace) {
pauthace->flags |= pnewace->flags;
pauthace->mask |= pnewace->mask;
pauthace->mask = le32_or(pauthace->mask, pnewace->mask);
} else {
pauthace = pnewace;
if (!le16_cmpz(inherited))
@ -876,7 +876,7 @@ int ntfs_inherit_acl(const ACL *oldacl, ACL *newacl,
if ((pnewace->type == ACCESS_ALLOWED_ACE_TYPE)
&& pownerace
&& !(pnewace->flags & ~pownerace->flags)) {
pownerace->mask |= pnewace->mask;
pownerace->mask = le32_or(pownerace->mask, pnewace->mask);
} else {
dst += usidsz + 8;
newcnt++;
@ -916,8 +916,8 @@ int ntfs_inherit_acl(const ACL *oldacl, ACL *newacl,
&& !(poldace->flags & NO_PROPAGATE_INHERIT_ACE)
&& !ntfs_same_sid(&poldace->sid, ownersid)
&& !ntfs_same_sid(&poldace->sid, groupsid)) {
if (!le32_andz(poldace->mask, GENERIC_ALL | GENERIC_READ
| GENERIC_WRITE | GENERIC_EXECUTE))
if (!le32_andz(poldace->mask, le32_or(GENERIC_ALL, le32_or(GENERIC_READ,
le32_or(GENERIC_WRITE, GENERIC_EXECUTE)))))
pnewace->flags |= INHERIT_ONLY_ACE;
else
pnewace->flags &= ~INHERIT_ONLY_ACE;
@ -2472,19 +2472,19 @@ static int buildacls(char *secattr, int offs, mode_t mode, int isdir,
if (isdir) {
gflags = DIR_INHERITANCE;
if (mode & S_IXUSR)
grants |= DIR_EXEC;
grants = le32_or(grants, DIR_EXEC);
if (mode & S_IWUSR)
grants |= DIR_WRITE;
grants = le32_or(grants, DIR_WRITE);
if (mode & S_IRUSR)
grants |= DIR_READ;
grants = le32_or(grants, DIR_READ);
} else {
gflags = FILE_INHERITANCE;
if (mode & S_IXUSR)
grants |= FILE_EXEC;
grants = le32_or(grants, FILE_EXEC);
if (mode & S_IWUSR)
grants |= FILE_WRITE;
grants = le32_or(grants, FILE_WRITE);
if (mode & S_IRUSR)
grants |= FILE_READ;
grants = le32_or(grants, FILE_READ);
}
/* a possible ACE to deny owner what he/she would */
@ -2498,37 +2498,37 @@ static int buildacls(char *secattr, int offs, mode_t mode, int isdir,
if (isdir) {
pdace->flags = DIR_INHERITANCE;
if (mode & (S_IXGRP | S_IXOTH))
denials |= DIR_EXEC;
denials = le32_or(denials, DIR_EXEC);
if (mode & (S_IWGRP | S_IWOTH))
denials |= DIR_WRITE;
denials = le32_or(denials, DIR_WRITE);
if (mode & (S_IRGRP | S_IROTH))
denials |= DIR_READ;
denials = le32_or(denials, DIR_READ);
} else {
pdace->flags = FILE_INHERITANCE;
if (mode & (S_IXGRP | S_IXOTH))
denials |= FILE_EXEC;
denials = le32_or(denials, FILE_EXEC);
if (mode & (S_IWGRP | S_IWOTH))
denials |= FILE_WRITE;
denials = le32_or(denials, FILE_WRITE);
if (mode & (S_IRGRP | S_IROTH))
denials |= FILE_READ;
denials = le32_or(denials, FILE_READ);
}
} else {
if (isdir) {
pdace->flags = DIR_INHERITANCE;
if ((mode & S_IXOTH) && !(mode & S_IXGRP))
denials |= DIR_EXEC;
denials = le32_or(denials, DIR_EXEC);
if ((mode & S_IWOTH) && !(mode & S_IWGRP))
denials |= DIR_WRITE;
denials = le32_or(denials, DIR_WRITE);
if ((mode & S_IROTH) && !(mode & S_IRGRP))
denials |= DIR_READ;
denials = le32_or(denials, DIR_READ);
} else {
pdace->flags = FILE_INHERITANCE;
if ((mode & S_IXOTH) && !(mode & S_IXGRP))
denials |= FILE_EXEC;
denials = le32_or(denials, FILE_EXEC);
if ((mode & S_IWOTH) && !(mode & S_IWGRP))
denials |= FILE_WRITE;
denials = le32_or(denials, FILE_WRITE);
if ((mode & S_IROTH) && !(mode & S_IRGRP))
denials |= FILE_READ;
denials = le32_or(denials, FILE_READ);
}
}
denials = le32_and(denials, ~grants);
@ -2580,19 +2580,19 @@ static int buildacls(char *secattr, int offs, mode_t mode, int isdir,
if (isdir) {
gflags = DIR_INHERITANCE;
if (mode & S_IXGRP)
grants |= DIR_EXEC;
grants = le32_or(grants, DIR_EXEC);
if (mode & S_IWGRP)
grants |= DIR_WRITE;
grants = le32_or(grants, DIR_WRITE);
if (mode & S_IRGRP)
grants |= DIR_READ;
grants = le32_or(grants, DIR_READ);
} else {
gflags = FILE_INHERITANCE;
if (mode & S_IXGRP)
grants |= FILE_EXEC;
grants = le32_or(grants, FILE_EXEC);
if (mode & S_IWGRP)
grants |= FILE_WRITE;
grants = le32_or(grants, FILE_WRITE);
if (mode & S_IRGRP)
grants |= FILE_READ;
grants = le32_or(grants, FILE_READ);
}
/* a possible ACE to deny group what it would get from world */
@ -2604,21 +2604,21 @@ static int buildacls(char *secattr, int offs, mode_t mode, int isdir,
if (isdir) {
pdace->flags = DIR_INHERITANCE;
if (mode & S_IXOTH)
denials |= DIR_EXEC;
denials = le32_or(denials, DIR_EXEC);
if (mode & S_IWOTH)
denials |= DIR_WRITE;
denials = le32_or(denials, DIR_WRITE);
if (mode & S_IROTH)
denials |= DIR_READ;
denials = le32_or(denials, DIR_READ);
} else {
pdace->flags = FILE_INHERITANCE;
if (mode & S_IXOTH)
denials |= FILE_EXEC;
denials = le32_or(denials, FILE_EXEC);
if (mode & S_IWOTH)
denials |= FILE_WRITE;
denials = le32_or(denials, FILE_WRITE);
if (mode & S_IROTH)
denials |= FILE_READ;
denials = le32_or(denials, FILE_READ);
}
denials = le32_and(denials, ~(grants | OWNER_RIGHTS));
denials = le32_and(denials, ~(le32_or(grants, OWNER_RIGHTS)));
if (!le32_cmpz(denials)) {
pdace->type = ACCESS_DENIED_ACE_TYPE;
pdace->size = cpu_to_le16(gsidsz + 8);
@ -2653,19 +2653,19 @@ static int buildacls(char *secattr, int offs, mode_t mode, int isdir,
if (isdir) {
pgace->flags = DIR_INHERITANCE;
if (mode & S_IXOTH)
grants |= DIR_EXEC;
grants = le32_or(grants, DIR_EXEC);
if (mode & S_IWOTH)
grants |= DIR_WRITE;
grants = le32_or(grants, DIR_WRITE);
if (mode & S_IROTH)
grants |= DIR_READ;
grants = le32_or(grants, DIR_READ);
} else {
pgace->flags = FILE_INHERITANCE;
if (mode & S_IXOTH)
grants |= FILE_EXEC;
grants = le32_or(grants, FILE_EXEC);
if (mode & S_IWOTH)
grants |= FILE_WRITE;
grants = le32_or(grants, FILE_WRITE);
if (mode & S_IROTH)
grants |= FILE_READ;
grants = le32_or(grants, FILE_READ);
}
pgace->size = cpu_to_le16(wsidsz + 8);
pgace->mask = grants;
@ -2683,7 +2683,7 @@ static int buildacls(char *secattr, int offs, mode_t mode, int isdir,
else
pgace->flags = FILE_INHERITANCE;
pgace->size = cpu_to_le16(asidsz + 8);
grants = OWNER_RIGHTS | FILE_READ | FILE_WRITE | FILE_EXEC;
grants = le32_or(OWNER_RIGHTS, le32_or(FILE_READ, le32_or(FILE_WRITE, FILE_EXEC)));
pgace->mask = grants;
memcpy((char*)&pgace->sid, adminsid, asidsz);
pos += asidsz + 8;
@ -2699,7 +2699,7 @@ static int buildacls(char *secattr, int offs, mode_t mode, int isdir,
else
pgace->flags = FILE_INHERITANCE;
pgace->size = cpu_to_le16(ssidsz + 8);
grants = OWNER_RIGHTS | FILE_READ | FILE_WRITE | FILE_EXEC;
grants = le32_or(OWNER_RIGHTS, le32_or(FILE_READ, le32_or(FILE_WRITE, FILE_EXEC)));
pgace->mask = grants;
memcpy((char*)&pgace->sid, systemsid, ssidsz);
pos += ssidsz + 8;
@ -2716,11 +2716,11 @@ static int buildacls(char *secattr, int offs, mode_t mode, int isdir,
pgace->size = cpu_to_le16(nsidsz + 8);
grants = const_cpu_to_le32(0);
if (mode & S_ISUID)
grants |= FILE_APPEND_DATA;
grants = le32_or(grants, FILE_APPEND_DATA);
if (mode & S_ISGID)
grants |= FILE_WRITE_DATA;
grants = le32_or(grants, FILE_WRITE_DATA);
if (mode & S_ISVTX)
grants |= FILE_READ_DATA;
grants = le32_or(grants, FILE_READ_DATA);
pgace->mask = grants;
memcpy((char*)&pgace->sid, nullsid, nsidsz);
pos += nsidsz + 8;
@ -3218,27 +3218,27 @@ static int build_std_permissions(const char *securattr,
|| ntfs_same_sid(ownersid, &pace->sid)) {
noown = FALSE;
if (pace->type == ACCESS_ALLOWED_ACE_TYPE)
allowown |= pace->mask;
allowown = le32_or(allowown, pace->mask);
else if (pace->type == ACCESS_DENIED_ACE_TYPE)
denyown |= pace->mask;
denyown = le32_or(denyown, pace->mask);
} else
if (ntfs_same_sid(gsid, &pace->sid)
&& le32_andz(pace->mask, WRITE_OWNER)) {
if (pace->type == ACCESS_ALLOWED_ACE_TYPE)
allowgrp |= pace->mask;
allowgrp = le32_or(allowgrp, pace->mask);
else if (pace->type == ACCESS_DENIED_ACE_TYPE)
denygrp |= pace->mask;
denygrp = le32_or(denygrp, pace->mask);
} else
if (is_world_sid((const SID*)&pace->sid)) {
if (pace->type == ACCESS_ALLOWED_ACE_TYPE)
allowall |= pace->mask;
allowall = le32_or(allowall, pace->mask);
else
if (pace->type == ACCESS_DENIED_ACE_TYPE)
denyall |= pace->mask;
denyall = le32_or(denyall, pace->mask);
} else
if ((ntfs_same_sid((const SID*)&pace->sid,nullsid))
&& (pace->type == ACCESS_ALLOWED_ACE_TYPE))
special |= pace->mask;
special = le32_or(special, pace->mask);
}
offace += le16_to_cpu(pace->size);
}
@ -3249,17 +3249,17 @@ static int build_std_permissions(const char *securattr,
* merges the admin ACEs
*/
if (noown)
allowown = (FILE_READ_DATA | FILE_WRITE_DATA | FILE_EXECUTE);
allowown = le32_or(FILE_READ_DATA, le32_or(FILE_WRITE_DATA, FILE_EXECUTE));
/*
* Add to owner rights granted to group or world
* unless denied personaly, and add to group rights
* granted to world unless denied specifically
*/
allowown |= (allowgrp | allowall);
allowgrp |= allowall;
allowown = le32_or(allowown, le32_or(allowgrp, allowall));
allowgrp = le32_or(allowgrp, allowall);
return (merge_permissions(isdir,
le32_and(allowown, ~(denyown | denyall)),
le32_and(allowgrp, ~(denygrp | denyall)),
le32_and(allowown, ~(le32_or(denyown, denyall))),
le32_and(allowgrp, ~(le32_or(denygrp, denyall))),
le32_and(allowall, ~denyall),
special));
}
@ -3308,27 +3308,27 @@ static int build_owngrp_permissions(const char *securattr,
|| ntfs_same_sid(ownersid, &pace->sid))
&& !le32_andz(pace->mask, WRITE_OWNER)) {
if (pace->type == ACCESS_ALLOWED_ACE_TYPE) {
allowown |= pace->mask;
allowown = le32_or(allowown, pace->mask);
ownpresent = TRUE;
}
} else
if (ntfs_same_sid(usid, &pace->sid)
&& le32_andz(pace->mask, WRITE_OWNER)) {
if (pace->type == ACCESS_ALLOWED_ACE_TYPE) {
allowgrp |= pace->mask;
allowgrp = le32_or(allowgrp, pace->mask);
grppresent = TRUE;
}
} else
if (is_world_sid((const SID*)&pace->sid)) {
if (pace->type == ACCESS_ALLOWED_ACE_TYPE)
allowall |= pace->mask;
allowall = le32_or(allowall, pace->mask);
else
if (pace->type == ACCESS_DENIED_ACE_TYPE)
denyall |= pace->mask;
denyall = le32_or(denyall, pace->mask);
} else
if ((ntfs_same_sid((const SID*)&pace->sid,nullsid))
&& (pace->type == ACCESS_ALLOWED_ACE_TYPE))
special |= pace->mask;
special = le32_or(special, pace->mask);
}
offace += le16_to_cpu(pace->size);
}
@ -3337,8 +3337,8 @@ static int build_owngrp_permissions(const char *securattr,
if (!grppresent)
allowgrp = allowall;
return (merge_permissions(isdir,
le32_and(allowown, ~(denyown | denyall)),
le32_and(allowgrp, ~(denygrp | denyall)),
le32_and(allowown, ~(le32_or(denyown, denyall))),
le32_and(allowgrp, ~(le32_or(denygrp, denyall))),
le32_and(allowall, ~denyall),
special));
}
@ -3494,47 +3494,47 @@ static int build_ownadmin_permissions(const char *securattr,
for (nace = 0; nace < acecnt; nace++) {
pace = (const ACCESS_ALLOWED_ACE*)&securattr[offace];
if (!(pace->flags & INHERIT_ONLY_ACE)
&& le32_andz(~pace->mask, ROOT_OWNER_UNMARK | ROOT_GROUP_UNMARK)) {
&& le32_andz(~pace->mask, le32_or(ROOT_OWNER_UNMARK, ROOT_GROUP_UNMARK))) {
if ((ntfs_same_sid(usid, &pace->sid)
|| ntfs_same_sid(ownersid, &pace->sid))
&& ((!le32_andz(pace->mask, WRITE_OWNER) && firstapply))) {
if (pace->type == ACCESS_ALLOWED_ACE_TYPE) {
allowown |= pace->mask;
allowown = le32_or(allowown, pace->mask);
isforeign &= ~1;
} else
if (pace->type == ACCESS_DENIED_ACE_TYPE)
denyown |= pace->mask;
denyown = le32_or(denyown, pace->mask);
} else
if (ntfs_same_sid(gsid, &pace->sid)
&& (le32_andz(pace->mask, WRITE_OWNER))) {
if (pace->type == ACCESS_ALLOWED_ACE_TYPE) {
allowgrp |= pace->mask;
allowgrp = le32_or(allowgrp, pace->mask);
isforeign &= ~2;
} else
if (pace->type == ACCESS_DENIED_ACE_TYPE)
denygrp |= pace->mask;
denygrp = le32_or(denygrp, pace->mask);
} else if (is_world_sid((const SID*)&pace->sid)) {
if (pace->type == ACCESS_ALLOWED_ACE_TYPE)
allowall |= pace->mask;
allowall = le32_or(allowall, pace->mask);
else
if (pace->type == ACCESS_DENIED_ACE_TYPE)
denyall |= pace->mask;
denyall = le32_or(denyall, pace->mask);
}
firstapply = FALSE;
} else
if (!(pace->flags & INHERIT_ONLY_ACE))
if ((ntfs_same_sid((const SID*)&pace->sid,nullsid))
&& (pace->type == ACCESS_ALLOWED_ACE_TYPE))
special |= pace->mask;
special = le32_or(special, pace->mask);
offace += le16_to_cpu(pace->size);
}
if (isforeign) {
allowown |= (allowgrp | allowall);
allowgrp |= allowall;
allowown = le32_or(allowown, le32_or(allowgrp, allowall));
allowgrp = le32_or(allowgrp, allowall);
}
return (merge_permissions(isdir,
le32_and(allowown, ~(denyown | denyall)),
le32_and(allowgrp, ~(denygrp | denyall)),
le32_and(allowown, ~(le32_or(denyown, denyall))),
le32_and(allowgrp, ~(le32_or(denygrp, denyall))),
le32_and(allowall, ~denyall),
special));
}

2
libntfs-3g/attrib.c
View File

@ -93,7 +93,7 @@ static int NAttrFlag(ntfs_attr *na, FILE_ATTR_FLAGS flag)
static void NAttrSetFlag(ntfs_attr *na, FILE_ATTR_FLAGS flag)
{
if (le32_eq(na->type, AT_DATA) && na->name == AT_UNNAMED)
na->ni->flags |= flag;
na->ni->flags = le32_or(na->ni->flags, flag);
else
ntfs_log_trace("Denied setting flag %d for not unnamed data "
"attribute\n", flag);

8
libntfs-3g/compress.c
View File

@ -856,7 +856,7 @@ do_next_cb:
err = errno;
na->data_size = tdata_size;
na->initialized_size = tinitialized_size;
na->ni->flags |= compression;
na->ni->flags = le32_or(na->ni->flags, compression);
na->data_flags = data_flags;
free(cb);
free(dest);
@ -873,7 +873,7 @@ do_next_cb:
} while (to_read > 0);
na->data_size = tdata_size;
na->initialized_size = tinitialized_size;
na->ni->flags |= compression;
na->ni->flags = le32_or(na->ni->flags, compression);
na->data_flags = data_flags;
ofs = 0;
} else {
@ -916,7 +916,7 @@ do_next_cb:
err = errno;
na->data_size = tdata_size;
na->initialized_size = tinitialized_size;
na->ni->flags |= compression;
na->ni->flags = le32_or(na->ni->flags, compression);
na->data_flags = data_flags;
free(cb);
free(dest);
@ -930,7 +930,7 @@ do_next_cb:
} while (to_read > 0);
na->data_size = tdata_size;
na->initialized_size = tinitialized_size;
na->ni->flags |= compression;
na->ni->flags = le32_or(na->ni->flags, compression);
na->data_flags = data_flags;
/* Just a precaution. */
if (cb_pos + 2 <= cb_end)

18
libntfs-3g/dir.c
View File

@ -988,7 +988,7 @@ static int ntfs_filldir(ntfs_inode *dir_ni, s64 *pos, u8 ivcn_bits,
if (MREF_LE(ie->indexed_file) == FILE_root)
return 0;
if (!le32_andz(ie->key.file_name.file_attributes,
FILE_ATTR_REPARSE_POINT | FILE_ATTR_SYSTEM)
le32_or(FILE_ATTR_REPARSE_POINT, FILE_ATTR_SYSTEM))
&& !metadata)
dt_type = ntfs_dir_entry_type(dir_ni, mref,
ie->key.file_name.file_attributes);
@ -1541,12 +1541,12 @@ static ntfs_inode *__ntfs_create(ntfs_inode *dir_ni, le32 securid,
si->file_attributes = FILE_ATTR_SYSTEM;
ni->flags = FILE_ATTR_SYSTEM;
}
ni->flags |= FILE_ATTR_ARCHIVE;
ni->flags = le32_or(ni->flags, FILE_ATTR_ARCHIVE);
if (NVolHideDotFiles(dir_ni->vol)
&& (name_len > 1)
&& (le16_eq(name[0], const_cpu_to_le16('.')))
&& (!le16_eq(name[1], const_cpu_to_le16('.'))))
ni->flags |= FILE_ATTR_HIDDEN;
ni->flags = le32_or(ni->flags, FILE_ATTR_HIDDEN);
/*
* Set compression flag according to parent directory
* unless NTFS version < 3.0 or cluster size > 4K
@ -1557,7 +1557,7 @@ static ntfs_inode *__ntfs_create(ntfs_inode *dir_ni, le32 securid,
&& NVolCompression(dir_ni->vol)
&& (dir_ni->vol->cluster_size <= MAX_COMPRESSION_CLUSTER_SIZE)
&& (S_ISREG(type) || S_ISDIR(type)))
ni->flags |= FILE_ATTR_COMPRESSED;
ni->flags = le32_or(ni->flags, FILE_ATTR_COMPRESSED);
/* Add STANDARD_INFORMATION to inode. */
if (ntfs_attr_add(ni, AT_STANDARD_INFORMATION, AT_UNNAMED, 0,
(u8*)si, si_len)) {
@ -1683,9 +1683,9 @@ static ntfs_inode *__ntfs_create(ntfs_inode *dir_ni, le32 securid,
if (!S_ISREG(type) && !S_ISDIR(type))
fn->file_attributes = FILE_ATTR_SYSTEM;
else
fn->file_attributes |= le32_and(ni->flags, FILE_ATTR_COMPRESSED);
fn->file_attributes |= FILE_ATTR_ARCHIVE;
fn->file_attributes |= le32_and(ni->flags, FILE_ATTR_HIDDEN);
fn->file_attributes = le32_or(fn->file_attributes, le32_and(ni->flags, FILE_ATTR_COMPRESSED));
fn->file_attributes = le32_or(fn->file_attributes, FILE_ATTR_ARCHIVE);
fn->file_attributes = le32_or(fn->file_attributes, le32_and(ni->flags, FILE_ATTR_HIDDEN));
fn->creation_time = ni->creation_time;
fn->last_data_change_time = ni->last_data_change_time;
fn->last_mft_change_time = ni->last_mft_change_time;
@ -2167,7 +2167,7 @@ static int ntfs_link_i(ntfs_inode *ni, ntfs_inode *dir_ni, const ntfschar *name,
if ((name_len > 1)
&& (le16_eq(name[0], const_cpu_to_le16('.')))
&& (!le16_eq(name[1], const_cpu_to_le16('.'))))
ni->flags |= FILE_ATTR_HIDDEN;
ni->flags = le32_or(ni->flags, FILE_ATTR_HIDDEN);
else
ni->flags = le32_and(ni->flags, ~FILE_ATTR_HIDDEN);
}
@ -2185,7 +2185,7 @@ static int ntfs_link_i(ntfs_inode *ni, ntfs_inode *dir_ni, const ntfschar *name,
fn->file_name_type = nametype;
fn->file_attributes = ni->flags;
if (!le16_andz(ni->mrec->flags, MFT_RECORD_IS_DIRECTORY)) {
fn->file_attributes |= FILE_ATTR_I30_INDEX_PRESENT;
fn->file_attributes = le32_or(fn->file_attributes, FILE_ATTR_I30_INDEX_PRESENT);
fn->data_size = fn->allocated_size = const_cpu_to_le64(0);
} else {
fn->allocated_size = cpu_to_sle64(ni->allocated_size);

4
libntfs-3g/efs.c
View File

@ -222,7 +222,7 @@ int ntfs_set_efs_info(ntfs_inode *ni, const char *value, size_t size,
res = 0;
if (ni && value && size) {
if (!le32_andz(ni->flags, FILE_ATTR_ENCRYPTED | FILE_ATTR_COMPRESSED)) {
if (!le32_andz(ni->flags, le32_or(FILE_ATTR_ENCRYPTED, FILE_ATTR_COMPRESSED))) {
if (!le32_andz(ni->flags, FILE_ATTR_ENCRYPTED)) {
ntfs_log_trace("Inode %lld already encrypted\n",
(long long)ni->mft_no);
@ -297,7 +297,7 @@ int ntfs_set_efs_info(ntfs_inode *ni, const char *value, size_t size,
if (fixup_loop(ni))
return -1;
}
ni->flags |= FILE_ATTR_ENCRYPTED;
ni->flags = le32_or(ni->flags, FILE_ATTR_ENCRYPTED);
NInoSetDirty(ni);
NInoFileNameSetDirty(ni);
}

4
libntfs-3g/inode.c
View File

@ -870,8 +870,8 @@ static int ntfs_inode_sync_file_name(ntfs_inode *ni, ntfs_inode *dir_ni)
/* Update flags and file size. */
fnx = (FILE_NAME_ATTR *)ictx->data;
fnx->file_attributes =
le32_and(fnx->file_attributes, ~FILE_ATTR_VALID_FLAGS) |
le32_and(ni->flags, FILE_ATTR_VALID_FLAGS);
le32_or(le32_and(fnx->file_attributes, ~FILE_ATTR_VALID_FLAGS),
le32_and(ni->flags, FILE_ATTR_VALID_FLAGS));
if (!le16_andz(ni->mrec->flags, MFT_RECORD_IS_DIRECTORY))
fnx->data_size = fnx->allocated_size
= const_cpu_to_le64(0);

4
libntfs-3g/reparse.c
View File

@ -1138,8 +1138,8 @@ int ntfs_set_ntfs_reparse_data(ntfs_inode *ni,
AT_UNNAMED,0,&dummy,
(s64)0);
if (!res) {
ni->flags |=
FILE_ATTR_REPARSE_POINT;
ni->flags = le32_or(ni->flags,
FILE_ATTR_REPARSE_POINT);
NInoFileNameSetDirty(ni);
}
NInoSetDirty(ni);

28
libntfs-3g/security.c
View File

@ -76,13 +76,13 @@
#define FIRST_SECURITY_ID 0x100 /* Lowest security id */
/* Mask for attributes which can be forced */
#define FILE_ATTR_SETTABLE ( FILE_ATTR_READONLY \
| FILE_ATTR_HIDDEN \
| FILE_ATTR_SYSTEM \
| FILE_ATTR_ARCHIVE \
| FILE_ATTR_TEMPORARY \
| FILE_ATTR_OFFLINE \
| FILE_ATTR_NOT_CONTENT_INDEXED )
#define FILE_ATTR_SETTABLE le32_or(FILE_ATTR_READONLY, \
le32_or(FILE_ATTR_HIDDEN, \
le32_or(FILE_ATTR_SYSTEM, \
le32_or(FILE_ATTR_ARCHIVE, \
le32_or(FILE_ATTR_TEMPORARY, \
le32_or(FILE_ATTR_OFFLINE, \
FILE_ATTR_NOT_CONTENT_INDEXED))))))
struct SII { /* this is an image of an $SII index entry */
le16 offs;
@ -2951,7 +2951,7 @@ int ntfs_set_owner_mode(struct SECURITY_CONTEXT *scx, ntfs_inode *ni,
if (mode & S_IWUSR)
ni->flags = le32_and(ni->flags, ~FILE_ATTR_READONLY);
else
ni->flags |= FILE_ATTR_READONLY;
ni->flags = le32_or(ni->flags, FILE_ATTR_READONLY);
NInoFileNameSetDirty(ni);
}
/* update cache, for subsequent use */
@ -4434,7 +4434,7 @@ int ntfs_set_ntfs_attrib(ntfs_inode *ni,
* Accept changing compression for a directory
* and set index root accordingly
*/
settable |= FILE_ATTR_COMPRESSED;
settable = le32_or(settable, FILE_ATTR_COMPRESSED);
if (!le32_andz(ni->flags ^ cpu_to_le32(attrib),
FILE_ATTR_COMPRESSED)) {
if (!le32_andz(ni->flags, FILE_ATTR_COMPRESSED))
@ -4449,8 +4449,8 @@ int ntfs_set_ntfs_attrib(ntfs_inode *ni,
}
}
if (!res) {
ni->flags = le32_and(ni->flags, ~settable) |
le32_and(cpu_to_le32(attrib), settable);
ni->flags = le32_or(le32_and(ni->flags, ~settable),
le32_and(cpu_to_le32(attrib), settable));
NInoFileNameSetDirty(ni);
NInoSetDirty(ni);
}
@ -5039,7 +5039,7 @@ BOOL ntfs_set_file_attributes(struct SECURITY_API *scapi,
* Accept changing compression for a directory
* and set index root accordingly
*/
settable |= FILE_ATTR_COMPRESSED;
settable = le32_or(settable, FILE_ATTR_COMPRESSED);
if (!le32_andz(ni->flags ^ cpu_to_le32(attrib),
FILE_ATTR_COMPRESSED)) {
if (!le32_andz(ni->flags, FILE_ATTR_COMPRESSED))
@ -5054,8 +5054,8 @@ BOOL ntfs_set_file_attributes(struct SECURITY_API *scapi,
}
}
if (!res) {
ni->flags = le32_and(ni->flags, ~settable)
| le32_and(cpu_to_le32(attrib), settable);
ni->flags = le32_or(le32_and(ni->flags, ~settable),
le32_and(cpu_to_le32(attrib), settable));
NInoSetDirty(ni);
NInoFileNameSetDirty(ni);
}

50
ntfsprogs/mkntfs.c
View File

@ -4288,7 +4288,7 @@ static BOOL create_file_volume(MFT_RECORD *m, leMFT_REF root_ref,
m = (MFT_RECORD*)(g_buf + 3 * g_vol->mft_record_size);
err = create_hardlink(g_index_block, root_ref, m,
MK_LE_MREF(FILE_Volume, FILE_Volume), 0LL, 0LL,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,
le32_or(FILE_ATTR_HIDDEN, FILE_ATTR_SYSTEM), 0, 0,
"$Volume", FILE_NAME_WIN32_AND_DOS);
if (!err) {
init_system_file_sd(FILE_Volume, &sd, &i);
@ -4440,13 +4440,13 @@ static BOOL mkntfs_create_root_structures(void)
m->flags = le16_or(m->flags, MFT_RECORD_IN_USE);
ntfs_bit_set(g_mft_bitmap, 0LL + i, 1);
}
file_attrs = FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM;
file_attrs = le32_or(FILE_ATTR_HIDDEN, FILE_ATTR_SYSTEM);
if (i == FILE_root) {
file_attrs |= FILE_ATTR_ARCHIVE;
file_attrs = le32_or(file_attrs, FILE_ATTR_ARCHIVE);
if (opts.disable_indexing)
file_attrs |= FILE_ATTR_NOT_CONTENT_INDEXED;
file_attrs = le32_or(file_attrs, FILE_ATTR_NOT_CONTENT_INDEXED);
if (opts.enable_compression)
file_attrs |= FILE_ATTR_COMPRESSED;
file_attrs = le32_or(file_attrs, FILE_ATTR_COMPRESSED);
}
/* setting specific security_id flag and */
/* file permissions for ntfs 3.x */
@ -4455,15 +4455,15 @@ static BOOL mkntfs_create_root_structures(void)
add_attr_std_info(m, file_attrs,
cpu_to_le32(0x0100));
} else if (i == 9) {
file_attrs |= FILE_ATTR_VIEW_INDEX_PRESENT;
file_attrs = le32_or(file_attrs, FILE_ATTR_VIEW_INDEX_PRESENT);
add_attr_std_info(m, file_attrs,
cpu_to_le32(0x0101));
} else if (i == 11) {
add_attr_std_info(m, file_attrs,
cpu_to_le32(0x0101));
} else if (i == 24 || i == 25 || i == 26) {
file_attrs |= FILE_ATTR_ARCHIVE;
file_attrs |= FILE_ATTR_VIEW_INDEX_PRESENT;
file_attrs = le32_or(file_attrs, FILE_ATTR_ARCHIVE);
file_attrs = le32_or(file_attrs, FILE_ATTR_VIEW_INDEX_PRESENT);
add_attr_std_info(m, file_attrs,
cpu_to_le32(0x0101));
} else {
@ -4479,8 +4479,8 @@ static BOOL mkntfs_create_root_structures(void)
m->flags = le16_or(m->flags, MFT_RECORD_IS_DIRECTORY);
m->link_count = cpu_to_le16(le16_to_cpu(m->link_count) + 1);
err = add_attr_file_name(m, root_ref, 0LL, 0LL,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM |
FILE_ATTR_I30_INDEX_PRESENT, 0, 0, ".",
le32_or(FILE_ATTR_HIDDEN, le32_or(FILE_ATTR_SYSTEM,
FILE_ATTR_I30_INDEX_PRESENT)), 0, 0, ".",
FILE_NAME_WIN32_AND_DOS);
if (!err) {
init_root_sd(&sd, &i);
@ -4534,8 +4534,8 @@ static BOOL mkntfs_create_root_structures(void)
MK_LE_MREF(FILE_MFT, 1),
((g_mft_size - 1)
| (g_vol->cluster_size - 1)) + 1,
g_mft_size, FILE_ATTR_HIDDEN |
FILE_ATTR_SYSTEM, 0, 0, "$MFT",
g_mft_size, le32_or(FILE_ATTR_HIDDEN,
FILE_ATTR_SYSTEM), 0, 0, "$MFT",
FILE_NAME_WIN32_AND_DOS);
/* mft_bitmap is not modified in mkntfs; no need to sync it later. */
if (!err)
@ -4556,7 +4556,7 @@ static BOOL mkntfs_create_root_structures(void)
MK_LE_MREF(FILE_MFTMirr, FILE_MFTMirr),
g_rl_mftmirr[0].length * g_vol->cluster_size,
g_rl_mftmirr[0].length * g_vol->cluster_size,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,
le32_or(FILE_ATTR_HIDDEN, FILE_ATTR_SYSTEM), 0, 0,
"$MFTMirr", FILE_NAME_WIN32_AND_DOS);
if (err < 0) {
ntfs_log_error("Couldn't create $MFTMirr: %s\n",
@ -4572,7 +4572,7 @@ static BOOL mkntfs_create_root_structures(void)
err = create_hardlink(g_index_block, root_ref, m,
MK_LE_MREF(FILE_LogFile, FILE_LogFile),
g_logfile_size, g_logfile_size,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,
le32_or(FILE_ATTR_HIDDEN, FILE_ATTR_SYSTEM), 0, 0,
"$LogFile", FILE_NAME_WIN32_AND_DOS);
if (err < 0) {
ntfs_log_error("Couldn't create $LogFile: %s\n",
@ -4588,7 +4588,7 @@ static BOOL mkntfs_create_root_structures(void)
MK_LE_MREF(FILE_AttrDef, FILE_AttrDef),
(g_vol->attrdef_len + g_vol->cluster_size - 1) &
~(g_vol->cluster_size - 1), g_vol->attrdef_len,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,
le32_or(FILE_ATTR_HIDDEN, FILE_ATTR_SYSTEM), 0, 0,
"$AttrDef", FILE_NAME_WIN32_AND_DOS);
if (!err) {
init_system_file_sd(FILE_AttrDef, &sd, &i);
@ -4616,7 +4616,7 @@ static BOOL mkntfs_create_root_structures(void)
(g_lcn_bitmap_byte_size + g_vol->cluster_size -
1) & ~(g_vol->cluster_size - 1),
g_lcn_bitmap_byte_size,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,
le32_or(FILE_ATTR_HIDDEN, FILE_ATTR_SYSTEM), 0, 0,
"$Bitmap", FILE_NAME_WIN32_AND_DOS);
if (err < 0) {
ntfs_log_error("Couldn't create $Bitmap: %s\n", strerror(-err));
@ -4707,7 +4707,7 @@ static BOOL mkntfs_create_root_structures(void)
MK_LE_MREF(FILE_Boot, FILE_Boot),
(8192 + g_vol->cluster_size - 1) &
~(g_vol->cluster_size - 1), 8192,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,
le32_or(FILE_ATTR_HIDDEN, FILE_ATTR_SYSTEM), 0, 0,
"$Boot", FILE_NAME_WIN32_AND_DOS);
if (!err) {
init_system_file_sd(FILE_Boot, &sd, &i);
@ -4757,7 +4757,7 @@ static BOOL mkntfs_create_root_structures(void)
if (!err) {
err = create_hardlink(g_index_block, root_ref, m,
MK_LE_MREF(FILE_BadClus, FILE_BadClus),
0LL, 0LL, FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM,
0LL, 0LL, le32_or(FILE_ATTR_HIDDEN, FILE_ATTR_SYSTEM),
0, 0, "$BadClus", FILE_NAME_WIN32_AND_DOS);
}
if (err < 0) {
@ -4772,8 +4772,8 @@ static BOOL mkntfs_create_root_structures(void)
if (!err)
err = create_hardlink(g_index_block, root_ref, m,
MK_LE_MREF(9, 9), 0LL, 0LL,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM |
FILE_ATTR_VIEW_INDEX_PRESENT, 0, 0,
le32_or(FILE_ATTR_HIDDEN, le32_or(FILE_ATTR_SYSTEM,
FILE_ATTR_VIEW_INDEX_PRESENT)), 0, 0,
"$Secure", FILE_NAME_WIN32_AND_DOS);
buf_sds = NULL;
buf_sds_first_size = 0;
@ -4828,7 +4828,7 @@ static BOOL mkntfs_create_root_structures(void)
g_vol->cluster_size - 1) &
~(g_vol->cluster_size - 1),
g_vol->upcase_len << 1,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,
le32_or(FILE_ATTR_HIDDEN, FILE_ATTR_SYSTEM), 0, 0,
"$UpCase", FILE_NAME_WIN32_AND_DOS);
if (err < 0) {
ntfs_log_error("Couldn't create $UpCase: %s\n", strerror(-err));
@ -4844,8 +4844,8 @@ static BOOL mkntfs_create_root_structures(void)
if (!err)
err = create_hardlink(g_index_block, root_ref, m,
MK_LE_MREF(11, 11), 0LL, 0LL,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM |
FILE_ATTR_I30_INDEX_PRESENT, 0, 0,
le32_or(FILE_ATTR_HIDDEN, le32_or(FILE_ATTR_SYSTEM,
FILE_ATTR_I30_INDEX_PRESENT)), 0, 0,
"$Extend", FILE_NAME_WIN32_AND_DOS);
/* FIXME: This should be IGNORE_CASE */
if (!err)
@ -4875,8 +4875,8 @@ static BOOL mkntfs_create_root_structures(void)
}
/* create systemfiles for ntfs volumes (3.1) */
/* starting with file 24 (ignoring file 16-23) */
extend_flags = FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM |
FILE_ATTR_ARCHIVE | FILE_ATTR_VIEW_INDEX_PRESENT;
extend_flags = le32_or(FILE_ATTR_HIDDEN, le32_or(FILE_ATTR_SYSTEM,
le32_or(FILE_ATTR_ARCHIVE, FILE_ATTR_VIEW_INDEX_PRESENT)));
ntfs_log_verbose("Creating $Quota (mft record 24)\n");
m = (MFT_RECORD*)(g_buf + 24 * g_vol->mft_record_size);
m->flags = le16_or(m->flags, MFT_RECORD_IS_4);

2
ntfsprogs/ntfscp.c
View File

@ -620,7 +620,7 @@ static int set_sizes(struct ALLOC_CONTEXT *alctx, ntfs_attr_search_ctx *ctx)
ni->data_size = na->data_size;
if (!le16_andz(na->data_flags, ATTR_IS_SPARSE)) {
ni->allocated_size = na->compressed_size;
ni->flags |= FILE_ATTR_SPARSE_FILE;
ni->flags = le32_or(ni->flags, FILE_ATTR_SPARSE_FILE);
} else
ni->allocated_size = na->allocated_size;
}

2
ntfsprogs/ntfsfallocate.c
View File

@ -719,7 +719,7 @@ static int ntfs_full_allocation(ntfs_attr *na, ntfs_attr_search_ctx *ctx,
if (!le16_andz(na->data_flags, ATTR_IS_SPARSE)) {
ni->allocated_size
= na->compressed_size;
ni->flags |= FILE_ATTR_SPARSE_FILE;
ni->flags = le32_or(ni->flags, FILE_ATTR_SPARSE_FILE);
} else
ni->allocated_size
= na->allocated_size;

2
ntfsprogs/ntfsfix.c
View File

@ -380,7 +380,7 @@ static int clear_badclus(ntfs_volume *vol)
<< vol->cluster_size_bits)) {
na->data_size = 0;
na->initialized_size = 0;
ni->flags |= FILE_ATTR_SPARSE_FILE;
ni->flags = le32_or(ni->flags, FILE_ATTR_SPARSE_FILE);
NInoFileNameSetDirty(ni);
ok = TRUE;
} else {

6
ntfsprogs/ntfsundelete.c
View File

@ -1590,9 +1590,9 @@ static void dump_record(struct ufile *file)
ntfs_log_quiet("Compressed ");
if (!le32_andz(f->flags, FILE_ATTR_ENCRYPTED))
ntfs_log_quiet("Encrypted ");
if (le32_andz(f->flags, (FILE_ATTR_SYSTEM | FILE_ATTR_DIRECTORY |
FILE_ATTR_SPARSE_FILE | FILE_ATTR_REPARSE_POINT |
FILE_ATTR_COMPRESSED | FILE_ATTR_ENCRYPTED))) {
if (le32_andz(f->flags, le32_or(FILE_ATTR_SYSTEM, le32_or(FILE_ATTR_DIRECTORY,
le32_or(FILE_ATTR_SPARSE_FILE, le32_or(FILE_ATTR_REPARSE_POINT,
le32_or(FILE_ATTR_COMPRESSED, FILE_ATTR_ENCRYPTED))))))) {
ntfs_log_quiet("%s", NONE);
}

66
ntfsprogs/sd.c
View File

@ -64,14 +64,14 @@ void init_system_file_sd(int sys_file_no, u8 **sd_val, int *sd_val_len)
switch (sys_file_no) {
case FILE_AttrDef:
case FILE_Boot:
aa_ace->mask = SYNCHRONIZE | STANDARD_RIGHTS_READ |
FILE_READ_ATTRIBUTES | FILE_READ_EA | FILE_READ_DATA;
aa_ace->mask = le32_or(SYNCHRONIZE, le32_or(STANDARD_RIGHTS_READ,
le32_or(FILE_READ_ATTRIBUTES, le32_or(FILE_READ_EA, FILE_READ_DATA))));
break;
default:
aa_ace->mask = SYNCHRONIZE | STANDARD_RIGHTS_WRITE |
FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
FILE_WRITE_EA | FILE_READ_EA | FILE_APPEND_DATA |
FILE_WRITE_DATA | FILE_READ_DATA;
aa_ace->mask = le32_or(SYNCHRONIZE, le32_or(STANDARD_RIGHTS_WRITE,
le32_or(FILE_WRITE_ATTRIBUTES, le32_or(FILE_READ_ATTRIBUTES,
le32_or(FILE_WRITE_EA, le32_or(FILE_READ_EA, le32_or(FILE_APPEND_DATA,
le32_or(FILE_WRITE_DATA, FILE_READ_DATA))))))));
break;
}
aa_ace->sid.revision = 1;
@ -100,16 +100,16 @@ void init_system_file_sd(int sys_file_no, u8 **sd_val, int *sd_val_len)
switch (sys_file_no) {
case FILE_AttrDef:
case FILE_Boot:
aa_ace->mask = SYNCHRONIZE | STANDARD_RIGHTS_READ |
FILE_READ_ATTRIBUTES | FILE_READ_EA |
FILE_READ_DATA;
aa_ace->mask = le32_or(SYNCHRONIZE, le32_or(STANDARD_RIGHTS_READ,
le32_or(FILE_READ_ATTRIBUTES, le32_or(FILE_READ_EA,
FILE_READ_DATA))));
break;
default:
aa_ace->mask = SYNCHRONIZE | STANDARD_RIGHTS_READ |
FILE_WRITE_ATTRIBUTES |
FILE_READ_ATTRIBUTES | FILE_WRITE_EA |
FILE_READ_EA | FILE_APPEND_DATA |
FILE_WRITE_DATA | FILE_READ_DATA;
aa_ace->mask = le32_or(SYNCHRONIZE, le32_or(STANDARD_RIGHTS_READ,
le32_or(FILE_WRITE_ATTRIBUTES,
le32_or(FILE_READ_ATTRIBUTES, le32_or(FILE_WRITE_EA,
le32_or(FILE_READ_EA, le32_or(FILE_APPEND_DATA,
le32_or(FILE_WRITE_DATA, FILE_READ_DATA))))))));
break;
}
aa_ace->sid.revision = 1;
@ -203,11 +203,11 @@ void init_root_sd(u8 **sd_val, int *sd_val_len)
ace->type = ACCESS_ALLOWED_ACE_TYPE;
ace->flags = 0;
ace->size = const_cpu_to_le16(0x18);
ace->mask = STANDARD_RIGHTS_ALL | FILE_WRITE_ATTRIBUTES |
FILE_LIST_DIRECTORY | FILE_WRITE_DATA |
FILE_ADD_SUBDIRECTORY | FILE_READ_EA | FILE_WRITE_EA |
FILE_TRAVERSE | FILE_DELETE_CHILD |
FILE_READ_ATTRIBUTES;
ace->mask = le32_or(STANDARD_RIGHTS_ALL, le32_or(FILE_WRITE_ATTRIBUTES,
le32_or(FILE_LIST_DIRECTORY, le32_or(FILE_WRITE_DATA,
le32_or(FILE_ADD_SUBDIRECTORY, le32_or(FILE_READ_EA, le32_or(FILE_WRITE_EA,
le32_or(FILE_TRAVERSE, le32_or(FILE_DELETE_CHILD,
FILE_READ_ATTRIBUTES)))))))));
ace->sid.revision = SID_REVISION;
ace->sid.sub_authority_count = 0x02;
/* SECURITY_NT_SID_AUTHORITY (S-1-5) */
@ -248,11 +248,11 @@ void init_root_sd(u8 **sd_val, int *sd_val_len)
ace->type = ACCESS_ALLOWED_ACE_TYPE;
ace->flags = 0;
ace->size = const_cpu_to_le16(0x14);
ace->mask = STANDARD_RIGHTS_ALL | FILE_WRITE_ATTRIBUTES |
FILE_LIST_DIRECTORY | FILE_WRITE_DATA |
FILE_ADD_SUBDIRECTORY | FILE_READ_EA | FILE_WRITE_EA |
FILE_TRAVERSE | FILE_DELETE_CHILD |
FILE_READ_ATTRIBUTES;
ace->mask = le32_or(STANDARD_RIGHTS_ALL, le32_or(FILE_WRITE_ATTRIBUTES,
le32_or(FILE_LIST_DIRECTORY, le32_or(FILE_WRITE_DATA,
le32_or(FILE_ADD_SUBDIRECTORY, le32_or(FILE_READ_EA, le32_or(FILE_WRITE_EA,
le32_or(FILE_TRAVERSE, le32_or(FILE_DELETE_CHILD,
FILE_READ_ATTRIBUTES)))))))));
ace->sid.revision = SID_REVISION;
ace->sid.sub_authority_count = 0x01;
/* SECURITY_NT_SID_AUTHORITY (S-1-5) */
@ -289,11 +289,11 @@ void init_root_sd(u8 **sd_val, int *sd_val_len)
ace->type = ACCESS_ALLOWED_ACE_TYPE;
ace->flags = 0;
ace->size = const_cpu_to_le16(0x14);
ace->mask = SYNCHRONIZE | READ_CONTROL | DELETE |
FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
FILE_TRAVERSE | FILE_WRITE_EA | FILE_READ_EA |
FILE_ADD_SUBDIRECTORY | FILE_ADD_FILE |
FILE_LIST_DIRECTORY;
ace->mask = le32_or(SYNCHRONIZE, le32_or(READ_CONTROL, le32_or(DELETE,
le32_or(FILE_WRITE_ATTRIBUTES, le32_or(FILE_READ_ATTRIBUTES,
le32_or(FILE_TRAVERSE, le32_or(FILE_WRITE_EA, le32_or(FILE_READ_EA,
le32_or(FILE_ADD_SUBDIRECTORY, le32_or(FILE_ADD_FILE,
FILE_LIST_DIRECTORY))))))))));
ace->sid.revision = SID_REVISION;
ace->sid.sub_authority_count = 0x01;
/* SECURITY_NT_SID_AUTHORITY (S-1-5) */
@ -312,7 +312,7 @@ void init_root_sd(u8 **sd_val, int *sd_val_len)
ace->flags = OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE |
INHERIT_ONLY_ACE;
ace->size = const_cpu_to_le16(0x14);
ace->mask = GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | DELETE;
ace->mask = le32_or(GENERIC_READ, le32_or(GENERIC_WRITE, le32_or(GENERIC_EXECUTE, DELETE)));
ace->sid.revision = SID_REVISION;
ace->sid.sub_authority_count = 0x01;
/* SECURITY_NT_SID_AUTHORITY (S-1-5) */
@ -330,8 +330,8 @@ void init_root_sd(u8 **sd_val, int *sd_val_len)
ace->type = ACCESS_ALLOWED_ACE_TYPE;
ace->flags = 0;
ace->size = const_cpu_to_le16(0x18);
ace->mask = SYNCHRONIZE | READ_CONTROL | FILE_READ_ATTRIBUTES |
FILE_TRAVERSE | FILE_READ_EA | FILE_LIST_DIRECTORY;
ace->mask = le32_or(SYNCHRONIZE, le32_or(READ_CONTROL, le32_or(FILE_READ_ATTRIBUTES,
le32_or(FILE_TRAVERSE, le32_or(FILE_READ_EA, FILE_LIST_DIRECTORY)))));
ace->sid.revision = SID_REVISION;
ace->sid.sub_authority_count = 0x02;
/* SECURITY_NT_SID_AUTHORITY (S-1-5) */
@ -352,7 +352,7 @@ void init_root_sd(u8 **sd_val, int *sd_val_len)
ace->flags = OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE |
INHERIT_ONLY_ACE;
ace->size = const_cpu_to_le16(0x18);
ace->mask = GENERIC_READ | GENERIC_EXECUTE;
ace->mask = le32_or(GENERIC_READ, GENERIC_EXECUTE);
ace->sid.revision = SID_REVISION;
ace->sid.sub_authority_count = 0x02;
/* SECURITY_NT_SID_AUTHORITY (S-1-5) */

10
src/lowntfs-3g.c
View File

@ -150,7 +150,7 @@
? 1 : ntfs_allowed_access(scx, ni, type))
#endif
#define set_archive(ni) (ni)->flags |= FILE_ATTR_ARCHIVE
#define set_archive(ni) (ni)->flags = le32_or((ni)->flags, FILE_ATTR_ARCHIVE)
#define INODE(ino) ((ino) == 1 ? (MFT_REF)FILE_root : (MFT_REF)(ino))
typedef enum {
@ -2891,7 +2891,7 @@ static void ntfs_fuse_listxattr(fuse_req_t req, fuse_ino_t ino, size_t size)
goto out;
}
/* Return with no result for symlinks, fifo, etc. */
if (!le32_andz(ni->flags, FILE_ATTR_SYSTEM | FILE_ATTR_REPARSE_POINT))
if (!le32_andz(ni->flags, le32_or(FILE_ATTR_SYSTEM, FILE_ATTR_REPARSE_POINT)))
goto exit;
/* otherwise file must be readable */
#if !KERNELPERMS | (POSIXACLS & !KERNELACLS)
@ -3040,7 +3040,7 @@ static void ntfs_fuse_getxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
goto out;
}
/* Return with no result for symlinks, fifo, etc. */
if (!le32_andz(ni->flags, FILE_ATTR_SYSTEM | FILE_ATTR_REPARSE_POINT)) {
if (!le32_andz(ni->flags, le32_or(FILE_ATTR_SYSTEM, FILE_ATTR_REPARSE_POINT))) {
res = -ENODATA;
goto exit;
}
@ -3237,7 +3237,7 @@ static void ntfs_fuse_setxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
break;
default :
/* User xattr not allowed for symlinks, fifo, etc. */
if (!le32_andz(ni->flags, FILE_ATTR_SYSTEM | FILE_ATTR_REPARSE_POINT)) {
if (!le32_andz(ni->flags, le32_or(FILE_ATTR_SYSTEM, FILE_ATTR_REPARSE_POINT))) {
res = -EPERM;
goto exit;
}
@ -3482,7 +3482,7 @@ static void ntfs_fuse_removexattr(fuse_req_t req, fuse_ino_t ino, const char *na
break;
default :
/* User xattr not allowed for symlinks, fifo, etc. */
if (!le32_andz(ni->flags, FILE_ATTR_SYSTEM | FILE_ATTR_REPARSE_POINT)) {
if (!le32_andz(ni->flags, le32_or(FILE_ATTR_SYSTEM, FILE_ATTR_REPARSE_POINT))) {
res = -EPERM;
goto exit;
}

10
src/ntfs-3g.c
View File

@ -127,7 +127,7 @@
? 1 : ntfs_allowed_access(scx, ni, type))
#endif
#define set_archive(ni) (ni)->flags |= FILE_ATTR_ARCHIVE
#define set_archive(ni) (ni)->flags = le32_or((ni)->flags, FILE_ATTR_ARCHIVE)
typedef enum {
FSTYPE_NONE,
@ -2689,7 +2689,7 @@ static int ntfs_fuse_listxattr(const char *path, char *list, size_t size)
if (!ni)
return -errno;
/* Return with no result for symlinks, fifo, etc. */
if (!le32_andz(ni->flags, FILE_ATTR_SYSTEM | FILE_ATTR_REPARSE_POINT))
if (!le32_andz(ni->flags, le32_or(FILE_ATTR_SYSTEM, FILE_ATTR_REPARSE_POINT)))
goto exit;
/* otherwise file must be readable */
#if !KERNELPERMS | (POSIXACLS & !KERNELACLS)
@ -2891,7 +2891,7 @@ static int ntfs_fuse_getxattr(const char *path, const char *name,
if (!ni)
return -errno;
/* Return with no result for symlinks, fifo, etc. */
if (!le32_andz(ni->flags, FILE_ATTR_SYSTEM | FILE_ATTR_REPARSE_POINT)) {
if (!le32_andz(ni->flags, le32_or(FILE_ATTR_SYSTEM, FILE_ATTR_REPARSE_POINT))) {
res = -ENODATA;
goto exit;
}
@ -3080,7 +3080,7 @@ static int ntfs_fuse_setxattr(const char *path, const char *name,
#else
/* User xattr not allowed for symlinks, fifo, etc. */
if ((namespace == XATTRNS_USER)
&& (!le32_andz(ni->flags, FILE_ATTR_SYSTEM | FILE_ATTR_REPARSE_POINT))) {
&& (!le32_andz(ni->flags, le32_or(FILE_ATTR_SYSTEM, FILE_ATTR_REPARSE_POINT)))) {
res = -EPERM;
goto exit;
}
@ -3317,7 +3317,7 @@ static int ntfs_fuse_removexattr(const char *path, const char *name)
#else
/* User xattr not allowed for symlinks, fifo, etc. */
if ((namespace == XATTRNS_USER)
&& (!le32_andz(ni->flags, FILE_ATTR_SYSTEM | FILE_ATTR_REPARSE_POINT))) {
&& (!le32_andz(ni->flags, le32_or(FILE_ATTR_SYSTEM, FILE_ATTR_REPARSE_POINT)))) {
res = -EPERM;
goto exit;
}