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

Remove union from HCFILE, using std file ops in ocl_check_dri, remove debug comments

Browse Source
pull/2075/head
Gabriele Gristina 5 years ago
parent c2e634c426
commit 5d3ed3e754
19 changed files with 69 additions and 335 deletions
Show Stats Download Patch File Download Diff File

11
include/types.h
Unescape View File

@ -993,15 +993,12 @@ typedef struct link_speed
typedef struct hc_fp
{
union
{
FILE *fp;
gzFile gfp;
} f;
FILE *pfp;
gzFile gfp;
bool is_gzip;
bool is_gzip;
char *mode;
const char *path;
char *mode;
} HCFILE;
#include "ext_nvrtc.h"

36
src/backend.c
Unescape View File

@ -137,25 +137,20 @@ static int ocl_check_dri (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx)
// Now we need to check if this an AMD vendor, because this is when the problems start
HCFILE fp_drm;
// FILE *fd_drm = fopen (drm_card0_vendor_path, "rb");
FILE *fd_drm = fopen (drm_card0_vendor_path, "rb");
if (hc_fopen (&fp_drm, drm_card0_vendor_path, "rb") == false) return 0;
// if (fd_drm == NULL) return 0;
if (fd_drm == NULL) return 0;
u32 vendor = 0;
// if (fscanf (fd_drm, "0x%x", &vendor) != 1)
if (hc_fscanf (&fp_drm, "0x%x", &vendor) != 1)
if (fscanf (fd_drm, "0x%x", &vendor) != 1)
{
// fclose (fd_drm);
hc_fclose (&fp_drm);
fclose (fd_drm);
return 0;
}
// fclose (fd_drm);
hc_fclose (&fp_drm);
fclose (fd_drm);
if (vendor != 4098) return 0;
@ -173,11 +168,9 @@ static int ocl_check_dri (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx)
// Now do the real check
HCFILE fp_dri;
// FILE *fd_dri = fopen (dri_card0_path, "rb");
FILE *fd_dri = fopen (dri_card0_path, "rb");
if (hc_fopen (&fp_dri, dri_card0_path, "rb") == false)
// if (fd_dri == NULL)
if (fd_dri == NULL)
{
event_log_error (hashcat_ctx, "Cannot access %s: %m.", dri_card0_path);
@ -189,8 +182,7 @@ static int ocl_check_dri (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx)
return -1;
}
// fclose (fd_dri);
hc_fclose (&fp_drm);
fclose (fd_dri);
#endif // __linux__
@ -448,17 +440,14 @@ static bool opencl_test_instruction (hashcat_ctx_t *hashcat_ctx, cl_context cont
static bool read_kernel_binary (hashcat_ctx_t *hashcat_ctx, const char *kernel_file, size_t *kernel_lengths, char **kernel_sources, const bool force_recompile)
{
// FILE *fp = fopen (kernel_file, "rb");
HCFILE fp;
// if (fp != NULL)
if (hc_fopen (&fp, kernel_file, "rb") != false)
{
struct stat st;
if (stat (kernel_file, &st))
{
// fclose (fp);
hc_fclose (&fp);
return false;
@ -470,7 +459,6 @@ static bool read_kernel_binary (hashcat_ctx_t *hashcat_ctx, const char *kernel_f
size_t num_read = hc_fread (buf, sizeof (char), st.st_size, &fp);
// fclose (fp);
hc_fclose (&fp);
if (num_read != (size_t) st.st_size)
@ -515,10 +503,8 @@ static bool write_kernel_binary (hashcat_ctx_t *hashcat_ctx, char *kernel_file,
{
if (binary_size > 0)
{
// FILE *fp = fopen (kernel_file, "wb");
HCFILE fp;
// if (fp == NULL)
if (hc_fopen (&fp, kernel_file, "wb") == false)
{
event_log_error (hashcat_ctx, "%s: %s", kernel_file, strerror (errno));
@ -528,10 +514,8 @@ static bool write_kernel_binary (hashcat_ctx_t *hashcat_ctx, char *kernel_file,
fp.is_gzip = false;
// if (lock_file (fp) == -1)
if (lock_file (fp.f.fp) == -1)
if (lock_file (fp.pfp) == -1)
{
// fclose (fp);
hc_fclose (&fp);
event_log_error (hashcat_ctx, "%s: %s", kernel_file, strerror (errno));
@ -541,10 +525,8 @@ static bool write_kernel_binary (hashcat_ctx_t *hashcat_ctx, char *kernel_file,
hc_fwrite (binary, sizeof (char), binary_size, &fp);
// fflush (fp);
hc_fflush (&fp);
// fclose (fp);
hc_fclose (&fp);
}

31
src/brain.c
Unescape View File

@ -539,21 +539,17 @@ u64 brain_compute_attack_wordlist (const char *filename)
char buf[FBUFSZ];
// FILE *fd = fopen (filename, "rb");
HCFILE fp;
hc_fopen (&fp, filename, "rb");
// while (!feof (fd))
while (!hc_feof (&fp))
{
// const size_t nread = fread (buf, 1, FBUFSZ, fd);
const size_t nread = hc_fread (buf, 1, FBUFSZ, &fp);
XXH64_update (state, buf, nread);
}
// fclose (fd);
hc_fclose (&fp);
const u64 hash = XXH64_digest (state);
@ -615,10 +611,8 @@ u32 brain_auth_challenge (void)
static const char *urandom = "/dev/urandom";
// FILE *fd = fopen (urandom, "rb");
HCFILE fp;
// if (fd == NULL)
if (hc_fopen (&fp, urandom, "rb") == false)
{
brain_logging (stderr, 0, "%s: %s\n", urandom, strerror (errno));
@ -626,18 +620,15 @@ u32 brain_auth_challenge (void)
return val;
}
// if (fread (&val, sizeof (val), 1, fd) != 1)
if (hc_fread (&val, sizeof (val), 1, &fp) != 1)
{
brain_logging (stderr, 0, "%s: %s\n", urandom, strerror (errno));
// fclose (fd);
hc_fclose (&fp);
return val;
}
// fclose (fd);
hc_fclose (&fp);
#endif
@ -1606,10 +1597,8 @@ bool brain_server_read_hash_dump (brain_server_db_hash_t *brain_server_db_hash,
return false;
}
// FILE *fd = fopen (file, "rb");
HCFILE fp;
// if (fd == NULL)
if (hc_fopen (&fp, file, "rb") == false)
{
brain_logging (stderr, 0, "%s: %s\n", file, strerror (errno));
@ -1624,20 +1613,17 @@ bool brain_server_read_hash_dump (brain_server_db_hash_t *brain_server_db_hash,
{
brain_logging (stderr, 0, "%s\n", MSG_ENOMEM);
// fclose (fd);
hc_fclose (&fp);
return false;
}
// const size_t nread = fread (brain_server_db_hash->long_buf, sizeof (brain_server_hash_long_t), temp_cnt, fd);
const size_t nread = hc_fread (brain_server_db_hash->long_buf, sizeof (brain_server_hash_long_t), temp_cnt, &fp);
if (nread != (size_t) temp_cnt)
{
brain_logging (stderr, 0, "%s: only %" PRIu64 " bytes read\n", file, (u64) nread * sizeof (brain_server_hash_long_t));
// fclose (fd);
hc_fclose (&fp);
return false;
@ -1647,7 +1633,6 @@ bool brain_server_read_hash_dump (brain_server_db_hash_t *brain_server_db_hash,
brain_server_db_hash->write_hashes = false;
// fclose (fd);
hc_fclose (&fp);
}
@ -1668,10 +1653,8 @@ bool brain_server_write_hash_dump (brain_server_db_hash_t *brain_server_db_hash,
// write to file
// FILE *fd = fopen (file, "wb");
HCFILE fp;
// if (fd == NULL)
if (hc_fopen (&fp, file, "wb") == false)
{
brain_logging (stderr, 0, "%s: %s\n", file, strerror (errno));
@ -1682,20 +1665,17 @@ bool brain_server_write_hash_dump (brain_server_db_hash_t *brain_server_db_hash,
{
fp.is_gzip = false;
// const size_t nwrite = fwrite (brain_server_db_hash->long_buf, sizeof (brain_server_hash_long_t), brain_server_db_hash->long_cnt, fd);
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));
// fclose (fd);
hc_fclose (&fp);
return false;
}
// fclose (fd);
hc_fclose (&fp);
brain_server_db_hash->write_hashes = false;
@ -1818,10 +1798,8 @@ bool brain_server_read_attack_dump (brain_server_db_attack_t *brain_server_db_at
return false;
}
// FILE *fd = fopen (file, "rb");
HCFILE fp;
// if (fd == NULL)
if (hc_fopen (&fp, file, "rb") == false)
{
brain_logging (stderr, 0, "%s: %s\n", file, strerror (errno));
@ -1836,20 +1814,17 @@ bool brain_server_read_attack_dump (brain_server_db_attack_t *brain_server_db_at
{
brain_logging (stderr, 0, "%s\n", MSG_ENOMEM);
// fclose (fd);
hc_fclose (&fp);
return false;
}
// const size_t nread = fread (brain_server_db_attack->long_buf, sizeof (brain_server_attack_long_t), temp_cnt, fd);
const size_t nread = hc_fread (brain_server_db_attack->long_buf, sizeof (brain_server_attack_long_t), temp_cnt, &fp);
if (nread != (size_t) temp_cnt)
{
brain_logging (stderr, 0, "%s: only %" PRIu64 " bytes read\n", file, (u64) nread * sizeof (brain_server_attack_long_t));
// fclose (fd);
hc_fclose (&fp);
return false;
@ -1859,7 +1834,6 @@ bool brain_server_read_attack_dump (brain_server_db_attack_t *brain_server_db_at
brain_server_db_attack->write_attacks = false;
// fclose (fd);
hc_fclose (&fp);
}
@ -1880,10 +1854,8 @@ bool brain_server_write_attack_dump (brain_server_db_attack_t *brain_server_db_a
// write to file
// FILE *fd = fopen (file, "wb");
HCFILE fp;
// if (fd == NULL)
if (hc_fopen (&fp, file, "wb") == false)
{
brain_logging (stderr, 0, "%s: %s\n", file, strerror (errno));
@ -1896,20 +1868,17 @@ bool brain_server_write_attack_dump (brain_server_db_attack_t *brain_server_db_a
// storing should not include reserved attacks only finished
// const size_t nwrite = fwrite (brain_server_db_attack->long_buf, sizeof (brain_server_attack_long_t), brain_server_db_attack->long_cnt, fd);
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)
{
brain_logging (stderr, 0, "%s: only %" PRIu64 " bytes written\n", file, (u64) nwrite * sizeof (brain_server_attack_long_t));
// fclose (fd);
hc_fclose (&fp);
return false;
}
// fclose (fd);
hc_fclose (&fp);
brain_server_db_attack->write_attacks = false;

2
src/cpu_crc32.c
Unescape View File

@ -92,7 +92,6 @@ int cpu_crc32 (const char *filename, u8 keytab[64])
{
u32 crc = ~0u;
// FILE *fd = fopen (filename, "rb");
HCFILE fp;
hc_fopen (&fp, filename, "rb");
@ -103,7 +102,6 @@ int cpu_crc32 (const char *filename, u8 keytab[64])
size_t nread = hc_fread (buf, sizeof (u8), MAX_KEY_SIZE, &fp);
// fclose (fd);
hc_fclose (&fp);
size_t kpos = 0;

16
src/debugfile.c
Unescape View File

@ -37,16 +37,13 @@ static void debugfile_format_plain (hashcat_ctx_t *hashcat_ctx, const u8 *plain_
if (needs_hexify == 1)
{
// fprintf (debugfile_ctx->fp, "$HEX[");
hc_fprintf (debugfile_ctx->fp, "$HEX[");
for (u32 i = 0; i < plain_len; i++)
{
// fprintf (debugfile_ctx->fp, "%02x", plain_ptr[i]);
hc_fprintf (debugfile_ctx->fp, "%02x", plain_ptr[i]);
}
// fprintf (debugfile_ctx->fp, "]");
hc_fprintf (debugfile_ctx->fp, "]");
}
else
@ -67,7 +64,6 @@ void debugfile_write_append (hashcat_ctx_t *hashcat_ctx, const u8 *rule_buf, con
{
debugfile_format_plain (hashcat_ctx, orig_plain_ptr, orig_plain_len);
// if ((debug_mode == 3) || (debug_mode == 4)) fputc (':', debugfile_ctx->fp);
if ((debug_mode == 3) || (debug_mode == 4)) hc_fputc (':', debugfile_ctx->fp);
}
@ -75,7 +71,6 @@ void debugfile_write_append (hashcat_ctx_t *hashcat_ctx, const u8 *rule_buf, con
if (debug_mode == 4)
{
// fputc (':', debugfile_ctx->fp);
hc_fputc (':', debugfile_ctx->fp);
debugfile_format_plain (hashcat_ctx, mod_plain_ptr, mod_plain_len);
@ -112,10 +107,8 @@ int debugfile_init (hashcat_ctx_t *hashcat_ctx)
if (debugfile_ctx->filename)
{
// FILE *fp = fopen (debugfile_ctx->filename, "ab");
HCFILE fp;
// if (fp == NULL)
if (hc_fopen (&fp, debugfile_ctx->filename, "ab") == false)
{
event_log_error (hashcat_ctx, "Could not open --debug-file file for writing.");
@ -125,10 +118,8 @@ int debugfile_init (hashcat_ctx_t *hashcat_ctx)
fp.is_gzip = false;
// if (lock_file (fp) == -1)
if (lock_file (fp.f.fp) == -1)
if (lock_file (fp.pfp) == -1)
{
// fclose (fp);
hc_fclose (&fp);
event_log_error (hashcat_ctx, "%s: %s", debugfile_ctx->filename, strerror (errno));
@ -136,16 +127,14 @@ int debugfile_init (hashcat_ctx_t *hashcat_ctx)
return -1;
}
// debugfile_ctx->fp = fp;
debugfile_ctx->fp = &fp;
}
else
{
HCFILE fp_tmp;
fp_tmp.is_gzip = false;
fp_tmp.f.fp = stdout;
fp_tmp.pfp = stdout;
// debugfile_ctx->fp = stdout;
debugfile_ctx->fp = &fp_tmp;
}
@ -160,7 +149,6 @@ void debugfile_destroy (hashcat_ctx_t *hashcat_ctx)
if (debugfile_ctx->filename)
{
// fclose (debugfile_ctx->fp);
hc_fclose (debugfile_ctx->fp);
}

15
src/dictstat.c
Unescape View File

@ -96,10 +96,8 @@ void dictstat_read (hashcat_ctx_t *hashcat_ctx)
if (hashconfig->dictstat_disable == true) return;
// FILE *fp = fopen (dictstat_ctx->filename, "rb");
HCFILE fp;
// if (fp == NULL)
if (hc_fopen (&fp, dictstat_ctx->filename, "rb") == false)
{
// first run, file does not exist, do not error out
@ -119,7 +117,6 @@ void dictstat_read (hashcat_ctx_t *hashcat_ctx)
{
event_log_error (hashcat_ctx, "%s: Invalid header", dictstat_ctx->filename);
// fclose (fp);
hc_fclose (&fp);
return;
@ -132,7 +129,6 @@ void dictstat_read (hashcat_ctx_t *hashcat_ctx)
{
event_log_error (hashcat_ctx, "%s: Invalid header, ignoring content", dictstat_ctx->filename);
// fclose (fp);
hc_fclose (&fp);
return;
@ -142,7 +138,6 @@ void dictstat_read (hashcat_ctx_t *hashcat_ctx)
{
event_log_error (hashcat_ctx, "%s: Invalid header, ignoring content", dictstat_ctx->filename);
// fclose (fp);
hc_fclose (&fp);
return;
@ -152,7 +147,6 @@ void dictstat_read (hashcat_ctx_t *hashcat_ctx)
{
event_log_warning (hashcat_ctx, "%s: Outdated header version, ignoring content", dictstat_ctx->filename);
// fclose (fp);
hc_fclose (&fp);
return;
@ -160,7 +154,6 @@ void dictstat_read (hashcat_ctx_t *hashcat_ctx)
// parse data
// while (!feof (fp))
while (!hc_feof (&fp))
{
dictstat_t d;
@ -179,7 +172,6 @@ void dictstat_read (hashcat_ctx_t *hashcat_ctx)
}
}
// fclose (fp);
hc_fclose (&fp);
}
@ -192,10 +184,8 @@ int dictstat_write (hashcat_ctx_t *hashcat_ctx)
if (hashconfig->dictstat_disable == true) return 0;
// FILE *fp = fopen (dictstat_ctx->filename, "wb");
HCFILE fp;
// if (fp == NULL)
if (hc_fopen (&fp, dictstat_ctx->filename, "wb") == false)
{
event_log_error (hashcat_ctx, "%s: %s", dictstat_ctx->filename, strerror (errno));
@ -205,10 +195,8 @@ int dictstat_write (hashcat_ctx_t *hashcat_ctx)
fp.is_gzip = false;
// if (lock_file (fp) == -1)
if (lock_file (fp.f.fp) == -1)
if (lock_file (fp.pfp) == -1)
{
// fclose (fp);
hc_fclose (&fp);
event_log_error (hashcat_ctx, "%s: %s", dictstat_ctx->filename, strerror (errno));
@ -231,7 +219,6 @@ int dictstat_write (hashcat_ctx_t *hashcat_ctx)
hc_fwrite (dictstat_ctx->base, sizeof (dictstat_t), dictstat_ctx->cnt, &fp);
// fclose (fp);
hc_fclose (&fp);
return 0;

13
src/hashes.c
Unescape View File

@ -184,10 +184,8 @@ int save_hash (hashcat_ctx_t *hashcat_ctx)
char separator = hashconfig->separator;
// FILE *fp = fopen (new_hashfile, "wb");
HCFILE fp;
// if (fp == NULL)
if (hc_fopen (&fp, new_hashfile, "wb") == false)
{
event_log_error (hashcat_ctx, "%s: %s", new_hashfile, strerror (errno));
@ -200,10 +198,8 @@ int save_hash (hashcat_ctx_t *hashcat_ctx)
fp.is_gzip = false;
// if (lock_file (fp) == -1)
if (lock_file (fp.f.fp) == -1)
if (lock_file (fp.pfp) == -1)
{
// fclose (fp);
hc_fclose (&fp);
event_log_error (hashcat_ctx, "%s: %s", new_hashfile, strerror (errno));
@ -246,10 +242,8 @@ int save_hash (hashcat_ctx_t *hashcat_ctx)
u32 i;
// for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
for (i = 0; i < user->user_len; i++) hc_fputc (user->user_name[i], &fp);
// fputc (separator, fp);
hc_fputc (separator, &fp);
}
@ -257,7 +251,6 @@ int save_hash (hashcat_ctx_t *hashcat_ctx)
out_buf[out_len] = 0;
// fprintf (fp, "%s" EOL, out_buf);
hc_fprintf (&fp, "%s" EOL, out_buf);
}
}
@ -265,10 +258,8 @@ int save_hash (hashcat_ctx_t *hashcat_ctx)
hcfree (out_buf);
// fflush (fp);
hc_fflush (&fp);
// fclose (fp);
hc_fclose (&fp);
unlink (old_hashfile);
@ -1805,6 +1796,8 @@ int hashes_init_selftest (hashcat_ctx_t *hashcat_ctx)
hc_fopen (&fp, tmpfile_bin, "wb");
fp.is_gzip = false;
const size_t st_hash_len = strlen (hashconfig->st_hash);
for (size_t i = 0; i < st_hash_len; i += 2)

35
src/hwmon.c
Unescape View File

@ -110,10 +110,8 @@ static int hm_SYSFS_get_fan_speed_current (hashcat_ctx_t *hashcat_ctx, const int
hcfree (syspath);
// FILE *fd_cur = fopen (path_cur, "r");
HCFILE fp_cur;
// if (fd_cur == NULL)
if (hc_fopen (&fp_cur, path_cur, "r") == false)
{
event_log_error (hashcat_ctx, "%s: %s", path_cur, strerror (errno));
@ -126,10 +124,8 @@ static int hm_SYSFS_get_fan_speed_current (hashcat_ctx_t *hashcat_ctx, const int
int pwm1_cur = 0;
// if (fscanf (fd_cur, "%d", &pwm1_cur) != 1)
if (hc_fscanf (&fp_cur, "%d", &pwm1_cur) != 1)
{
// fclose (fd_cur);
hc_fclose (&fp_cur);
event_log_error (hashcat_ctx, "%s: unexpected data.", path_cur);
@ -140,13 +136,10 @@ static int hm_SYSFS_get_fan_speed_current (hashcat_ctx_t *hashcat_ctx, const int
return -1;
}
// fclose (fd_cur);
hc_fclose (&fp_cur);
// FILE *fd_max = fopen (path_max, "r");
HCFILE fp_max;
// if (fd_max == NULL)
if (hc_fopen (&fp_max, path_max, "r") == false)
{
event_log_error (hashcat_ctx, "%s: %s", path_max, strerror (errno));
@ -159,10 +152,8 @@ static int hm_SYSFS_get_fan_speed_current (hashcat_ctx_t *hashcat_ctx, const int
int pwm1_max = 0;
// if (fscanf (fd_max, "%d", &pwm1_max) != 1)
if (hc_fscanf (&fp_max, "%d", &pwm1_max) != 1)
{
// fclose (fd_max);
hc_fclose (&fp_max);
event_log_error (hashcat_ctx, "%s: unexpected data.", path_max);
@ -173,7 +164,6 @@ static int hm_SYSFS_get_fan_speed_current (hashcat_ctx_t *hashcat_ctx, const int
return -1;
}
// fclose (fd_max);
hc_fclose (&fp_max);
if (pwm1_max == 0)
@ -210,10 +200,8 @@ static int hm_SYSFS_get_temperature_current (hashcat_ctx_t *hashcat_ctx, const i
hcfree (syspath);
// FILE *fd = fopen (path, "r");
HCFILE fp;
// if (fd == NULL)
if (hc_fopen (&fp, path, "r") == false)
{
event_log_error (hashcat_ctx, "%s: %s", path, strerror (errno));
@ -225,10 +213,8 @@ static int hm_SYSFS_get_temperature_current (hashcat_ctx_t *hashcat_ctx, const i
int temperature = 0;
// if (fscanf (fd, "%d", &temperature) != 1)
if (hc_fscanf (&fp, "%d", &temperature) != 1)
{
// fclose (fd);
hc_fclose (&fp);
event_log_error (hashcat_ctx, "%s: unexpected data.", path);
@ -238,7 +224,6 @@ static int hm_SYSFS_get_temperature_current (hashcat_ctx_t *hashcat_ctx, const i
return -1;
}
// fclose (fd);
hc_fclose (&fp);
*val = temperature / 1000;
@ -260,10 +245,8 @@ static int hm_SYSFS_get_pp_dpm_sclk (hashcat_ctx_t *hashcat_ctx, const int backe
hcfree (syspath);
// FILE *fd = fopen (path, "r");
HCFILE fp;
// if (fd == NULL)
if (hc_fopen (&fp, path, "r") == false)
{
event_log_error (hashcat_ctx, "%s: %s", path, strerror (errno));
@ -275,12 +258,10 @@ static int hm_SYSFS_get_pp_dpm_sclk (hashcat_ctx_t *hashcat_ctx, const int backe
int clockfreq = 0;
// while (!feof (fd))
while (!hc_feof (&fp))
{
char buf[HCBUFSIZ_TINY];
char buf[HCBUFSIZ_TINY] = { 0 };
// char *ptr = fgets (buf, sizeof (buf), fd);
char *ptr = hc_fgets (buf, sizeof (buf), &fp);
if (ptr == NULL) continue;
@ -298,7 +279,6 @@ static int hm_SYSFS_get_pp_dpm_sclk (hashcat_ctx_t *hashcat_ctx, const int backe
if (rc == 2) break;
}
// fclose (fd);
hc_fclose (&fp);
*val = clockfreq;
@ -320,10 +300,8 @@ static int hm_SYSFS_get_pp_dpm_mclk (hashcat_ctx_t *hashcat_ctx, const int backe
hcfree (syspath);
// FILE *fd = fopen (path, "r");
HCFILE fp;
// if (fd == NULL)
if (hc_fopen (&fp, path, "r") == false)
{
event_log_error (hashcat_ctx, "%s: %s", path, strerror (errno));
@ -335,12 +313,10 @@ static int hm_SYSFS_get_pp_dpm_mclk (hashcat_ctx_t *hashcat_ctx, const int backe
int clockfreq = 0;
// while (!feof (fd))
while (!hc_feof (&fp))
{
char buf[HCBUFSIZ_TINY];
// char *ptr = fgets (buf, sizeof (buf), fd);
char *ptr = hc_fgets (buf, sizeof (buf), &fp);
if (ptr == NULL) continue;
@ -358,7 +334,6 @@ static int hm_SYSFS_get_pp_dpm_mclk (hashcat_ctx_t *hashcat_ctx, const int backe
if (rc == 2) break;
}
// fclose (fd);
hc_fclose (&fp);
*val = clockfreq;
@ -380,10 +355,8 @@ static int hm_SYSFS_get_pp_dpm_pcie (hashcat_ctx_t *hashcat_ctx, const int backe
hcfree (syspath);
// FILE *fd = fopen (path, "r");
HCFILE fp;
// if (fd == NULL)
if (hc_fopen (&fp, path, "r") == false)
{
event_log_error (hashcat_ctx, "%s: %s", path, strerror (errno));
@ -395,12 +368,10 @@ static int hm_SYSFS_get_pp_dpm_pcie (hashcat_ctx_t *hashcat_ctx, const int backe
int lanes = 0;
// while (!feof (fd))
while (!hc_feof (&fp))
{
char buf[HCBUFSIZ_TINY];
// char *ptr = fgets (buf, sizeof (buf), fd);
char *ptr = hc_fgets (buf, sizeof (buf), &fp);
if (ptr == NULL) continue;
@ -419,7 +390,6 @@ static int hm_SYSFS_get_pp_dpm_pcie (hashcat_ctx_t *hashcat_ctx, const int backe
if (rc == 3) break;
}
// fclose (fd);
hc_fclose (&fp);
*val = lanes;
@ -490,10 +460,8 @@ static int nvml_init (hashcat_ctx_t *hashcat_ctx)
if (!nvml->lib)
{
// FILE *nvml_lib = fopen ("/proc/registry/HKEY_LOCAL_MACHINE/SOFTWARE/NVIDIA Corporation/Global/NVSMI/NVSMIPATH", "rb");
HCFILE nvml_lib;
// if (nvml_lib == NULL)
if (hc_fopen (&nvml_lib, "/proc/registry/HKEY_LOCAL_MACHINE/SOFTWARE/NVIDIA Corporation/Global/NVSMI/NVSMIPATH", "rb") == false)
{
//if (user_options->quiet == false)
@ -508,7 +476,6 @@ static int nvml_init (hashcat_ctx_t *hashcat_ctx)
hc_fread (nvml_winpath, 100, 1, &nvml_lib);
// fclose (nvml_lib);
hc_fclose (&nvml_lib);
ssize_t size = cygwin_conv_path (CCP_WIN_A_TO_POSIX | CCP_PROC_CYGDRIVE, nvml_winpath, NULL, 0);

8
src/logfile.c
Unescape View File

@ -43,10 +43,8 @@ void logfile_append (hashcat_ctx_t *hashcat_ctx, const char *fmt, ...)
if (logfile_ctx->enabled == false) return;
// FILE *fp = fopen (logfile_ctx->logfile, "ab");
HCFILE fp;
// if (fp == NULL)
if (hc_fopen (&fp, logfile_ctx->logfile, "ab") == false)
{
event_log_error (hashcat_ctx, "%s: %s", logfile_ctx->logfile, strerror (errno));
@ -56,24 +54,20 @@ void logfile_append (hashcat_ctx_t *hashcat_ctx, const char *fmt, ...)
fp.is_gzip = false;
// lock_file (fp);
lock_file (fp.f.fp);
lock_file (fp.pfp);
va_list ap;
va_start (ap, fmt);
// vfprintf (fp, fmt, ap);
hc_vfprintf (&fp, fmt, ap);
va_end (ap);
hc_fwrite (EOL, strlen (EOL), 1, &fp);
// fflush (fp);
hc_fflush (&fp);
// fclose (fp);
hc_fclose (&fp);
}

15
src/loopback.c
Unescape View File

@ -38,16 +38,13 @@ static void loopback_format_plain (hashcat_ctx_t *hashcat_ctx, const u8 *plain_p
if (needs_hexify == 1)
{
// fprintf (loopback_ctx->fp, "$HEX[");
hc_fprintf (loopback_ctx->fp, "$HEX[");
for (u32 i = 0; i < plain_len; i++)
{
// fprintf (loopback_ctx->fp, "%02x", plain_ptr[i]);
hc_fprintf (loopback_ctx->fp, "%02x", plain_ptr[i]);
}
// fprintf (loopback_ctx->fp, "]");
hc_fprintf (loopback_ctx->fp, "]");
}
else
@ -108,10 +105,8 @@ int loopback_write_open (hashcat_ctx_t *hashcat_ctx)
hc_asprintf (&loopback_ctx->filename, "%s/%s.%d_%u", induct_ctx->root_directory, LOOPBACK_FILE, (int) now, random_num);
// FILE *fp = fopen (loopback_ctx->filename, "ab");
HCFILE fp;
// if (fp == NULL)
if (hc_fopen (&fp, loopback_ctx->filename, "ab") == false)
{
event_log_error (hashcat_ctx, "%s: %s", loopback_ctx->filename, strerror (errno));
@ -121,7 +116,6 @@ int loopback_write_open (hashcat_ctx_t *hashcat_ctx)
fp.is_gzip = false;
// loopback_ctx->fp = fp;
loopback_ctx->fp = &fp;
loopback_ctx->unused = true;
@ -148,7 +142,6 @@ void loopback_write_close (hashcat_ctx_t *hashcat_ctx)
if (loopback_ctx->fp == NULL) return;
// fclose (loopback_ctx->fp);
hc_fclose (loopback_ctx->fp);
if (loopback_ctx->unused == true)
@ -163,21 +156,17 @@ void loopback_write_append (hashcat_ctx_t *hashcat_ctx, const u8 *plain_ptr, con
if (loopback_ctx->enabled == false) return;
// FILE *fp = loopback_ctx->fp;
HCFILE *fp = loopback_ctx->fp;
loopback_format_plain (hashcat_ctx, plain_ptr, plain_len);
// lock_file (fp);
lock_file (fp->f.fp);
lock_file (fp->pfp);
hc_fwrite (EOL, strlen (EOL), 1, fp);
// fflush (fp);
hc_fflush (fp);
// if (unlock_file (fp))
if (unlock_file (fp->f.fp))
if (unlock_file (fp->pfp))
{
event_log_error (hashcat_ctx, "%s: Failed to unlock file", loopback_ctx->filename);
}

29
src/main.c
Unescape View File

@ -28,33 +28,23 @@
int _dowildcard = -1;
#endif
//static void main_log_clear_line (MAYBE_UNUSED const size_t prev_len, MAYBE_UNUSED FILE *fp)
static void main_log_clear_line (MAYBE_UNUSED const size_t prev_len, MAYBE_UNUSED HCFILE *fp)
{
#if defined (_WIN)
// fputc ('\r', fp);
hc_fputc ('\r', fp);
for (size_t i = 0; i < prev_len; i++)
{
// fputc (' ', fp);
hc_fputc (' ', fp);
}
for (size_t i = 0; i < prev_len; i++) hc_fputc (' ', fp);
// fputc ('\r', fp);
hc_fputc ('\r', fp);
#else
// fputs ("\033[2K\r", fp);
hc_fprintf(fp, "\033[2K\r");
// fputs ("\033[2K\r", fp);
#endif
}
//static void main_log (hashcat_ctx_t *hashcat_ctx, FILE *fp, const int loglevel)
static void main_log (hashcat_ctx_t *hashcat_ctx, HCFILE *fp, const int loglevel)
{
event_ctx_t *event_ctx = hashcat_ctx->event_ctx;
@ -107,7 +97,7 @@ static void main_log (hashcat_ctx_t *hashcat_ctx, HCFILE *fp, const int loglevel
#else
switch (loglevel)
{
case LOGLEVEL_INFO: break;
case LOGLEVEL_INFO: break;
case LOGLEVEL_WARNING: hc_fwrite ("\033[33m", 5, 1, fp); break;
case LOGLEVEL_ERROR: hc_fwrite ("\033[31m", 5, 1, fp); break;
case LOGLEVEL_ADVICE: hc_fwrite ("\033[33m", 5, 1, fp); break;
@ -131,7 +121,7 @@ static void main_log (hashcat_ctx_t *hashcat_ctx, HCFILE *fp, const int loglevel
#else
switch (loglevel)
{
case LOGLEVEL_INFO: break;
case LOGLEVEL_INFO: break;
case LOGLEVEL_WARNING: hc_fwrite ("\033[0m", 4, 1, fp); break;
case LOGLEVEL_ERROR: hc_fwrite ("\033[0m", 4, 1, fp); break;
case LOGLEVEL_ADVICE: hc_fwrite ("\033[0m", 4, 1, fp); break;
@ -152,7 +142,6 @@ static void main_log (hashcat_ctx_t *hashcat_ctx, HCFILE *fp, const int loglevel
}
}
// fflush (fp);
hc_fflush (fp);
}
@ -164,9 +153,8 @@ static void main_log_advice (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MAYBE_UNUS
HCFILE fp;
fp.is_gzip = false;
fp.f.fp = stdout;
fp.pfp = stdout;
// main_log (hashcat_ctx, stdout, LOGLEVEL_ADVICE);
main_log (hashcat_ctx, &fp, LOGLEVEL_ADVICE);
}
@ -174,9 +162,8 @@ static void main_log_info (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED
{
HCFILE fp;
fp.is_gzip = false;
fp.f.fp = stdout;
fp.pfp = stdout;
// main_log (hashcat_ctx, stdout, LOGLEVEL_INFO);
main_log (hashcat_ctx, &fp, LOGLEVEL_INFO);
}
@ -184,9 +171,8 @@ static void main_log_warning (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MAYBE_UNU
{
HCFILE fp;
fp.is_gzip = false;
fp.f.fp = stdout;
fp.pfp = stdout;
// main_log (hashcat_ctx, stdout, LOGLEVEL_WARNING);
main_log (hashcat_ctx, &fp, LOGLEVEL_WARNING);
}
@ -194,9 +180,8 @@ static void main_log_error (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSE
{
HCFILE fp;
fp.is_gzip = false;
fp.f.fp = stderr;
fp.pfp = stderr;
// main_log (hashcat_ctx, stderr, LOGLEVEL_ERROR);
main_log (hashcat_ctx, &fp, LOGLEVEL_ERROR);
}

45
src/mpsp.c
Unescape View File

@ -582,10 +582,8 @@ static void mp_setup_sys (cs_t *mp_sys)
static int mp_setup_usr (hashcat_ctx_t *hashcat_ctx, cs_t *mp_sys, cs_t *mp_usr, const char *buf, const u32 userindex)
{
// FILE *fp = fopen (buf, "rb");
HCFILE fp;
// if (fp == NULL) // feof() in case if file is empty
if (hc_fopen (&fp, buf, "rb") == false)
{
const int rc = mp_expand (hashcat_ctx, buf, strlen (buf), mp_sys, mp_usr, userindex, 1);
@ -598,18 +596,15 @@ static int mp_setup_usr (hashcat_ctx_t *hashcat_ctx, cs_t *mp_sys, cs_t *mp_usr,
const size_t nread = hc_fread (mp_file, 1, sizeof (mp_file) - 1, &fp);
// if (!feof (fp))
if (!hc_feof (&fp))
{
event_log_error (hashcat_ctx, "%s: Custom charset file is too large.", buf);
// fclose (fp);
hc_fclose (&fp);
return -1;
}
// fclose (fp);
hc_fclose (&fp);
if (nread == 0)
@ -715,10 +710,8 @@ static int sp_setup_tbl (hashcat_ctx_t *hashcat_ctx)
return -1;
}
// FILE *fd = fopen (hcstat, "rb");
HCFILE fp;
// if (fd == NULL)
if (hc_fopen (&fp, hcstat, "rb") == false)
{
event_log_error (hashcat_ctx, "%s: %s", hcstat, strerror (errno));
@ -734,7 +727,6 @@ static int sp_setup_tbl (hashcat_ctx_t *hashcat_ctx)
{
event_log_error (hashcat_ctx, "%s: Could not read data.", hcstat);
// fclose (fd);
hc_fclose (&fp);
hcfree (inbuf);
@ -742,7 +734,6 @@ static int sp_setup_tbl (hashcat_ctx_t *hashcat_ctx)
return -1;
}
// fclose (fd);
hc_fclose (&fp);
u8 *outbuf = (u8 *) hcmalloc (SP_FILESZ);
@ -1469,10 +1460,8 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx)
if (hc_path_is_file (arg) == true)
{
// FILE *mask_fp = fopen (arg, "r");
HCFILE mask_fp;
// if (mask_fp == NULL)
if (hc_fopen (&mask_fp, arg, "r") == false)
{
event_log_error (hashcat_ctx, "%s: %s", arg, strerror (errno));
@ -1482,12 +1471,6 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx)
char *line_buf = (char *) hcmalloc (HCBUFSIZ_LARGE);
// workaround for new fgetl
/* HCFILE fp;
fp.is_gzip = 0;
fp.f.fp = mask_fp;
*/
// while (!feof (mask_fp))
while (!hc_feof (&mask_fp))
{
const size_t line_len = fgetl (&mask_fp, line_buf);
@ -1513,7 +1496,6 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx)
if (rc == -1)
{
// fclose (mask_fp);
hc_fclose (&mask_fp);
return -1;
@ -1522,7 +1504,6 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx)
hcfree (line_buf);
// fclose (mask_fp);
hc_fclose (&mask_fp);
}
else
@ -1572,10 +1553,8 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx)
{
mask_ctx->mask_from_file = true;
// FILE *mask_fp = fopen (arg, "r");
HCFILE mask_fp;
// if (mask_fp == NULL)
if (hc_fopen (&mask_fp, arg, "r") == false)
{
event_log_error (hashcat_ctx, "%s: %s", arg, strerror (errno));
@ -1584,14 +1563,7 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx)
}
char *line_buf = (char *) hcmalloc (HCBUFSIZ_LARGE);
/*
// workaround for new fgetl
HCFILE fp;
fp.is_gzip = 0;
fp.f.fp = mask_fp;
while (!feof (mask_fp))
*/
while (!hc_feof (&mask_fp))
{
const size_t line_len = fgetl (&mask_fp, line_buf);
@ -1617,7 +1589,6 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx)
if (rc == -1)
{
// fclose (mask_fp);
hc_fclose (&mask_fp);
return -1;
@ -1626,7 +1597,6 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx)
hcfree (line_buf);
// fclose (mask_fp);
hc_fclose (&mask_fp);
}
else
@ -1657,10 +1627,8 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx)
{
mask_ctx->mask_from_file = true;
// FILE *mask_fp = fopen (arg, "r");
HCFILE mask_fp;
// if (mask_fp == NULL)
if (hc_fopen (&mask_fp, arg, "r") == false)
{
event_log_error (hashcat_ctx, "%s: %s", arg, strerror (errno));
@ -1669,14 +1637,7 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx)
}
char *line_buf = (char *) hcmalloc (HCBUFSIZ_LARGE);
/*
// workaround for new fgetl
HCFILE fp;
fp.is_gzip = 0;
fp.f.fp = mask_fp;
while (!feof (mask_fp))
*/
while (!hc_feof (&mask_fp))
{
const size_t line_len = fgetl (&mask_fp, line_buf);
@ -1702,7 +1663,6 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx)
if (rc == -1)
{
// fclose (mask_fp);
hc_fclose (&mask_fp);
return -1;
@ -1711,7 +1671,6 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx)
hcfree (line_buf);
// fclose (mask_fp);
hc_fclose (&mask_fp);
}
else

8
src/outfile.c
Unescape View File

@ -390,10 +390,8 @@ int outfile_write_open (hashcat_ctx_t *hashcat_ctx)
if (outfile_ctx->filename == NULL) return 0;
// FILE *fp = fopen (outfile_ctx->filename, "ab");
HCFILE fp;
// if (fp == NULL)
if (hc_fopen (&fp, outfile_ctx->filename, "ab") == false)
{
event_log_error (hashcat_ctx, "%s: %s", outfile_ctx->filename, strerror (errno));
@ -403,10 +401,8 @@ int outfile_write_open (hashcat_ctx_t *hashcat_ctx)
fp.is_gzip = false;
// if (lock_file (fp) == -1)
if (lock_file (fp.f.fp) == -1)
if (lock_file (fp.pfp) == -1)
{
// fclose (fp);
hc_fclose (&fp);
event_log_error (hashcat_ctx, "%s: %s", outfile_ctx->filename, strerror (errno));
@ -414,7 +410,6 @@ int outfile_write_open (hashcat_ctx_t *hashcat_ctx)
return -1;
}
// outfile_ctx->fp = fp;
outfile_ctx->fp = &fp;
return 0;
@ -426,7 +421,6 @@ void outfile_write_close (hashcat_ctx_t *hashcat_ctx)
if (outfile_ctx->fp == NULL) return;
// fclose (outfile_ctx->fp);
hc_fclose (outfile_ctx->fp);
}

16
src/outfile_check.c
Unescape View File

@ -155,20 +155,16 @@ static int outfile_remove (hashcat_ctx_t *hashcat_ctx)
for (int j = 0; j < out_cnt; j++)
{
// FILE *fp = fopen (out_info[j].file_name, "rb");
HCFILE fp;
// if (fp == NULL) continue;
if (hc_fopen (&fp, out_info[j].file_name, "rb") == false) continue;
//hc_thread_mutex_lock (status_ctx->mux_display);
struct stat outfile_stat;
// if (fstat (fileno (fp), &outfile_stat))
if (fstat (hc_fileno (&fp), &outfile_stat))
{
// fclose (fp);
hc_fclose (&fp);
continue;
@ -180,21 +176,13 @@ static int outfile_remove (hashcat_ctx_t *hashcat_ctx)
out_info[j].seek = 0;
}
// fseeko (fp, out_info[j].seek, SEEK_SET);
hc_fseek (&fp, out_info[j].seek, SEEK_SET);
char *line_buf = (char *) hcmalloc (HCBUFSIZ_LARGE);
// large portion of the following code is the same as in potfile_remove_parse
// maybe subject of a future optimization
/*
// workaround for new fgetl
HCFILE fp_tmp;
fp_tmp.is_gzip = 0;
fp_tmp.f.fp = fp;
while (!feof (fp))
*/
while (!hc_feof (&fp))
{
size_t line_len = fgetl (&fp, line_buf);
@ -319,12 +307,10 @@ static int outfile_remove (hashcat_ctx_t *hashcat_ctx)
hcfree (line_buf);
// out_info[j].seek = ftello (fp);
out_info[j].seek = hc_ftell (&fp);
//hc_thread_mutex_unlock (status_ctx->mux_display);
// fclose (fp);
hc_fclose (&fp);
if (status_ctx->shutdown_inner == true) break;

7
src/pidfile.c
Unescape View File

@ -16,17 +16,14 @@ static int check_running_process (hashcat_ctx_t *hashcat_ctx)
char *pidfile_filename = pidfile_ctx->filename;
// FILE *fp = fopen (pidfile_filename, "rb");
HCFILE fp;
// if (fp == NULL) return 0;
if (hc_fopen (&fp, pidfile_filename, "rb") == false) return 0;
pidfile_data_t *pd = (pidfile_data_t *) hcmalloc (sizeof (pidfile_data_t));
const size_t nread = hc_fread (pd, sizeof (pidfile_data_t), 1, &fp);
// fclose (fp);
hc_fclose (&fp);
if (nread != 1)
@ -156,10 +153,8 @@ static int write_pidfile (hashcat_ctx_t *hashcat_ctx)
char *pidfile_filename = pidfile_ctx->filename;
// FILE *fp = fopen (pidfile_filename, "wb");
HCFILE fp;
// if (fp == NULL)
if (hc_fopen (&fp, pidfile_filename, "wb") == false)
{
event_log_error (hashcat_ctx, "%s: %s", pidfile_filename, strerror (errno));
@ -171,10 +166,8 @@ static int write_pidfile (hashcat_ctx_t *hashcat_ctx)
hc_fwrite (pd, sizeof (pidfile_data_t), 1, &fp);
// fflush (fp);
hc_fflush (&fp);
// fclose (fp);
hc_fclose (&fp);
return 0;

2
src/potfile.c
Unescape View File

@ -528,7 +528,7 @@ int potfile_remove_parse (hashcat_ctx_t *hashcat_ctx)
// workaround for new fgetl
HCFILE fp;
fp.is_gzip = false;
fp.f.fp = potfile_ctx->fp;
fp.pfp = potfile_ctx->fp;
while (!feof (potfile_ctx->fp))
{

20
src/restore.c
Unescape View File

@ -54,10 +54,8 @@ static int read_restore (hashcat_ctx_t *hashcat_ctx)
char *eff_restore_file = restore_ctx->eff_restore_file;
// FILE *fp = fopen (eff_restore_file, "rb");
HCFILE fp;
// if (fp == NULL)
if (hc_fopen (&fp, eff_restore_file, "rb") == false)
{
event_log_error (hashcat_ctx, "Restore file '%s': %s", eff_restore_file, strerror (errno));
@ -67,12 +65,10 @@ static int read_restore (hashcat_ctx_t *hashcat_ctx)
restore_data_t *rd = restore_ctx->rd;
// if (fread (rd, sizeof (restore_data_t), 1, fp) != 1)
if (hc_fread (rd, sizeof (restore_data_t), 1, &fp) != 1)
{
event_log_error (hashcat_ctx, "Cannot read %s", eff_restore_file);
// fclose (fp);
hc_fclose (&fp);
return -1;
@ -84,7 +80,6 @@ static int read_restore (hashcat_ctx_t *hashcat_ctx)
{
event_log_error (hashcat_ctx, "Unusually low number of arguments (argc) within restore file %s", eff_restore_file);
// fclose (fp);
hc_fclose (&fp);
return -1;
@ -94,7 +89,6 @@ static int read_restore (hashcat_ctx_t *hashcat_ctx)
{
event_log_error (hashcat_ctx, "Unusually high number of arguments (argc) within restore file %s", eff_restore_file);
// fclose (fp);
hc_fclose (&fp);
return -1;
@ -106,12 +100,10 @@ static int read_restore (hashcat_ctx_t *hashcat_ctx)
for (u32 i = 0; i < rd->argc; i++)
{
// if (fgets (buf, HCBUFSIZ_LARGE - 1, fp) == NULL)
if (hc_fgets (buf, HCBUFSIZ_LARGE - 1, &fp) == NULL)
{
event_log_error (hashcat_ctx, "Cannot read %s", eff_restore_file);
// fclose (fp);
hc_fclose (&fp);
return -1;
@ -126,7 +118,6 @@ static int read_restore (hashcat_ctx_t *hashcat_ctx)
hcfree (buf);
// fclose (fp);
hc_fclose (&fp);
if (hc_path_exist (rd->cwd) == false)
@ -212,10 +203,8 @@ static int write_restore (hashcat_ctx_t *hashcat_ctx)
char *new_restore_file = restore_ctx->new_restore_file;
// FILE *fp = fopen (new_restore_file, "wb");
HCFILE fp;
// if (fp == NULL)
if (hc_fopen (&fp, new_restore_file, "wb") == false)
{
event_log_error (hashcat_ctx, "%s: %s", new_restore_file, strerror (errno));
@ -225,12 +214,10 @@ static int write_restore (hashcat_ctx_t *hashcat_ctx)
fp.is_gzip = false;
// if (setvbuf (fp, NULL, _IONBF, 0))
if (setvbuf (fp.f.fp, NULL, _IONBF, 0))
if (setvbuf (fp.pfp, NULL, _IONBF, 0))
{
event_log_error (hashcat_ctx, "setvbuf file '%s': %s", new_restore_file, strerror (errno));
// fclose (fp);
hc_fclose (&fp);
return -1;
@ -240,20 +227,15 @@ static int write_restore (hashcat_ctx_t *hashcat_ctx)
for (u32 i = 0; i < rd->argc; i++)
{
// fprintf (fp, "%s", rd->argv[i]);
hc_fprintf (&fp, "%s", rd->argv[i]);
// fputc ('\n', fp);
hc_fputc ('\n', &fp);
}
// fflush (fp);
hc_fflush (&fp);
// fsync (fileno (fp));
fsync (hc_fileno (&fp));
// fclose (fp);
hc_fclose (&fp);
rd->masks_pos = 0;

79
src/shared.c
Unescape View File

@ -349,16 +349,12 @@ bool hc_path_has_bom (const char *path)
{
u8 buf[8] = { 0 };
// FILE *fp = fopen (path, "rb");
HCFILE fp;
// if (fp == NULL) return false;
if (hc_fopen (&fp, path, "rb") == false) return false;
// const size_t nread = fread (buf, 1, sizeof (buf), fp);
const size_t nread = hc_fread (buf, 1, sizeof (buf), &fp);
// fclose (fp);
hc_fclose (&fp);
if (nread < 1) return false;
@ -624,15 +620,15 @@ bool hc_fopen (HCFILE *fp, const char *path, char *mode)
{
fclose (fp_tmp);
if (!(fp->f.gfp = gzopen (path, mode))) return false;
if (!(fp->gfp = gzopen (path, mode))) return false;
fp->is_gzip = true;
}
else
{
fp->f.fp = fp_tmp;
fp->pfp = fp_tmp;
rewind (fp->f.fp);
rewind (fp->pfp);
}
fp->path = path;
@ -648,9 +644,9 @@ size_t hc_fread (void *ptr, size_t size, size_t nmemb, HCFILE *fp)
if (fp == NULL) return -1;
if (fp->is_gzip)
n = gzfread (ptr, size, nmemb, fp->f.gfp);
n = gzfread (ptr, size, nmemb, fp->gfp);
else
n = fread (ptr, size, nmemb, fp->f.fp);
n = fread (ptr, size, nmemb, fp->pfp);
return n;
}
@ -662,9 +658,9 @@ size_t hc_fwrite (void *ptr, size_t size, size_t nmemb, HCFILE *fp)
if (fp == NULL) return -1;
if (fp->is_gzip)
n = gzfwrite (ptr, size, nmemb, fp->f.gfp);
n = gzfwrite (ptr, size, nmemb, fp->gfp);
else
n = fwrite (ptr, size, nmemb, fp->f.fp);
n = fwrite (ptr, size, nmemb, fp->pfp);
if (n != nmemb) return -1;
@ -678,9 +674,9 @@ int hc_fseek (HCFILE *fp, off_t offset, int whence)
if (fp == NULL) return -1;
if (fp->is_gzip)
r = gzseek (fp->f.gfp, (z_off_t) offset, whence);
r = gzseek (fp->gfp, (z_off_t) offset, whence);
else
r = fseeko (fp->f.fp, offset, whence);
r = fseeko (fp->pfp, offset, whence);
return r;
}
@ -690,9 +686,9 @@ void hc_rewind (HCFILE *fp)
if (fp == NULL) return;
if (fp->is_gzip)
gzrewind (fp->f.gfp);
gzrewind (fp->gfp);
else
rewind (fp->f.fp);
rewind (fp->pfp);
}
off_t hc_ftell (HCFILE *fp)
@ -702,9 +698,9 @@ off_t hc_ftell (HCFILE *fp)
if (fp == NULL) return -1;
if (fp->is_gzip)
n = (off_t) gztell (fp->f.gfp);
n = (off_t) gztell (fp->gfp);
else
n = ftello (fp->f.fp);
n = ftello (fp->pfp);
return n;
}
@ -716,9 +712,9 @@ int hc_fputc (int c, HCFILE *fp)
if (fp == NULL) return -1;
if (fp->is_gzip)
r = gzputc (fp->f.gfp, c);
r = gzputc (fp->gfp, c);
else
r = fputc (c, fp->f.fp);
r = fputc (c, fp->pfp);
return r;
}
@ -730,9 +726,9 @@ int hc_fgetc (HCFILE *fp)
if (fp == NULL) return -1;
if (fp->is_gzip)
r = gzgetc (fp->f.gfp);
r = gzgetc (fp->gfp);
else
r = fgetc (fp->f.fp);
r = fgetc (fp->pfp);
return r;
}
@ -744,9 +740,9 @@ char *hc_fgets (char *buf, int len, HCFILE *fp)
if (fp == NULL) return NULL;
if (fp->is_gzip)
r = gzgets (fp->f.gfp, buf, len);
r = gzgets (fp->gfp, buf, len);
else
r = fgets (buf, len, fp->f.fp);
r = fgets (buf, len, fp->pfp);
return r;
}
@ -758,9 +754,9 @@ int hc_vfprintf (HCFILE *fp, const char *format, va_list ap)
if (fp == NULL) return -1;
if (fp->is_gzip)
r = gzvprintf (fp->f.gfp, format, ap);
r = gzvprintf (fp->gfp, format, ap);
else
r = vfprintf (fp->f.fp, format, ap);
r = vfprintf (fp->pfp, format, ap);
return r;
}
@ -775,9 +771,9 @@ int hc_fprintf (HCFILE *fp, const char *format, ...)
va_start (ap, format);
if (fp->is_gzip)
r = gzvprintf (fp->f.gfp, format, ap);
r = gzvprintf (fp->gfp, format, ap);
else
r = vfprintf (fp->f.fp, format, ap);
r = vfprintf (fp->pfp, format, ap);
va_end (ap);
@ -823,7 +819,7 @@ int hc_fileno (HCFILE *fp)
close (rdup);
}
else
r = fileno (fp->f.fp);
r = fileno (fp->pfp);
return r;
}
@ -835,9 +831,9 @@ int hc_feof (HCFILE *fp)
if (fp == NULL) return -1;
if (fp->is_gzip)
r = gzeof (fp->f.gfp);
r = gzeof (fp->gfp);
else
r = feof (fp->f.fp);
r = feof (fp->pfp);
return r;
}
@ -847,9 +843,9 @@ void hc_fflush (HCFILE *fp)
if (fp == NULL) return;
if (fp->is_gzip)
gzflush (fp->f.gfp, Z_SYNC_FLUSH);
gzflush (fp->gfp, Z_SYNC_FLUSH);
else
fflush (fp->f.fp);
fflush (fp->pfp);
}
void hc_fclose (HCFILE *fp)
@ -857,11 +853,11 @@ void hc_fclose (HCFILE *fp)
if (fp == NULL) return;
if (fp->is_gzip)
gzclose (fp->f.gfp);
gzclose (fp->gfp);
else
fclose (fp->f.fp);
fclose (fp->pfp);
fp->is_gzip = -1;
fp->is_gzip = false;
fp->path = NULL;
fp->mode = NULL;
@ -876,44 +872,31 @@ bool hc_same_files (char *file1, char *file2)
int do_check = 0;
// FILE *fp;
HCFILE fp;
// fp = fopen (file1, "r");
// if (fp)
if (hc_fopen (&fp, file1, "r") == true)
{
// if (fstat (fileno (fp), &tmpstat_file1))
if (fstat (hc_fileno (&fp), &tmpstat_file1))
{
// fclose (fp);
hc_fclose (&fp);
return false;
}
// fclose (fp);
hc_fclose (&fp);
do_check++;
}
// fp = fopen (file2, "r");
// if (fp)
if (hc_fopen (&fp, file2, "r") == true)
{
// if (fstat (fileno (fp), &tmpstat_file2))
if (fstat (hc_fileno (&fp), &tmpstat_file2))
{
// fclose (fp);
hc_fclose (&fp);
return false;
}
// fclose (fp);
hc_fclose (&fp);
do_check++;

16
src/stdout.c
Unescape View File

@ -63,21 +63,16 @@ int process_stdout (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param,
HCFILE fp_tmp;
fp_tmp.is_gzip = false;
fp_tmp.f.fp = stdout;
fp_tmp.pfp = stdout;
// out.fp = stdout;
out.fp = &fp_tmp;
/// PORKODIO
char *filename = outfile_ctx->filename;
if (filename)
{
// FILE *fp = fopen (filename, "ab");
HCFILE fp;
// if (fp == NULL)
if (hc_fopen (&fp, filename, "ab") == false)
{
event_log_error (hashcat_ctx, "%s: %s", filename, strerror (errno));
@ -87,10 +82,8 @@ int process_stdout (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param,
fp.is_gzip = false;
// if (lock_file (fp) == -1)
if (lock_file (fp.f.fp) == -1)
if (lock_file (fp.pfp) == -1)
{
// fclose (fp);
hc_fclose (&fp);
event_log_error (hashcat_ctx, "%s: %s", filename, strerror (errno));
@ -121,7 +114,6 @@ int process_stdout (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param,
if (rc == -1)
{
// if (filename) fclose (out.fp);
if (filename) hc_fclose (out.fp);
return -1;
@ -166,7 +158,6 @@ int process_stdout (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param,
if (rc == -1)
{
// if (filename) fclose (out.fp);
if (filename) hc_fclose (out.fp);
return -1;
@ -237,7 +228,6 @@ int process_stdout (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param,
if (rc == -1)
{
// if (filename) fclose (out.fp);
if (filename) hc_fclose (out.fp);
return -1;
@ -275,7 +265,6 @@ int process_stdout (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param,
if (rc == -1)
{
// if (filename) fclose (out.fp);
if (filename) hc_fclose (out.fp);
return -1;
@ -308,7 +297,6 @@ int process_stdout (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param,
out_flush (&out);
// if (filename) fclose (out.fp);
if (filename) hc_fclose (out.fp);
return 0;

Write Preview
Loading…
Cancel
Save