arno
/
hashcat
mirror of https://github.com/hashcat/hashcat.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Run through Clang's readability-else-after-return

Browse Source 
There's no need for a return statement in an else path. Just take it out.
Simplifies the code slightly.
pull/2144/head
Rosen Penev 5 years ago
parent 6ecb42b3ea
commit 6dc72ebcc5
No known key found for this signature in database
GPG Key ID: 36D31CFA845F0E3B
6 changed files with 158 additions and 223 deletions
Show Stats Download Patch File Download Diff File

52
src/backend.c
Unescape View File

@ -4532,44 +4532,42 @@ int run_cracker (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, co
break; break;
} }
else
double total_msec = device_param->speed_msec[0];
for (u32 speed_pos = 1; speed_pos < device_param->speed_pos; speed_pos++)
{ {
double total_msec = device_param->speed_msec[0]; total_msec += device_param->speed_msec[speed_pos];
}
for (u32 speed_pos = 1; speed_pos < device_param->speed_pos; speed_pos++) if (user_options->slow_candidates == true)
{
if ((total_msec > 4000) || (device_param->speed_pos == SPEED_CACHE - 1))
{ {
total_msec += device_param->speed_msec[speed_pos]; const u32 speed_pos = device_param->speed_pos;
}
if (user_options->slow_candidates == true) if (speed_pos)
{
if ((total_msec > 4000) || (device_param->speed_pos == SPEED_CACHE - 1))
{ {
const u32 speed_pos = device_param->speed_pos; device_param->speed_cnt[0] = device_param->speed_cnt[speed_pos - 1];
device_param->speed_msec[0] = device_param->speed_msec[speed_pos - 1];
if (speed_pos) }
{
device_param->speed_cnt[0] = device_param->speed_cnt[speed_pos - 1];
device_param->speed_msec[0] = device_param->speed_msec[speed_pos - 1];
}
device_param->speed_pos = 0; device_param->speed_pos = 0;
device_param->speed_only_finish = true; device_param->speed_only_finish = true;
break; break;
}
} }
else }
{ else
// it's unclear if 4s is enough to turn on boost mode for all backend device {
// it's unclear if 4s is enough to turn on boost mode for all backend device
if ((total_msec > 4000) || (device_param->speed_pos == SPEED_CACHE - 1)) if ((total_msec > 4000) || (device_param->speed_pos == SPEED_CACHE - 1))
{ {
device_param->speed_only_finish = true; device_param->speed_only_finish = true;
break; break;
}
} }
} }
} }

26
src/benchmark.c
Unescape View File

@ -57,28 +57,26 @@ int benchmark_next (hashcat_ctx_t *hashcat_ctx)
return hash_mode; return hash_mode;
} }
else
char *modulefile = (char *) hcmalloc (HCBUFSIZ_TINY);
for (int i = cur; i < MODULE_HASH_MODES_MAXIMUM; i++)
{ {
char *modulefile = (char *) hcmalloc (HCBUFSIZ_TINY); module_filename (folder_config, i, modulefile, HCBUFSIZ_TINY);
for (int i = cur; i < MODULE_HASH_MODES_MAXIMUM; i++) if (hc_path_exist (modulefile) == true)
{ {
module_filename (folder_config, i, modulefile, HCBUFSIZ_TINY); const int hash_mode = i;
if (hc_path_exist (modulefile) == true)
{
const int hash_mode = i;
cur = hash_mode + 1; cur = hash_mode + 1;
hcfree (modulefile); hcfree (modulefile);
return hash_mode; return hash_mode;
}
} }
hcfree (modulefile);
} }
hcfree (modulefile);
return -1; return -1;
} }

118
src/brain.c
Unescape View File

