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

Replace switch statements for le/be types with equivalent if statements. 

Since the le/be-types are now typedef'd to aggregate types, we can't use
those in switch statements.
edge.strict_endians
Erik Larsson 2016-01-28 08:29:02 +01:00
parent 1fdd4fbb71
commit 7e85b4ccd4
5 changed files with 107 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
libntfs-3g/collate.c
View File

@ -246,26 +246,26 @@ COLLATE ntfs_get_collate_function(COLLATION_RULES cr)
{
COLLATE collate;
switch (cr) {
case COLLATION_BINARY :
/* switch (cr) { */
if (le32_eq(cr, COLLATION_BINARY)) {
collate = ntfs_collate_binary;
break;
case COLLATION_FILE_NAME :
}
else if (le32_eq(cr, COLLATION_FILE_NAME)) {
collate = ntfs_collate_file_name;
break;
case COLLATION_NTOFS_SECURITY_HASH :
}
else if (le32_eq(cr, COLLATION_NTOFS_SECURITY_HASH)) {
collate = ntfs_collate_ntofs_security_hash;
break;
case COLLATION_NTOFS_ULONG :
}
else if (le32_eq(cr, COLLATION_NTOFS_ULONG)) {
collate = ntfs_collate_ntofs_ulong;
break;
case COLLATION_NTOFS_ULONGS :
}
else if (le32_eq(cr, COLLATION_NTOFS_ULONGS)) {
collate = ntfs_collate_ntofs_ulongs;
break;
default :
}
else {
errno = EOPNOTSUPP;
collate = (COLLATE)NULL;
break;
/* break; */
}
return (collate);
}

32
libntfs-3g/reparse.c
View File

@ -443,8 +443,8 @@ static BOOL valid_reparse_data(ntfs_inode *ni,
&& (((size_t)le16_to_cpu(reparse_attr->reparse_data_length)
+ sizeof(REPARSE_POINT)) == size);
if (ok) {
switch (reparse_attr->reparse_tag) {
case IO_REPARSE_TAG_MOUNT_POINT :
/* switch (reparse_attr->reparse_tag) { */
if (le32_eq(reparse_attr->reparse_tag, IO_REPARSE_TAG_MOUNT_POINT)) {
mount_point_data = (const struct MOUNT_POINT_REPARSE_DATA*)
reparse_attr->reparse_data;
offs = le16_to_cpu(mount_point_data->subst_name_offset);
@ -455,8 +455,8 @@ static BOOL valid_reparse_data(ntfs_inode *ni,
+ sizeof(struct MOUNT_POINT_REPARSE_DATA)
+ offs + lth)) > size))
ok = FALSE;
break;
case IO_REPARSE_TAG_SYMLINK :
}
else if (le32_eq(reparse_attr->reparse_tag, IO_REPARSE_TAG_SYMLINK)) {
symlink_data = (const struct SYMLINK_REPARSE_DATA*)
reparse_attr->reparse_data;
offs = le16_to_cpu(symlink_data->subst_name_offset);
@ -465,9 +465,9 @@ static BOOL valid_reparse_data(ntfs_inode *ni,
+ sizeof(struct SYMLINK_REPARSE_DATA)
+ offs + lth)) > size)
ok = FALSE;
break;
default :
break;
}
else {
/* break; */
}
}
if (!ok)
@ -738,8 +738,8 @@ char *ntfs_make_symlink(ntfs_inode *ni, const char *mnt_point,
AT_REPARSE_POINT,(ntfschar*)NULL, 0, &attr_size);
if (reparse_attr && attr_size
&& valid_reparse_data(ni, reparse_attr, attr_size)) {
switch (reparse_attr->reparse_tag) {
case IO_REPARSE_TAG_MOUNT_POINT :
/* switch (reparse_attr->reparse_tag) { */
if (le32_eq(reparse_attr->reparse_tag, IO_REPARSE_TAG_MOUNT_POINT)) {
mount_point_data = (struct MOUNT_POINT_REPARSE_DATA*)
reparse_attr->reparse_data;
offs = le16_to_cpu(mount_point_data->subst_name_offset);
@ -750,8 +750,8 @@ char *ntfs_make_symlink(ntfs_inode *ni, const char *mnt_point,
lth/2, mnt_point, isdir);
if (target)
bad = FALSE;
break;
case IO_REPARSE_TAG_SYMLINK :
}
else if (le32_eq(reparse_attr->reparse_tag, IO_REPARSE_TAG_SYMLINK)) {
symlink_data = (struct SYMLINK_REPARSE_DATA*)
reparse_attr->reparse_data;
offs = le16_to_cpu(symlink_data->subst_name_offset);
@ -805,7 +805,7 @@ char *ntfs_make_symlink(ntfs_inode *ni, const char *mnt_point,
}
break;
}
break;
} else {
}
free(reparse_attr);
}
@ -833,11 +833,11 @@ BOOL ntfs_possible_symlink(ntfs_inode *ni)
reparse_attr = (REPARSE_POINT*)ntfs_attr_readall(ni,
AT_REPARSE_POINT,(ntfschar*)NULL, 0, &attr_size);
if (reparse_attr && attr_size) {
switch (reparse_attr->reparse_tag) {
case IO_REPARSE_TAG_MOUNT_POINT :
case IO_REPARSE_TAG_SYMLINK :
/* switch (reparse_attr->reparse_tag) { */
if (le32_eq(reparse_attr->reparse_tag, IO_REPARSE_TAG_MOUNT_POINT) ||
le32_eq(reparse_attr->reparse_tag, IO_REPARSE_TAG_SYMLINK)) {
possible = TRUE;
default : ;
} else {
}
free(reparse_attr);
}

16
ntfsprogs/ntfsdecrypt.c
View File

@ -1071,23 +1071,23 @@ static ntfs_fek *ntfs_fek_import_from_raw(u8 *fek_buf, unsigned fek_size)
fek->des_gcry_cipher_hd_ptr = NULL;
*(gcry_cipher_hd_t***)(fek->key_data + ((key_size + 7) & ~7)) =
&fek->des_gcry_cipher_hd_ptr;
switch (fek->alg_id) {
case CALG_DESX:
/* switch (fek->alg_id) { */
if (le32_eq(fek->alg_id, CALG_DESX)) {
wanted_key_size = 16;
gcry_algo = GCRY_CIPHER_DES;
gcry_mode = GCRY_CIPHER_MODE_ECB;
break;
case CALG_3DES:
}
else if (le32_eq(fek->alg_id, CALG_3DES)) {
wanted_key_size = 24;
gcry_algo = GCRY_CIPHER_3DES;
gcry_mode = GCRY_CIPHER_MODE_CBC;
break;
case CALG_AES_256:
}
else if (le32_eq(fek->alg_id, CALG_AES_256)) {
wanted_key_size = 32;
gcry_algo = GCRY_CIPHER_AES256;
gcry_mode = GCRY_CIPHER_MODE_CBC;
break;
default:
}
else {
wanted_key_size = 8;
gcry_algo = GCRY_CIPHER_DES;
gcry_mode = GCRY_CIPHER_MODE_CBC;

106
ntfsprogs/ntfsinfo.c
View File

@ -1231,25 +1231,25 @@ static void ntfs_dump_sds(ATTR_RECORD *attr, ntfs_inode *ni)
static const char *get_attribute_type_name(le32 type)
{
switch (type) {
case AT_UNUSED: return "$UNUSED";
case AT_STANDARD_INFORMATION: return "$STANDARD_INFORMATION";
case AT_ATTRIBUTE_LIST: return "$ATTRIBUTE_LIST";
case AT_FILE_NAME: return "$FILE_NAME";
case AT_OBJECT_ID: return "$OBJECT_ID";
case AT_SECURITY_DESCRIPTOR: return "$SECURITY_DESCRIPTOR";
case AT_VOLUME_NAME: return "$VOLUME_NAME";
case AT_VOLUME_INFORMATION: return "$VOLUME_INFORMATION";
case AT_DATA: return "$DATA";
case AT_INDEX_ROOT: return "$INDEX_ROOT";
case AT_INDEX_ALLOCATION: return "$INDEX_ALLOCATION";
case AT_BITMAP: return "$BITMAP";
case AT_REPARSE_POINT: return "$REPARSE_POINT";
case AT_EA_INFORMATION: return "$EA_INFORMATION";
case AT_EA: return "$EA";
case AT_PROPERTY_SET: return "$PROPERTY_SET";
case AT_LOGGED_UTILITY_STREAM: return "$LOGGED_UTILITY_STREAM";
case AT_END: return "$END";
/* switch(type) */ {
if (le32_eq(type, AT_UNUSED)) return "$UNUSED";
else if (le32_eq(type, AT_STANDARD_INFORMATION)) return "$STANDARD_INFORMATION";
else if (le32_eq(type, AT_ATTRIBUTE_LIST)) return "$ATTRIBUTE_LIST";
else if (le32_eq(type, AT_FILE_NAME)) return "$FILE_NAME";
else if (le32_eq(type, AT_OBJECT_ID)) return "$OBJECT_ID";
else if (le32_eq(type, AT_SECURITY_DESCRIPTOR)) return "$SECURITY_DESCRIPTOR";
else if (le32_eq(type, AT_VOLUME_NAME)) return "$VOLUME_NAME";
else if (le32_eq(type, AT_VOLUME_INFORMATION)) return "$VOLUME_INFORMATION";
else if (le32_eq(type, AT_DATA)) return "$DATA";
else if (le32_eq(type, AT_INDEX_ROOT)) return "$INDEX_ROOT";
else if (le32_eq(type, AT_INDEX_ALLOCATION)) return "$INDEX_ALLOCATION";
else if (le32_eq(type, AT_BITMAP)) return "$BITMAP";
else if (le32_eq(type, AT_REPARSE_POINT)) return "$REPARSE_POINT";
else if (le32_eq(type, AT_EA_INFORMATION)) return "$EA_INFORMATION";
else if (le32_eq(type, AT_EA)) return "$EA";
else if (le32_eq(type, AT_PROPERTY_SET)) return "$PROPERTY_SET";
else if (le32_eq(type, AT_LOGGED_UTILITY_STREAM)) return "$LOGGED_UTILITY_STREAM";
else if (le32_eq(type, AT_END)) return "$END";
}
return "$UNKNOWN";
@ -2264,57 +2264,57 @@ static void ntfs_dump_file_attributes(ntfs_inode *inode)
ntfs_dump_attribute_header(ctx, inode->vol, &runcount);
switch (ctx->attr->type) {
case AT_STANDARD_INFORMATION:
if (le32_eq(ctx->attr->type, AT_STANDARD_INFORMATION)) {
ntfs_dump_attr_standard_information(ctx->attr);
break;
case AT_ATTRIBUTE_LIST:
}
else if (le32_eq(ctx->attr->type, AT_ATTRIBUTE_LIST)) {
ntfs_dump_attr_list(ctx->attr, inode->vol);
break;
case AT_FILE_NAME:
}
else if (le32_eq(ctx->attr->type, AT_FILE_NAME)) {
ntfs_dump_attr_file_name(ctx->attr);
break;
case AT_OBJECT_ID:
}
else if (le32_eq(ctx->attr->type, AT_OBJECT_ID)) {
ntfs_dump_attr_object_id(ctx->attr, inode->vol);
break;
case AT_SECURITY_DESCRIPTOR:
}
else if (le32_eq(ctx->attr->type, AT_SECURITY_DESCRIPTOR)) {
ntfs_dump_attr_security_descriptor(ctx->attr,
inode->vol);
break;
case AT_VOLUME_NAME:
}
else if (le32_eq(ctx->attr->type, AT_VOLUME_NAME)) {
ntfs_dump_attr_volume_name(ctx->attr);
break;
case AT_VOLUME_INFORMATION:
}
else if (le32_eq(ctx->attr->type, AT_VOLUME_INFORMATION)) {
ntfs_dump_attr_volume_information(ctx->attr);
break;
case AT_DATA:
}
else if (le32_eq(ctx->attr->type, AT_DATA)) {
ntfs_dump_attr_data(ctx->attr, inode);
break;
case AT_INDEX_ROOT:
}
else if (le32_eq(ctx->attr->type, AT_INDEX_ROOT)) {
ntfs_dump_attr_index_root(ctx->attr, inode);
break;
case AT_INDEX_ALLOCATION:
}
else if (le32_eq(ctx->attr->type, AT_INDEX_ALLOCATION)) {
ntfs_dump_attr_index_allocation(ctx->attr, inode);
break;
case AT_BITMAP:
}
else if (le32_eq(ctx->attr->type, AT_BITMAP)) {
ntfs_dump_attr_bitmap(ctx->attr);
break;
case AT_REPARSE_POINT:
}
else if (le32_eq(ctx->attr->type, AT_REPARSE_POINT)) {
ntfs_dump_attr_reparse_point(ctx->attr);
break;
case AT_EA_INFORMATION:
}
else if (le32_eq(ctx->attr->type, AT_EA_INFORMATION)) {
ntfs_dump_attr_ea_information(ctx->attr);
break;
case AT_EA:
}
else if (le32_eq(ctx->attr->type, AT_EA)) {
ntfs_dump_attr_ea(ctx->attr, inode->vol);
break;
case AT_PROPERTY_SET:
}
else if (le32_eq(ctx->attr->type, AT_PROPERTY_SET)) {
ntfs_dump_attr_property_set(ctx->attr);
break;
case AT_LOGGED_UTILITY_STREAM:
}
else if (le32_eq(ctx->attr->type, AT_LOGGED_UTILITY_STREAM)) {
ntfs_dump_attr_logged_utility_stream(ctx->attr, inode);
break;
default:
}
else {
ntfs_dump_attr_unknown(ctx->attr);
}
}

34
ntfsprogs/ntfstruncate.c
View File

@ -316,28 +316,28 @@ static void dump_resident_attr_val(ATTR_TYPES type, char *val, u32 val_len)
int i, j;
u32 u;
switch (type) {
case AT_STANDARD_INFORMATION:
/* switch (type) { */
if (le32_eq(type, AT_STANDARD_INFORMATION)) {
// TODO
printf("%s\n", todo);
return;
case AT_ATTRIBUTE_LIST:
} else if (le32_eq(type, AT_ATTRIBUTE_LIST)) {
// TODO
printf("%s\n", todo);
return;
case AT_FILE_NAME:
} else if (le32_eq(type, AT_FILE_NAME)) {
// TODO
printf("%s\n", todo);
return;
case AT_OBJECT_ID:
} else if (le32_eq(type, AT_OBJECT_ID)) {
// TODO
printf("%s\n", todo);
return;
case AT_SECURITY_DESCRIPTOR:
} else if (le32_eq(type, AT_SECURITY_DESCRIPTOR)) {
// TODO
printf("%s\n", todo);
return;
case AT_VOLUME_NAME:
} else if (le32_eq(type, AT_VOLUME_NAME)) {
printf("Volume name length = %u\n", (unsigned int)val_len);
if (val_len) {
buf = calloc(1, val_len);
@ -352,7 +352,7 @@ static void dump_resident_attr_val(ATTR_TYPES type, char *val, u32 val_len)
free(buf);
}
return;
case AT_VOLUME_INFORMATION:
} else if (le32_eq(type, AT_VOLUME_INFORMATION)) {
#define VOL_INF(x) ((VOLUME_INFORMATION *)(x))
printf("NTFS version %i.%i\n", VOL_INF(val)->major_ver,
VOL_INF(val)->minor_ver);
@ -412,37 +412,37 @@ static void dump_resident_attr_val(ATTR_TYPES type, char *val, u32 val_len)
}
printf("\n");
return;
case AT_DATA:
} else if (le32_eq(type, AT_DATA)) {
printf(skip, "DATA");
return;
case AT_INDEX_ROOT:
} else if (le32_eq(type, AT_INDEX_ROOT)) {
// TODO
printf("%s\n", todo);
return;
case AT_INDEX_ALLOCATION:
} else if (le32_eq(type, AT_INDEX_ALLOCATION)) {
// TODO
printf("%s\n", todo);
return;
case AT_BITMAP:
} else if (le32_eq(type, AT_BITMAP)) {
printf(skip, "BITMAP");
return;
case AT_REPARSE_POINT:
} else if (le32_eq(type, AT_REPARSE_POINT)) {
// TODO
printf("%s\n", todo);
return;
case AT_EA_INFORMATION:
} else if (le32_eq(type, AT_EA_INFORMATION)) {
// TODO
printf("%s\n", don_t_know);
return;
case AT_EA:
} else if (le32_eq(type, AT_EA)) {
// TODO
printf("%s\n", don_t_know);
return;
case AT_LOGGED_UTILITY_STREAM:
} else if (le32_eq(type, AT_LOGGED_UTILITY_STREAM)) {
// TODO
printf("%s\n", don_t_know);
return;
default:
} else {
u = le32_to_cpu(type);
printf("Cannot display unknown %s defined attribute type 0x%x"
".\n", u >=