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

Replace all le16 non-zero "and" test conditions with !le16_andz(...).

edge.strict_endians
Erik Larsson 2016-01-28 08:28:46 +01:00
parent 01c493f16c
commit 35c72761c7
27 changed files with 190 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -320,4 +320,6 @@
#define be16_cmpz(a) (!(a))
#define le16_andz(a, b) (!((a) & (b)))
#endif /* defined _NTFS_ENDIANS_H */

4
libntfs-3g/acls.c
View File

@ -687,12 +687,12 @@ BOOL ntfs_valid_descr(const char *securattr, unsigned int attrsz)
* but "Dr Watson" has SE_DACL_PRESENT though no DACL
*/
&& (!offdacl
|| ((phead->control & SE_DACL_PRESENT)
|| (!le16_andz(phead->control, SE_DACL_PRESENT)
&& ((pdacl->revision == ACL_REVISION)
|| (pdacl->revision == ACL_REVISION_DS))))
/* same for SACL */
&& (!offsacl
|| ((phead->control & SE_SACL_PRESENT)
|| (!le16_andz(phead->control, SE_SACL_PRESENT)
&& ((psacl->revision == ACL_REVISION)
|| (psacl->revision == ACL_REVISION_DS))))) {
/*

68
libntfs-3g/attrib.c
View File

@ -357,7 +357,7 @@ void ntfs_attr_init(ntfs_attr *na, const BOOL non_resident,
na->data_flags = data_flags;
if (non_resident)
NAttrSetNonResident(na);
if (data_flags & ATTR_COMPRESSION_MASK)
if (!le16_andz(data_flags, ATTR_COMPRESSION_MASK))
NAttrSetCompressed(na);
if (encrypted)
NAttrSetEncrypted(na);
@ -366,7 +366,7 @@ void ntfs_attr_init(ntfs_attr *na, const BOOL non_resident,
na->allocated_size = allocated_size;
na->data_size = data_size;
na->initialized_size = initialized_size;
if ((data_flags & ATTR_COMPRESSION_MASK) || sparse) {
if (!le16_andz(data_flags, ATTR_COMPRESSION_MASK) || sparse) {
ntfs_volume *vol = na->ni->vol;
na->compressed_size = compressed_size;
@ -479,7 +479,7 @@ ntfs_attr *ntfs_attr_open(ntfs_inode *ni, const ATTR_TYPES type,
/* a file may be sparse though its unnamed data is not (cf $UsnJrnl) */
if (le32_eq(na->type, AT_DATA) && na->name == AT_UNNAMED &&
(((a->flags & ATTR_IS_SPARSE) && !NAttrSparse(na)) ||
((!le16_andz(a->flags, ATTR_IS_SPARSE) && !NAttrSparse(na)) ||
(!(a->flags & ATTR_IS_ENCRYPTED) != !NAttrEncrypted(na)))) {
errno = EIO;
ntfs_log_perror("Inode %lld has corrupt attribute flags "
@ -489,7 +489,7 @@ ntfs_attr *ntfs_attr_open(ntfs_inode *ni, const ATTR_TYPES type,
}
if (a->non_resident) {
if ((a->flags & ATTR_COMPRESSION_MASK)
if (!le16_andz(a->flags, ATTR_COMPRESSION_MASK)
&& !a->compression_unit) {
errno = EIO;
ntfs_log_perror("Compressed inode %lld attr 0x%x has "
@ -498,8 +498,8 @@ ntfs_attr *ntfs_attr_open(ntfs_inode *ni, const ATTR_TYPES type,
goto put_err_out;
}
ntfs_attr_init(na, TRUE, a->flags,
a->flags & ATTR_IS_ENCRYPTED,
a->flags & ATTR_IS_SPARSE,
!le16_andz(a->flags, ATTR_IS_ENCRYPTED),
!le16_andz(a->flags, ATTR_IS_SPARSE),
sle64_to_cpu(a->allocated_size),
sle64_to_cpu(a->data_size),
sle64_to_cpu(a->initialized_size),
@ -508,8 +508,8 @@ ntfs_attr *ntfs_attr_open(ntfs_inode *ni, const ATTR_TYPES type,
} else {
s64 l = le32_to_cpu(a->value_length);
ntfs_attr_init(na, FALSE, a->flags,
a->flags & ATTR_IS_ENCRYPTED,
a->flags & ATTR_IS_SPARSE, (l + 7) & ~7, l, l,
!le16_andz(a->flags, ATTR_IS_ENCRYPTED),
!le16_andz(a->flags, ATTR_IS_SPARSE), (l + 7) & ~7, l, l,
!le16_cmpz(cs) ? (l + 7) & ~7 : 0, 0);
}
ntfs_attr_put_search_ctx(ctx);
@ -942,7 +942,7 @@ static s64 ntfs_attr_pread_i(ntfs_attr *na, const s64 pos, s64 count, void *b)
/* Sanity checking arguments is done in ntfs_attr_pread(). */
if ((na->data_flags & ATTR_COMPRESSION_MASK) && NAttrNonResident(na)) {
if (!le16_andz(na->data_flags, ATTR_COMPRESSION_MASK) && NAttrNonResident(na)) {
if (le16_eq(na->data_flags & ATTR_COMPRESSION_MASK,
ATTR_IS_COMPRESSED))
return ntfs_compressed_attr_pread(na, pos, count, b);
@ -973,7 +973,7 @@ static s64 ntfs_attr_pread_i(ntfs_attr *na, const s64 pos, s64 count, void *b)
max_read = na->data_size;
max_init = na->initialized_size;
if (na->ni->vol->efs_raw
&& (na->data_flags & ATTR_IS_ENCRYPTED)
&& !le16_andz(na->data_flags, ATTR_IS_ENCRYPTED)
&& NAttrNonResident(na)) {
if (na->data_size != na->initialized_size) {
ntfs_log_error("uninitialized encrypted file not supported\n");
@ -1031,7 +1031,7 @@ res_err_out:
* restored
*/
if (na->ni->vol->efs_raw &&
(na->data_flags & ATTR_IS_ENCRYPTED) &&
!le16_andz(na->data_flags, ATTR_IS_ENCRYPTED) &&
((pos + count) > max_init-2)) {
efs_padding_length = 511 - ((na->data_size - 1) & 511);
if (pos+count == max_init) {
@ -1303,7 +1303,7 @@ static int ntfs_attr_fill_hole(ntfs_attr *na, s64 count, s64 *ofs,
* not be desirable for files which can
* be updated
*/
if (na->data_flags & ATTR_COMPRESSION_MASK)
if (!le16_andz(na->data_flags, ATTR_COMPRESSION_MASK))
lcn_seek_from = rlc->lcn + rlc->length;
else
lcn_seek_from = rlc->lcn + (from_vcn - rlc->vcn);
@ -1326,7 +1326,7 @@ static int ntfs_attr_fill_hole(ntfs_attr *na, s64 count, s64 *ofs,
need = ((*ofs + to_write - 1) >> vol->cluster_size_bits)
+ 1 + (*rl)->vcn - from_vcn;
if ((na->data_flags & ATTR_COMPRESSION_MASK)
if (!le16_andz(na->data_flags, ATTR_COMPRESSION_MASK)
&& (need < na->compression_block_clusters)) {
/*
* for a compressed file, be sure to allocate the full
@ -1358,7 +1358,7 @@ static int ntfs_attr_fill_hole(ntfs_attr *na, s64 count, s64 *ofs,
lcn_seek_from, DATA_ZONE);
if (!rlc)
goto err_out;
if (na->data_flags & (ATTR_COMPRESSION_MASK | ATTR_IS_SPARSE))
if (!le16_andz(na->data_flags, ATTR_COMPRESSION_MASK | ATTR_IS_SPARSE))
na->compressed_size += need << vol->cluster_size_bits;
*rl = ntfs_runlists_merge(na->rl, rlc);
@ -1367,7 +1367,7 @@ static int ntfs_attr_fill_hole(ntfs_attr *na, s64 count, s64 *ofs,
* For a compressed attribute, we must be sure there are two
* available entries, so reserve them before it gets too late.
*/
if (*rl && (na->data_flags & ATTR_COMPRESSION_MASK)) {
if (*rl && !le16_andz(na->data_flags, ATTR_COMPRESSION_MASK)) {
runlist_element *oldrl = na->rl;
na->rl = *rl;
*rl = ntfs_rl_extend(na,*rl,2);
@ -1817,7 +1817,7 @@ s64 ntfs_attr_pwrite(ntfs_attr *na, const s64 pos, s64 count, const void *b)
* access denied, which is what Windows NT4 does, too.
* Moreover a file cannot be both encrypted and compressed.
*/
if ((na->data_flags & ATTR_IS_ENCRYPTED)
if (!le16_andz(na->data_flags, ATTR_IS_ENCRYPTED)
&& (compressed || !vol->efs_raw)) {
errno = EACCES;
goto errno_set;
@ -2023,7 +2023,7 @@ s64 ntfs_attr_pwrite(ntfs_attr *na, const s64 pos, s64 count, const void *b)
}
na->initialized_size = pos + count;
#if CACHE_NIDATA_SIZE
if (na->ni->mrec->flags & MFT_RECORD_IS_DIRECTORY
if (!le16_andz(na->ni->mrec->flags, MFT_RECORD_IS_DIRECTORY)
? le32_eq(na->type, AT_INDEX_ROOT) && na->name == NTFS_INDEX_I30
: le32_eq(na->type, AT_DATA) && na->name == AT_UNNAMED) {
na->ni->data_size = na->data_size;
@ -2479,7 +2479,7 @@ retry:
if (!NVolReadOnly(vol)) {
failed = ntfs_compressed_close(na, rl, ofs, &update_from);
#if CACHE_NIDATA_SIZE
if (na->ni->mrec->flags & MFT_RECORD_IS_DIRECTORY
if (!le16_andz(na->ni->mrec->flags, MFT_RECORD_IS_DIRECTORY)
? le32_eq(na->type, AT_INDEX_ROOT) && na->name == NTFS_INDEX_I30
: le32_eq(na->type, AT_DATA) && na->name == AT_UNNAMED) {
na->ni->data_size = na->data_size;
@ -3860,7 +3860,7 @@ int ntfs_resident_attr_record_add(ntfs_inode *ni, ATTR_TYPES type,
goto put_err_out;
}
}
if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY
if (!le16_andz(ni->mrec->flags, MFT_RECORD_IS_DIRECTORY)
? le32_eq(type, AT_INDEX_ROOT) && name == NTFS_INDEX_I30
: le32_eq(type, AT_DATA) && name == AT_UNNAMED) {
ni->data_size = size;
@ -3950,7 +3950,7 @@ int ntfs_non_resident_attr_record_add(ntfs_inode *ni, ATTR_TYPES type,
dataruns_size = (dataruns_size + 7) & ~7;
length = offsetof(ATTR_RECORD, compressed_size) + ((sizeof(ntfschar) *
name_len + 7) & ~7) + dataruns_size +
((flags & (ATTR_IS_COMPRESSED | ATTR_IS_SPARSE)) ?
(!le16_andz(flags, ATTR_IS_COMPRESSED | ATTR_IS_SPARSE) ?
sizeof(a->compressed_size) : 0);
if (ntfs_make_room_for_attr(ctx->mrec, (u8*) ctx->attr, length)) {
err = errno;
@ -3964,13 +3964,13 @@ int ntfs_non_resident_attr_record_add(ntfs_inode *ni, ATTR_TYPES type,
a->non_resident = 1;
a->name_length = name_len;
a->name_offset = cpu_to_le16(offsetof(ATTR_RECORD, compressed_size) +
((flags & (ATTR_IS_COMPRESSED | ATTR_IS_SPARSE)) ?
(!le16_andz(flags, ATTR_IS_COMPRESSED | ATTR_IS_SPARSE) ?
sizeof(a->compressed_size) : 0));
a->flags = flags;
a->instance = m->next_attr_instance;
a->lowest_vcn = cpu_to_sle64(lowest_vcn);
a->mapping_pairs_offset = cpu_to_le16(length - dataruns_size);
a->compression_unit = (flags & ATTR_IS_COMPRESSED)
a->compression_unit = !le16_andz(flags, ATTR_IS_COMPRESSED)
? STANDARD_COMPRESSION_UNIT : 0;
/* If @lowest_vcn == 0, than setup empty attribute. */
if (!lowest_vcn) {
@ -4997,14 +4997,14 @@ static int ntfs_resident_attr_resize_i(ntfs_attr *na, const s64 newsize,
/* Update attribute size everywhere. */
na->data_size = na->initialized_size = newsize;
na->allocated_size = (newsize + 7) & ~7;
if ((na->data_flags & ATTR_COMPRESSION_MASK)
if (!le16_andz(na->data_flags, ATTR_COMPRESSION_MASK)
|| NAttrSparse(na))
na->compressed_size = na->allocated_size;
if (na->ni->mrec->flags & MFT_RECORD_IS_DIRECTORY
if (!le16_andz(na->ni->mrec->flags, MFT_RECORD_IS_DIRECTORY)
? le32_eq(na->type, AT_INDEX_ROOT) && na->name == NTFS_INDEX_I30
: le32_eq(na->type, AT_DATA) && na->name == AT_UNNAMED) {
na->ni->data_size = na->data_size;
if (((na->data_flags & ATTR_COMPRESSION_MASK)
if ((!le16_andz(na->data_flags, ATTR_COMPRESSION_MASK)
|| NAttrSparse(na))
&& NAttrNonResident(na))
na->ni->allocated_size
@ -5291,7 +5291,7 @@ static int ntfs_attr_make_resident(ntfs_attr *na, ntfs_attr_search_ctx *ctx)
if (ntfs_attr_can_be_resident(vol, na->type))
return -1;
if (na->data_flags & ATTR_IS_ENCRYPTED) {
if (!le16_andz(na->data_flags, ATTR_IS_ENCRYPTED)) {
ntfs_log_trace("Making encrypted streams resident is not "
"implemented yet.\n");
errno = EOPNOTSUPP;
@ -5494,7 +5494,7 @@ static int ntfs_attr_update_meta(ATTR_RECORD *a, ntfs_attr *na, MFT_RECORD *m,
}
/* Attribute no longer sparse. */
if (!sparse && (a->flags & ATTR_IS_SPARSE) &&
if (!sparse && !le16_andz(a->flags, ATTR_IS_SPARSE) &&
!(a->flags & ATTR_IS_COMPRESSED)) {
NAttrClearSparse(na);
@ -5515,7 +5515,7 @@ static int ntfs_attr_update_meta(ATTR_RECORD *a, ntfs_attr *na, MFT_RECORD *m,
/* Update compressed size if required. */
if (NAttrFullyMapped(na)
&& (sparse || (na->data_flags & ATTR_COMPRESSION_MASK))) {
&& (sparse || !le16_andz(na->data_flags, ATTR_COMPRESSION_MASK))) {
s64 new_compr_size;
new_compr_size = ntfs_rl_get_compressed_size(na->ni->vol, na->rl);
@ -5530,7 +5530,7 @@ static int ntfs_attr_update_meta(ATTR_RECORD *a, ntfs_attr *na, MFT_RECORD *m,
* allocated size in the index.
*/
if (le32_eq(na->type, AT_DATA) && na->name == AT_UNNAMED) {
if (sparse || (na->data_flags & ATTR_COMPRESSION_MASK))
if (sparse || !le16_andz(na->data_flags, ATTR_COMPRESSION_MASK))
na->ni->allocated_size = na->compressed_size;
else
na->ni->allocated_size = na->allocated_size;
@ -5888,7 +5888,7 @@ retry:
cur_max_mp_size = le32_to_cpu(m->bytes_allocated) -
le32_to_cpu(m->bytes_in_use) -
(offsetof(ATTR_RECORD, compressed_size) +
(((na->data_flags & ATTR_COMPRESSION_MASK)
((!le16_andz(na->data_flags, ATTR_COMPRESSION_MASK)
|| NAttrSparse(na)) ?
sizeof(a->compressed_size) : 0)) -
((sizeof(ntfschar) * na->name_len + 7) & ~7);
@ -6015,7 +6015,7 @@ static int ntfs_non_resident_attr_shrink(ntfs_attr *na, const s64 newsize)
}
/* The first cluster outside the new allocation. */
if (na->data_flags & ATTR_COMPRESSION_MASK)
if (!le16_andz(na->data_flags, ATTR_COMPRESSION_MASK))
/*
* For compressed files we must keep full compressions blocks,
* but currently we do not decompress/recompress the last
@ -6094,7 +6094,7 @@ static int ntfs_non_resident_attr_shrink(ntfs_attr *na, const s64 newsize)
ctx->attr->initialized_size = cpu_to_sle64(newsize);
}
/* Update data size in the index. */
if (na->ni->mrec->flags & MFT_RECORD_IS_DIRECTORY) {
if (!le16_andz(na->ni->mrec->flags, MFT_RECORD_IS_DIRECTORY)) {
if (le32_eq(na->type, AT_INDEX_ROOT) && na->name == NTFS_INDEX_I30) {
na->ni->data_size = na->data_size;
na->ni->allocated_size = na->allocated_size;
@ -6326,7 +6326,7 @@ static int ntfs_non_resident_attr_expand_i(ntfs_attr *na, const s64 newsize,
na->data_size = newsize;
ctx->attr->data_size = cpu_to_sle64(newsize);
/* Update data size in the index. */
if (na->ni->mrec->flags & MFT_RECORD_IS_DIRECTORY) {
if (!le16_andz(na->ni->mrec->flags, MFT_RECORD_IS_DIRECTORY)) {
if (le32_eq(na->type, AT_INDEX_ROOT) && na->name == NTFS_INDEX_I30) {
na->ni->data_size = na->data_size;
na->ni->allocated_size = na->allocated_size;
@ -6438,7 +6438,7 @@ static int ntfs_attr_truncate_i(ntfs_attr *na, const s64 newsize,
* Encrypted attributes are not supported. We return access denied,
* which is what Windows NT4 does, too.
*/
if ((na->data_flags & ATTR_IS_ENCRYPTED) && !na->ni->vol->efs_raw) {
if (!le16_andz(na->data_flags, ATTR_IS_ENCRYPTED) && !na->ni->vol->efs_raw) {
errno = EACCES;
ntfs_log_trace("Cannot truncate encrypted attribute\n");
goto out;

14
libntfs-3g/dir.c
View File

@ -311,7 +311,7 @@ u64 ntfs_inode_lookup_by_name(ntfs_inode *dir_ni,
* The last entry cannot contain a name. It can however contain
* a pointer to a child node in the B+tree so we just break out.
*/
if (ie->ie_flags & INDEX_ENTRY_END)
if (!le16_andz(ie->ie_flags, INDEX_ENTRY_END))
break;
if (!le16_to_cpu(ie->length)) {
@ -450,7 +450,7 @@ descend_into_child_node:
* The last entry cannot contain a name. It can however contain
* a pointer to a child node in the B+tree so we just break out.
*/
if (ie->ie_flags & INDEX_ENTRY_END)
if (!le16_andz(ie->ie_flags, INDEX_ENTRY_END))
break;
if (!le16_to_cpu(ie->length)) {
@ -487,7 +487,7 @@ descend_into_child_node:
* We have finished with this index buffer without success. Check for
* the presence of a child node.
*/
if (ie->ie_flags & INDEX_ENTRY_NODE) {
if (!le16_andz(ie->ie_flags, INDEX_ENTRY_NODE)) {
if ((ia->index.ih_flags & NODE_MASK) == LEAF_NODE) {
ntfs_log_error("Index entry with child node found in a leaf "
"node in directory inode %lld.\n",
@ -1244,7 +1244,7 @@ int ntfs_readdir(ntfs_inode *dir_ni, s64 *pos,
index_end)
goto dir_err_out;
/* The last entry cannot contain a name. */
if (ie->ie_flags & INDEX_ENTRY_END)
if (!le16_andz(ie->ie_flags, INDEX_ENTRY_END))
break;
if (!le16_to_cpu(ie->length))
@ -1400,7 +1400,7 @@ find_next_index_buffer:
goto dir_err_out;
}
/* The last entry cannot contain a name. */
if (ie->ie_flags & INDEX_ENTRY_END)
if (!le16_andz(ie->ie_flags, INDEX_ENTRY_END))
break;
if (!le16_to_cpu(ie->length))
@ -1690,7 +1690,7 @@ static ntfs_inode *__ntfs_create(ntfs_inode *dir_ni, le32 securid,
fn->last_data_change_time = ni->last_data_change_time;
fn->last_mft_change_time = ni->last_mft_change_time;
fn->last_access_time = ni->last_access_time;
if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY)
if (!le16_andz(ni->mrec->flags, MFT_RECORD_IS_DIRECTORY))
fn->data_size = fn->allocated_size = const_cpu_to_le64(0);
else {
fn->data_size = cpu_to_sle64(ni->data_size);
@ -2184,7 +2184,7 @@ static int ntfs_link_i(ntfs_inode *ni, ntfs_inode *dir_ni, const ntfschar *name,
fn->file_name_length = name_len;
fn->file_name_type = nametype;
fn->file_attributes = ni->flags;
if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY) {
if (!le16_andz(ni->mrec->flags, MFT_RECORD_IS_DIRECTORY)) {
fn->file_attributes |= FILE_ATTR_I30_INDEX_PRESENT;
fn->data_size = fn->allocated_size = const_cpu_to_le64(0);
} else {

20
libntfs-3g/index.c
View File

@ -222,7 +222,7 @@ static u8 *ntfs_ie_get_end(INDEX_HEADER *ih)
static int ntfs_ie_end(INDEX_ENTRY *ie)
{
return ie->ie_flags & INDEX_ENTRY_END || le16_cmpz(ie->length);
return !le16_andz(ie->ie_flags, INDEX_ENTRY_END) || le16_cmpz(ie->length);
}
/**
@ -376,7 +376,7 @@ static INDEX_ENTRY *ntfs_ie_dup_novcn(INDEX_ENTRY *ie)
ntfs_log_trace("Entering\n");
if (ie->ie_flags & INDEX_ENTRY_NODE)
if (!le16_andz(ie->ie_flags, INDEX_ENTRY_NODE))
size -= sizeof(VCN);
dup = ntfs_malloc(size);
@ -1077,7 +1077,7 @@ static int ntfs_ib_cut_tail(ntfs_index_context *icx, INDEX_BLOCK *ib,
ies_end = (char *)ntfs_ie_get_end(&ib->index);
ie_last = ntfs_ie_get_last((INDEX_ENTRY *)ies_start, ies_end);
if (ie_last->ie_flags & INDEX_ENTRY_NODE)
if (!le16_andz(ie_last->ie_flags, INDEX_ENTRY_NODE))
ntfs_ie_set_vcn(ie_last, ntfs_ie_get_vcn(ie));
memcpy(ie, ie_last, le16_to_cpu(ie_last->length));
@ -1816,7 +1816,7 @@ int ntfs_index_rm(ntfs_index_context *icx)
else
ih = &icx->ib->index;
if (icx->entry->ie_flags & INDEX_ENTRY_NODE) {
if (!le16_andz(icx->entry->ie_flags, INDEX_ENTRY_NODE)) {
ret = ntfs_index_rm_node(icx);
@ -1955,7 +1955,7 @@ static INDEX_ENTRY *ntfs_index_walk_down(INDEX_ENTRY *ie,
entry = ictx->entry;
} else
entry = (INDEX_ENTRY*)NULL;
} while (entry && (entry->ie_flags & INDEX_ENTRY_NODE));
} while (entry && !le16_andz(entry->ie_flags, INDEX_ENTRY_NODE));
return (entry);
}
@ -2006,7 +2006,7 @@ static INDEX_ENTRY *ntfs_index_walk_up(INDEX_ENTRY *ie,
}
ictx->entry = entry;
} while (entry && (ictx->pindex > 0)
&& (entry->ie_flags & INDEX_ENTRY_END));
&& !le16_andz(entry->ie_flags, INDEX_ENTRY_END));
} else
entry = (INDEX_ENTRY*)NULL;
return (entry);
@ -2050,7 +2050,7 @@ INDEX_ENTRY *ntfs_index_next(INDEX_ENTRY *ie, ntfs_index_context *ictx)
* if this happens, walk up
*/
if (ie->ie_flags & INDEX_ENTRY_END)
if (!le16_andz(ie->ie_flags, INDEX_ENTRY_END))
next = ntfs_index_walk_up(ie, ictx);
else {
/*
@ -2064,20 +2064,20 @@ INDEX_ENTRY *ntfs_index_next(INDEX_ENTRY *ie, ntfs_index_context *ictx)
/* walk down if it has a subnode */
if (flags & INDEX_ENTRY_NODE) {
if (!le16_andz(flags, INDEX_ENTRY_NODE)) {
next = ntfs_index_walk_down(next,ictx);
} else {
/* walk up it has no subnode, nor data */
if (flags & INDEX_ENTRY_END) {
if (!le16_andz(flags, INDEX_ENTRY_END)) {
next = ntfs_index_walk_up(next, ictx);
}
}
}
/* return NULL if stuck at end of a block */
if (next && (next->ie_flags & INDEX_ENTRY_END))
if (next && !le16_andz(next->ie_flags, INDEX_ENTRY_END))
next = (INDEX_ENTRY*)NULL;
return (next);
}

12
libntfs-3g/inode.c
View File

@ -259,8 +259,8 @@ get_size:
} else {
if (ctx->attr->non_resident) {
ni->data_size = sle64_to_cpu(ctx->attr->data_size);
if (ctx->attr->flags &
(ATTR_IS_COMPRESSED | ATTR_IS_SPARSE))
if (!le16_andz(ctx->attr->flags,
(ATTR_IS_COMPRESSED | ATTR_IS_SPARSE)))
ni->allocated_size = sle64_to_cpu(
ctx->attr->compressed_size);
else
@ -872,7 +872,7 @@ static int ntfs_inode_sync_file_name(ntfs_inode *ni, ntfs_inode *dir_ni)
fnx->file_attributes =
(fnx->file_attributes & ~FILE_ATTR_VALID_FLAGS) |
(ni->flags & FILE_ATTR_VALID_FLAGS);
if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY)
if (!le16_andz(ni->mrec->flags, MFT_RECORD_IS_DIRECTORY))
fnx->data_size = fnx->allocated_size
= const_cpu_to_le64(0);
else {
@ -956,7 +956,7 @@ static int ntfs_inode_sync_in_dir(ntfs_inode *ni, ntfs_inode *dir_ni)
ntfs_log_enter("Entering for inode %lld\n", (long long)ni->mft_no);
/* Update STANDARD_INFORMATION. */
if ((ni->mrec->flags & MFT_RECORD_IN_USE) && ni->nr_extents != -1 &&
if (!le16_andz(ni->mrec->flags, MFT_RECORD_IN_USE) && ni->nr_extents != -1 &&
ntfs_inode_sync_standard_information(ni)) {
if (!err || errno == EIO) {
err = errno;
@ -966,7 +966,7 @@ static int ntfs_inode_sync_in_dir(ntfs_inode *ni, ntfs_inode *dir_ni)
}
/* Update FILE_NAME's in the index. */
if ((ni->mrec->flags & MFT_RECORD_IN_USE) && ni->nr_extents != -1 &&
if (!le16_andz(ni->mrec->flags, MFT_RECORD_IN_USE) && ni->nr_extents != -1 &&
NInoFileNameTestAndClearDirty(ni) &&
ntfs_inode_sync_file_name(ni, dir_ni)) {
if (!err || errno == EIO) {
@ -980,7 +980,7 @@ static int ntfs_inode_sync_in_dir(ntfs_inode *ni, ntfs_inode *dir_ni)
}
/* Write out attribute list from cache to disk. */
if ((ni->mrec->flags & MFT_RECORD_IN_USE) && ni->nr_extents != -1 &&
if (!le16_andz(ni->mrec->flags, MFT_RECORD_IN_USE) && ni->nr_extents != -1 &&
NInoAttrList(ni) && NInoAttrListTestAndClearDirty(ni)) {
ntfs_attr *na;

4
libntfs-3g/mft.c
View File

@ -1443,7 +1443,7 @@ found_free_rec:
/* Sanity check that the mft record is really not in use. */
if (!forced_mft_data
&& (ntfs_is_file_record(m->magic)
&& (m->flags & MFT_RECORD_IN_USE))) {
&& !le16_andz(m->flags, MFT_RECORD_IN_USE))) {
ntfs_log_error("Inode %lld is used but it wasn't marked in "
"$MFT bitmap. Fixed.\n", (long long)bit);
free(m);
@ -1747,7 +1747,7 @@ found_free_rec:
goto undo_mftbmp_alloc;
}
/* Sanity check that the mft record is really not in use. */
if (ntfs_is_file_record(m->magic) && (m->flags & MFT_RECORD_IN_USE)) {
if (ntfs_is_file_record(m->magic) && !le16_andz(m->flags, MFT_RECORD_IN_USE)) {
ntfs_log_error("Inode %lld is used but it wasn't marked in "
"$MFT bitmap. Fixed.\n", (long long)bit);
free(m);

10
libntfs-3g/reparse.c
View File

@ -169,7 +169,7 @@ static u64 ntfs_fix_file_name(ntfs_inode *dir_ni, ntfschar *uname,
* We generally only get the first matching candidate,
* so we still have to check whether this is a real match
*/
if (icx->entry && (icx->entry->ie_flags & INDEX_ENTRY_END))
if (icx->entry && !le16_andz(icx->entry->ie_flags, INDEX_ENTRY_END))
/* get next entry if reaching end of block */
entry = ntfs_index_next(icx->entry, icx);
else
@ -252,11 +252,11 @@ static char *search_absolute(ntfs_volume *vol, ntfschar *path,
path[start++] = const_cpu_to_le16('/');
}
} while (ni
&& (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY)
&& !le16_andz(ni->mrec->flags, MFT_RECORD_IS_DIRECTORY)
&& !(ni->flags & FILE_ATTR_REPARSE_POINT)
&& (start < count));
if (ni
&& ((ni->mrec->flags & MFT_RECORD_IS_DIRECTORY ? isdir : !isdir)
&& ((!le16_andz(ni->mrec->flags, MFT_RECORD_IS_DIRECTORY) ? isdir : !isdir)
|| (ni->flags & FILE_ATTR_REPARSE_POINT)))
if (ntfs_ucstombs(path, count, &target, 0) < 0) {
if (target) {
@ -358,8 +358,8 @@ static char *search_relative(ntfs_inode *ni, ntfschar *path, int count)
} else {
pos += lth;
if (!morelinks
&& (ni->mrec->flags ^ curni->mrec->flags)
& MFT_RECORD_IS_DIRECTORY)
&& !le16_andz(ni->mrec->flags ^ curni->mrec->flags,
MFT_RECORD_IS_DIRECTORY))
ok = FALSE;
if (ntfs_inode_close(curni))
ok = FALSE;

26
libntfs-3g/security.c
View File

@ -873,7 +873,7 @@ static le32 setsecurityattr(ntfs_volume *vol,
* lookup() may return a node with no data,
* if so get next
*/
if (entry->ie_flags & INDEX_ENTRY_END)
if (!le16_andz(entry->ie_flags, INDEX_ENTRY_END))
entry = ntfs_index_next(entry,xsdh);
do {
collision = FALSE;
@ -1685,7 +1685,7 @@ static struct CACHED_PERMISSIONS *enter_cache(struct SECURITY_CONTEXT *scx,
} else {
cacheentry = (struct CACHED_PERMISSIONS*)NULL;
#if CACHE_LEGACY_SIZE
if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY) {
if (!le16_andz(ni->mrec->flags, MFT_RECORD_IS_DIRECTORY)) {
struct CACHED_PERMISSIONS_LEGACY wanted;
struct CACHED_PERMISSIONS_LEGACY *legacy;
@ -1768,7 +1768,7 @@ static struct CACHED_PERMISSIONS *fetch_cache(struct SECURITY_CONTEXT *scx,
#if CACHE_LEGACY_SIZE
else {
cacheentry = (struct CACHED_PERMISSIONS*)NULL;
if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY) {
if (!le16_andz(ni->mrec->flags, MFT_RECORD_IS_DIRECTORY)) {
struct CACHED_PERMISSIONS_LEGACY wanted;
struct CACHED_PERMISSIONS_LEGACY *legacy;
@ -3214,7 +3214,7 @@ int ntfs_set_ntfs_acl(struct SECURITY_CONTEXT *scx, ntfs_inode *ni,
* For safety, invalidate even if updating
* failed.
*/
if ((ni->mrec->flags & MFT_RECORD_IS_DIRECTORY)
if (!le16_andz(ni->mrec->flags, MFT_RECORD_IS_DIRECTORY)
&& le32_cmpz(ni->security_id)) {
struct CACHED_PERMISSIONS_LEGACY legacy;
@ -3450,7 +3450,7 @@ int ntfs_allowed_access(struct SECURITY_CONTEXT *scx,
if (!scx->mapping[MAPUSERS]
|| (!scx->uid
&& (!(accesstype & S_IEXEC)
|| (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY))))
|| !le16_andz(ni->mrec->flags, MFT_RECORD_IS_DIRECTORY))))
allow = 1;
else {
perm = ntfs_get_perm(scx, ni, accesstype);
@ -4390,7 +4390,7 @@ int ntfs_get_ntfs_attrib(ntfs_inode *ni, char *value, size_t size)
outsize = 0; /* default to no data and no error */
if (ni) {
attrib = le32_to_cpu(ni->flags);
if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY)
if (!le16_andz(ni->mrec->flags, MFT_RECORD_IS_DIRECTORY))
attrib |= const_le32_to_cpu(FILE_ATTR_DIRECTORY);
else
attrib &= ~const_le32_to_cpu(FILE_ATTR_DIRECTORY);
@ -4429,7 +4429,7 @@ int ntfs_set_ntfs_attrib(ntfs_inode *ni,
memcpy(&attrib,value,sizeof(FILE_ATTR_FLAGS));
settable = FILE_ATTR_SETTABLE;
res = 0;
if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY) {
if (!le16_andz(ni->mrec->flags, MFT_RECORD_IS_DIRECTORY)) {
/*
* Accept changing compression for a directory
* and set index root accordingly
@ -4737,7 +4737,7 @@ static BOOL mergesecurityattr(ntfs_volume *vol, const char *oldattr,
& (SE_DACL_PRESENT
| SE_DACL_DEFAULTED
| SE_DACL_PROTECTED);
if (newhead->control & SE_DACL_AUTO_INHERIT_REQ)
if (!le16_andz(newhead->control, SE_DACL_AUTO_INHERIT_REQ))
control |= SE_DACL_AUTO_INHERITED;
} else
control |= oldhead->control
@ -4769,7 +4769,7 @@ static BOOL mergesecurityattr(ntfs_volume *vol, const char *oldattr,
& (SE_SACL_PRESENT
| SE_SACL_DEFAULTED
| SE_SACL_PROTECTED);
if (newhead->control & SE_SACL_AUTO_INHERIT_REQ)
if (!le16_andz(newhead->control, SE_SACL_AUTO_INHERIT_REQ))
control |= SE_SACL_AUTO_INHERITED;
} else
control |= oldhead->control
@ -4932,7 +4932,7 @@ int ntfs_set_file_security(struct SECURITY_API *scapi,
&& le32_cmpz(phead->group)
&& !(phead->control & SE_GROUP_DEFAULTED));
if (!missing
&& (phead->control & SE_SELF_RELATIVE)
&& !le16_andz(phead->control, SE_SELF_RELATIVE)
&& ntfs_valid_descr(attr, attrsz)) {
ni = ntfs_pathname_to_inode(scapi->security.vol,
NULL, path);
@ -4987,7 +4987,7 @@ int ntfs_get_file_attributes(struct SECURITY_API *scapi, const char *path)
ni = ntfs_pathname_to_inode(scapi->security.vol, NULL, path);
if (ni) {
attrib = le32_to_cpu(ni->flags);
if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY)
if (!le16_andz(ni->mrec->flags, MFT_RECORD_IS_DIRECTORY))
attrib |= const_le32_to_cpu(FILE_ATTR_DIRECTORY);
else
attrib &= ~const_le32_to_cpu(FILE_ATTR_DIRECTORY);
@ -5034,7 +5034,7 @@ BOOL ntfs_set_file_attributes(struct SECURITY_API *scapi,
ni = ntfs_pathname_to_inode(scapi->security.vol, NULL, path);
if (ni) {
settable = FILE_ATTR_SETTABLE;
if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY) {
if (!le16_andz(ni->mrec->flags, MFT_RECORD_IS_DIRECTORY)) {
/*
* Accept changing compression for a directory
* and set index root accordingly
@ -5079,7 +5079,7 @@ BOOL ntfs_read_directory(struct SECURITY_API *scapi,
if (scapi && (scapi->magic == MAGIC_API) && callback) {
ni = ntfs_pathname_to_inode(scapi->security.vol, NULL, path);
if (ni) {
if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY) {
if (!le16_andz(ni->mrec->flags, MFT_RECORD_IS_DIRECTORY)) {
pos = 0;
ntfs_readdir(ni,&pos,context,callback);
ok = !ntfs_inode_close(ni);

8
libntfs-3g/volume.c
View File

@ -329,8 +329,8 @@ mft_has_no_attr_list:
goto io_error_exit;
}
/* $MFT must be uncompressed and unencrypted. */
if (a->flags & ATTR_COMPRESSION_MASK ||
a->flags & ATTR_IS_ENCRYPTED) {
if (!le16_andz(a->flags, ATTR_COMPRESSION_MASK) ||
!le16_andz(a->flags, ATTR_IS_ENCRYPTED)) {
ntfs_log_error("$MFT must be uncompressed and "
"unencrypted.\n");
goto io_error_exit;
@ -962,7 +962,7 @@ ntfs_volume *ntfs_device_mount(struct ntfs_device *dev, ntfs_mount_flags flags)
s = "mft record";
mrec = (MFT_RECORD*)(m + i * vol->mft_record_size);
if (mrec->flags & MFT_RECORD_IN_USE) {
if (!le16_andz(mrec->flags, MFT_RECORD_IN_USE)) {
if (ntfs_is_baad_recordp(mrec)) {
ntfs_log_error("$MFT error: Incomplete multi "
"sector transfer detected in "
@ -976,7 +976,7 @@ ntfs_volume *ntfs_device_mount(struct ntfs_device *dev, ntfs_mount_flags flags)
}
}
mrec2 = (MFT_RECORD*)(m2 + i * vol->mft_record_size);
if (mrec2->flags & MFT_RECORD_IN_USE) {
if (!le16_andz(mrec2->flags, MFT_RECORD_IN_USE)) {
if (ntfs_is_baad_recordp(mrec2)) {
ntfs_log_error("$MFTMirr error: Incomplete "
"multi sector transfer "

22
ntfsprogs/mkntfs.c
View File

@ -1470,19 +1470,19 @@ static int insert_positioned_attr_in_mft_record(MFT_RECORD *m,
goto err_out;
}
a = ctx->attr;
if (flags & ATTR_COMPRESSION_MASK) {
if (!le16_andz(flags, ATTR_COMPRESSION_MASK)) {
ntfs_log_error("Compressed attributes not supported yet.\n");
/* FIXME: Compress attribute into a temporary buffer, set */
/* val accordingly and save the compressed size. */
err = -EOPNOTSUPP;
goto err_out;
}
if (flags & (ATTR_IS_ENCRYPTED | ATTR_IS_SPARSE)) {
if (!le16_andz(flags, ATTR_IS_ENCRYPTED | ATTR_IS_SPARSE)) {
ntfs_log_error("Encrypted/sparse attributes not supported.\n");
err = -EOPNOTSUPP;
goto err_out;
}
if (flags & ATTR_COMPRESSION_MASK) {
if (!le16_andz(flags, ATTR_COMPRESSION_MASK)) {
hdr_size = 72;
/* FIXME: This compression stuff is all wrong. Never mind for */
/* now. (AIA) */
@ -1561,8 +1561,8 @@ static int insert_positioned_attr_in_mft_record(MFT_RECORD *m,
a->data_size = cpu_to_sle64(val_len);
if (name_len)
memcpy((char*)a + hdr_size, uname, name_len << 1);
if (flags & ATTR_COMPRESSION_MASK) {
if (flags & ATTR_COMPRESSION_MASK & ~ATTR_IS_COMPRESSED) {
if (!le16_andz(flags, ATTR_COMPRESSION_MASK)) {
if (!le16_andz(flags, ATTR_COMPRESSION_MASK & ~ATTR_IS_COMPRESSED)) {
ntfs_log_error("Unknown compression format. Reverting "
"to standard compression.\n");
a->flags &= ~ATTR_COMPRESSION_MASK;
@ -1661,14 +1661,14 @@ static int insert_non_resident_attr_in_mft_record(MFT_RECORD *m,
goto err_out;
}
a = ctx->attr;
if (flags & ATTR_COMPRESSION_MASK) {
if (!le16_andz(flags, ATTR_COMPRESSION_MASK)) {
ntfs_log_error("Compressed attributes not supported yet.\n");
/* FIXME: Compress attribute into a temporary buffer, set */
/* val accordingly and save the compressed size. */
err = -EOPNOTSUPP;
goto err_out;
}
if (flags & (ATTR_IS_ENCRYPTED | ATTR_IS_SPARSE)) {
if (!le16_andz(flags, ATTR_IS_ENCRYPTED | ATTR_IS_SPARSE)) {
ntfs_log_error("Encrypted/sparse attributes not supported.\n");
err = -EOPNOTSUPP;
goto err_out;
@ -1684,7 +1684,7 @@ static int insert_non_resident_attr_in_mft_record(MFT_RECORD *m,
} else {
rl = NULL;
}
if (flags & ATTR_COMPRESSION_MASK) {
if (!le16_andz(flags, ATTR_COMPRESSION_MASK)) {
hdr_size = 72;
/* FIXME: This compression stuff is all wrong. Never mind for */
/* now. (AIA) */
@ -1758,8 +1758,8 @@ static int insert_non_resident_attr_in_mft_record(MFT_RECORD *m,
a->initialized_size = cpu_to_sle64(val_len);
if (name_len)
memcpy((char*)a + hdr_size, uname, name_len << 1);
if (flags & ATTR_COMPRESSION_MASK) {
if (flags & ATTR_COMPRESSION_MASK & ~ATTR_IS_COMPRESSED) {
if (!le16_andz(flags, ATTR_COMPRESSION_MASK)) {
if (!le16_andz(flags, ATTR_COMPRESSION_MASK & ~ATTR_IS_COMPRESSED)) {
ntfs_log_error("Unknown compression format. Reverting "
"to standard compression.\n");
a->flags &= ~ATTR_COMPRESSION_MASK;
@ -4301,7 +4301,7 @@ static BOOL create_file_volume(MFT_RECORD *m, leMFT_REF root_ref,
err = add_attr_vol_name(m, g_vol->vol_name, g_vol->vol_name ?
strlen(g_vol->vol_name) : 0);
if (!err) {
if (fl & VOLUME_IS_DIRTY)
if (!le16_andz(fl, VOLUME_IS_DIRTY))
ntfs_log_quiet("Setting the volume dirty so check "
"disk runs on next reboot into "
"Windows.\n");

4
ntfsprogs/ntfsck.c
View File

@ -469,7 +469,7 @@ static ATTR_REC *check_attr_record(ATTR_REC *attr_rec, MFT_RECORD *mft_rec,
// todo: instance is unique.
// Check flags.
if (attr_rec->flags & ~(const_cpu_to_le16(0xc0ff))) {
if (!le16_andz(attr_rec->flags, ~(const_cpu_to_le16(0xc0ff)))) {
check_failed("Attribute %lld:0x%x Unknown flags (0x%x).\n",
(long long)current_mft_record, (int)attr_type,
(int)le16_to_cpu(attr_rec->flags));
@ -858,7 +858,7 @@ int main(int argc, char **argv)
replay_log(vol);
if (vol->flags & VOLUME_IS_DIRTY)
if (!le16_andz(vol->flags, VOLUME_IS_DIRTY))
ntfs_log_warning("Volume is dirty.\n");
check_volume(vol);

2
ntfsprogs/ntfsclone.c
View File

@ -2161,7 +2161,7 @@ static void mount_volume(unsigned long new_mntflag)
exit(1);
}
if (vol->flags & VOLUME_IS_DIRTY)
if (!le16_andz(vol->flags, VOLUME_IS_DIRTY))
if (opt.force-- <= 0)
err_exit(dirty_volume_msg, opt.volume);

10
ntfsprogs/ntfscp.c
View File

@ -612,13 +612,13 @@ static int set_sizes(struct ALLOC_CONTEXT *alctx, ntfs_attr_search_ctx *ctx)
attr->data_size = cpu_to_le64(na->data_size);
attr->initialized_size = cpu_to_le64(na->initialized_size);
attr->allocated_size = cpu_to_le64(na->allocated_size);
if (na->data_flags & ATTR_IS_SPARSE)
if (!le16_andz(na->data_flags, ATTR_IS_SPARSE))
attr->compressed_size = cpu_to_le64(na->compressed_size);
/* Copy the unnamed data attribute sizes to inode */
if (le32_eq(opts.attribute, AT_DATA) && !na->name_len) {
ni = na->ni;
ni->data_size = na->data_size;
if (na->data_flags & ATTR_IS_SPARSE) {
if (!le16_andz(na->data_flags, ATTR_IS_SPARSE)) {
ni->allocated_size = na->compressed_size;
ni->flags |= FILE_ATTR_SPARSE_FILE;
} else
@ -865,7 +865,7 @@ int main(int argc, char *argv[])
return 1;
}
if ((vol->flags & VOLUME_IS_DIRTY) && !opts.force)
if (!le16_andz(vol->flags, VOLUME_IS_DIRTY) && !opts.force)
goto umount;
NVolSetCompression(vol); /* allow compression */
@ -961,7 +961,7 @@ int main(int argc, char *argv[])
free(parent_dirname);
}
/* The destination is a directory. */
if ((out->mrec->flags & MFT_RECORD_IS_DIRECTORY) && !opts.inode) {
if (!le16_andz(out->mrec->flags, MFT_RECORD_IS_DIRECTORY) && !opts.inode) {
char *filename;
char *overwrite_filename;
int overwrite_filename_len;
@ -1107,7 +1107,7 @@ int main(int argc, char *argv[])
}
offset += bw;
}
if ((na->data_flags & ATTR_COMPRESSION_MASK)
if (!le16_andz(na->data_flags, ATTR_COMPRESSION_MASK)
&& ntfs_attr_pclose(na))
ntfs_log_perror("ERROR: ntfs_attr_pclose failed");
ntfs_log_verbose("Syncing.\n");

4
ntfsprogs/ntfsdump_logfile.c
View File

@ -563,11 +563,11 @@ static void dump_log_record(LOG_RECORD *lr)
else {
int _b = 0;
if (lr->flags & LOG_RECORD_MULTI_PAGE) {
if (!le16_andz(lr->flags, LOG_RECORD_MULTI_PAGE)) {
ntfs_log_info(" LOG_RECORD_MULTI_PAGE");
_b = 1;
}
if (lr->flags & ~LOG_RECORD_MULTI_PAGE) {
if (!le16_andz(lr->flags, ~LOG_RECORD_MULTI_PAGE)) {
if (_b)
ntfs_log_info(" |");
ntfs_log_info(" Unknown flags");

10
ntfsprogs/ntfsfallocate.c
View File

@ -545,7 +545,7 @@ static int ntfs_merge_allocation(ntfs_attr *na, runlist_element *rl,
err = ntfs_inner_zero(na, rl);
}
if (!err) {
if (na->data_flags & ATTR_IS_SPARSE) {
if (!le16_andz(na->data_flags, ATTR_IS_SPARSE)) {
na->compressed_size += size;
if (na->compressed_size >= na->allocated_size) {
na->data_flags &= ~ATTR_IS_SPARSE;
@ -709,14 +709,14 @@ static int ntfs_full_allocation(ntfs_attr *na, ntfs_attr_search_ctx *ctx,
= cpu_to_le64(na->initialized_size);
attr->allocated_size
= cpu_to_le64(na->allocated_size);
if (na->data_flags & ATTR_IS_SPARSE)
if (!le16_andz(na->data_flags, ATTR_IS_SPARSE))
attr->compressed_size
= cpu_to_le64(na->compressed_size);
/* Copy the unnamed data attribute sizes to inode */
if (le32_eq(attr_type, AT_DATA) && !attr_name_len) {
ni = na->ni;
ni->data_size = na->data_size;
if (na->data_flags & ATTR_IS_SPARSE) {
if (!le16_andz(na->data_flags, ATTR_IS_SPARSE)) {
ni->allocated_size
= na->compressed_size;
ni->flags |= FILE_ATTR_SPARSE_FILE;
@ -754,7 +754,7 @@ static int ntfs_fallocate(ntfs_inode *ni, s64 alloc_offs, s64 alloc_len)
err = -1;
} else {
errmess = (const char*)NULL;
if (na->data_flags & ATTR_IS_COMPRESSED) {
if (!le16_andz(na->data_flags, ATTR_IS_COMPRESSED)) {
errmess= "Cannot fallocate a compressed file";
}
@ -850,7 +850,7 @@ int main(int argc, char **argv)
err_exit(vol, "Failed to mount %s: %s\n", dev_name,
strerror(errno));
if ((vol->flags & VOLUME_IS_DIRTY) && !opts.force)
if (!le16_andz(vol->flags, VOLUME_IS_DIRTY) && !opts.force)
err_exit(vol, "Volume is dirty, please run chkdsk.\n");
if (ntfs_volume_get_free_space(vol))

10
ntfsprogs/ntfsfix.c
View File

@ -298,7 +298,7 @@ static int set_dirty_flag(ntfs_volume *vol)
/* Porting note: We test for the current state of VOLUME_IS_DIRTY. This
* should actually be more appropriate than testing for NVolWasDirty. */
if (vol->flags & VOLUME_IS_DIRTY)
if (!le16_andz(vol->flags, VOLUME_IS_DIRTY))
return 0;
ntfs_log_info("Setting required flags on partition... ");
/*
@ -483,7 +483,7 @@ static int fix_mftmirr(ntfs_volume *vol)
use_mirr = FALSE;
mrec = (MFT_RECORD*)(m + i * vol->mft_record_size);
if (mrec->flags & MFT_RECORD_IN_USE) {
if (!le16_andz(mrec->flags, MFT_RECORD_IN_USE)) {
if (ntfs_is_baad_record(mrec->magic)) {
ntfs_log_info(FAILED);
ntfs_log_error("$MFT error: Incomplete multi "
@ -501,7 +501,7 @@ static int fix_mftmirr(ntfs_volume *vol)
}
}
mrec2 = (MFT_RECORD*)(m2 + i * vol->mft_record_size);
if (mrec2->flags & MFT_RECORD_IN_USE) {
if (!le16_andz(mrec2->flags, MFT_RECORD_IN_USE)) {
if (ntfs_is_baad_record(mrec2->magic)) {
ntfs_log_info(FAILED);
ntfs_log_error("$MFTMirr error: Incomplete "
@ -920,7 +920,7 @@ static BOOL self_mapped_selfloc_condition(struct MFT_SELF_LOCATED *selfloc)
>> vol->cluster_size_bits;
a = find_unnamed_attr(mft1,AT_DATA);
if (a
&& (mft1->flags & MFT_RECORD_IN_USE)
&& !le16_andz(mft1->flags, MFT_RECORD_IN_USE)
&& ((VCN)le64_to_cpu(a->lowest_vcn) == lowest_vcn)
&& (le64_to_cpu(mft1->base_mft_record)
== selfloc->mft_ref0)
@ -973,7 +973,7 @@ static BOOL spare_record_selfloc_condition(struct MFT_SELF_LOCATED *selfloc)
&& !ntfs_mst_post_read_fixup((NTFS_RECORD*)mft2,
vol->mft_record_size)) {
if (le64_cmpz(mft2->base_mft_record)
&& (mft2->flags & MFT_RECORD_IN_USE)
&& !le16_andz(mft2->flags, MFT_RECORD_IN_USE)
&& !find_unnamed_attr(mft2,AT_ATTRIBUTE_LIST)
&& !find_unnamed_attr(mft2,AT_FILE_NAME)) {
ok = TRUE;

52
ntfsprogs/ntfsinfo.c
View File

@ -421,9 +421,9 @@ static void ntfs_dump_volume(ntfs_volume *vol)
printf("\tVolume Name: %s\n", vol->vol_name);
printf("\tVolume State: %lu\n", vol->state);
printf("\tVolume Flags: 0x%04x", (int)vol->flags);
if (vol->flags & VOLUME_IS_DIRTY)
if (!le16_andz(vol->flags, VOLUME_IS_DIRTY))
printf(" DIRTY");
if (vol->flags & VOLUME_MODIFIED_BY_CHKDSK)
if (!le16_andz(vol->flags, VOLUME_MODIFIED_BY_CHKDSK))
printf(" MODIFIED_BY_CHKDSK");
printf("\n");
printf("\tVolume Version: %u.%u\n", vol->major_ver, vol->minor_ver);
@ -983,7 +983,7 @@ static void ntfs_dump_security_descriptor(SECURITY_DESCRIPTOR_ATTR *sec_desc,
printf("%s\tControl:\t\t 0x%04x\n", indent,
le16_to_cpu(sec_desc->control));
if (~sec_desc->control & SE_SELF_RELATIVE) {
if (!le16_andz(~sec_desc->control, SE_SELF_RELATIVE)) {
SECURITY_DESCRIPTOR *sd = (SECURITY_DESCRIPTOR *)sec_desc;
printf("%s\tOwner SID pointer:\t %p\n", indent, sd->owner);
@ -1011,8 +1011,8 @@ static void ntfs_dump_security_descriptor(SECURITY_DESCRIPTOR_ATTR *sec_desc,
printf("%s\tGroup SID:\t\t missing\n", indent);
printf("%s\tSystem ACL:\t\t ", indent);
if (sec_desc->control & SE_SACL_PRESENT) {
if (sec_desc->control & SE_SACL_DEFAULTED) {
if (!le16_andz(sec_desc->control, SE_SACL_PRESENT)) {
if (!le16_andz(sec_desc->control, SE_SACL_DEFAULTED)) {
printf("defaulted");
}
printf("\n");
@ -1024,8 +1024,8 @@ static void ntfs_dump_security_descriptor(SECURITY_DESCRIPTOR_ATTR *sec_desc,
}
printf("%s\tDiscretionary ACL:\t ", indent);
if (sec_desc->control & SE_DACL_PRESENT) {
if (sec_desc->control & SE_SACL_DEFAULTED) {
if (!le16_andz(sec_desc->control, SE_DACL_PRESENT)) {
if (!le16_andz(sec_desc->control, SE_SACL_DEFAULTED)) {
printf("defaulted");
}
printf("\n");
@ -1131,28 +1131,28 @@ static void ntfs_dump_attr_volume_information(ATTR_RECORD *attr)
printf("\tVolume Version:\t\t %d.%d\n", vol_information->major_ver,
vol_information->minor_ver);
printf("\tVolume Flags:\t\t ");
if (vol_information->flags & VOLUME_IS_DIRTY)
if (!le16_andz(vol_information->flags, VOLUME_IS_DIRTY))
printf("DIRTY ");
if (vol_information->flags & VOLUME_RESIZE_LOG_FILE)
if (!le16_andz(vol_information->flags, VOLUME_RESIZE_LOG_FILE))
printf("RESIZE_LOG ");
if (vol_information->flags & VOLUME_UPGRADE_ON_MOUNT)
if (!le16_andz(vol_information->flags, VOLUME_UPGRADE_ON_MOUNT))
printf("UPG_ON_MOUNT ");
if (vol_information->flags & VOLUME_MOUNTED_ON_NT4)
if (!le16_andz(vol_information->flags, VOLUME_MOUNTED_ON_NT4))
printf("MOUNTED_NT4 ");
if (vol_information->flags & VOLUME_DELETE_USN_UNDERWAY)
if (!le16_andz(vol_information->flags, VOLUME_DELETE_USN_UNDERWAY))
printf("DEL_USN ");
if (vol_information->flags & VOLUME_REPAIR_OBJECT_ID)
if (!le16_andz(vol_information->flags, VOLUME_REPAIR_OBJECT_ID))
printf("REPAIR_OBJID ");
if (vol_information->flags & VOLUME_CHKDSK_UNDERWAY)
if (!le16_andz(vol_information->flags, VOLUME_CHKDSK_UNDERWAY))
printf("CHKDSK_UNDERWAY ");
if (vol_information->flags & VOLUME_MODIFIED_BY_CHKDSK)
if (!le16_andz(vol_information->flags, VOLUME_MODIFIED_BY_CHKDSK))
printf("MOD_BY_CHKDSK ");
if (vol_information->flags & VOLUME_FLAGS_MASK) {
if (!le16_andz(vol_information->flags, VOLUME_FLAGS_MASK)) {
printf("(0x%04x)\n",
(unsigned)le16_to_cpu(vol_information->flags));
} else
printf("none set (0x0000)\n");
if (vol_information->flags & (~VOLUME_FLAGS_MASK))
if (!le16_andz(vol_information->flags, ~VOLUME_FLAGS_MASK))
printf("\t\t\t\t Unknown Flags: 0x%04x\n",
le16_to_cpu(vol_information->flags &
(~VOLUME_FLAGS_MASK)));
@ -1358,8 +1358,8 @@ static void ntfs_dump_attribute_header(ntfs_attr_search_ctx *ctx,
(long long)sle64_to_cpu(a->initialized_size),
(unsigned long long)
sle64_to_cpu(a->initialized_size));
if (a->compression_unit || a->flags & ATTR_IS_COMPRESSED ||
a->flags & ATTR_IS_SPARSE)
if (a->compression_unit || !le16_andz(a->flags, ATTR_IS_COMPRESSED) ||
!le16_andz(a->flags, ATTR_IS_SPARSE))
printf("\tCompressed size:\t %llu (0x%llx)\n",
(signed long long)
sle64_to_cpu(a->compressed_size),
@ -1614,7 +1614,7 @@ static int ntfs_dump_index_entries(INDEX_ENTRY *entry, INDEX_ATTR_TYPE type)
int numb_entries = 1;
while (1) {
if (!opts.verbose) {
if (entry->ie_flags & INDEX_ENTRY_END)
if (!le16_andz(entry->ie_flags, INDEX_ENTRY_END))
break;
entry = (INDEX_ENTRY *)((u8 *)entry +
le16_to_cpu(entry->length));
@ -1630,11 +1630,11 @@ static int ntfs_dump_index_entries(INDEX_ENTRY *entry, INDEX_ATTR_TYPE type)
ntfs_log_verbose("\t\tIndex entry flags:\t 0x%02x\n",
(unsigned)le16_to_cpu(entry->ie_flags));
if (entry->ie_flags & INDEX_ENTRY_NODE)
if (!le16_andz(entry->ie_flags, INDEX_ENTRY_NODE))
ntfs_log_verbose("\t\tSubnode VCN:\t\t %lld (0x%llx)\n",
(long long)ntfs_ie_get_vcn(entry),
(long long)ntfs_ie_get_vcn(entry));
if (entry->ie_flags & INDEX_ENTRY_END)
if (!le16_andz(entry->ie_flags, INDEX_ENTRY_END))
break;
switch (type) {
@ -2189,20 +2189,20 @@ static void ntfs_dump_inode_general_info(ntfs_inode *inode)
printf("MFT Record Flags:\t ");
if (!le16_cmpz(inode_flags)) {
if (MFT_RECORD_IN_USE & inode_flags) {
if (!le16_andz(MFT_RECORD_IN_USE, inode_flags)) {
printf("IN_USE ");
inode_flags &= ~MFT_RECORD_IN_USE;
}
if (MFT_RECORD_IS_DIRECTORY & inode_flags) {
if (!le16_andz(MFT_RECORD_IS_DIRECTORY, inode_flags)) {
printf("DIRECTORY ");
inode_flags &= ~MFT_RECORD_IS_DIRECTORY;
}
/* The meaning of IS_4 is illusive but not its existence. */
if (MFT_RECORD_IS_4 & inode_flags) {
if (!le16_andz(MFT_RECORD_IS_4, inode_flags)) {
printf("IS_4 ");
inode_flags &= ~MFT_RECORD_IS_4;
}
if (MFT_RECORD_IS_VIEW_INDEX & inode_flags) {
if (!le16_andz(MFT_RECORD_IS_VIEW_INDEX, inode_flags)) {
printf("VIEW_INDEX ");
inode_flags &= ~MFT_RECORD_IS_VIEW_INDEX;
}

2
ntfsprogs/ntfsls.c
View File

@ -671,7 +671,7 @@ int main(int argc, char **argv)
pos = 0;
memset(&dirent, 0, sizeof(dirent));
dirent.vol = vol;
if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY) {
if (!le16_andz(ni->mrec->flags, MFT_RECORD_IS_DIRECTORY)) {
if (opts.recursive)
readdir_recursive(ni, &pos, &dirent);
else

4
ntfsprogs/ntfsmftalloc.c
View File

@ -236,11 +236,11 @@ static void dump_mft_record(MFT_RECORD *m)
u = le16_to_cpu(m->attrs_offset);
ntfs_log_info("First attribute offset = %u (0x%x)\n", u, u);
ntfs_log_info("Flags = %u: ", le16_to_cpu(m->flags));
if (m->flags & MFT_RECORD_IN_USE)
if (!le16_andz(m->flags, MFT_RECORD_IN_USE))
ntfs_log_info("MFT_RECORD_IN_USE");
else
ntfs_log_info("MFT_RECORD_NOT_IN_USE");
if (m->flags & MFT_RECORD_IS_DIRECTORY)
if (!le16_andz(m->flags, MFT_RECORD_IS_DIRECTORY))
ntfs_log_info(" | MFT_RECORD_IS_DIRECTORY");
ntfs_log_info("\n");
u = le32_to_cpu(m->bytes_in_use);

16
ntfsprogs/ntfsresize.c
View File

@ -735,11 +735,11 @@ static void collect_resize_constraints(ntfs_resize_t *resize, runlist *rl)
if (inode != FILE_MFTMirr)
supported = 1;
} else if (flags & ATTR_IS_SPARSE) {
} else if (!le16_andz(flags, ATTR_IS_SPARSE)) {
llcn = &resize->last_sparse;
supported = 1;
} else if (flags & ATTR_IS_COMPRESSED) {
} else if (!le16_andz(flags, ATTR_IS_COMPRESSED)) {
llcn = &resize->last_compressed;
supported = 1;
@ -2777,7 +2777,7 @@ static ntfs_volume *mount_volume(void)
}
vol = check_volume();
if (vol->flags & VOLUME_IS_DIRTY)
if (!le16_andz(vol->flags, VOLUME_IS_DIRTY))
if (opt.force-- <= 0)
err_exit("Volume is scheduled for check.\nRun chkdsk /f"
" and please try again, or see option -f.\n");
@ -3004,7 +3004,7 @@ static ATTR_RECORD *get_unnamed_attr(expand_t *expand, ATTR_TYPES type,
+ (inum << vol->mft_record_size_bits)
+ expand->byte_increment;
got = ntfs_mst_pread(vol->dev, pos, 1, vol->mft_record_size, mrec);
if ((got == 1) && (mrec->flags & MFT_RECORD_IN_USE)) {
if ((got == 1) && !le16_andz(mrec->flags, MFT_RECORD_IN_USE)) {
a = find_attr(expand->mrec, type, NULL, 0);
found = a && le32_eq(a->type, type) && !a->name_length;
}
@ -3039,7 +3039,7 @@ static ATTR_RECORD *read_and_get_attr(expand_t *expand, ATTR_TYPES type,
+ (inum << vol->mft_record_size_bits)
+ expand->byte_increment;
got = ntfs_mst_pread(vol->dev, pos, 1, vol->mft_record_size, mrec);
if ((got == 1) && (mrec->flags & MFT_RECORD_IN_USE)) {
if ((got == 1) && !le16_andz(mrec->flags, MFT_RECORD_IN_USE)) {
a = find_attr(expand->mrec, type, name, namelen);
}
if (!a) {
@ -3242,7 +3242,7 @@ static int check_expand_constraints(expand_t *expand)
volinfo = (VOLUME_INFORMATION*)
(le16_to_cpu(a->value_offset) + (char*)a);
flags = volinfo->flags;
if ((flags & VOLUME_IS_DIRTY) && (opt.force-- <= 0)) {
if (!le16_andz(flags, VOLUME_IS_DIRTY) && (opt.force-- <= 0)) {
err_printf("Volume is scheduled for check.\nRun chkdsk /f"
" and please try again, or see option -f.\n");
res = -1;
@ -4054,7 +4054,7 @@ static int rebase_inode(expand_t *expand, const runlist_element *prl,
+ ((inum - jnum) << vol->mft_record_size_bits);
if ((ntfs_mst_pread(vol->dev, pos, 1,
vol->mft_record_size, mrec) == 1)
&& (mrec->flags & MFT_RECORD_IN_USE)) {
&& !le16_andz(mrec->flags, MFT_RECORD_IN_USE)) {
switch (inum) {
case FILE_Bitmap :
case FILE_Boot :
@ -4128,7 +4128,7 @@ static int rebase_all_inodes(expand_t *expand)
<< vol->cluster_size_bits;
got = ntfs_mst_pread(vol->dev, pos, 1,
vol->mft_record_size, mrec);
if ((got == 1) && (mrec->flags & MFT_RECORD_IN_USE)) {
if ((got == 1) && !le16_andz(mrec->flags, MFT_RECORD_IN_USE)) {
pos = expand->mft_lcn << vol->cluster_size_bits;
if (opt.verbose)
ntfs_log_verbose("Rebasing inode %lld cluster 0x%llx\n",

30
ntfsprogs/ntfstruncate.c
View File

@ -364,46 +364,46 @@ static void dump_resident_attr_val(ATTR_TYPES type, char *val, u32 val_len)
return;
}
j = 0;
if (i & VOLUME_MODIFIED_BY_CHKDSK) {
if (!le16_andz(i, VOLUME_MODIFIED_BY_CHKDSK)) {
j = 1;
printf("VOLUME_MODIFIED_BY_CHKDSK");
}
if (i & VOLUME_REPAIR_OBJECT_ID) {
if (!le16_andz(i, VOLUME_REPAIR_OBJECT_ID)) {
if (j)
printf(" | ");
else
j = 0;
printf("VOLUME_REPAIR_OBJECT_ID");
}
if (i & VOLUME_DELETE_USN_UNDERWAY) {
if (!le16_andz(i, VOLUME_DELETE_USN_UNDERWAY)) {
if (j)
printf(" | ");
else
j = 0;
printf("VOLUME_DELETE_USN_UNDERWAY");
}
if (i & VOLUME_MOUNTED_ON_NT4) {
if (!le16_andz(i, VOLUME_MOUNTED_ON_NT4)) {
if (j)
printf(" | ");
else
j = 0;
printf("VOLUME_MOUNTED_ON_NT4");
}
if (i & VOLUME_UPGRADE_ON_MOUNT) {
if (!le16_andz(i, VOLUME_UPGRADE_ON_MOUNT)) {
if (j)
printf(" | ");
else
j = 0;
printf("VOLUME_UPGRADE_ON_MOUNT");
}
if (i & VOLUME_RESIZE_LOG_FILE) {
if (!le16_andz(i, VOLUME_RESIZE_LOG_FILE)) {
if (j)
printf(" | ");
else
j = 0;
printf("VOLUME_RESIZE_LOG_FILE");
}
if (i & VOLUME_IS_DIRTY) {
if (!le16_andz(i, VOLUME_IS_DIRTY)) {
if (j)
printf(" | ");
else
@ -514,7 +514,7 @@ static void dump_non_resident_attr(ATTR_RECORD *a)
l = sle64_to_cpu(a->initialized_size);
printf("Initialized size = %lli (0x%llx)\n", (long long)l,
(unsigned long long)l);
if (a->flags & ATTR_COMPRESSION_MASK) {
if (!le16_andz(a->flags, ATTR_COMPRESSION_MASK)) {
l = sle64_to_cpu(a->compressed_size);
printf("Compressed size = %lli (0x%llx)\n", (long long)l,
(unsigned long long)l);
@ -584,12 +584,12 @@ static void dump_attr_record(MFT_RECORD *m, ATTR_RECORD *a)
printf("NONE");
else {
int first = TRUE;
if (u & ATTR_COMPRESSION_MASK) {
if (u & ATTR_IS_COMPRESSED) {
if (!le16_andz(u, ATTR_COMPRESSION_MASK)) {
if (!le16_andz(u, ATTR_IS_COMPRESSED)) {
printf("ATTR_IS_COMPRESSED");
first = FALSE;
}
if ((u & ATTR_COMPRESSION_MASK) & ~ATTR_IS_COMPRESSED) {
if (!le16_andz(u & ATTR_COMPRESSION_MASK, ~ATTR_IS_COMPRESSED)) {
if (!first)
printf(" | ");
else
@ -597,14 +597,14 @@ static void dump_attr_record(MFT_RECORD *m, ATTR_RECORD *a)
printf("ATTR_UNKNOWN_COMPRESSION");
}
}
if (u & ATTR_IS_ENCRYPTED) {
if (!le16_andz(u, ATTR_IS_ENCRYPTED)) {
if (!first)
printf(" | ");
else
first = FALSE;
printf("ATTR_IS_ENCRYPTED");
}
if (u & ATTR_IS_SPARSE) {
if (!le16_andz(u, ATTR_IS_SPARSE)) {
if (!first)
printf(" | ");
else
@ -645,11 +645,11 @@ static void dump_mft_record(MFT_RECORD *m)
u = le16_to_cpu(m->attrs_offset);
printf("First attribute offset = %u (0x%x)\n", u, u);
printf("Flags = %u: ", le16_to_cpu(m->flags));
if (m->flags & MFT_RECORD_IN_USE)
if (!le16_andz(m->flags, MFT_RECORD_IN_USE))
printf("MFT_RECORD_IN_USE");
else
printf("MFT_RECORD_NOT_IN_USE");
if (m->flags & MFT_RECORD_IS_DIRECTORY)
if (!le16_andz(m->flags, MFT_RECORD_IS_DIRECTORY))
printf(" | MFT_RECORD_IS_DIRECTORY");
printf("\n");
u = le32_to_cpu(m->bytes_in_use);

6
ntfsprogs/ntfsundelete.c
View File

@ -1278,8 +1278,8 @@ static int get_data(struct ufile *file, ntfs_volume *vol)
}
data->resident = !rec->non_resident;
data->compressed = (rec->flags & ATTR_IS_COMPRESSED) ? 1 : 0;
data->encrypted = (rec->flags & ATTR_IS_ENCRYPTED) ? 1 : 0;
data->compressed = !le16_andz(rec->flags, ATTR_IS_COMPRESSED) ? 1 : 0;
data->encrypted = !le16_andz(rec->flags, ATTR_IS_ENCRYPTED) ? 1 : 0;
if (rec->name_length) {
data->uname = (ntfschar *)((char *)rec +
@ -1973,7 +1973,7 @@ static int undelete_file(ntfs_volume *vol, long long inode)
* list_record(). Otherwise, when undeleting, a file will always be
* listed as 0% recoverable even if successfully undeleted. +mabs
*/
if (file->mft->flags & MFT_RECORD_IN_USE) {
if (!le16_andz(file->mft->flags, MFT_RECORD_IN_USE)) {
ntfs_log_error("Record is in use by the mft\n");
if (!opts.force) {
free(buffer);

6
ntfsprogs/ntfswipe.c
View File

@ -771,7 +771,7 @@ static s64 wipe_attribute(ntfs_volume *vol, int byte, enum action act,
if (!offset)
return 0;
if (na->data_flags & ATTR_IS_ENCRYPTED)
if (!le16_andz(na->data_flags, ATTR_IS_ENCRYPTED))
offset = (((offset - 1) >> 10) + 1) << 10;
size = (vol->cluster_size - offset) % vol->cluster_size;
@ -831,7 +831,7 @@ static s64 wipe_attr_tail(ntfs_inode *ni, ntfschar *name, int namelen,
goto close_attr;
}
if (na->data_flags & ATTR_COMPRESSION_MASK)
if (!le16_andz(na->data_flags, ATTR_COMPRESSION_MASK))
wiped = wipe_compressed_attribute(vol, byte, act, na);
else
wiped = wipe_attribute(vol, byte, act, na);
@ -2142,7 +2142,7 @@ int main(int argc, char *argv[])
if (!vol)
goto free;
if ((vol->flags & VOLUME_IS_DIRTY) && !opts.force)
if (!le16_andz(vol->flags, VOLUME_IS_DIRTY) && !opts.force)
goto umount;
if (opts.info) {

2
ntfsprogs/utils.c
View File

@ -303,7 +303,7 @@ ntfs_volume * utils_mount_volume(const char *device, unsigned long flags)
* libntfs-3g does not record whether the volume log file was dirty
* before mount, so we can only warn if the VOLUME_IS_DIRTY flag is set
* in VOLUME_INFORMATION. */
if (vol->flags & VOLUME_IS_DIRTY) {
if (!le16_andz(vol->flags, VOLUME_IS_DIRTY)) {
if (!(flags & NTFS_MNT_RECOVER)) {
ntfs_log_error("%s", dirty_volume_msg);
ntfs_umount(vol, FALSE);

16
src/lowntfs-3g.c
View File

@ -602,7 +602,7 @@ static int ntfs_fuse_getstat(struct SECURITY_CONTEXT *scx,
memset(stbuf, 0, sizeof(struct stat));
withusermapping = (scx->mapping[MAPUSERS] != (struct MAPPING*)NULL);
if ((ni->mrec->flags & MFT_RECORD_IS_DIRECTORY)
if (!le16_andz(ni->mrec->flags, MFT_RECORD_IS_DIRECTORY)
|| (ni->flags & FILE_ATTR_REPARSE_POINT)) {
if (ni->flags & FILE_ATTR_REPARSE_POINT) {
char *target;
@ -1266,7 +1266,7 @@ static void ntfs_fuse_open(fuse_req_t req, fuse_ino_t ino,
if ((res >= 0)
&& (fi->flags & (O_WRONLY | O_RDWR))) {
/* mark a future need to compress the last chunk */
if (na->data_flags & ATTR_COMPRESSION_MASK)
if (!le16_andz(na->data_flags, ATTR_COMPRESSION_MASK))
state |= CLOSE_COMPRESSED;
#ifdef HAVE_SETXATTR /* extended attributes interface required */
/* mark a future need to fixup encrypted inode */
@ -1346,7 +1346,7 @@ static void ntfs_fuse_read(fuse_req_t req, fuse_ino_t ino, size_t size,
/* limit reads at next 512 byte boundary for encrypted attributes */
if (ctx->efs_raw
&& max_read
&& (na->data_flags & ATTR_IS_ENCRYPTED)
&& !le16_andz(na->data_flags, ATTR_IS_ENCRYPTED)
&& NAttrNonResident(na)) {
max_read = ((na->data_size+511) & ~511) + 2;
}
@ -1595,7 +1595,7 @@ static int ntfs_fuse_trunc(struct SECURITY_CONTEXT *scx, fuse_ino_t ino,
* zero, which is optimized as creating a hole when possible.
*/
oldsize = na->data_size;
if ((na->data_flags & ATTR_COMPRESSION_MASK)
if (!le16_andz(na->data_flags, ATTR_COMPRESSION_MASK)
&& (size > na->initialized_size)) {
char zero = 0;
if (ntfs_attr_pwrite(na, size - 1, 1, &zero) <= 0)
@ -2091,7 +2091,7 @@ static int ntfs_fuse_newlink(fuse_req_t req __attribute__((unused)),
}
/* Do not accept linking to a directory (except for renaming) */
if (e && (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY)) {
if (e && !le16_andz(ni->mrec->flags, MFT_RECORD_IS_DIRECTORY)) {
errno = EPERM;
res = -errno;
goto exit;
@ -2213,7 +2213,7 @@ static int ntfs_fuse_rm(fuse_req_t req, fuse_ino_t parent, const char *name,
#if defined(__sun) && defined (__SVR4)
/* on Solaris : deny unlinking directories */
if (rm_type
== (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY ? RM_LINK : RM_DIR)) {
== (!le16_andz(ni->mrec->flags, MFT_RECORD_IS_DIRECTORY) ? RM_LINK : RM_DIR)) {
errno = EPERM;
res = -errno;
goto exit;
@ -2677,7 +2677,7 @@ static void ntfs_fuse_bmap(fuse_req_t req, fuse_ino_t ino, size_t blocksize,
goto close_inode;
}
if ((na->data_flags & (ATTR_COMPRESSION_MASK | ATTR_IS_ENCRYPTED))
if (!le16_andz(na->data_flags, ATTR_COMPRESSION_MASK | ATTR_IS_ENCRYPTED)
|| !NAttrNonResident(na)) {
ret = -EINVAL;
goto close_attr;
@ -3064,7 +3064,7 @@ static void ntfs_fuse_getxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
rsize = na->data_size;
if (ctx->efs_raw
&& rsize
&& (na->data_flags & ATTR_IS_ENCRYPTED)
&& !le16_andz(na->data_flags, ATTR_IS_ENCRYPTED)
&& NAttrNonResident(na))
rsize = ((na->data_size + 511) & ~511) + 2;
if (size) {

14
src/ntfs-3g.c
View File

@ -696,7 +696,7 @@ static int ntfs_fuse_getattr(const char *org_path, struct stat *stbuf)
goto exit;
}
#endif
if (((ni->mrec->flags & MFT_RECORD_IS_DIRECTORY)
if ((!le16_andz(ni->mrec->flags, MFT_RECORD_IS_DIRECTORY)
|| (ni->flags & FILE_ATTR_REPARSE_POINT))
&& !stream_name_len) {
if (ni->flags & FILE_ATTR_REPARSE_POINT) {
@ -790,7 +790,7 @@ static int ntfs_fuse_getattr(const char *org_path, struct stat *stbuf)
/* encrypted named stream */
/* round size up to next 512 byte boundary */
if (ctx->efs_raw && stream_name_len &&
(na->data_flags & ATTR_IS_ENCRYPTED) &&
!le16_andz(na->data_flags, ATTR_IS_ENCRYPTED) &&
NAttrNonResident(na))
stbuf->st_size = ((na->data_size+511) & ~511)+2;
#endif /* HAVE_SETXATTR */
@ -1203,7 +1203,7 @@ static int ntfs_fuse_open(const char *org_path,
if ((res >= 0)
&& (fi->flags & (O_WRONLY | O_RDWR))) {
/* mark a future need to compress the last chunk */
if (na->data_flags & ATTR_COMPRESSION_MASK)
if (!le16_andz(na->data_flags, ATTR_COMPRESSION_MASK))
fi->fh |= CLOSE_COMPRESSED;
#ifdef HAVE_SETXATTR /* extended attributes interface required */
/* mark a future need to fixup encrypted inode */
@ -1264,7 +1264,7 @@ static int ntfs_fuse_read(const char *org_path, char *buf, size_t size,
/* limit reads at next 512 byte boundary for encrypted attributes */
if (ctx->efs_raw
&& max_read
&& (na->data_flags & ATTR_IS_ENCRYPTED)
&& !le16_andz(na->data_flags, ATTR_IS_ENCRYPTED)
&& NAttrNonResident(na)) {
max_read = ((na->data_size+511) & ~511) + 2;
}
@ -1462,7 +1462,7 @@ static int ntfs_fuse_trunc(const char *org_path, off_t size,
* zero, which is optimized as creating a hole when possible.
*/
oldsize = na->data_size;
if ((na->data_flags & ATTR_COMPRESSION_MASK)
if (!le16_andz(na->data_flags, ATTR_COMPRESSION_MASK)
&& (size > na->initialized_size)) {
char zero = 0;
if (ntfs_attr_pwrite(na, size - 1, 1, &zero) <= 0)
@ -2494,7 +2494,7 @@ static int ntfs_fuse_bmap(const char *path, size_t blocksize, uint64_t *idx)
goto close_inode;
}
if ((na->data_flags & (ATTR_COMPRESSION_MASK | ATTR_IS_ENCRYPTED))
if (!le16_andz(na->data_flags, ATTR_COMPRESSION_MASK | ATTR_IS_ENCRYPTED)
|| !NAttrNonResident(na)) {
ret = -EINVAL;
goto close_attr;
@ -2915,7 +2915,7 @@ static int ntfs_fuse_getxattr(const char *path, const char *name,
rsize = na->data_size;
if (ctx->efs_raw
&& rsize
&& (na->data_flags & ATTR_IS_ENCRYPTED)
&& !le16_andz(na->data_flags, ATTR_IS_ENCRYPTED)
&& NAttrNonResident(na))
rsize = ((na->data_size + 511) & ~511) + 2;
if (size) {