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

Whitespace cleanup

edge.strict_endians
uvman 2006-10-27 12:24:29 +00:00
parent 880529ee5a
commit ff55ecb513
16 changed files with 346 additions and 348 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
include/ntfs/layout.h
View File

@ -244,7 +244,7 @@ typedef enum {
*
* These are the so far known MFT_RECORD_* flags (16-bit) which contain
* information about the mft record in which they are present.
*
*
* MFT_RECORD_IS_4 exists on all $Extend sub-files.
* It seems that it marks it is a metadata file with MFT record >24, however,
* it is unknown if it is limited to metadata files only.
@ -480,7 +480,7 @@ typedef struct {
* Each attribute type has a corresponding attribute name (Unicode string of
* maximum 64 character length) as described by the attribute definitions
* present in the data attribute of the $AttrDef system file.
*
*
* On NTFS 3.0 volumes the names are just as the types are named in the below
* enum exchanging AT_ for the dollar sign ($). If that isn't a revealing
* choice of symbol... (-;
@ -867,15 +867,15 @@ typedef enum {
* This is a copy of the MFT_RECORD_IS_DIRECTORY bit from the mft
* record, telling us whether this is a directory or not, i.e. whether
* it has an index root attribute named "$I30" or not.
*
* This flag is only present in the FILE_NAME attribute (in the
*
* This flag is only present in the FILE_NAME attribute (in the
* file_attributes field).
*/
FILE_ATTR_I30_INDEX_PRESENT = const_cpu_to_le32(0x10000000),
/**
* FILE_ATTR_VIEW_INDEX_PRESENT - Does have a non-directory index?
*
*
* This is a copy of the MFT_RECORD_IS_VIEW_INDEX bit from the mft
* record, telling us whether this file has a view index present (eg.
* object id index, quota index, one of the security indexes and the

2
include/ntfs/list.h
View File

@ -24,7 +24,7 @@
/**
* struct list_head - Simple doubly linked list implementation.
*
*
* Copied from Linux kernel 2.4.2-ac18 into Linux-NTFS (with minor
* modifications). - AIA
*

6
include/ntfs/support.h
View File

@ -98,13 +98,13 @@
/**
* ntfs_calloc, ntfs_malloc
*
*
* Return a pointer to the allocated memory or NULL if the request fails.
*/
static inline void *ntfs_calloc(size_t size)
{
void *p;
p = calloc(1, size);
if (!p)
ntfs_log_perror("Failed to calloc %lld bytes", (long long)size);
@ -114,7 +114,7 @@ static inline void *ntfs_calloc(size_t size)
static inline void *ntfs_malloc(size_t size)
{
void *p;
p = malloc(size);
if (!p)
ntfs_log_perror("Failed to malloc %lld bytes", (long long)size);

18
libntfs/attrib.c
View File

@ -3861,7 +3861,7 @@ static int ntfs_resident_attr_resize(ntfs_attr *na, const s64 newsize)
goto put_err_out;
}
/*
/*
* Force index allocation creation instead of moving out index root
* from the base MFT record.
*/
@ -4988,21 +4988,21 @@ int ntfs_attr_truncate(ntfs_attr *na, const s64 newsize)
ntfs_inode_update_time(na->ni);
return ret;
}
/**
* ntfs_attr_readall - read the entire data from an ntfs attribute
* @ni: open ntfs inode in which the ntfs attribute resides
* @type: attribute type
* @name: attribute name in little endian Unicode or AT_UNNAMED or NULL
* @name_len: length of attribute @name in Unicode characters (if @name given)
* @data_size: if non-NULL then store here the data size
* @data_size: if non-NULL then store here the data size
*
* This function will read the entire content of an ntfs attribute.
* If @name is AT_UNNAMED then look specifically for an unnamed attribute.
* If @name is NULL then the attribute could be either named or not.
* If @name is NULL then the attribute could be either named or not.
* In both those cases @name_len is not used at all.
*
* On success a buffer is allocated with the content of the attribute
* On success a buffer is allocated with the content of the attribute
* and which needs to be freed when it's not needed anymore. If the
* @data_size parameter is non-NULL then the data size is set there.
*
@ -5014,7 +5014,7 @@ void *ntfs_attr_readall(ntfs_inode *ni, const ATTR_TYPES type,
ntfs_attr *na;
void *data, *ret = NULL;
s64 size;
na = ntfs_attr_open(ni, type, name, name_len);
if (!na) {
ntfs_log_perror("ntfs_attr_open failed");
@ -5047,13 +5047,13 @@ int ntfs_attr_exist(ntfs_inode *ni, const ATTR_TYPES type, ntfschar *name,
{
ntfs_attr_search_ctx *ctx;
int ret;
ntfs_log_trace("Entering.\n");
ctx = ntfs_attr_get_search_ctx(ni, NULL);
if (!ctx)
return 0;
ret = ntfs_attr_lookup(type, name, name_len, CASE_SENSITIVE, 0, NULL, 0,
ctx);

4
libntfs/dir.c
View File

@ -1175,7 +1175,7 @@ static ntfs_inode *__ntfs_create(ntfs_inode *dir_ni,
* 4 bytes to every SID.
*/
sd_len = sizeof(SECURITY_DESCRIPTOR_ATTR) + 2 * (sizeof(SID) + 4) +
sizeof(ACL) + sizeof(ACCESS_ALLOWED_ACE);
sizeof(ACL) + sizeof(ACCESS_ALLOWED_ACE);
sd = calloc(1, sd_len);
if (!sd) {
err = errno;
@ -1191,7 +1191,7 @@ static ntfs_inode *__ntfs_create(ntfs_inode *dir_ni,
sid->sub_authority[0] = cpu_to_le32(32);
sid->sub_authority[1] = cpu_to_le32(544);
sid->identifier_authority.value[5] = 5;
sid = (SID*)((u8*)sid + sizeof(SID) + 4);
sid = (SID*)((u8*)sid + sizeof(SID) + 4);
sd->group = cpu_to_le32((u8*)sid - (u8*)sd);
sid->revision = 1;
sid->sub_authority_count = 2;

452
libntfs/index.c
View File

File diff suppressed because it is too large Load Diff

4
libntfs/inode.c
View File

@ -1111,7 +1111,7 @@ void ntfs_inode_update_time(ntfs_inode *ni)
* Check if the mft record given by @mft_no and @attr contains the bad sector
* list. Please note that mft record numbers describing $Badclus extent inodes
* will not match the current $Badclus:$Bad check.
*
*
* On success return 1 if the file is $Badclus:$Bad, otherwise return 0.
* On error return -1 with errno set to the error code.
*/
@ -1125,7 +1125,7 @@ int ntfs_inode_badclus_bad(u64 mft_no, ATTR_RECORD *attr)
errno = EINVAL;
return -1;
}
if (mft_no != FILE_BadClus)
return 0;

12
libntfs/runlist.c
View File

@ -1586,31 +1586,31 @@ int ntfs_rl_truncate(runlist **arl, const VCN start_vcn)
ntfs_log_perror("rl_truncate error: arl: %p *arl: %p", arl, *arl);
return -1;
}
rl = *arl;
if (start_vcn < rl->vcn) {
errno = EINVAL;
ntfs_log_perror("Start_vcn lies outside front of runlist");
return -1;
}
/* Find the starting vcn in the run list. */
while (rl->length) {
if (start_vcn < rl[1].vcn)
break;
rl++;
}
if (!rl->length) {
errno = EIO;
ntfs_log_trace("Truncating already truncated runlist?\n");
return -1;
}
/* Truncate the run. */
rl->length = start_vcn - rl->vcn;
/*
* If a run was partially truncated, make the following runlist
* element a terminator instead of the truncated runlist

4
libntfs/unistr.c
View File

@ -708,12 +708,12 @@ void ntfs_upcase_table_build(ntfschar *uc, u32 uc_len)
* @len: length of output buffer in Unicode characters
*
* Convert the input @s string into the corresponding little endian,
* 2-byte Unicode string. The length of the converted string is less
* 2-byte Unicode string. The length of the converted string is less
* or equal to the maximum length allowed by the NTFS format (255).
*
* If @s is NULL then return AT_UNNAMED.
*
* On success the function returns the Unicode string in an allocated
* On success the function returns the Unicode string in an allocated
* buffer and the caller is responsible to free it when it's not needed
* anymore.
*

2
libntfs/unix_io.c
View File

@ -91,7 +91,7 @@ static int ntfs_device_unix_io_open(struct ntfs_device *dev, int flags)
/*
* Open the device/file obtaining the file descriptor for exclusive
* access (but only if mounting r/w).
*/
*/
if ((flags & O_RDWR) == O_RDWR)
flags |= O_EXCL;
*(int*)dev->d_private = open(dev->d_name, flags);

4
libntfs/volume.c
View File

@ -217,7 +217,7 @@ static int ntfs_mft_load(ntfs_volume *vol)
}
mft_has_no_attr_list:
/* Receive attributes from STANDARD_INFORMATION. */
std_info = ntfs_attr_readall(vol->mft_ni, AT_STANDARD_INFORMATION,
std_info = ntfs_attr_readall(vol->mft_ni, AT_STANDARD_INFORMATION,
AT_UNNAMED, 0, NULL);
vol->mft_ni->flags = std_info->file_attributes;
@ -815,7 +815,7 @@ ntfs_volume *ntfs_device_mount(struct ntfs_device *dev, unsigned long flags)
ntfs_log_perror("Failed to read $MFTMirr");
else {
ntfs_log_debug("Failed to read $MFTMirr, unexpected "
"length (%d != %lld).\n",
"length (%d != %lld).\n",
vol->mftmirr_size, l);
errno = EIO;
}

20
ntfsprogs/mkntfs.c
View File

@ -2861,7 +2861,7 @@ static int initialize_quota(MFT_RECORD *m)
INDEX_ENTRY *idx_entry_o, *idx_entry_q1, *idx_entry_q2;
QUOTA_O_INDEX_DATA *idx_entry_o_data;
QUOTA_CONTROL_ENTRY *idx_entry_q1_data, *idx_entry_q2_data;
err = 0;
/* q index entry num 1 */
q1_size = 0x48;
@ -3790,7 +3790,7 @@ static BOOL mkntfs_initialize_bitmaps(void)
g_rl_mft_bmp = ntfs_malloc(2 * sizeof(runlist));
if (!g_rl_mft_bmp)
return FALSE;
g_rl_mft_bmp[0].vcn = 0LL;
/* Mft bitmap is right after $Boot's data. */
i = (8192 + g_vol->cluster_size - 1) / g_vol->cluster_size;
@ -3855,7 +3855,7 @@ static BOOL mkntfs_initialize_rl_mft(void)
g_rl_mft = ntfs_malloc(2 * sizeof(runlist));
if (!g_rl_mft)
return FALSE;
g_rl_mft[0].vcn = 0LL;
g_rl_mft[0].lcn = g_mft_lcn;
/* rounded up division by cluster size */
@ -3876,7 +3876,7 @@ static BOOL mkntfs_initialize_rl_mft(void)
g_rl_mftmirr = ntfs_malloc(2 * sizeof(runlist));
if (!g_rl_mftmirr)
return FALSE;
g_rl_mftmirr[0].vcn = 0LL;
g_rl_mftmirr[0].lcn = g_mftmirr_lcn;
/*
@ -3912,7 +3912,7 @@ static BOOL mkntfs_initialize_rl_logfile(void)
g_rl_logfile = ntfs_malloc(2 * sizeof(runlist));
if (!g_rl_logfile)
return FALSE;
volume_size = g_vol->nr_clusters << g_vol->cluster_size_bits;
@ -3935,7 +3935,7 @@ static BOOL mkntfs_initialize_rl_logfile(void)
g_logfile_size = (volume_size / 100) &
~(g_vol->cluster_size - 1);
} else {
/*
/*
* FIXME: The $LogFile size is 64 MiB upwards from 12GiB but
* the "200" divider below apparently approximates "100" or
* some other value as the volume size decreases. For example:
@ -3996,7 +3996,7 @@ static BOOL mkntfs_initialize_rl_boot(void)
g_rl_boot = ntfs_malloc(2 * sizeof(runlist));
if (!g_rl_boot)
return FALSE;
g_rl_boot[0].vcn = 0LL;
g_rl_boot[0].lcn = 0LL;
/*
@ -4023,7 +4023,7 @@ static BOOL mkntfs_initialize_rl_bad(void)
g_rl_bad = ntfs_malloc(2 * sizeof(runlist));
if (!g_rl_bad)
return FALSE;
g_rl_bad[0].vcn = 0LL;
g_rl_bad[0].lcn = -1LL;
/*
@ -4498,7 +4498,7 @@ static BOOL mkntfs_create_root_structures(void)
buf_log = ntfs_malloc(g_logfile_size);
if (!buf_log)
return FALSE;
memset(buf_log, -1, g_logfile_size);
err = add_attr_data_positioned(m, NULL, 0, 0, 0, g_rl_logfile, buf_log,
g_logfile_size);
@ -4969,7 +4969,7 @@ static int mkntfs_redirect(struct mkntfs_options *opts2)
g_vol->upcase = ntfs_malloc(g_vol->upcase_len * sizeof(ntfschar));
if (!g_vol->upcase)
goto done;
init_upcase_table(g_vol->upcase, g_vol->upcase_len * sizeof(ntfschar));
if (g_vol->major_ver < 3) {
g_vol->attrdef = ntfs_calloc(36000);

26
ntfsprogs/ntfsclone.c
View File

@ -755,9 +755,9 @@ static void wipe_index_entry_timestams(INDEX_ENTRY *e)
e->key.file_name.last_data_change_time = timestamp;
e->key.file_name.last_mft_change_time = timestamp;
e->key.file_name.last_access_time = timestamp;
wiped_timestamp_data += 32;
e = (INDEX_ENTRY *)((u8 *)e + le16_to_cpu(e->length));
}
}
@ -785,7 +785,7 @@ static void wipe_index_allocation_timestamps(ntfs_inode *ni, ATTR_RECORD *attr)
name = (ntfschar *)((u8 *)attr + le16_to_cpu(attr->name_offset));
name_len = attr->name_length;
byte = bitmap = ntfs_attr_readall(ni, AT_BITMAP, name, name_len, NULL);
if (!byte) {
perr_printf("Failed to read $BITMAP attribute");
@ -812,7 +812,7 @@ static void wipe_index_allocation_timestamps(ntfs_inode *ni, ATTR_RECORD *attr)
bit = 0;
while ((u8 *)tmp_indexa < (u8 *)indexa + na->data_size) {
if (*byte & (1 << bit)) {
if (*byte & (1 << bit)) {
if (ntfs_mst_post_read_fixup((NTFS_RECORD *)tmp_indexa,
le32_to_cpu(
indexr->index_block_size))) {
@ -834,7 +834,7 @@ static void wipe_index_allocation_timestamps(ntfs_inode *ni, ATTR_RECORD *attr)
goto out_indexa;
}
}
tmp_indexa = (INDEX_ALLOCATION *)((u8 *)tmp_indexa +
tmp_indexa = (INDEX_ALLOCATION *)((u8 *)tmp_indexa +
le32_to_cpu(indexr->index_block_size));
bit++;
if (bit > 7) {
@ -842,7 +842,7 @@ static void wipe_index_allocation_timestamps(ntfs_inode *ni, ATTR_RECORD *attr)
byte++;
}
}
if (ntfs_rl_pwrite(vol, na->rl, 0, na->data_size, indexa) != na->data_size)
perr_printf("ntfs_rl_pwrite failed for inode %lld", ni->mft_no);
out_indexa:
@ -924,7 +924,7 @@ static void wipe_timestamps(ntfs_walk_clusters_ctx *image)
else if (a->type == AT_STANDARD_INFORMATION)
WIPE_TIMESTAMPS(STANDARD_INFORMATION, a, timestamp);
else if (a->type == AT_INDEX_ROOT)
wipe_index_root_timestamps(a, timestamp);
}
@ -1168,7 +1168,7 @@ static void mft_record_write_with_same_usn(ntfs_volume *volume, ntfs_inode *ni)
{
if (ntfs_mft_usn_dec(ni->mrec))
perr_exit("ntfs_mft_usn_dec");
if (ntfs_mft_record_write(volume, ni->mft_no, ni->mrec))
perr_exit("ntfs_mft_record_write");
}
@ -1176,12 +1176,12 @@ static void mft_record_write_with_same_usn(ntfs_volume *volume, ntfs_inode *ni)
static void mft_inode_write_with_same_usn(ntfs_volume *volume, ntfs_inode *ni)
{
s32 i;
mft_record_write_with_same_usn(volume, ni);
if (ni->nr_extents <= 0)
return;
for (i = 0; i < ni->nr_extents; ++i) {
ntfs_inode *eni = ni->extent_nis[i];
mft_record_write_with_same_usn(volume, eni);
@ -1719,7 +1719,7 @@ static void check_dest_free_space(u64 src_bytes)
if (opt.metadata || opt.blkdev_out || opt.std_out)
return;
/*
/*
* TODO: save_image needs a bit more space than src_bytes
* due to the free space encoding overhead.
*/
@ -1732,7 +1732,7 @@ static void check_dest_free_space(u64 src_bytes)
dest_bytes = (u64)stvfs.f_frsize * stvfs.f_bfree;
if (!dest_bytes)
dest_bytes = (u64)stvfs.f_bsize * stvfs.f_bfree;
if (dest_bytes < src_bytes)
err_exit("Destination doesn't have enough free space: "
"%llu MB < %llu MB\n",

28
ntfsprogs/ntfscmp.c
View File

@ -496,7 +496,7 @@ static int setup_cmp_ia(ntfs_attr *na, struct cmp_ia *cia)
perr_println("Failed to readall BITMAP");
return -1;
}
cia->byte = cia->bitmap;
cia->byte = cia->bitmap;
cia->tmp_ia = cia->ia = ntfs_malloc(na->data_size);
if (!cia->tmp_ia)
@ -506,7 +506,7 @@ static int setup_cmp_ia(ntfs_attr *na, struct cmp_ia *cia)
perr_println("Failed to pread INDEX_ALLOCATION");
goto free_ia;
}
return 0;
free_ia:
free(cia->ia);
@ -520,28 +520,28 @@ static void cmp_index_allocation(ntfs_attr *na1, ntfs_attr *na2)
struct cmp_ia cia1, cia2;
int bit, ret1, ret2;
u32 ib_size;
if (setup_cmp_ia(na1, &cia1))
return;
if (setup_cmp_ia(na2, &cia2))
return;
/*
/*
* FIXME: ia can be the same even if the bitmap sizes are different.
*/
if (cia1.bm_size != cia1.bm_size)
goto out;
if (cmp_buffer(cia1.bitmap, cia2.bitmap, cia1.bm_size, na1))
goto out;
if (cmp_buffer((u8 *)cia1.ia, (u8 *)cia2.ia, 0x18, na1))
goto out;
ib_size = cia1.ia->index.allocated_size + 0x18;
bit = 0;
while ((u8 *)cia1.tmp_ia < (u8 *)cia1.ia + na1->data_size) {
if (*cia1.byte & (1 << bit)) {
if (*cia1.byte & (1 << bit)) {
ret1 = ntfs_mst_post_read_fixup((NTFS_RECORD *)cia1.tmp_ia,
ib_size);
ret2 = ntfs_mst_post_read_fixup((NTFS_RECORD *)cia2.tmp_ia,
@ -550,19 +550,19 @@ static void cmp_index_allocation(ntfs_attr *na1, ntfs_attr *na2)
print_differ(na1);
goto out;
}
if (ret1 == -1)
continue;
if (cmp_buffer(((u8 *)cia1.tmp_ia) + 0x18,
if (cmp_buffer(((u8 *)cia1.tmp_ia) + 0x18,
((u8 *)cia2.tmp_ia) + 0x18,
cia1.ia->index.index_length, na1))
goto out;
}
cia1.tmp_ia = (INDEX_ALLOCATION *)((u8 *)cia1.tmp_ia + ib_size);
cia2.tmp_ia = (INDEX_ALLOCATION *)((u8 *)cia2.tmp_ia + ib_size);
bit++;
if (bit > 7) {
bit = 0;
@ -615,7 +615,7 @@ static void cmp_attribute_data(ntfs_attr *na1, ntfs_attr *na2)
printf("%lld != %lld\n", pos + count1, na1->data_size);
exit(1);
}
if (cmp_buffer(buf1, buf2, count1, na1))
return;
}

98
ntfsprogs/ntfsinfo.c
View File

@ -617,7 +617,7 @@ static void ntfs_dump_attr_standard_information(ATTR_RECORD *attr)
(unsigned)value_length);
}
}
static void ntfs_dump_bytes(u8 *buf, int start, int stop)
{
int i;
@ -647,7 +647,7 @@ static void ntfs_dump_attr_list(ATTR_RECORD *attr, ntfs_volume *vol)
value = ntfs_malloc(l);
if (!value)
return;
l = ntfs_get_attribute_value(vol, attr, value);
if (!l) {
ntfs_log_perror("ntfs_get_attribute_value failed");
@ -698,7 +698,7 @@ static void ntfs_dump_attr_list(ATTR_RECORD *attr, ntfs_volume *vol)
} else
printf("unnamed\n");
printf("\t\tPadding:\t");
ntfs_dump_bytes((u8 *)entry, entry->name_offset +
ntfs_dump_bytes((u8 *)entry, entry->name_offset +
sizeof(ntfschar) * entry->name_length,
le16_to_cpu(entry->length));
printf("\n");
@ -864,7 +864,7 @@ static void ntfs_dump_acl(const char *prefix, ACL *acl)
printf("%sRevision\t %u\n", prefix, acl->revision);
/*
/*
* Do not recalculate le16_to_cpu every iteration (minor speedup on
* big-endian machines.
*/
@ -913,7 +913,7 @@ static void ntfs_dump_security_descriptor(SECURITY_DESCRIPTOR_ATTR *sec_desc,
const char *indent)
{
char *sid;
printf("%s\tRevision:\t\t %u\n", indent, sec_desc->revision);
/* TODO: parse the flags */
@ -921,17 +921,16 @@ static void ntfs_dump_security_descriptor(SECURITY_DESCRIPTOR_ATTR *sec_desc,
le16_to_cpu(sec_desc->control));
if (~sec_desc->control & SE_SELF_RELATIVE) {
SECURITY_DESCRIPTOR *sd = (SECURITY_DESCRIPTOR *)sec_desc;
printf("%s\tOwner SID pointer:\t %p\n", indent, sd->owner);
printf("%s\tGroup SID pointer:\t %p\n", indent, sd->group);
printf("%s\tSACL pointer:\t\t %p\n", indent, sd->sacl);
printf("%s\tDACL pointer:\t\t %p\n", indent, sd->dacl);
return;
}
if (sec_desc->owner) {
sid = ntfs_sid_to_mbs((SID *)((char *)sec_desc +
le32_to_cpu(sec_desc->owner)), NULL, 0);
@ -1017,8 +1016,8 @@ static void ntfs_dump_attr_security_descriptor(ATTR_RECORD *attr, ntfs_volume *v
}
ntfs_dump_security_descriptor(sec_desc_attr, "");
if (attr->non_resident)
if (attr->non_resident)
free(sec_desc_attr);
}
@ -1099,7 +1098,7 @@ static void ntfs_dump_attr_volume_information(ATTR_RECORD *attr)
}
static ntfschar NTFS_DATA_SDS[5] = { const_cpu_to_le16('$'),
const_cpu_to_le16('S'), const_cpu_to_le16('D'),
const_cpu_to_le16('S'), const_cpu_to_le16('D'),
const_cpu_to_le16('S'), const_cpu_to_le16('\0') };
static void ntfs_dump_sds_entry(SECURITY_DESCRIPTOR_HEADER *sds)
@ -1117,10 +1116,10 @@ static void ntfs_dump_sds_entry(SECURITY_DESCRIPTOR_HEADER *sds)
ntfs_log_verbose("\t\tLength:\t\t\t %u (0x%x)\n",
(unsigned)le32_to_cpu(sds->length),
(unsigned)le32_to_cpu(sds->length));
sd = (SECURITY_DESCRIPTOR_RELATIVE *)((char *)sds +
sizeof(SECURITY_DESCRIPTOR_HEADER));
ntfs_dump_security_descriptor(sd, "\t");
}
@ -1131,22 +1130,22 @@ static void ntfs_dump_sds(ATTR_RECORD *attr, ntfs_inode *ni)
int name_len;
s64 data_size;
u64 inode;
inode = ni->mft_no;
if (ni->nr_extents < 0)
inode = ni->base_ni->mft_no;
if (FILE_Secure != inode)
return;
name_len = attr->name_length;
if (!name_len)
return;
name = (ntfschar *)((u8 *)attr + le16_to_cpu(attr->name_offset));
if (!ntfs_names_are_equal(NTFS_DATA_SDS, sizeof(NTFS_DATA_SDS) / 2 - 1,
name, name_len, 0, NULL, 0))
return;
sd = sds = ntfs_attr_readall(ni, AT_DATA, name, name_len, &data_size);
if (!sd) {
ntfs_log_perror("Failed to read $SDS attribute");
@ -1156,10 +1155,10 @@ static void ntfs_dump_sds(ATTR_RECORD *attr, ntfs_inode *ni)
* FIXME: The right way is based on the indexes, so we couldn't
* miss real entries. For now, dump until it makes sense.
*/
while (sd->length && sd->hash &&
while (sd->length && sd->hash &&
le64_to_cpu(sd->offset) < (u64)data_size &&
le32_to_cpu(sd->length) < (u64)data_size &&
le64_to_cpu(sd->offset) +
le64_to_cpu(sd->offset) +
le32_to_cpu(sd->length) < (u64)data_size) {
ntfs_dump_sds_entry(sd);
sd = (SECURITY_DESCRIPTOR_HEADER *)((char*)sd +
@ -1193,10 +1192,10 @@ static const char *get_attribute_type_name(u32 type)
return "$UNKNOWN";
}
static void ntfs_dump_attribute_header(ATTR_RECORD *a, ntfs_volume *vol)
{
printf("Dumping attribute %s (0x%x)\n",
printf("Dumping attribute %s (0x%x)\n",
get_attribute_type_name(a->type),
(unsigned)le32_to_cpu(a->type));
@ -1274,7 +1273,7 @@ static void ntfs_dump_attribute_header(ATTR_RECORD *a, ntfs_volume *vol)
sle64_to_cpu(a->initialized_size));
if (a->compression_unit || a->flags & ATTR_IS_COMPRESSED ||
a->flags & ATTR_IS_SPARSE)
printf("\tCompressed size:\t %llu (0x%llx)\n",
printf("\tCompressed size:\t %llu (0x%llx)\n",
(signed long long)
sle64_to_cpu(a->compressed_size),
(signed long long)
@ -1324,7 +1323,7 @@ static void ntfs_dump_index_key(INDEX_ENTRY *entry, INDEX_ATTR_TYPE type)
{
char *sid;
char printable_GUID[37];
switch (type) {
case INDEX_ATTR_SECURE_SII:
ntfs_log_verbose("\t\tKey security id:\t %u (0x%x)\n",
@ -1382,9 +1381,9 @@ typedef union {
static void ntfs_dump_index_data(INDEX_ENTRY *entry, INDEX_ATTR_TYPE type)
{
INDEX_ENTRY_DATA *data;
data = (INDEX_ENTRY_DATA *)((u8 *)entry + entry->data_offset);
switch (type) {
case INDEX_ATTR_SECURE_SII:
ntfs_log_verbose("\t\tHash:\t\t\t 0x%08x\n",
@ -1580,7 +1579,7 @@ static INDEX_ATTR_TYPE get_index_attr_type(ntfs_inode *ni, ATTR_RECORD *attr,
if (!attr->name_length)
return INDEX_ATTR_UNKNOWN;
if (index_root->type) {
if (index_root->type == AT_FILE_NAME)
return INDEX_ATTR_DIRECTORY_I30;
@ -1590,12 +1589,12 @@ static INDEX_ATTR_TYPE get_index_attr_type(ntfs_inode *ni, ATTR_RECORD *attr,
index_root->type);
return INDEX_ATTR_UNKNOWN;
}
if (utils_is_metadata(ni) <= 0)
return INDEX_ATTR_UNKNOWN;
if (utils_inode_get_name(ni, file_name, sizeof(file_name)) <= 0)
return INDEX_ATTR_UNKNOWN;
if (COMPARE_INDEX_NAMES(attr, NTFS_INDEX_SDH))
return INDEX_ATTR_SECURE_SDH;
else if (COMPARE_INDEX_NAMES(attr, NTFS_INDEX_SII))
@ -1612,7 +1611,7 @@ static INDEX_ATTR_TYPE get_index_attr_type(ntfs_inode *ni, ATTR_RECORD *attr,
else if (!strcmp(file_name, "/$Extend/$ObjId"))
return INDEX_ATTR_OBJID_O;
}
return INDEX_ATTR_UNKNOWN;
}
@ -1649,7 +1648,7 @@ static void ntfs_dump_index_header(const char *indent, INDEX_HEADER *idx)
(unsigned)le32_to_cpu(idx->allocated_size),
(unsigned)le32_to_cpu(idx->allocated_size));
printf("%sIndex header flags:\t 0x%02x\n", indent, idx->flags);
/* FIXME: there are 3 reserved bytes here */
}
@ -1670,7 +1669,7 @@ static void ntfs_dump_attr_index_root(ATTR_RECORD *attr, ntfs_inode *ni)
type = get_index_attr_type(ni, attr, index_root);
printf("\tIndexed Attr Type:\t ");
ntfs_dump_index_attr_type(type);
/* collation rule dumping */
printf("\tCollation Rule:\t\t %u (0x%x)\n",
(unsigned)le32_to_cpu(index_root->collation_rule),
@ -1717,7 +1716,7 @@ static s32 ntfs_dump_index_block(INDEX_BLOCK *ib, INDEX_ATTR_TYPE type,
u32 ib_size)
{
INDEX_ENTRY *entry;
if (ntfs_mst_post_read_fixup((NTFS_RECORD*)ib, ib_size)) {
ntfs_log_perror("Damaged INDX record");
return -1;
@ -1729,15 +1728,15 @@ static s32 ntfs_dump_index_block(INDEX_BLOCK *ib, INDEX_ATTR_TYPE type,
ntfs_log_verbose("\t\tNode VCN:\t\t %lld (0x%llx)\n",
(unsigned long long)sle64_to_cpu(ib->index_block_vcn),
(unsigned long long)sle64_to_cpu(ib->index_block_vcn));
entry = (INDEX_ENTRY*)((u8*)ib +
entry = (INDEX_ENTRY*)((u8*)ib +
le32_to_cpu(ib->index.entries_offset) + 0x18);
if (opts.verbose) {
ntfs_dump_index_header("\t\t", &ib->index);
printf("\n");
}
return ntfs_dump_index_entries(entry, type);
}
@ -1764,19 +1763,19 @@ static void ntfs_dump_attr_index_allocation(ATTR_RECORD *attr, ntfs_inode *ni)
ntfs_log_perror("Failed to read $INDEX_ROOT attribute");
return;
}
type = get_index_attr_type(ni, attr, ir);
name = (ntfschar *)((u8 *)attr + le16_to_cpu(attr->name_offset));
name_len = attr->name_length;
byte = bitmap = ntfs_attr_readall(ni, AT_BITMAP, name, name_len, NULL);
if (!byte) {
ntfs_log_perror("Failed to read $BITMAP attribute");
goto out_index_root;
}
tmp_alloc = allocation = ntfs_attr_readall(ni, AT_INDEX_ALLOCATION,
tmp_alloc = allocation = ntfs_attr_readall(ni, AT_INDEX_ALLOCATION,
name, name_len, &data_size);
if (!tmp_alloc) {
ntfs_log_perror("Failed to read $INDEX_ALLOCATION attribute");
@ -1787,7 +1786,7 @@ static void ntfs_dump_attr_index_allocation(ATTR_RECORD *attr, ntfs_inode *ni)
while ((u8 *)tmp_alloc < (u8 *)allocation + data_size) {
if (*byte & (1 << bit)) {
int entries;
entries = ntfs_dump_index_block(tmp_alloc, type,
le32_to_cpu(
ir->index_block_size));
@ -1797,7 +1796,7 @@ static void ntfs_dump_attr_index_allocation(ATTR_RECORD *attr, ntfs_inode *ni)
printf("\tIndex entries:\t\t %d\n", entries);
}
}
tmp_alloc = (INDEX_ALLOCATION *)((u8 *)tmp_alloc +
tmp_alloc = (INDEX_ALLOCATION *)((u8 *)tmp_alloc +
le32_to_cpu(
ir->index_block_size));
bit++;
@ -1809,7 +1808,7 @@ static void ntfs_dump_attr_index_allocation(ATTR_RECORD *attr, ntfs_inode *ni)
printf("\tIndex entries total:\t %d\n", total_entries);
printf("\tINDX blocks total:\t %d\n", total_indx_blocks);
free(allocation);
out_bitmap:
free(bitmap);
@ -2083,9 +2082,9 @@ static void ntfs_dump_inode_general_info(ntfs_inode *inode)
printf("Next Attribute Instance: %u (0x%x)\n",
(unsigned)le16_to_cpu(mrec->next_attr_instance),
(unsigned)le16_to_cpu(mrec->next_attr_instance));
printf("MFT Padding:\t");
ntfs_dump_bytes((u8 *)mrec, le16_to_cpu(mrec->usa_ofs) +
ntfs_dump_bytes((u8 *)mrec, le16_to_cpu(mrec->usa_ofs) +
2 * le16_to_cpu(mrec->usa_count),
le16_to_cpu(mrec->attrs_offset));
printf("\n");
@ -2102,7 +2101,6 @@ static void ntfs_dump_file_attributes(ntfs_inode *inode)
see ntfs_attr_lookup documentation for detailed explanation */
ctx = ntfs_attr_get_search_ctx(inode, NULL);
while (!ntfs_attr_lookup(AT_UNUSED, NULL, 0, 0, 0, NULL, 0, ctx)) {
if (ctx->attr->type == AT_END || ctx->attr->type == AT_UNUSED) {
printf("Weird: %s attribute type was found, please "
"report this.\n",
@ -2110,9 +2108,9 @@ static void ntfs_dump_file_attributes(ntfs_inode *inode)
ctx->attr->type));
continue;
}
ntfs_dump_attribute_header(ctx->attr, inode->vol);
switch (ctx->attr->type) {
case AT_STANDARD_INFORMATION:
ntfs_dump_attr_standard_information(ctx->attr);
@ -2194,7 +2192,7 @@ int main(int argc, char **argv)
ntfs_volume *vol;
setlinebuf(stdout);
ntfs_log_set_handler(ntfs_log_handler_outerr);
if (!parse_options(argc, argv)) {

2
ntfsprogs/ntfsresize.c
View File

@ -2028,7 +2028,7 @@ static int check_bad_sectors(ntfs_volume *vol)
if (!ctx->attr->non_resident)
err_exit("Resident attribute in $BadClust! Please report to "
"%s\n", NTFS_DEV_LIST);
/*
/*
* FIXME: The below would be partial for non-base records in the
* not yet supported multi-record case. Alternatively use audited
* ntfs_attr_truncate after an umount & mount.