Markus F.X.J. Oberhumer
269 lines
11 KiB
C++
269 lines
11 KiB
C++
/* util.h --
|
|
|
|
This file is part of the UPX executable compressor.
|
|
|
|
Copyright (C) 1996-2023 Markus Franz Xaver Johannes Oberhumer
|
|
Copyright (C) 1996-2023 Laszlo Molnar
|
|
All Rights Reserved.
|
|
|
|
UPX and the UCL library are free software; you can redistribute them
|
|
and/or modify them under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation; either version 2 of
|
|
the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; see the file COPYING.
|
|
If not, write to the Free Software Foundation, Inc.,
|
|
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
Markus F.X.J. Oberhumer Laszlo Molnar
|
|
<markus@oberhumer.com> <ezerotven+github@gmail.com>
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
/*************************************************************************
|
|
// assert sane memory buffer sizes to protect against integer overflows
|
|
// and malicious header fields
|
|
// see C 11 standard, Annex K
|
|
**************************************************************************/
|
|
|
|
inline bool mem_size_valid_bytes(upx_uint64_t bytes) noexcept { return bytes <= UPX_RSIZE_MAX; }
|
|
|
|
bool mem_size_valid(upx_uint64_t element_size, upx_uint64_t n, upx_uint64_t extra1 = 0,
|
|
upx_uint64_t extra2 = 0) noexcept;
|
|
|
|
// will throw on invalid size
|
|
upx_rsize_t mem_size(upx_uint64_t element_size, upx_uint64_t n, upx_uint64_t extra1,
|
|
upx_uint64_t extra2 = 0);
|
|
|
|
//
|
|
// inline fast paths:
|
|
//
|
|
|
|
// will throw on invalid size
|
|
inline upx_rsize_t mem_size(upx_uint64_t element_size, upx_uint64_t n) {
|
|
upx_uint64_t bytes = element_size * n;
|
|
if very_unlikely (element_size == 0 || element_size > UPX_RSIZE_MAX || n > UPX_RSIZE_MAX ||
|
|
bytes > UPX_RSIZE_MAX)
|
|
return mem_size(element_size, n, 0, 0); // this will throw
|
|
return ACC_ICONV(upx_rsize_t, bytes);
|
|
}
|
|
|
|
// will throw on invalid size
|
|
inline upx_rsize_t mem_size_get_n(upx_uint64_t element_size, upx_uint64_t n) {
|
|
(void) mem_size(element_size, n); // assert size
|
|
return ACC_ICONV(upx_rsize_t, n); // and return n
|
|
}
|
|
|
|
// will throw on invalid size
|
|
inline void mem_size_assert(upx_uint64_t element_size, upx_uint64_t n) {
|
|
(void) mem_size(element_size, n); // assert size
|
|
}
|
|
|
|
// "new" with asserted size; will throw on invalid size
|
|
#if DEBUG
|
|
template <class T>
|
|
T *NewArray(upx_uint64_t n) {
|
|
size_t bytes = mem_size(sizeof(T), n); // assert size
|
|
T *array = new T[size_t(n)];
|
|
if (array != nullptr && bytes > 0) {
|
|
memset(array, 0xfb, bytes);
|
|
(void) VALGRIND_MAKE_MEM_UNDEFINED(array, bytes);
|
|
}
|
|
return array;
|
|
}
|
|
#define New(type, n) (NewArray<type>((n)))
|
|
#else
|
|
#define New(type, n) new type[mem_size_get_n(sizeof(type), (n))]
|
|
#endif
|
|
|
|
/*************************************************************************
|
|
// ptr util
|
|
**************************************************************************/
|
|
|
|
// ptrdiff_t with nullptr checks and asserted size; will throw on failure
|
|
// NOTE: returns size_in_bytes, not number of elements!
|
|
int ptr_diff_bytes(const void *a, const void *b);
|
|
unsigned ptr_udiff_bytes(const void *a, const void *b); // asserts a >= b
|
|
|
|
// short names "ptr_diff" and "ptr_udiff" for types with sizeof(X) == 1
|
|
template <class T, class U>
|
|
inline typename std::enable_if<sizeof(T) == 1 && sizeof(U) == 1, int>::type ptr_diff(const T *a,
|
|
const U *b) {
|
|
return ptr_diff_bytes(a, b);
|
|
}
|
|
template <class T, class U>
|
|
inline typename std::enable_if<sizeof(T) == 1 && sizeof(U) == 1, unsigned>::type
|
|
ptr_udiff(const T *a, const U *b) {
|
|
return ptr_udiff_bytes(a, b);
|
|
}
|
|
|
|
// check that buffers do not overlap; will throw on error
|
|
noinline void uintptr_check_no_overlap(upx_uintptr_t a, size_t a_size, upx_uintptr_t b,
|
|
size_t b_size);
|
|
noinline void uintptr_check_no_overlap(upx_uintptr_t a, size_t a_size, upx_uintptr_t b,
|
|
size_t b_size, upx_uintptr_t c, size_t c_size);
|
|
|
|
forceinline void ptr_check_no_overlap(const void *a, size_t a_size, const void *b, size_t b_size) {
|
|
uintptr_check_no_overlap((upx_uintptr_t) a, a_size, (upx_uintptr_t) b, b_size);
|
|
}
|
|
forceinline void ptr_check_no_overlap(const void *a, size_t a_size, const void *b, size_t b_size,
|
|
const void *c, size_t c_size) {
|
|
uintptr_check_no_overlap((upx_uintptr_t) a, a_size, (upx_uintptr_t) b, b_size,
|
|
(upx_uintptr_t) c, c_size);
|
|
}
|
|
|
|
/*************************************************************************
|
|
// stdlib
|
|
**************************************************************************/
|
|
|
|
void *upx_calloc(size_t n, size_t element_size);
|
|
|
|
void upx_memswap(void *a, void *b, size_t n);
|
|
|
|
void upx_stable_sort(void *array, size_t n, size_t element_size,
|
|
int (*compare)(const void *, const void *));
|
|
|
|
/*************************************************************************
|
|
// OwningPointer(T)
|
|
// simple pointer type alias to explicitly mark ownership of objects; purely
|
|
// cosmetic to improve source code readability, no real functionality
|
|
**************************************************************************/
|
|
|
|
#if 0
|
|
|
|
// this works
|
|
#define OwningPointer(T) T *
|
|
|
|
#elif !(DEBUG)
|
|
|
|
// this also works
|
|
template <class T>
|
|
using OwningPointer = T *;
|
|
#define OwningPointer(T) OwningPointer<T>
|
|
|
|
#else
|
|
|
|
// also works: a trivial class with just a number of no-ops
|
|
template <class T>
|
|
struct OwningPointer final {
|
|
static_assert(std::is_class_v<T>); // UPX convention
|
|
typedef typename std::add_lvalue_reference<T>::type reference;
|
|
typedef typename std::add_lvalue_reference<const T>::type const_reference;
|
|
typedef typename std::add_pointer<T>::type pointer;
|
|
typedef typename std::add_pointer<const T>::type const_pointer;
|
|
pointer ptr;
|
|
inline OwningPointer(pointer p) noexcept : ptr(p) {}
|
|
inline operator pointer() noexcept { return ptr; }
|
|
inline operator const_pointer() const noexcept { return ptr; }
|
|
inline reference operator*() noexcept { return *ptr; }
|
|
inline const_reference operator*() const noexcept { return *ptr; }
|
|
inline pointer operator->() noexcept { return ptr; }
|
|
inline const_pointer operator->() const noexcept { return ptr; }
|
|
};
|
|
// must overload mem_clear()
|
|
template <class T>
|
|
inline void mem_clear(OwningPointer<T> object) noexcept {
|
|
mem_clear((T *) object);
|
|
}
|
|
#define OwningPointer(T) OwningPointer<T>
|
|
|
|
#endif
|
|
|
|
template <class T>
|
|
inline void owner_delete(OwningPointer(T)(&object)) noexcept {
|
|
static_assert(std::is_class_v<T>); // UPX convention
|
|
static_assert(std::is_nothrow_destructible_v<T>);
|
|
if (object != nullptr) {
|
|
delete (T *) object;
|
|
object = nullptr;
|
|
}
|
|
}
|
|
|
|
// disable some overloads
|
|
#if defined(__clang__) || __GNUC__ != 7
|
|
template <class T>
|
|
inline void owner_delete(T (&array)[]) noexcept DELETED_FUNCTION;
|
|
#endif
|
|
template <class T, size_t N>
|
|
inline void owner_delete(T (&array)[N]) noexcept DELETED_FUNCTION;
|
|
|
|
/*************************************************************************
|
|
// TriBool - tri-state bool
|
|
**************************************************************************/
|
|
|
|
template <class T = int, T TOther = -1> // an enum with an underlying type and 3 values
|
|
class TriBool {
|
|
public:
|
|
// types
|
|
typedef T underlying_type;
|
|
static_assert(std::is_integral_v<underlying_type>);
|
|
typedef decltype(T(0) + T(0)) promoted_type;
|
|
static_assert(std::is_integral_v<promoted_type>);
|
|
static_assert(TOther != 0 && TOther != 1);
|
|
enum value_type : underlying_type { False = 0, True = 1, Other = TOther };
|
|
// constructors
|
|
forceinline constexpr TriBool() noexcept = default;
|
|
forceinline ~TriBool() noexcept = default;
|
|
constexpr TriBool(value_type x) noexcept : value(x) {}
|
|
constexpr TriBool(promoted_type x) noexcept : value(x == 0 ? False : (x == 1 ? True : Other)) {}
|
|
// access
|
|
constexpr value_type getValue() const noexcept { return value; }
|
|
// checks for > 0, so TOther determines if Other is false (the default) or true
|
|
explicit constexpr operator bool() const noexcept { return value > False; }
|
|
// query; this is NOT the same as operator bool()
|
|
constexpr bool isStrictFalse() const noexcept { return value == False; }
|
|
constexpr bool isStrictTrue() const noexcept { return value == True; }
|
|
constexpr bool isStrictBool() const noexcept { return value == False || value == True; }
|
|
constexpr bool isOther() const noexcept { return value != False && value != True; }
|
|
// "other" can mean many things, depending on usage context, so provide some alternative names:
|
|
// constexpr bool isDefault() const noexcept { return isOther(); } // might be misleading
|
|
constexpr bool isIndeterminate() const noexcept { return isOther(); }
|
|
constexpr bool isUndecided() const noexcept { return isOther(); }
|
|
// constexpr bool isUnset() const noexcept { return isOther(); } // might be misleading
|
|
constexpr bool operator==(TriBool other) const noexcept { return value == other.value; }
|
|
constexpr bool operator==(value_type other) const noexcept { return value == other; }
|
|
constexpr bool operator==(promoted_type other) const noexcept { return value == other; }
|
|
protected:
|
|
// value
|
|
value_type value = False;
|
|
};
|
|
|
|
typedef TriBool<> tribool;
|
|
|
|
/*************************************************************************
|
|
// misc. support functions
|
|
**************************************************************************/
|
|
|
|
int find(const void *b, int blen, const void *what, int wlen) noexcept;
|
|
int find_be16(const void *b, int blen, unsigned what) noexcept;
|
|
int find_be32(const void *b, int blen, unsigned what) noexcept;
|
|
int find_be64(const void *b, int blen, upx_uint64_t what) noexcept;
|
|
int find_le16(const void *b, int blen, unsigned what) noexcept;
|
|
int find_le32(const void *b, int blen, unsigned what) noexcept;
|
|
int find_le64(const void *b, int blen, upx_uint64_t what) noexcept;
|
|
|
|
int mem_replace(void *b, int blen, const void *what, int wlen, const void *r) noexcept;
|
|
|
|
char *fn_basename(const char *name);
|
|
int fn_strcmp(const char *n1, const char *n2);
|
|
char *fn_strlwr(char *n);
|
|
bool fn_has_ext(const char *name, const char *ext, bool ignore_case = true);
|
|
|
|
bool file_exists(const char *name);
|
|
bool maketempname(char *ofilename, size_t size, const char *ifilename, const char *ext,
|
|
bool force = true);
|
|
bool makebakname(char *ofilename, size_t size, const char *ifilename, bool force = true);
|
|
|
|
unsigned get_ratio(upx_uint64_t u_len, upx_uint64_t c_len);
|
|
bool set_method_name(char *buf, size_t size, int method, int level);
|
|
void center_string(char *buf, size_t size, const char *s);
|
|
|
|
/* vim:set ts=4 sw=4 et: */
|