/* 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 */ #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 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((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 inline typename std::enable_if::type ptr_diff(const T *a, const U *b) { return ptr_diff_bytes(a, b); } template inline typename std::enable_if::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 using OwningPointer = T *; #define OwningPointer(T) OwningPointer #else // also works: a trivial class with just a number of no-ops template struct OwningPointer final { static_assert(std::is_class_v); // UPX convention typedef typename std::add_lvalue_reference::type reference; typedef typename std::add_lvalue_reference::type const_reference; typedef typename std::add_pointer::type pointer; typedef typename std::add_pointer::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 inline void mem_clear(OwningPointer object) noexcept { mem_clear((T *) object); } #define OwningPointer(T) OwningPointer #endif template inline void owner_delete(OwningPointer(T)(&object)) noexcept { static_assert(std::is_class_v); // UPX convention static_assert(std::is_nothrow_destructible_v); if (object != nullptr) { delete (T *) object; object = nullptr; } } // disable some overloads #if defined(__clang__) || __GNUC__ != 7 template inline void owner_delete(T (&array)[]) noexcept DELETED_FUNCTION; #endif template inline void owner_delete(T (&array)[N]) noexcept DELETED_FUNCTION; /************************************************************************* // TriBool - tri-state bool **************************************************************************/ template // an enum with an underlying type and 3 values class TriBool { public: // types typedef T underlying_type; static_assert(std::is_integral_v); typedef decltype(T(0) + T(0)) promoted_type; static_assert(std::is_integral_v); 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: */