@ -1589,36 +1589,34 @@ bool brain_server_read_hash_dump (brain_server_db_hash_t *brain_server_db_hash,
return false; return false;
} }
else
{
i64 temp_cnt = (u64) sb.st_size / sizeof (brain_server_hash_long_t);
if (brain_server_db_hash_realloc (brain_server_db_hash, temp_cnt) == false)
{
brain_logging (stderr, 0, "%s\n", MSG_ENOMEM);
hc_fclose (&fp);
return false; i64 temp_cnt = (u64) sb.st_size / sizeof (brain_server_hash_long_t);
}
const size_t nread = hc_fread (brain_server_db_hash->long_buf, sizeof (brain_server_hash_long_t), temp_cnt, &fp); if (brain_server_db_hash_realloc (brain_server_db_hash, temp_cnt) == false)
{
brain_logging (stderr, 0, "%s\n", MSG_ENOMEM);
if (nread != (size_t) temp_cnt) hc_fclose (&fp);
{
brain_logging (stderr, 0, "%s: only %" PRIu64 " bytes read\n", file, (u64) nread * sizeof (brain_server_hash_long_t));
hc_fclose (&fp); return false;
}
return false; const size_t nread = hc_fread (brain_server_db_hash->long_buf, sizeof (brain_server_hash_long_t), temp_cnt, &fp);
}
brain_server_db_hash->long_cnt = temp_cnt; if (nread != (size_t) temp_cnt)
brain_server_db_hash->write_hashes = false; {
brain_logging (stderr, 0, "%s: only %" PRIu64 " bytes read\n", file, (u64) nread * sizeof (brain_server_hash_long_t));
hc_fclose (&fp); hc_fclose (&fp);
return false;
} }
brain_server_db_hash->long_cnt = temp_cnt;
brain_server_db_hash->write_hashes = false;
hc_fclose (&fp);
const double ms = hc_timer_get (timer_dump); const double ms = hc_timer_get (timer_dump);
brain_logging (stdout, 0, "Read %" PRIu64 " bytes from session 0x%08x in %.2f ms\n", (u64) sb.st_size, brain_server_db_hash->brain_session, ms); brain_logging (stdout, 0, "Read %" PRIu64 " bytes from session 0x%08x in %.2f ms\n", (u64) sb.st_size, brain_server_db_hash->brain_session, ms);
@ -1644,24 +1642,22 @@ bool brain_server_write_hash_dump (brain_server_db_hash_t *brain_server_db_hash,
return false; return false;
} }
else
{
const size_t nwrite = hc_fwrite (brain_server_db_hash->long_buf, sizeof (brain_server_hash_long_t), brain_server_db_hash->long_cnt, &fp);
if (nwrite != (size_t) brain_server_db_hash->long_cnt)
{
brain_logging (stderr, 0, "%s: only %" PRIu64 " bytes written\n", file, (u64) nwrite * sizeof (brain_server_hash_long_t));
hc_fclose (&fp); const size_t nwrite = hc_fwrite (brain_server_db_hash->long_buf, sizeof (brain_server_hash_long_t), brain_server_db_hash->long_cnt, &fp);
return false; if (nwrite != (size_t) brain_server_db_hash->long_cnt)
} {
brain_logging (stderr, 0, "%s: only %" PRIu64 " bytes written\n", file, (u64) nwrite * sizeof (brain_server_hash_long_t));
hc_fclose (&fp); hc_fclose (&fp);
brain_server_db_hash->write_hashes = false; return false;
} }
hc_fclose (&fp);
brain_server_db_hash->write_hashes = false;
// stats // stats
const double ms = hc_timer_get (timer_dump); const double ms = hc_timer_get (timer_dump);
@ -1790,36 +1786,34 @@ bool brain_server_read_attack_dump (brain_server_db_attack_t *brain_server_db_at
return false; return false;
} }
else
{
i64 temp_cnt = (u64) sb.st_size / sizeof (brain_server_attack_long_t);
if (brain_server_db_attack_realloc (brain_server_db_attack, temp_cnt, 0) == false)
{
brain_logging (stderr, 0, "%s\n", MSG_ENOMEM);
hc_fclose (&fp);
return false; i64 temp_cnt = (u64) sb.st_size / sizeof (brain_server_attack_long_t);
}
const size_t nread = hc_fread (brain_server_db_attack->long_buf, sizeof (brain_server_attack_long_t), temp_cnt, &fp); if (brain_server_db_attack_realloc (brain_server_db_attack, temp_cnt, 0) == false)
{
brain_logging (stderr, 0, "%s\n", MSG_ENOMEM);
if (nread != (size_t) temp_cnt) hc_fclose (&fp);
{
brain_logging (stderr, 0, "%s: only %" PRIu64 " bytes read\n", file, (u64) nread * sizeof (brain_server_attack_long_t));
hc_fclose (&fp); return false;
}
return false; const size_t nread = hc_fread (brain_server_db_attack->long_buf, sizeof (brain_server_attack_long_t), temp_cnt, &fp);
}
brain_server_db_attack->long_cnt = temp_cnt; if (nread != (size_t) temp_cnt)
brain_server_db_attack->write_attacks = false; {
brain_logging (stderr, 0, "%s: only %" PRIu64 " bytes read\n", file, (u64) nread * sizeof (brain_server_attack_long_t));
hc_fclose (&fp); hc_fclose (&fp);
return false;
} }
brain_server_db_attack->long_cnt = temp_cnt;
brain_server_db_attack->write_attacks = false;
hc_fclose (&fp);
const double ms = hc_timer_get (timer_dump); const double ms = hc_timer_get (timer_dump);
brain_logging (stdout, 0, "Read %" PRIu64 " bytes from attack 0x%08x in %.2f ms\n", (u64) sb.st_size, brain_server_db_attack->brain_attack, ms); brain_logging (stdout, 0, "Read %" PRIu64 " bytes from attack 0x%08x in %.2f ms\n", (u64) sb.st_size, brain_server_db_attack->brain_attack, ms);
@ -1845,26 +1839,24 @@ bool brain_server_write_attack_dump (brain_server_db_attack_t *brain_server_db_a
return false; return false;
} }
else
{
// storing should not include reserved attacks only finished
const size_t nwrite = hc_fwrite (brain_server_db_attack->long_buf, sizeof (brain_server_attack_long_t), brain_server_db_attack->long_cnt, &fp);
if (nwrite != (size_t) brain_server_db_attack->long_cnt) // storing should not include reserved attacks only finished
{
brain_logging (stderr, 0, "%s: only %" PRIu64 " bytes written\n", file, (u64) nwrite * sizeof (brain_server_attack_long_t));
hc_fclose (&fp); const size_t nwrite = hc_fwrite (brain_server_db_attack->long_buf, sizeof (brain_server_attack_long_t), brain_server_db_attack->long_cnt, &fp);
return false; if (nwrite != (size_t) brain_server_db_attack->long_cnt)
} {
brain_logging (stderr, 0, "%s: only %" PRIu64 " bytes written\n", file, (u64) nwrite * sizeof (brain_server_attack_long_t));
hc_fclose (&fp); hc_fclose (&fp);
brain_server_db_attack->write_attacks = false; return false;
} }
hc_fclose (&fp);
brain_server_db_attack->write_attacks = false;
// stats // stats
const double ms = hc_timer_get (timer_dump); const double ms = hc_timer_get (timer_dump);

