mirror of
https://github.com/hashcat/hashcat.git
synced 2024-12-23 07:08:19 +00:00
308 lines
9.1 KiB
C++
308 lines
9.1 KiB
C++
/*
|
|
*
|
|
* Copyright (c) 1997
|
|
* Christian Michelsen Research AS
|
|
* Advanced Computing
|
|
* Fantoftvegen 38, 5036 BERGEN, Norway
|
|
* http://www.cmr.no
|
|
*
|
|
* Permission to use, copy, modify, distribute and sell this software
|
|
* and its documentation for any purpose is hereby granted without fee,
|
|
* provided that the above copyright notice appear in all copies and
|
|
* that both that copyright notice and this permission notice appear
|
|
* in supporting documentation. Christian Michelsen Research AS makes no
|
|
* representations about the suitability of this software for any
|
|
* purpose. It is provided "as is" without express or implied warranty.
|
|
*
|
|
*/
|
|
|
|
#ifndef ZSTREAM__H
|
|
#define ZSTREAM__H
|
|
|
|
/*
|
|
* zstream.h - C++ interface to the 'zlib' general purpose compression library
|
|
* $Id: zstream.h 1.1 1997-06-25 12:00:56+02 tyge Exp tyge $
|
|
*/
|
|
|
|
#include <strstream.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include "zlib.h"
|
|
|
|
#if defined(_WIN32)
|
|
# include <fcntl.h>
|
|
# include <io.h>
|
|
# define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
|
|
#else
|
|
# define SET_BINARY_MODE(file)
|
|
#endif
|
|
|
|
class zstringlen {
|
|
public:
|
|
zstringlen(class izstream&);
|
|
zstringlen(class ozstream&, const char*);
|
|
size_t value() const { return val.word; }
|
|
private:
|
|
struct Val { unsigned char byte; size_t word; } val;
|
|
};
|
|
|
|
// ----------------------------- izstream -----------------------------
|
|
|
|
class izstream
|
|
{
|
|
public:
|
|
izstream() : m_fp(0) {}
|
|
izstream(FILE* fp) : m_fp(0) { open(fp); }
|
|
izstream(const char* name) : m_fp(0) { open(name); }
|
|
~izstream() { close(); }
|
|
|
|
/* Opens a gzip (.gz) file for reading.
|
|
* open() can be used to read a file which is not in gzip format;
|
|
* in this case read() will directly read from the file without
|
|
* decompression. errno can be checked to distinguish two error
|
|
* cases (if errno is zero, the zlib error is Z_MEM_ERROR).
|
|
*/
|
|
void open(const char* name) {
|
|
if (m_fp) close();
|
|
m_fp = ::gzopen(name, "rb");
|
|
}
|
|
|
|
void open(FILE* fp) {
|
|
SET_BINARY_MODE(fp);
|
|
if (m_fp) close();
|
|
m_fp = ::gzdopen(fileno(fp), "rb");
|
|
}
|
|
|
|
/* Flushes all pending input if necessary, closes the compressed file
|
|
* and deallocates all the (de)compression state. The return value is
|
|
* the zlib error number (see function error() below).
|
|
*/
|
|
int close() {
|
|
int r = ::gzclose(m_fp);
|
|
m_fp = 0; return r;
|
|
}
|
|
|
|
/* Binary read the given number of bytes from the compressed file.
|
|
*/
|
|
int read(void* buf, size_t len) {
|
|
return ::gzread(m_fp, buf, len);
|
|
}
|
|
|
|
/* Returns the error message for the last error which occurred on the
|
|
* given compressed file. errnum is set to zlib error number. If an
|
|
* error occurred in the file system and not in the compression library,
|
|
* errnum is set to Z_ERRNO and the application may consult errno
|
|
* to get the exact error code.
|
|
*/
|
|
const char* error(int* errnum) {
|
|
return ::gzerror(m_fp, errnum);
|
|
}
|
|
|
|
gzFile fp() { return m_fp; }
|
|
|
|
private:
|
|
gzFile m_fp;
|
|
};
|
|
|
|
/*
|
|
* Binary read the given (array of) object(s) from the compressed file.
|
|
* If the input file was not in gzip format, read() copies the objects number
|
|
* of bytes into the buffer.
|
|
* returns the number of uncompressed bytes actually read
|
|
* (0 for end of file, -1 for error).
|
|
*/
|
|
template <class T, class Items>
|
|
inline int read(izstream& zs, T* x, Items items) {
|
|
return ::gzread(zs.fp(), x, items*sizeof(T));
|
|
}
|
|
|
|
/*
|
|
* Binary input with the '>' operator.
|
|
*/
|
|
template <class T>
|
|
inline izstream& operator>(izstream& zs, T& x) {
|
|
::gzread(zs.fp(), &x, sizeof(T));
|
|
return zs;
|
|
}
|
|
|
|
|
|
inline zstringlen::zstringlen(izstream& zs) {
|
|
zs > val.byte;
|
|
if (val.byte == 255) zs > val.word;
|
|
else val.word = val.byte;
|
|
}
|
|
|
|
/*
|
|
* Read length of string + the string with the '>' operator.
|
|
*/
|
|
inline izstream& operator>(izstream& zs, char* x) {
|
|
zstringlen len(zs);
|
|
::gzread(zs.fp(), x, len.value());
|
|
x[len.value()] = '\0';
|
|
return zs;
|
|
}
|
|
|
|
inline char* read_string(izstream& zs) {
|
|
zstringlen len(zs);
|
|
char* x = new char[len.value()+1];
|
|
::gzread(zs.fp(), x, len.value());
|
|
x[len.value()] = '\0';
|
|
return x;
|
|
}
|
|
|
|
// ----------------------------- ozstream -----------------------------
|
|
|
|
class ozstream
|
|
{
|
|
public:
|
|
ozstream() : m_fp(0), m_os(0) {
|
|
}
|
|
ozstream(FILE* fp, int level = Z_DEFAULT_COMPRESSION)
|
|
: m_fp(0), m_os(0) {
|
|
open(fp, level);
|
|
}
|
|
ozstream(const char* name, int level = Z_DEFAULT_COMPRESSION)
|
|
: m_fp(0), m_os(0) {
|
|
open(name, level);
|
|
}
|
|
~ozstream() {
|
|
close();
|
|
}
|
|
|
|
/* Opens a gzip (.gz) file for writing.
|
|
* The compression level parameter should be in 0..9
|
|
* errno can be checked to distinguish two error cases
|
|
* (if errno is zero, the zlib error is Z_MEM_ERROR).
|
|
*/
|
|
void open(const char* name, int level = Z_DEFAULT_COMPRESSION) {
|
|
char mode[4] = "wb\0";
|
|
if (level != Z_DEFAULT_COMPRESSION) mode[2] = '0'+level;
|
|
if (m_fp) close();
|
|
m_fp = ::gzopen(name, mode);
|
|
}
|
|
|
|
/* open from a FILE pointer.
|
|
*/
|
|
void open(FILE* fp, int level = Z_DEFAULT_COMPRESSION) {
|
|
SET_BINARY_MODE(fp);
|
|
char mode[4] = "wb\0";
|
|
if (level != Z_DEFAULT_COMPRESSION) mode[2] = '0'+level;
|
|
if (m_fp) close();
|
|
m_fp = ::gzdopen(fileno(fp), mode);
|
|
}
|
|
|
|
/* Flushes all pending output if necessary, closes the compressed file
|
|
* and deallocates all the (de)compression state. The return value is
|
|
* the zlib error number (see function error() below).
|
|
*/
|
|
int close() {
|
|
if (m_os) {
|
|
::gzwrite(m_fp, m_os->str(), m_os->pcount());
|
|
delete[] m_os->str(); delete m_os; m_os = 0;
|
|
}
|
|
int r = ::gzclose(m_fp); m_fp = 0; return r;
|
|
}
|
|
|
|
/* Binary write the given number of bytes into the compressed file.
|
|
*/
|
|
int write(const void* buf, size_t len) {
|
|
return ::gzwrite(m_fp, (voidp) buf, len);
|
|
}
|
|
|
|
/* Flushes all pending output into the compressed file. The parameter
|
|
* _flush is as in the deflate() function. The return value is the zlib
|
|
* error number (see function gzerror below). flush() returns Z_OK if
|
|
* the flush_ parameter is Z_FINISH and all output could be flushed.
|
|
* flush() should be called only when strictly necessary because it can
|
|
* degrade compression.
|
|
*/
|
|
int flush(int _flush) {
|
|
os_flush();
|
|
return ::gzflush(m_fp, _flush);
|
|
}
|
|
|
|
/* Returns the error message for the last error which occurred on the
|
|
* given compressed file. errnum is set to zlib error number. If an
|
|
* error occurred in the file system and not in the compression library,
|
|
* errnum is set to Z_ERRNO and the application may consult errno
|
|
* to get the exact error code.
|
|
*/
|
|
const char* error(int* errnum) {
|
|
return ::gzerror(m_fp, errnum);
|
|
}
|
|
|
|
gzFile fp() { return m_fp; }
|
|
|
|
ostream& os() {
|
|
if (m_os == 0) m_os = new ostrstream;
|
|
return *m_os;
|
|
}
|
|
|
|
void os_flush() {
|
|
if (m_os && m_os->pcount()>0) {
|
|
ostrstream* oss = new ostrstream;
|
|
oss->fill(m_os->fill());
|
|
oss->flags(m_os->flags());
|
|
oss->precision(m_os->precision());
|
|
oss->width(m_os->width());
|
|
::gzwrite(m_fp, m_os->str(), m_os->pcount());
|
|
delete[] m_os->str(); delete m_os; m_os = oss;
|
|
}
|
|
}
|
|
|
|
private:
|
|
gzFile m_fp;
|
|
ostrstream* m_os;
|
|
};
|
|
|
|
/*
|
|
* Binary write the given (array of) object(s) into the compressed file.
|
|
* returns the number of uncompressed bytes actually written
|
|
* (0 in case of error).
|
|
*/
|
|
template <class T, class Items>
|
|
inline int write(ozstream& zs, const T* x, Items items) {
|
|
return ::gzwrite(zs.fp(), (voidp) x, items*sizeof(T));
|
|
}
|
|
|
|
/*
|
|
* Binary output with the '<' operator.
|
|
*/
|
|
template <class T>
|
|
inline ozstream& operator<(ozstream& zs, const T& x) {
|
|
::gzwrite(zs.fp(), (voidp) &x, sizeof(T));
|
|
return zs;
|
|
}
|
|
|
|
inline zstringlen::zstringlen(ozstream& zs, const char* x) {
|
|
val.byte = 255; val.word = ::strlen(x);
|
|
if (val.word < 255) zs < (val.byte = val.word);
|
|
else zs < val;
|
|
}
|
|
|
|
/*
|
|
* Write length of string + the string with the '<' operator.
|
|
*/
|
|
inline ozstream& operator<(ozstream& zs, const char* x) {
|
|
zstringlen len(zs, x);
|
|
::gzwrite(zs.fp(), (voidp) x, len.value());
|
|
return zs;
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
inline ozstream& operator<(ozstream& zs, char* const& x) {
|
|
return zs < (const char*) x;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Ascii write with the << operator;
|
|
*/
|
|
template <class T>
|
|
inline ostream& operator<<(ozstream& zs, const T& x) {
|
|
zs.os_flush();
|
|
return zs.os() << x;
|
|
}
|
|
|
|
#endif
|