10
src/potfile.c
Unescape View File

@ -576,12 +576,10 @@ int potfile_remove_parse (hashcat_ctx_t *hashcat_ctx)
continue; continue;
} }
else
{ // should be rejected?
// should be rejected? //const int parser_status = module_ctx->module_hash_decode_potfile (hashconfig, hash_buf.digest, hash_buf.salt, hash_buf.esalt, hash_buf.hook_salt, hash_buf.hash_info, line_hash_buf, line_hash_len, NULL);
//const int parser_status = module_ctx->module_hash_decode_potfile (hashconfig, hash_buf.digest, hash_buf.salt, hash_buf.esalt, hash_buf.hook_salt, hash_buf.hash_info, line_hash_buf, line_hash_len, NULL); //if (parser_status != PARSER_OK) continue;
//if (parser_status != PARSER_OK) continue;
}
} }
else else
{ {

145
src/status.c
Unescape View File

@ -327,34 +327,28 @@ char *status_get_hash_target (const hashcat_ctx_t *hashcat_ctx)
return tmp_buf2; return tmp_buf2;
} }
else
if (hashconfig->opts_type & OPTS_TYPE_BINARY_HASHFILE)
{ {
if (hashconfig->opts_type & OPTS_TYPE_BINARY_HASHFILE) return hcstrdup (hashes->hashfile);
{ }
return hcstrdup (hashes->hashfile);
}
else
{
char *tmp_buf = (char *) hcmalloc (HCBUFSIZ_LARGE);
const int tmp_len = hash_encode (hashcat_ctx->hashconfig, hashcat_ctx->hashes, hashcat_ctx->module_ctx, tmp_buf, HCBUFSIZ_LARGE, 0, 0); char *tmp_buf = (char *) hcmalloc (HCBUFSIZ_LARGE);
tmp_buf[tmp_len] = 0; const int tmp_len = hash_encode (hashcat_ctx->hashconfig, hashcat_ctx->hashes, hashcat_ctx->module_ctx, tmp_buf, HCBUFSIZ_LARGE, 0, 0);
compress_terminal_line_length (tmp_buf, 19, 6); // 19 = strlen ("Hash.Target......: ") tmp_buf[tmp_len] = 0;
char *tmp_buf2 = strdup (tmp_buf); compress_terminal_line_length (tmp_buf, 19, 6); // 19 = strlen ("Hash.Target......: ")
free (tmp_buf); char *tmp_buf2 = strdup (tmp_buf);
return tmp_buf2; free (tmp_buf);
}
} return tmp_buf2;
}
else
{
return hcstrdup (hashes->hashfile);
} }
return hcstrdup (hashes->hashfile);
} }
int status_get_guess_mode (const hashcat_ctx_t *hashcat_ctx) int status_get_guess_mode (const hashcat_ctx_t *hashcat_ctx)
@ -389,30 +383,21 @@ int status_get_guess_mode (const hashcat_ctx_t *hashcat_ctx)
{ {
return GUESS_MODE_STRAIGHT_FILE_RULES_FILE; return GUESS_MODE_STRAIGHT_FILE_RULES_FILE;
} }
else if (has_rule_gen == true) if (has_rule_gen == true)
{ {
return GUESS_MODE_STRAIGHT_FILE_RULES_GEN; return GUESS_MODE_STRAIGHT_FILE_RULES_GEN;
} }
else return GUESS_MODE_STRAIGHT_FILE;
{
return GUESS_MODE_STRAIGHT_FILE;
}
} }
else if (has_rule_file == true)
{ {
if (has_rule_file == true) return GUESS_MODE_STRAIGHT_STDIN_RULES_FILE;
{
return GUESS_MODE_STRAIGHT_STDIN_RULES_FILE;
}
else if (has_rule_gen == true)
{
return GUESS_MODE_STRAIGHT_STDIN_RULES_GEN;
}
else
{
return GUESS_MODE_STRAIGHT_STDIN;
}
} }
if (has_rule_gen == true)
{
return GUESS_MODE_STRAIGHT_STDIN_RULES_GEN;
}
return GUESS_MODE_STRAIGHT_STDIN;
} }
if (user_options->attack_mode == ATTACK_MODE_COMBI) if (user_options->attack_mode == ATTACK_MODE_COMBI)
@ -421,10 +406,7 @@ int status_get_guess_mode (const hashcat_ctx_t *hashcat_ctx)
{ {
return GUESS_MODE_COMBINATOR_BASE_LEFT; return GUESS_MODE_COMBINATOR_BASE_LEFT;
} }
else return GUESS_MODE_COMBINATOR_BASE_RIGHT;
{
return GUESS_MODE_COMBINATOR_BASE_RIGHT;
}
} }
if (user_options->attack_mode == ATTACK_MODE_BF) if (user_options->attack_mode == ATTACK_MODE_BF)
@ -433,10 +415,7 @@ int status_get_guess_mode (const hashcat_ctx_t *hashcat_ctx)
{ {
return GUESS_MODE_MASK_CS; return GUESS_MODE_MASK_CS;
} }
else return GUESS_MODE_MASK;
{
return GUESS_MODE_MASK;
}
} }
if (user_options->attack_mode == ATTACK_MODE_HYBRID1) if (user_options->attack_mode == ATTACK_MODE_HYBRID1)
@ -445,10 +424,7 @@ int status_get_guess_mode (const hashcat_ctx_t *hashcat_ctx)
{ {
return GUESS_MODE_HYBRID1_CS; return GUESS_MODE_HYBRID1_CS;
} }
else return GUESS_MODE_HYBRID1;
{
return GUESS_MODE_HYBRID1;
}
} }
if (user_options->attack_mode == ATTACK_MODE_HYBRID2) if (user_options->attack_mode == ATTACK_MODE_HYBRID2)
@ -457,10 +433,7 @@ int status_get_guess_mode (const hashcat_ctx_t *hashcat_ctx)
{ {
return GUESS_MODE_HYBRID2_CS; return GUESS_MODE_HYBRID2_CS;
} }
else return GUESS_MODE_HYBRID2;
{
return GUESS_MODE_HYBRID2;
}
} }
return GUESS_MODE_NONE; return GUESS_MODE_NONE;
@ -490,10 +463,7 @@ char *status_get_guess_base (const hashcat_ctx_t *hashcat_ctx)
{ {
return strdup (combinator_ctx->dict1); return strdup (combinator_ctx->dict1);
} }
else return strdup (combinator_ctx->dict2);
{
return strdup (combinator_ctx->dict2);
}
} }
if (user_options->attack_mode == ATTACK_MODE_BF) if (user_options->attack_mode == ATTACK_MODE_BF)
@ -518,14 +488,11 @@ char *status_get_guess_base (const hashcat_ctx_t *hashcat_ctx)
return strdup (mask_ctx->mask); return strdup (mask_ctx->mask);
} }
else
{
const straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx;
return strdup (straight_ctx->dict); const straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx;
}
}
return strdup (straight_ctx->dict);
}
return NULL; return NULL;
} }
@ -568,12 +535,10 @@ int status_get_guess_base_offset (const hashcat_ctx_t *hashcat_ctx)
return mask_ctx->masks_pos + 1; return mask_ctx->masks_pos + 1;
} }
else
{
const straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx;
return straight_ctx->dicts_pos + 1; const straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx;
}
return straight_ctx->dicts_pos + 1;
} }
return 0; return 0;
@ -618,12 +583,10 @@ int status_get_guess_base_count (const hashcat_ctx_t *hashcat_ctx)
return mask_ctx->masks_cnt; return mask_ctx->masks_cnt;
} }
else
{
const straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx;
return straight_ctx->dicts_cnt; const straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx;
}
return straight_ctx->dicts_cnt;
} }
return 0; return 0;
@ -657,10 +620,7 @@ char *status_get_guess_mod (const hashcat_ctx_t *hashcat_ctx)
{ {
return strdup (combinator_ctx->dict2); return strdup (combinator_ctx->dict2);
} }
else return strdup (combinator_ctx->dict1);
{
return strdup (combinator_ctx->dict1);
}
} }
if (user_options->attack_mode == ATTACK_MODE_BF) if (user_options->attack_mode == ATTACK_MODE_BF)
@ -683,12 +643,10 @@ char *status_get_guess_mod (const hashcat_ctx_t *hashcat_ctx)
return strdup (straight_ctx->dict); return strdup (straight_ctx->dict);
} }
else
{
const mask_ctx_t *mask_ctx = hashcat_ctx->mask_ctx;
return strdup (mask_ctx->mask); const mask_ctx_t *mask_ctx = hashcat_ctx->mask_ctx;
}
return strdup (mask_ctx->mask);
} }
return NULL; return NULL;
@ -729,12 +687,10 @@ int status_get_guess_mod_offset (const hashcat_ctx_t *hashcat_ctx)
return straight_ctx->dicts_pos + 1; return straight_ctx->dicts_pos + 1;
} }
else
{
const mask_ctx_t *mask_ctx = hashcat_ctx->mask_ctx;
return mask_ctx->masks_pos + 1; const mask_ctx_t *mask_ctx = hashcat_ctx->mask_ctx;
}
return mask_ctx->masks_pos + 1;
} }
return 0; return 0;
@ -775,12 +731,10 @@ int status_get_guess_mod_count (const hashcat_ctx_t *hashcat_ctx)
return straight_ctx->dicts_cnt; return straight_ctx->dicts_cnt;
} }
else
{
const mask_ctx_t *mask_ctx = hashcat_ctx->mask_ctx;
return mask_ctx->masks_cnt; const mask_ctx_t *mask_ctx = hashcat_ctx->mask_ctx;
}
return mask_ctx->masks_cnt;
} }
return 0; return 0;
@ -1196,10 +1150,7 @@ int status_get_progress_mode (const hashcat_ctx_t *hashcat_ctx)
{ {
return PROGRESS_MODE_KEYSPACE_KNOWN; return PROGRESS_MODE_KEYSPACE_KNOWN;
} }
else return PROGRESS_MODE_KEYSPACE_UNKNOWN;
{
return PROGRESS_MODE_KEYSPACE_UNKNOWN;
}
} }
double status_get_progress_finished_percent (const hashcat_ctx_t *hashcat_ctx) double status_get_progress_finished_percent (const hashcat_ctx_t *hashcat_ctx)

30
src/user_options.c
Unescape View File

@ -1909,28 +1909,26 @@ u64 user_options_extra_amplifier (hashcat_ctx_t *hashcat_ctx)
{ {
return 1; return 1;
} }
else
if (user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT)
{ {
if (user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT) if (straight_ctx->kernel_rules_cnt)
{ {
if (straight_ctx->kernel_rules_cnt) return straight_ctx->kernel_rules_cnt;
{
return straight_ctx->kernel_rules_cnt;
}
} }
else if (user_options_extra->attack_kern == ATTACK_KERN_COMBI) }
else if (user_options_extra->attack_kern == ATTACK_KERN_COMBI)
{
if (combinator_ctx->combs_cnt)
{ {
if (combinator_ctx->combs_cnt) return combinator_ctx->combs_cnt;
{
return combinator_ctx->combs_cnt;
}
} }
else if (user_options_extra->attack_kern == ATTACK_KERN_BF) }
else if (user_options_extra->attack_kern == ATTACK_KERN_BF)
{
if (mask_ctx->bfs_cnt)
{ {
if (mask_ctx->bfs_cnt) return mask_ctx->bfs_cnt;
{
return mask_ctx->bfs_cnt;
}
} }
} }

Write Preview
Loading…
Cancel
Save