diff options
37 files changed, 5625 insertions, 455 deletions
diff --git a/.drone.yml b/.drone.yml index c7e10cdbc..f2221908b 100644 --- a/.drone.yml +++ b/.drone.yml @@ -41,7 +41,7 @@ steps: -DENABLE_LIBUNWIND=ON -DENABLE_HYPERSCAN=ON -GNinja - $CI_WORKSPACE + $DRONE_WORKSPACE - ncpu=$(getconf _NPROCESSORS_ONLN) - ninja -j $ncpu install - ninja -j $ncpu rspamd-test @@ -72,7 +72,7 @@ steps: -DENABLE_FULL_DEBUG=ON -DENABLE_HYPERSCAN=ON -DSANITIZE=address - $CI_WORKSPACE + $DRONE_WORKSPACE - ncpu=$(getconf _NPROCESSORS_ONLN) - make -j $ncpu install - make -j $ncpu rspamd-test @@ -185,12 +185,12 @@ steps: # use umask to create world-writable files so nobody can write to *.gcda files created by root - umask 0000 - set +e - - RSPAMD_INSTALLROOT=/rspamd/install robot --removekeywords wuks --exclude isbroken $CI_WORKSPACE/test/functional/cases; EXIT_CODE=$? + - RSPAMD_INSTALLROOT=/rspamd/install robot --removekeywords wuks --exclude isbroken $DRONE_WORKSPACE/test/functional/cases; EXIT_CODE=$? - set -e # upload test results to nginx frontent using WebDAV PUT - > if [ -n "$HTTP_PUT_AUTH" ]; then - $CI_WORKSPACE/test/tools/http_put.py log.html report.html https://$DRONE_SYSTEM_HOSTNAME/testlogs/$DRONE_REPO/$DRONE_BUILD_NUMBER/; + $DRONE_WORKSPACE/test/tools/http_put.py log.html report.html https://$DRONE_SYSTEM_HOSTNAME/testlogs/$DRONE_REPO/$DRONE_BUILD_NUMBER/; fi # core_pattern=/var/tmp/%u.%e.core so one or two cores can be saved for each binary - core_files=$(find /var/tmp/ -name '*.core') @@ -216,7 +216,7 @@ steps: commands: - cd /rspamd/build # extract coverage data for C code from .gcda files and save it in a format suitable for coveralls.io - - $CI_WORKSPACE/test/tools/gcov_coveralls.py --exclude test --prefix /rspamd/build --prefix $CI_WORKSPACE --out coverage.c.json + - $DRONE_WORKSPACE/test/tools/gcov_coveralls.py --exclude test --prefix /rspamd/build --prefix $DRONE_WORKSPACE --out coverage.c.json # luacov-coveralls reads luacov.stats.out generated by functional tests # (see collect_lua_coverage() in test/functional/lib/rspamd.py) # and writes json report for coveralls.io @@ -224,7 +224,7 @@ steps: # * merge coverage for C and Lua code # * remove prefixes from absolute paths (in luacov-coveralls files), filter test, contrib, e. t.c # * upload report to coveralls.io - - $CI_WORKSPACE/test/tools/merge_coveralls.py --root $CI_WORKSPACE --input coverage.c.json unit_test_lua.json coverage.functional.lua.json --token=$COVERALLS_REPO_TOKEN + - $DRONE_WORKSPACE/test/tools/merge_coveralls.py --root $DRONE_WORKSPACE --input coverage.c.json unit_test_lua.json coverage.functional.lua.json --token=$COVERALLS_REPO_TOKEN environment: COVERALLS_REPO_TOKEN: { from_secret: coveralls_repo_token } when: @@ -283,6 +283,6 @@ trigger: --- kind: signature -hmac: f872f03e58aa40d039377909ef889f867b77d82cdd8b87b398096e3a1e954a24 +hmac: 13670c504d29a1249b3a06c171016f14377e3c74101935bc23f6c542036562df ... diff --git a/CMakeLists.txt b/CMakeLists.txt index d3db35b20..af30d351b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -9,17 +9,19 @@ CMAKE_MINIMUM_REQUIRED(VERSION 3.12 FATAL_ERROR) SET(RSPAMD_VERSION_MAJOR 3) SET(RSPAMD_VERSION_MINOR 7) +SET(RSPAMD_VERSION_PATCH 0) # Keep two digits all the time SET(RSPAMD_VERSION_MAJOR_NUM ${RSPAMD_VERSION_MAJOR}0) SET(RSPAMD_VERSION_MINOR_NUM ${RSPAMD_VERSION_MINOR}0) +SET(RSPAMD_VERSION_PATCH_NUM ${RSPAMD_VERSION_PATCH}0) IF (GIT_ID) SET(GIT_VERSION 1) SET(RSPAMD_ID "${GIT_ID}") ENDIF () -SET(RSPAMD_VERSION "${RSPAMD_VERSION_MAJOR}.${RSPAMD_VERSION_MINOR}") +SET(RSPAMD_VERSION "${RSPAMD_VERSION_MAJOR}.${RSPAMD_VERSION_MINOR}.${RSPAMD_VERSION_PATCH}") PROJECT(rspamd VERSION "${RSPAMD_VERSION}" LANGUAGES C CXX ASM) @@ -54,7 +56,7 @@ OPTION(ENABLE_CLANG_PLUGIN "Enable clang static analysing plugin [default: OFF]" OPTION(ENABLE_PCRE2 "Enable pcre2 instead of pcre [default: ON]" ON) OPTION(ENABLE_JEMALLOC "Build rspamd with jemalloc allocator [default: OFF]" OFF) OPTION(ENABLE_UTILS "Build rspamd internal utils [default: OFF]" OFF) -OPTION(ENABLE_LIBUNWIND "Use libunwind to print crash traces [default: OFF]" OFF) +OPTION(ENABLE_LIBUNWIND "Obsoleted [default: OFF]" OFF) OPTION(ENABLE_LUA_TRACE "Trace all Lua C API invocations [default: OFF]" OFF) OPTION(ENABLE_LUA_REPL "Enables Lua repl (requires C++11 compiler) [default: ON]" ON) OPTION(ENABLE_FASTTEXT "Link with FastText library [default: OFF]" OFF) @@ -206,14 +208,6 @@ IF (ENABLE_JEMALLOC MATCHES "ON" AND NOT SANITIZE) SET(WITH_JEMALLOC "1") ENDIF () -IF (ENABLE_LIBUNWIND MATCHES "ON") - ProcessPackage(LIBUNWIND LIBRARY unwind INCLUDE libunwind.h INCLUDE_SUFFIXES include/libunwind - ROOT ${LIBUNWIND_ROOT_DIR} MODULES libunwind) - SET(WITH_LIBUNWIND "1") -ELSE () - CHECK_SYMBOL_EXISTS(backtrace "execinfo.h" HAVE_BACKTRACE) -ENDIF () - ProcessPackage(GLIB2 LIBRARY glib-2.0 INCLUDE glib.h INCLUDE_SUFFIXES include/glib include/glib-2.0 ROOT ${GLIB_ROOT_DIR} MODULES glib-2.0>=2.28) @@ -631,6 +625,12 @@ ADD_SUBDIRECTORY(contrib/libev) ADD_SUBDIRECTORY(contrib/kann) ADD_SUBDIRECTORY(contrib/fastutf8) ADD_SUBDIRECTORY(contrib/google-ced) +ADD_SUBDIRECTORY(contrib/backward-cpp) +message(STATUS "Backward-cpp config: ${BACKWARD_DEFINITIONS}") +if (BACKWARD_LIBRARIES) + message(STATUS "Backward-cpp libraries: ${BACKWARD_LIBRARIES}") +endif() + IF (SYSTEM_FMT MATCHES "OFF") INCLUDE_DIRECTORIES("${CMAKE_SOURCE_DIR}/contrib/fmt/include") ELSE () diff --git a/config.h.in b/config.h.in index 44dc3cdf3..59c70c67c 100644 --- a/config.h.in +++ b/config.h.in @@ -52,10 +52,8 @@ #cmakedefine HAVE_PATH_MAX 1 /* OSX has broken JIT support in PCRE, disable it */ -#ifndef __APPLE__ #cmakedefine HAVE_PCRE_JIT 1 #cmakedefine HAVE_PCRE_JIT_FAST 1 -#endif #cmakedefine HAVE_PIDFILE 1 #cmakedefine HAVE_PIDFILE_FILENO 1 @@ -113,11 +111,10 @@ #cmakedefine WITH_PCRE2 1 #cmakedefine WITH_SNOWBALL 1 #cmakedefine WITH_SQLITE 1 -#cmakedefine WITH_LIBUNWIND 1 #cmakedefine WITH_LUA_TRACE 1 #cmakedefine WITH_LUA_REPL 1 #cmakedefine WITH_FASTTEXT 1 -#cmakedefine HAVE_BACKTRACE 1 +#cmakedefine BACKWARD_ENABLE 1 #cmakedefine DISABLE_PTHREAD_MUTEX 1 @@ -188,9 +185,11 @@ #define RSPAMD_VERSION_MAJOR "${RSPAMD_VERSION_MAJOR}" #define RSPAMD_VERSION_MINOR "${RSPAMD_VERSION_MINOR}" +#define RSPAMD_VERSION_PATCH "${RSPAMD_VERSION_PATCH}" #define RSPAMD_VERSION_MAJOR_NUM ${RSPAMD_VERSION_MAJOR_NUM} #define RSPAMD_VERSION_MINOR_NUM ${RSPAMD_VERSION_MINOR_NUM} +#define RSPAMD_VERSION_PATCH_NUM ${RSPAMD_VERSION_PATCH_NUM} #define RSPAMD_VERSION_BRANCH "${RSPAMD_VERSION_MAJOR}" diff --git a/contrib/DEPENDENCY_INFO.md b/contrib/DEPENDENCY_INFO.md index 4b3f8cb1c..3fdf29a3d 100644 --- a/contrib/DEPENDENCY_INFO.md +++ b/contrib/DEPENDENCY_INFO.md @@ -1,39 +1,41 @@ # Rspamd Dependency Info -| Name | Version | License | Patched | Notes | -|------------------------|---------|---------------------| --- | --- | -| aho-corasick | ? | LGPL-3.0 | YES | lowercase support | -| cdb | 1.1.0 | Public Domain / CC0 | NO | | -| hiredis | 0.13.3 | BSD-3-Clause | YES | many changes | -| libev | 4.33 | BSD-2-Clause | YES | many changes | -| lc-btrie | ? | BSD-3-Clause | YES | mempool support | -| libottery | ? | Public Domain / CC0 | YES | many changes | -| librdns | ? | BSD-2-Clause | YES | | -| libucl | ? | BSD-2-Clause | YES | | -| replxx | 6d93360 | BSD-2-Clause | YES | libicu usage | -| lua-argparse | 0.7.1 | MIT | NO | | -| lua-bit | 1.0.2 | MIT | YES | build fixes | -| lua-fun | ? | MIT | YES | rspamd text | -| lua-lpeg | 1.0 | MIT | YES | rspamd text + alloc| -| lua-moses | ? | MIT | NO | | -| lua-lupa | ? | MIT | NO | | -| lua-tableshape | 2.6.0 | MIT | NO | | -| mumhash | ? | MIT | NO | | -| ngx-http-parser | 2.2.0 | MIT | YES | spamc support | -| Mozilla-PublicSuffix | ? | MIT | NO | | -| snowball | ? | BSD-3-Clause | NO | | -| t1ha | ? | Zlib | NO | | -| uthash | 1.9.8 | BSD | YES | | -| xxhash | 0.8.1 | BSD | NO | | -| zstd | 1.5.4 | BSD | YES | build fixes only | -| google-ced | 37529e6 | Apache 2 | YES | build fixes | -| kann | ? | MIT | YES | blas/lapack changes| -| fpconv | ? | Boost | YES | many changes | -| fastutf8 | ? | MIT | YES | many changes | -| expected | v1.0 | Public Domain / CC0 | NO | | -| frozen | 1.0.1 | Apache 2 | NO | | -| fmt | 10.0.0 | MIT | NO | | -| doctest | 2.4.6 | MIT | NO | | -| function2 | 4.1.0 | Boost | NO | | -| ankerl/svector | 1.0.2 | MIT | NO | | -| ankerl/unordered_dense | 2.0.1 | MIT | NO | | +| Name | Version | License | Patched | Notes | +|------------------------|---------|---------------------|---------|---------------------| +| aho-corasick | ? | LGPL-3.0 | YES | lowercase support | +| cdb | 1.1.0 | Public Domain / CC0 | NO | | +| hiredis | 0.13.3 | BSD-3-Clause | YES | many changes | +| libev | 4.33 | BSD-2-Clause | YES | many changes | +| lc-btrie | ? | BSD-3-Clause | YES | mempool support | +| libottery | ? | Public Domain / CC0 | YES | many changes | +| librdns | ? | BSD-2-Clause | YES | | +| libucl | ? | BSD-2-Clause | YES | | +| replxx | 6d93360 | BSD-2-Clause | YES | libicu usage | +| lua-argparse | 0.7.1 | MIT | NO | | +| lua-bit | 1.0.2 | MIT | YES | build fixes | +| lua-fun | ? | MIT | YES | rspamd text | +| lua-lpeg | 1.0 | MIT | YES | rspamd text + alloc | +| lua-moses | ? | MIT | NO | | +| lua-lupa | ? | MIT | NO | | +| lua-tableshape | 2.6.0 | MIT | NO | | +| mumhash | ? | MIT | NO | | +| ngx-http-parser | 2.2.0 | MIT | YES | spamc support | +| Mozilla-PublicSuffix | ? | MIT | NO | | +| snowball | ? | BSD-3-Clause | NO | | +| t1ha | ? | Zlib | NO | | +| uthash | 1.9.8 | BSD | YES | | +| xxhash | 0.8.1 | BSD | NO | | +| zstd | 1.5.4 | BSD | YES | build fixes only | +| google-ced | 37529e6 | Apache 2 | YES | build fixes | +| kann | ? | MIT | YES | blas/lapack changes | +| fpconv | ? | Boost | YES | many changes | +| fastutf8 | ? | MIT | YES | many changes | +| expected | v1.0 | Public Domain / CC0 | NO | | +| frozen | 1.0.1 | Apache 2 | NO | | +| fmt | 10.0.0 | MIT | NO | | +| doctest | 2.4.6 | MIT | NO | | +| function2 | 4.1.0 | Boost | NO | | +| ankerl/svector | 1.0.2 | MIT | NO | | +| ankerl/unordered_dense | 2.0.1 | MIT | NO | | +| backward-cpp | 1.6 | MIT | NO | | + diff --git a/contrib/backward-cpp/BackwardConfig.cmake b/contrib/backward-cpp/BackwardConfig.cmake new file mode 100644 index 000000000..e04e3facb --- /dev/null +++ b/contrib/backward-cpp/BackwardConfig.cmake @@ -0,0 +1,247 @@ +# +# BackwardMacros.cmake +# Copyright 2013 Google Inc. All Rights Reserved. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +############################################################################### +# OPTIONS +############################################################################### + +set(STACK_WALKING_UNWIND TRUE CACHE BOOL + "Use compiler's unwind API") +set(STACK_WALKING_BACKTRACE FALSE CACHE BOOL + "Use backtrace from (e)glibc for stack walking") +set(STACK_WALKING_LIBUNWIND FALSE CACHE BOOL + "Use libunwind for stack walking") + +set(STACK_DETAILS_AUTO_DETECT TRUE CACHE BOOL + "Auto detect backward's stack details dependencies") + +set(STACK_DETAILS_BACKTRACE_SYMBOL FALSE CACHE BOOL + "Use backtrace from (e)glibc for symbols resolution") +set(STACK_DETAILS_DW FALSE CACHE BOOL + "Use libdw to read debug info") +set(STACK_DETAILS_BFD FALSE CACHE BOOL + "Use libbfd to read debug info") +set(STACK_DETAILS_DWARF FALSE CACHE BOOL + "Use libdwarf/libelf to read debug info") + +if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR AND NOT DEFINED BACKWARD_TESTS) + # If this is a top level CMake project, we most lixely want the tests + set(BACKWARD_TESTS ON CACHE BOOL "Enable tests") +else() + set(BACKWARD_TESTS OFF CACHE BOOL "Enable tests") +endif() +############################################################################### +# CONFIGS +############################################################################### +include(FindPackageHandleStandardArgs) + +if (STACK_WALKING_LIBUNWIND) + # libunwind works on the macOS without having to add special include + # paths or libraries + if (NOT APPLE) + find_path(LIBUNWIND_INCLUDE_DIR NAMES "libunwind.h") + find_library(LIBUNWIND_LIBRARY unwind) + + if (LIBUNWIND_LIBRARY) + include(CheckSymbolExists) + check_symbol_exists(UNW_INIT_SIGNAL_FRAME libunwind.h HAVE_UNW_INIT_SIGNAL_FRAME) + if (NOT HAVE_UNW_INIT_SIGNAL_FRAME) + message(STATUS "libunwind does not support unwinding from signal handler frames") + endif() + endif() + + set(LIBUNWIND_INCLUDE_DIRS ${LIBUNWIND_INCLUDE_DIR}) + set(LIBDWARF_LIBRARIES ${LIBUNWIND_LIBRARY}) + find_package_handle_standard_args(libunwind DEFAULT_MSG + LIBUNWIND_LIBRARY LIBUNWIND_INCLUDE_DIR) + mark_as_advanced(LIBUNWIND_INCLUDE_DIR LIBUNWIND_LIBRARY) + list(APPEND _BACKWARD_LIBRARIES ${LIBUNWIND_LIBRARY}) + endif() + + # Disable other unwinders if libunwind is found + set(STACK_WALKING_UNWIND FALSE) + set(STACK_WALKING_BACKTRACE FALSE) +endif() + +if (${STACK_DETAILS_AUTO_DETECT}) + if(NOT CMAKE_VERSION VERSION_LESS 3.17) + set(_name_mismatched_arg NAME_MISMATCHED) + endif() + # find libdw + find_path(LIBDW_INCLUDE_DIR NAMES "elfutils/libdw.h" "elfutils/libdwfl.h") + find_library(LIBDW_LIBRARY dw) + set(LIBDW_INCLUDE_DIRS ${LIBDW_INCLUDE_DIR} ) + set(LIBDW_LIBRARIES ${LIBDW_LIBRARY} ) + find_package_handle_standard_args(libdw ${_name_mismatched_arg} + REQUIRED_VARS LIBDW_LIBRARY LIBDW_INCLUDE_DIR) + mark_as_advanced(LIBDW_INCLUDE_DIR LIBDW_LIBRARY) + + # find libbfd + find_path(LIBBFD_INCLUDE_DIR NAMES "bfd.h") + find_path(LIBDL_INCLUDE_DIR NAMES "dlfcn.h") + find_library(LIBBFD_LIBRARY bfd) + find_library(LIBDL_LIBRARY dl) + set(LIBBFD_INCLUDE_DIRS ${LIBBFD_INCLUDE_DIR} ${LIBDL_INCLUDE_DIR}) + set(LIBBFD_LIBRARIES ${LIBBFD_LIBRARY} ${LIBDL_LIBRARY}) + find_package_handle_standard_args(libbfd ${_name_mismatched_arg} + REQUIRED_VARS LIBBFD_LIBRARY LIBBFD_INCLUDE_DIR + LIBDL_LIBRARY LIBDL_INCLUDE_DIR) + mark_as_advanced(LIBBFD_INCLUDE_DIR LIBBFD_LIBRARY + LIBDL_INCLUDE_DIR LIBDL_LIBRARY) + + # find libdwarf + find_path(LIBDWARF_INCLUDE_DIR NAMES "libdwarf.h" PATH_SUFFIXES libdwarf) + find_path(LIBELF_INCLUDE_DIR NAMES "libelf.h") + find_path(LIBDL_INCLUDE_DIR NAMES "dlfcn.h") + find_library(LIBDWARF_LIBRARY dwarf) + find_library(LIBELF_LIBRARY elf) + find_library(LIBDL_LIBRARY dl) + set(LIBDWARF_INCLUDE_DIRS ${LIBDWARF_INCLUDE_DIR} ${LIBELF_INCLUDE_DIR} ${LIBDL_INCLUDE_DIR}) + set(LIBDWARF_LIBRARIES ${LIBDWARF_LIBRARY} ${LIBELF_LIBRARY} ${LIBDL_LIBRARY}) + find_package_handle_standard_args(libdwarf ${_name_mismatched_arg} + REQUIRED_VARS LIBDWARF_LIBRARY LIBDWARF_INCLUDE_DIR + LIBELF_LIBRARY LIBELF_INCLUDE_DIR + LIBDL_LIBRARY LIBDL_INCLUDE_DIR) + mark_as_advanced(LIBDWARF_INCLUDE_DIR LIBDWARF_LIBRARY + LIBELF_INCLUDE_DIR LIBELF_LIBRARY + LIBDL_INCLUDE_DIR LIBDL_LIBRARY) + + if (LIBDW_FOUND) + LIST(APPEND _BACKWARD_INCLUDE_DIRS ${LIBDW_INCLUDE_DIRS}) + LIST(APPEND _BACKWARD_LIBRARIES ${LIBDW_LIBRARIES}) + set(STACK_DETAILS_DW TRUE) + set(STACK_DETAILS_BFD FALSE) + set(STACK_DETAILS_DWARF FALSE) + set(STACK_DETAILS_BACKTRACE_SYMBOL FALSE) + elseif(LIBBFD_FOUND) + LIST(APPEND _BACKWARD_INCLUDE_DIRS ${LIBBFD_INCLUDE_DIRS}) + LIST(APPEND _BACKWARD_LIBRARIES ${LIBBFD_LIBRARIES}) + + # If we attempt to link against static bfd, make sure to link its dependencies, too + get_filename_component(bfd_lib_ext "${LIBBFD_LIBRARY}" EXT) + if (bfd_lib_ext STREQUAL "${CMAKE_STATIC_LIBRARY_SUFFIX}") + list(APPEND _BACKWARD_LIBRARIES iberty z) + endif() + + set(STACK_DETAILS_DW FALSE) + set(STACK_DETAILS_BFD TRUE) + set(STACK_DETAILS_DWARF FALSE) + set(STACK_DETAILS_BACKTRACE_SYMBOL FALSE) + elseif(LIBDWARF_FOUND) + LIST(APPEND _BACKWARD_INCLUDE_DIRS ${LIBDWARF_INCLUDE_DIRS}) + LIST(APPEND _BACKWARD_LIBRARIES ${LIBDWARF_LIBRARIES}) + + set(STACK_DETAILS_DW FALSE) + set(STACK_DETAILS_BFD FALSE) + set(STACK_DETAILS_DWARF TRUE) + set(STACK_DETAILS_BACKTRACE_SYMBOL FALSE) + else() + set(STACK_DETAILS_DW FALSE) + set(STACK_DETAILS_BFD FALSE) + set(STACK_DETAILS_DWARF FALSE) + set(STACK_DETAILS_BACKTRACE_SYMBOL TRUE) + endif() +else() + if (STACK_DETAILS_DW) + LIST(APPEND _BACKWARD_LIBRARIES dw) + endif() + + if (STACK_DETAILS_BFD) + LIST(APPEND _BACKWARD_LIBRARIES bfd dl) + endif() + + if (STACK_DETAILS_DWARF) + LIST(APPEND _BACKWARD_LIBRARIES dwarf elf) + endif() +endif() + +macro(map_definitions var_prefix define_prefix) + foreach(def ${ARGN}) + if (${${var_prefix}${def}}) + LIST(APPEND _BACKWARD_DEFINITIONS "${define_prefix}${def}=1") + else() + LIST(APPEND _BACKWARD_DEFINITIONS "${define_prefix}${def}=0") + endif() + endforeach() +endmacro() + +if (NOT _BACKWARD_DEFINITIONS) + map_definitions("STACK_WALKING_" "BACKWARD_HAS_" UNWIND LIBUNWIND BACKTRACE) + map_definitions("STACK_DETAILS_" "BACKWARD_HAS_" BACKTRACE_SYMBOL DW BFD DWARF) +endif() + +if(WIN32) + list(APPEND _BACKWARD_LIBRARIES dbghelp psapi) + if(MINGW) + set(MINGW_MSVCR_LIBRARY "msvcr90$<$<CONFIG:DEBUG>:d>" CACHE STRING "Mingw MSVC runtime import library") + list(APPEND _BACKWARD_LIBRARIES ${MINGW_MSVCR_LIBRARY}) + endif() +endif() + +set(BACKWARD_INCLUDE_DIR "${CMAKE_CURRENT_LIST_DIR}") + +set(BACKWARD_HAS_EXTERNAL_LIBRARIES FALSE) +set(FIND_PACKAGE_REQUIRED_VARS BACKWARD_INCLUDE_DIR) +if(DEFINED _BACKWARD_LIBRARIES) + set(BACKWARD_HAS_EXTERNAL_LIBRARIES TRUE) + list(APPEND FIND_PACKAGE_REQUIRED_VARS _BACKWARD_LIBRARIES) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Backward + REQUIRED_VARS ${FIND_PACKAGE_REQUIRED_VARS} +) +list(APPEND _BACKWARD_INCLUDE_DIRS ${BACKWARD_INCLUDE_DIR}) + +macro(add_backward target) + target_include_directories(${target} PRIVATE ${BACKWARD_INCLUDE_DIRS}) + set_property(TARGET ${target} APPEND PROPERTY COMPILE_DEFINITIONS ${BACKWARD_DEFINITIONS}) + set_property(TARGET ${target} APPEND PROPERTY LINK_LIBRARIES ${BACKWARD_LIBRARIES}) +endmacro() + +set(BACKWARD_INCLUDE_DIRS ${_BACKWARD_INCLUDE_DIRS} CACHE INTERNAL "_BACKWARD_INCLUDE_DIRS") +set(BACKWARD_DEFINITIONS ${_BACKWARD_DEFINITIONS} CACHE INTERNAL "BACKWARD_DEFINITIONS") +set(BACKWARD_LIBRARIES ${_BACKWARD_LIBRARIES} CACHE INTERNAL "BACKWARD_LIBRARIES") +mark_as_advanced(BACKWARD_INCLUDE_DIRS BACKWARD_DEFINITIONS BACKWARD_LIBRARIES) + +# Expand each definition in BACKWARD_DEFINITIONS to its own cmake var and export +# to outer scope +foreach(var ${BACKWARD_DEFINITIONS}) + string(REPLACE "=" ";" var_as_list ${var}) + list(GET var_as_list 0 var_name) + list(GET var_as_list 1 var_value) + set(${var_name} ${var_value}) + mark_as_advanced(${var_name}) +endforeach() + +if (NOT TARGET Backward::Backward) + add_library(Backward::Backward INTERFACE IMPORTED) + set_target_properties(Backward::Backward PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${BACKWARD_INCLUDE_DIRS}" + INTERFACE_COMPILE_DEFINITIONS "${BACKWARD_DEFINITIONS}" + ) + if(BACKWARD_HAS_EXTERNAL_LIBRARIES) + set_target_properties(Backward::Backward PROPERTIES + INTERFACE_LINK_LIBRARIES "${BACKWARD_LIBRARIES}" + ) + endif() +endif() diff --git a/contrib/backward-cpp/CMakeLists.txt b/contrib/backward-cpp/CMakeLists.txt new file mode 100644 index 000000000..038c50516 --- /dev/null +++ b/contrib/backward-cpp/CMakeLists.txt @@ -0,0 +1,88 @@ +# +# CMakeLists.txt +# Copyright 2013 Google Inc. All Rights Reserved. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +cmake_minimum_required(VERSION 3.0) +project(backward CXX) + +# Introduce variables: +# * CMAKE_INSTALL_LIBDIR +# * CMAKE_INSTALL_BINDIR +# * CMAKE_INSTALL_INCLUDEDIR +include(GNUInstallDirs) + +include(BackwardConfig.cmake) + +# check if compiler is nvcc or nvcc_wrapper +set(COMPILER_IS_NVCC false) +get_filename_component(COMPILER_NAME ${CMAKE_CXX_COMPILER} NAME) +if (COMPILER_NAME MATCHES "^nvcc") + set(COMPILER_IS_NVCC true) +endif() + +if (DEFINED ENV{OMPI_CXX} OR DEFINED ENV{MPICH_CXX}) + if ( ($ENV{OMPI_CXX} MATCHES "nvcc") OR ($ENV{MPICH_CXX} MATCHES "nvcc") ) + set(COMPILER_IS_NVCC true) + endif() +endif() + +# set CXX standard +set(CMAKE_CXX_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 11) +if (${COMPILER_IS_NVCC}) + # GNU CXX extensions are not supported by nvcc + set(CMAKE_CXX_EXTENSIONS OFF) +endif() + +############################################################################### +# COMPILER FLAGS +############################################################################### + +if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_COMPILER_IS_GNUCXX) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra") + if (NOT ${COMPILER_IS_NVCC}) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic-errors") + endif() + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g") +endif() + +############################################################################### +# BACKWARD OBJECT +############################################################################### + +add_library(backward_object OBJECT backward.cpp) +target_compile_definitions(backward_object PRIVATE ${BACKWARD_DEFINITIONS}) +target_include_directories(backward_object PRIVATE ${BACKWARD_INCLUDE_DIRS}) +set(BACKWARD_ENABLE $<TARGET_OBJECTS:backward_object> CACHE STRING + "Link with this object to setup backward automatically") + + +############################################################################### +# BACKWARD LIBRARY (Includes backward.cpp) +############################################################################### +option(BACKWARD_SHARED "Build dynamic backward-cpp shared lib" OFF) + +if(BACKWARD_SHARED) + set(libtype SHARED) +endif() +add_library(backward ${libtype} backward.cpp) +target_compile_definitions(backward PUBLIC ${BACKWARD_DEFINITIONS}) +target_include_directories(backward PUBLIC ${BACKWARD_INCLUDE_DIRS})
\ No newline at end of file diff --git a/contrib/backward-cpp/backward.cpp b/contrib/backward-cpp/backward.cpp new file mode 100644 index 000000000..110441cba --- /dev/null +++ b/contrib/backward-cpp/backward.cpp @@ -0,0 +1,42 @@ +// Pick your poison. +// +// On GNU/Linux, you have few choices to get the most out of your stack trace. +// +// By default you get: +// - object filename +// - function name +// +// In order to add: +// - source filename +// - line and column numbers +// - source code snippet (assuming the file is accessible) + +// Install one of the following libraries then uncomment one of the macro (or +// better, add the detection of the lib and the macro definition in your build +// system) + +// - apt-get install libdw-dev ... +// - g++/clang++ -ldw ... +// #define BACKWARD_HAS_DW 1 + +// - apt-get install binutils-dev ... +// - g++/clang++ -lbfd ... +// #define BACKWARD_HAS_BFD 1 + +// - apt-get install libdwarf-dev ... +// - g++/clang++ -ldwarf ... +// #define BACKWARD_HAS_DWARF 1 + +// Regardless of the library you choose to read the debug information, +// for potentially more detailed stack traces you can use libunwind +// - apt-get install libunwind-dev +// - g++/clang++ -lunwind +// #define BACKWARD_HAS_LIBUNWIND 1 + +#include "backward.hpp" + +namespace backward { + +backward::SignalHandling sh; + +} // namespace backward diff --git a/contrib/backward-cpp/backward.hpp b/contrib/backward-cpp/backward.hpp new file mode 100644 index 000000000..ac7ad5173 --- /dev/null +++ b/contrib/backward-cpp/backward.hpp @@ -0,0 +1,4464 @@ +/* + * backward.hpp + * Copyright 2013 Google Inc. All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#ifndef H_6B9572DA_A64B_49E6_B234_051480991C89 +#define H_6B9572DA_A64B_49E6_B234_051480991C89 + +#ifndef __cplusplus +#error "It's not going to compile without a C++ compiler..." +#endif + +#if defined(BACKWARD_CXX11) +#elif defined(BACKWARD_CXX98) +#else +#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800) +#define BACKWARD_CXX11 +#define BACKWARD_ATLEAST_CXX11 +#define BACKWARD_ATLEAST_CXX98 +#if __cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) +#define BACKWARD_ATLEAST_CXX17 +#endif +#else +#define BACKWARD_CXX98 +#define BACKWARD_ATLEAST_CXX98 +#endif +#endif + +// You can define one of the following (or leave it to the auto-detection): +// +// #define BACKWARD_SYSTEM_LINUX +// - specialization for linux +// +// #define BACKWARD_SYSTEM_DARWIN +// - specialization for Mac OS X 10.5 and later. +// +// #define BACKWARD_SYSTEM_WINDOWS +// - specialization for Windows (Clang 9 and MSVC2017) +// +// #define BACKWARD_SYSTEM_UNKNOWN +// - placebo implementation, does nothing. +// +#if defined(BACKWARD_SYSTEM_LINUX) +#elif defined(BACKWARD_SYSTEM_DARWIN) +#elif defined(BACKWARD_SYSTEM_UNKNOWN) +#elif defined(BACKWARD_SYSTEM_WINDOWS) +#else +#if defined(__linux) || defined(__linux__) +#define BACKWARD_SYSTEM_LINUX +#elif defined(__APPLE__) +#define BACKWARD_SYSTEM_DARWIN +#elif defined(_WIN32) +#define BACKWARD_SYSTEM_WINDOWS +#else +#define BACKWARD_SYSTEM_UNKNOWN +#endif +#endif + +#define NOINLINE __attribute__((noinline)) + +#include <algorithm> +#include <cctype> +#include <cstdio> +#include <cstdlib> +#include <cstring> +#include <fstream> +#include <iomanip> +#include <iostream> +#include <limits> +#include <new> +#include <sstream> +#include <streambuf> +#include <string> +#include <vector> +#include <exception> +#include <iterator> + +#if defined(BACKWARD_SYSTEM_LINUX) + +// On linux, backtrace can back-trace or "walk" the stack using the following +// libraries: +// +// #define BACKWARD_HAS_UNWIND 1 +// - unwind comes from libgcc, but I saw an equivalent inside clang itself. +// - with unwind, the stacktrace is as accurate as it can possibly be, since +// this is used by the C++ runtine in gcc/clang for stack unwinding on +// exception. +// - normally libgcc is already linked to your program by default. +// +// #define BACKWARD_HAS_LIBUNWIND 1 +// - libunwind provides, in some cases, a more accurate stacktrace as it knows +// to decode signal handler frames and lets us edit the context registers when +// unwinding, allowing stack traces over bad function references. +// +// #define BACKWARD_HAS_BACKTRACE == 1 +// - backtrace seems to be a little bit more portable than libunwind, but on +// linux, it uses unwind anyway, but abstract away a tiny information that is +// sadly really important in order to get perfectly accurate stack traces. +// - backtrace is part of the (e)glib library. +// +// The default is: +// #define BACKWARD_HAS_UNWIND == 1 +// +// Note that only one of the define should be set to 1 at a time. +// +#if BACKWARD_HAS_UNWIND == 1 +#elif BACKWARD_HAS_LIBUNWIND == 1 +#elif BACKWARD_HAS_BACKTRACE == 1 +#else +#undef BACKWARD_HAS_UNWIND +#define BACKWARD_HAS_UNWIND 1 +#undef BACKWARD_HAS_LIBUNWIND +#define BACKWARD_HAS_LIBUNWIND 0 +#undef BACKWARD_HAS_BACKTRACE +#define BACKWARD_HAS_BACKTRACE 0 +#endif + +// On linux, backward can extract detailed information about a stack trace +// using one of the following libraries: +// +// #define BACKWARD_HAS_DW 1 +// - libdw gives you the most juicy details out of your stack traces: +// - object filename +// - function name +// - source filename +// - line and column numbers +// - source code snippet (assuming the file is accessible) +// - variable names (if not optimized out) +// - variable values (not supported by backward-cpp) +// - You need to link with the lib "dw": +// - apt-get install libdw-dev +// - g++/clang++ -ldw ... +// +// #define BACKWARD_HAS_BFD 1 +// - With libbfd, you get a fair amount of details: +// - object filename +// - function name +// - source filename +// - line numbers +// - source code snippet (assuming the file is accessible) +// - You need to link with the lib "bfd": +// - apt-get install binutils-dev +// - g++/clang++ -lbfd ... +// +// #define BACKWARD_HAS_DWARF 1 +// - libdwarf gives you the most juicy details out of your stack traces: +// - object filename +// - function name +// - source filename +// - line and column numbers +// - source code snippet (assuming the file is accessible) +// - variable names (if not optimized out) +// - variable values (not supported by backward-cpp) +// - You need to link with the lib "dwarf": +// - apt-get install libdwarf-dev +// - g++/clang++ -ldwarf ... +// +// #define BACKWARD_HAS_BACKTRACE_SYMBOL 1 +// - backtrace provides minimal details for a stack trace: +// - object filename +// - function name +// - backtrace is part of the (e)glib library. +// +// The default is: +// #define BACKWARD_HAS_BACKTRACE_SYMBOL == 1 +// +// Note that only one of the define should be set to 1 at a time. +// +#if BACKWARD_HAS_DW == 1 +#elif BACKWARD_HAS_BFD == 1 +#elif BACKWARD_HAS_DWARF == 1 +#elif BACKWARD_HAS_BACKTRACE_SYMBOL == 1 +#else +#undef BACKWARD_HAS_DW +#define BACKWARD_HAS_DW 0 +#undef BACKWARD_HAS_BFD +#define BACKWARD_HAS_BFD 0 +#undef BACKWARD_HAS_DWARF +#define BACKWARD_HAS_DWARF 0 +#undef BACKWARD_HAS_BACKTRACE_SYMBOL +#define BACKWARD_HAS_BACKTRACE_SYMBOL 1 +#endif + +#include <cxxabi.h> +#include <fcntl.h> +#ifdef __ANDROID__ +// Old Android API levels define _Unwind_Ptr in both link.h and +// unwind.h Rename the one in link.h as we are not going to be using +// it +#define _Unwind_Ptr _Unwind_Ptr_Custom +#include <link.h> +#undef _Unwind_Ptr +#else +#include <link.h> +#endif +#include <signal.h> +#include <sys/stat.h> +#include <syscall.h> +#include <unistd.h> + +#if BACKWARD_HAS_BFD == 1 +// NOTE: defining PACKAGE{,_VERSION} is required before including +// bfd.h on some platforms, see also: +// https://sourceware.org/bugzilla/show_bug.cgi?id=14243 +#ifndef PACKAGE +#define PACKAGE +#endif +#ifndef PACKAGE_VERSION +#define PACKAGE_VERSION +#endif +#include <bfd.h> +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#include <dlfcn.h> +#undef _GNU_SOURCE +#else +#include <dlfcn.h> +#endif +#endif + +#if BACKWARD_HAS_DW == 1 +#include <dwarf.h> +#include <elfutils/libdw.h> +#include <elfutils/libdwfl.h> +#endif + +#if BACKWARD_HAS_DWARF == 1 +#include <algorithm> +#include <dwarf.h> +#include <libdwarf.h> +#include <libelf.h> +#include <map> +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#include <dlfcn.h> +#undef _GNU_SOURCE +#else +#include <dlfcn.h> +#endif +#endif + +#if (BACKWARD_HAS_BACKTRACE == 1) || (BACKWARD_HAS_BACKTRACE_SYMBOL == 1) +// then we shall rely on backtrace +#include <execinfo.h> +#endif + +#endif // defined(BACKWARD_SYSTEM_LINUX) + +#if defined(BACKWARD_SYSTEM_DARWIN) +// On Darwin, backtrace can back-trace or "walk" the stack using the following +// libraries: +// +// #define BACKWARD_HAS_UNWIND 1 +// - unwind comes from libgcc, but I saw an equivalent inside clang itself. +// - with unwind, the stacktrace is as accurate as it can possibly be, since +// this is used by the C++ runtine in gcc/clang for stack unwinding on +// exception. +// - normally libgcc is already linked to your program by default. +// +// #define BACKWARD_HAS_LIBUNWIND 1 +// - libunwind comes from clang, which implements an API compatible version. +// - libunwind provides, in some cases, a more accurate stacktrace as it knows +// to decode signal handler frames and lets us edit the context registers when +// unwinding, allowing stack traces over bad function references. +// +// #define BACKWARD_HAS_BACKTRACE == 1 +// - backtrace is available by default, though it does not produce as much +// information as another library might. +// +// The default is: +// #define BACKWARD_HAS_UNWIND == 1 +// +// Note that only one of the define should be set to 1 at a time. +// +#if BACKWARD_HAS_UNWIND == 1 +#elif BACKWARD_HAS_BACKTRACE == 1 +#elif BACKWARD_HAS_LIBUNWIND == 1 +#else +#undef BACKWARD_HAS_UNWIND +#define BACKWARD_HAS_UNWIND 1 +#undef BACKWARD_HAS_BACKTRACE +#define BACKWARD_HAS_BACKTRACE 0 +#undef BACKWARD_HAS_LIBUNWIND +#define BACKWARD_HAS_LIBUNWIND 0 +#endif + +// On Darwin, backward can extract detailed information about a stack trace +// using one of the following libraries: +// +// #define BACKWARD_HAS_BACKTRACE_SYMBOL 1 +// - backtrace provides minimal details for a stack trace: +// - object filename +// - function name +// +// The default is: +// #define BACKWARD_HAS_BACKTRACE_SYMBOL == 1 +// +#if BACKWARD_HAS_BACKTRACE_SYMBOL == 1 +#else +#undef BACKWARD_HAS_BACKTRACE_SYMBOL +#define BACKWARD_HAS_BACKTRACE_SYMBOL 1 +#endif + +#include <cxxabi.h> +#include <fcntl.h> +#include <pthread.h> +#include <signal.h> +#include <sys/stat.h> +#include <unistd.h> + +#if (BACKWARD_HAS_BACKTRACE == 1) || (BACKWARD_HAS_BACKTRACE_SYMBOL == 1) +#include <execinfo.h> +#endif +#endif // defined(BACKWARD_SYSTEM_DARWIN) + +#if defined(BACKWARD_SYSTEM_WINDOWS) + +#include <condition_variable> +#include <mutex> +#include <thread> + +#include <basetsd.h> +typedef SSIZE_T ssize_t; + +#ifndef NOMINMAX +#define NOMINMAX +#endif +#include <windows.h> +#include <winnt.h> + +#include <psapi.h> +#include <signal.h> + +#ifndef __clang__ +#undef NOINLINE +#define NOINLINE __declspec(noinline) +#endif + +#ifdef _MSC_VER +#pragma comment(lib, "psapi.lib") +#pragma comment(lib, "dbghelp.lib") +#endif + +// Comment / packing is from stackoverflow: +// https://stackoverflow.com/questions/6205981/windows-c-stack-trace-from-a-running-app/28276227#28276227 +// Some versions of imagehlp.dll lack the proper packing directives themselves +// so we need to do it. +#pragma pack(push, before_imagehlp, 8) +#include <imagehlp.h> +#pragma pack(pop, before_imagehlp) + +// TODO maybe these should be undefined somewhere else? +#undef BACKWARD_HAS_UNWIND +#undef BACKWARD_HAS_BACKTRACE +#if BACKWARD_HAS_PDB_SYMBOL == 1 +#else +#undef BACKWARD_HAS_PDB_SYMBOL +#define BACKWARD_HAS_PDB_SYMBOL 1 +#endif + +#endif + +#if BACKWARD_HAS_UNWIND == 1 + +#include <unwind.h> +// while gcc's unwind.h defines something like that: +// extern _Unwind_Ptr _Unwind_GetIP (struct _Unwind_Context *); +// extern _Unwind_Ptr _Unwind_GetIPInfo (struct _Unwind_Context *, int *); +// +// clang's unwind.h defines something like this: +// uintptr_t _Unwind_GetIP(struct _Unwind_Context* __context); +// +// Even if the _Unwind_GetIPInfo can be linked to, it is not declared, worse we +// cannot just redeclare it because clang's unwind.h doesn't define _Unwind_Ptr +// anyway. +// +// Luckily we can play on the fact that the guard macros have a different name: +#ifdef __CLANG_UNWIND_H +// In fact, this function still comes from libgcc (on my different linux boxes, +// clang links against libgcc). +#include <inttypes.h> +extern "C" uintptr_t _Unwind_GetIPInfo(_Unwind_Context *, int *); +#endif + +#endif // BACKWARD_HAS_UNWIND == 1 + +#if BACKWARD_HAS_LIBUNWIND == 1 +#define UNW_LOCAL_ONLY +#include <libunwind.h> +#endif // BACKWARD_HAS_LIBUNWIND == 1 + +#ifdef BACKWARD_ATLEAST_CXX11 +#include <unordered_map> +#include <utility> // for std::swap +namespace backward { +namespace details { +template <typename K, typename V> struct hashtable { + typedef std::unordered_map<K, V> type; +}; +using std::move; +} // namespace details +} // namespace backward +#else // NOT BACKWARD_ATLEAST_CXX11 +#define nullptr NULL +#define override +#include <map> +namespace backward { +namespace details { +template <typename K, typename V> struct hashtable { + typedef std::map<K, V> type; +}; +template <typename T> const T &move(const T &v) { return v; } +template <typename T> T &move(T &v) { return v; } +} // namespace details +} // namespace backward +#endif // BACKWARD_ATLEAST_CXX11 + +namespace backward { +namespace details { +#if defined(BACKWARD_SYSTEM_WINDOWS) +const char kBackwardPathDelimiter[] = ";"; +#else +const char kBackwardPathDelimiter[] = ":"; +#endif +} // namespace details +} // namespace backward + +namespace backward { + +namespace system_tag { +struct linux_tag; // seems that I cannot call that "linux" because the name +// is already defined... so I am adding _tag everywhere. +struct darwin_tag; +struct windows_tag; +struct unknown_tag; + +#if defined(BACKWARD_SYSTEM_LINUX) +typedef linux_tag current_tag; +#elif defined(BACKWARD_SYSTEM_DARWIN) +typedef darwin_tag current_tag; +#elif defined(BACKWARD_SYSTEM_WINDOWS) +typedef windows_tag current_tag; +#elif defined(BACKWARD_SYSTEM_UNKNOWN) +typedef unknown_tag current_tag; +#else +#error "May I please get my system defines?" +#endif +} // namespace system_tag + +namespace trace_resolver_tag { +#if defined(BACKWARD_SYSTEM_LINUX) +struct libdw; +struct libbfd; +struct libdwarf; +struct backtrace_symbol; + +#if BACKWARD_HAS_DW == 1 +typedef libdw current; +#elif BACKWARD_HAS_BFD == 1 +typedef libbfd current; +#elif BACKWARD_HAS_DWARF == 1 +typedef libdwarf current; +#elif BACKWARD_HAS_BACKTRACE_SYMBOL == 1 +typedef backtrace_symbol current; +#else +#error "You shall not pass, until you know what you want." +#endif +#elif defined(BACKWARD_SYSTEM_DARWIN) +struct backtrace_symbol; + +#if BACKWARD_HAS_BACKTRACE_SYMBOL == 1 +typedef backtrace_symbol current; +#else +#error "You shall not pass, until you know what you want." +#endif +#elif defined(BACKWARD_SYSTEM_WINDOWS) +struct pdb_symbol; +#if BACKWARD_HAS_PDB_SYMBOL == 1 +typedef pdb_symbol current; +#else +#error "You shall not pass, until you know what you want." +#endif +#endif +} // namespace trace_resolver_tag + +namespace details { + +template <typename T> struct rm_ptr { typedef T type; }; + +template <typename T> struct rm_ptr<T *> { typedef T type; }; + +template <typename T> struct rm_ptr<const T *> { typedef const T type; }; + +template <typename R, typename T, R (*F)(T)> struct deleter { + template <typename U> void operator()(U &ptr) const { (*F)(ptr); } +}; + +template <typename T> struct default_delete { + void operator()(T &ptr) const { delete ptr; } +}; + +template <typename T, typename Deleter = deleter<void, void *, &::free>> +class handle { + struct dummy; + T _val; + bool _empty; + +#ifdef BACKWARD_ATLEAST_CXX11 + handle(const handle &) = delete; + handle &operator=(const handle &) = delete; +#endif + +public: + ~handle() { + if (!_empty) { + Deleter()(_val); + } + } + + explicit handle() : _val(), _empty(true) {} + explicit handle(T val) : _val(val), _empty(false) { + if (!_val) + _empty = true; + } + +#ifdef BACKWARD_ATLEAST_CXX11 + handle(handle &&from) : _empty(true) { swap(from); } + handle &operator=(handle &&from) { + swap(from); + return *this; + } +#else + explicit handle(const handle &from) : _empty(true) { + // some sort of poor man's move semantic. + swap(const_cast<handle &>(from)); + } + handle &operator=(const handle &from) { + // some sort of poor man's move semantic. + swap(const_cast<handle &>(from)); + return *this; + } +#endif + + void reset(T new_val) { + handle tmp(new_val); + swap(tmp); + } + + void update(T new_val) { + _val = new_val; + _empty = !static_cast<bool>(new_val); + } + + operator const dummy *() const { + if (_empty) { + return nullptr; + } + return reinterpret_cast<const dummy *>(_val); + } + T get() { return _val; } + T release() { + _empty = true; + return _val; + } + void swap(handle &b) { + using std::swap; + swap(b._val, _val); // can throw, we are safe here. + swap(b._empty, _empty); // should not throw: if you cannot swap two + // bools without throwing... It's a lost cause anyway! + } + + T &operator->() { return _val; } + const T &operator->() const { return _val; } + + typedef typename rm_ptr<T>::type &ref_t; + typedef const typename rm_ptr<T>::type &const_ref_t; + ref_t operator*() { return *_val; } + const_ref_t operator*() const { return *_val; } + ref_t operator[](size_t idx) { return _val[idx]; } + + // Watch out, we've got a badass over here + T *operator&() { + _empty = false; + return &_val; + } +}; + +// Default demangler implementation (do nothing). +template <typename TAG> struct demangler_impl { + static std::string demangle(const char *funcname) { return funcname; } +}; + +#if defined(BACKWARD_SYSTEM_LINUX) || defined(BACKWARD_SYSTEM_DARWIN) + +template <> struct demangler_impl<system_tag::current_tag> { + demangler_impl() : _demangle_buffer_length(0) {} + + std::string demangle(const char *funcname) { + using namespace details; + char *result = abi::__cxa_demangle(funcname, _demangle_buffer.get(), + &_demangle_buffer_length, nullptr); + if (result) { + _demangle_buffer.update(result); + return result; + } + return funcname; + } + +private: + details::handle<char *> _demangle_buffer; + size_t _demangle_buffer_length; +}; + +#endif // BACKWARD_SYSTEM_LINUX || BACKWARD_SYSTEM_DARWIN + +struct demangler : public demangler_impl<system_tag::current_tag> {}; + +// Split a string on the platform's PATH delimiter. Example: if delimiter +// is ":" then: +// "" --> [] +// ":" --> ["",""] +// "::" --> ["","",""] +// "/a/b/c" --> ["/a/b/c"] +// "/a/b/c:/d/e/f" --> ["/a/b/c","/d/e/f"] +// etc. +inline std::vector<std::string> split_source_prefixes(const std::string &s) { + std::vector<std::string> out; + size_t last = 0; + size_t next = 0; + size_t delimiter_size = sizeof(kBackwardPathDelimiter) - 1; + while ((next = s.find(kBackwardPathDelimiter, last)) != std::string::npos) { + out.push_back(s.substr(last, next - last)); + last = next + delimiter_size; + } + if (last <= s.length()) { + out.push_back(s.substr(last)); + } + return out; +} + +} // namespace details + +/*************** A TRACE ***************/ + +struct Trace { + void *addr; + size_t idx; + + Trace() : addr(nullptr), idx(0) {} + + explicit Trace(void *_addr, size_t _idx) : addr(_addr), idx(_idx) {} +}; + +struct ResolvedTrace : public Trace { + + struct SourceLoc { + std::string function; + std::string filename; + unsigned line; + unsigned col; + + SourceLoc() : line(0), col(0) {} + + bool operator==(const SourceLoc &b) const { + return function == b.function && filename == b.filename && + line == b.line && col == b.col; + } + + bool operator!=(const SourceLoc &b) const { return !(*this == b); } + }; + + // In which binary object this trace is located. + std::string object_filename; + + // The function in the object that contain the trace. This is not the same + // as source.function which can be an function inlined in object_function. + std::string object_function; + + // The source location of this trace. It is possible for filename to be + // empty and for line/col to be invalid (value 0) if this information + // couldn't be deduced, for example if there is no debug information in the + // binary object. + SourceLoc source; + + // An optionals list of "inliners". All the successive sources location + // from where the source location of the trace (the attribute right above) + // is inlined. It is especially useful when you compiled with optimization. + typedef std::vector<SourceLoc> source_locs_t; + source_locs_t inliners; + + ResolvedTrace() : Trace() {} + ResolvedTrace(const Trace &mini_trace) : Trace(mini_trace) {} +}; + +/*************** STACK TRACE ***************/ + +// default implemention. +template <typename TAG> class StackTraceImpl { +public: + size_t size() const { return 0; } + Trace operator[](size_t) const { return Trace(); } + size_t load_here(size_t = 0) { return 0; } + size_t load_from(void *, size_t = 0, void * = nullptr, void * = nullptr) { + return 0; + } + size_t thread_id() const { return 0; } + void skip_n_firsts(size_t) {} +}; + +class StackTraceImplBase { +public: + StackTraceImplBase() + : _thread_id(0), _skip(0), _context(nullptr), _error_addr(nullptr) {} + + size_t thread_id() const { return _thread_id; } + + void skip_n_firsts(size_t n) { _skip = n; } + +protected: + void load_thread_info() { +#ifdef BACKWARD_SYSTEM_LINUX +#ifndef __ANDROID__ + _thread_id = static_cast<size_t>(syscall(SYS_gettid)); +#else + _thread_id = static_cast<size_t>(gettid()); +#endif + if (_thread_id == static_cast<size_t>(getpid())) { + // If the thread is the main one, let's hide that. + // I like to keep little secret sometimes. + _thread_id = 0; + } +#elif defined(BACKWARD_SYSTEM_DARWIN) + _thread_id = reinterpret_cast<size_t>(pthread_self()); + if (pthread_main_np() == 1) { + // If the thread is the main one, let's hide that. + _thread_id = 0; + } +#endif + } + + void set_context(void *context) { _context = context; } + void *context() const { return _context; } + + void set_error_addr(void *error_addr) { _error_addr = error_addr; } + void *error_addr() const { return _error_addr; } + + size_t skip_n_firsts() const { return _skip; } + +private: + size_t _thread_id; + size_t _skip; + void *_context; + void *_error_addr; +}; + +class StackTraceImplHolder : public StackTraceImplBase { +public: + size_t size() const { + return (_stacktrace.size() >= skip_n_firsts()) + ? _stacktrace.size() - skip_n_firsts() + : 0; + } + Trace operator[](size_t idx) const { + if (idx >= size()) { + return Trace(); + } + return Trace(_stacktrace[idx + skip_n_firsts()], idx); + } + void *const *begin() const { + if (size()) { + return &_stacktrace[skip_n_firsts()]; + } + return nullptr; + } + +protected: + std::vector<void *> _stacktrace; +}; + +#if BACKWARD_HAS_UNWIND == 1 + +namespace details { + +template <typename F> class Unwinder { +public: + size_t operator()(F &f, size_t depth) { + _f = &f; + _index = -1; + _depth = depth; + _Unwind_Backtrace(&this->backtrace_trampoline, this); + return static_cast<size_t>(_index); + } + +private: + F *_f; + ssize_t _index; + size_t _depth; + + static _Unwind_Reason_Code backtrace_trampoline(_Unwind_Context *ctx, + void *self) { + return (static_cast<Unwinder *>(self))->backtrace(ctx); + } + + _Unwind_Reason_Code backtrace(_Unwind_Context *ctx) { + if (_index >= 0 && static_cast<size_t>(_index) >= _depth) + return _URC_END_OF_STACK; + + int ip_before_instruction = 0; + uintptr_t ip = _Unwind_GetIPInfo(ctx, &ip_before_instruction); + + if (!ip_before_instruction) { + // calculating 0-1 for unsigned, looks like a possible bug to sanitiziers, + // so let's do it explicitly: + if (ip == 0) { + ip = std::numeric_limits<uintptr_t>::max(); // set it to 0xffff... (as + // from casting 0-1) + } else { + ip -= 1; // else just normally decrement it (no overflow/underflow will + // happen) + } + } + + if (_index >= 0) { // ignore first frame. + (*_f)(static_cast<size_t>(_index), reinterpret_cast<void *>(ip)); + } + _index += 1; + return _URC_NO_REASON; + } +}; + +template <typename F> size_t unwind(F f, size_t depth) { + Unwinder<F> unwinder; + return unwinder(f, depth); +} + +} // namespace details + +template <> +class StackTraceImpl<system_tag::current_tag> : public StackTraceImplHolder { +public: + NOINLINE + size_t load_here(size_t depth = 32, void *context = nullptr, + void *error_addr = nullptr) { + load_thread_info(); + set_context(context); + set_error_addr(error_addr); + if (depth == 0) { + return 0; + } + _stacktrace.resize(depth); + size_t trace_cnt = details::unwind(callback(*this), depth); + _stacktrace.resize(trace_cnt); + skip_n_firsts(0); + return size(); + } + size_t load_from(void *addr, size_t depth = 32, void *context = nullptr, + void *error_addr = nullptr) { + load_here(depth + 8, context, error_addr); + + for (size_t i = 0; i < _stacktrace.size(); ++i) { + if (_stacktrace[i] == addr) { + skip_n_firsts(i); + break; + } + } + + _stacktrace.resize(std::min(_stacktrace.size(), skip_n_firsts() + depth)); + return size(); + } + +private: + struct callback { + StackTraceImpl &self; + callback(StackTraceImpl &_self) : self(_self) {} + + void operator()(size_t idx, void *addr) { self._stacktrace[idx] = addr; } + }; +}; + +#elif BACKWARD_HAS_LIBUNWIND == 1 + +template <> +class StackTraceImpl<system_tag::current_tag> : public StackTraceImplHolder { +public: + __attribute__((noinline)) size_t load_here(size_t depth = 32, + void *_context = nullptr, + void *_error_addr = nullptr) { + set_context(_context); + set_error_addr(_error_addr); + load_thread_info(); + if (depth == 0) { + return 0; + } + _stacktrace.resize(depth + 1); + + int result = 0; + + unw_context_t ctx; + size_t index = 0; + + // Add the tail call. If the Instruction Pointer is the crash address it + // means we got a bad function pointer dereference, so we "unwind" the + // bad pointer manually by using the return address pointed to by the + // Stack Pointer as the Instruction Pointer and letting libunwind do + // the rest + + if (context()) { + ucontext_t *uctx = reinterpret_cast<ucontext_t *>(context()); +#ifdef REG_RIP // x86_64 + if (uctx->uc_mcontext.gregs[REG_RIP] == + reinterpret_cast<greg_t>(error_addr())) { + uctx->uc_mcontext.gregs[REG_RIP] = + *reinterpret_cast<size_t *>(uctx->uc_mcontext.gregs[REG_RSP]); + } + _stacktrace[index] = + reinterpret_cast<void *>(uctx->uc_mcontext.gregs[REG_RIP]); + ++index; + ctx = *reinterpret_cast<unw_context_t *>(uctx); +#elif defined(REG_EIP) // x86_32 + if (uctx->uc_mcontext.gregs[REG_EIP] == + reinterpret_cast<greg_t>(error_addr())) { + uctx->uc_mcontext.gregs[REG_EIP] = + *reinterpret_cast<size_t *>(uctx->uc_mcontext.gregs[REG_ESP]); + } + _stacktrace[index] = + reinterpret_cast<void *>(uctx->uc_mcontext.gregs[REG_EIP]); + ++index; + ctx = *reinterpret_cast<unw_context_t *>(uctx); +#elif defined(__arm__) + // libunwind uses its own context type for ARM unwinding. + // Copy the registers from the signal handler's context so we can + // unwind + unw_getcontext(&ctx); + ctx.regs[UNW_ARM_R0] = uctx->uc_mcontext.arm_r0; + ctx.regs[UNW_ARM_R1] = uctx->uc_mcontext.arm_r1; + ctx.regs[UNW_ARM_R2] = uctx->uc_mcontext.arm_r2; + ctx.regs[UNW_ARM_R3] = uctx->uc_mcontext.arm_r3; + ctx.regs[UNW_ARM_R4] = uctx->uc_mcontext.arm_r4; + ctx.regs[UNW_ARM_R5] = uctx->uc_mcontext.arm_r5; + ctx.regs[UNW_ARM_R6] = uctx->uc_mcontext.arm_r6; + ctx.regs[UNW_ARM_R7] = uctx->uc_mcontext.arm_r7; + ctx.regs[UNW_ARM_R8] = uctx->uc_mcontext.arm_r8; + ctx.regs[UNW_ARM_R9] = uctx->uc_mcontext.arm_r9; + ctx.regs[UNW_ARM_R10] = uctx->uc_mcontext.arm_r10; + ctx.regs[UNW_ARM_R11] = uctx->uc_mcontext.arm_fp; + ctx.regs[UNW_ARM_R12] = uctx->uc_mcontext.arm_ip; + ctx.regs[UNW_ARM_R13] = uctx->uc_mcontext.arm_sp; + ctx.regs[UNW_ARM_R14] = uctx->uc_mcontext.arm_lr; + ctx.regs[UNW_ARM_R15] = uctx->uc_mcontext.arm_pc; + + // If we have crashed in the PC use the LR instead, as this was + // a bad function dereference + if (reinterpret_cast<unsigned long>(error_addr()) == + uctx->uc_mcontext.arm_pc) { + ctx.regs[UNW_ARM_R15] = + uctx->uc_mcontext.arm_lr - sizeof(unsigned long); + } + _stacktrace[index] = reinterpret_cast<void *>(ctx.regs[UNW_ARM_R15]); + ++index; +#elif defined(__APPLE__) && defined(__x86_64__) + unw_getcontext(&ctx); + // OS X's implementation of libunwind uses its own context object + // so we need to convert the passed context to libunwind's format + // (information about the data layout taken from unw_getcontext.s + // in Apple's libunwind source + ctx.data[0] = uctx->uc_mcontext->__ss.__rax; + ctx.data[1] = uctx->uc_mcontext->__ss.__rbx; + ctx.data[2] = uctx->uc_mcontext->__ss.__rcx; + ctx.data[3] = uctx->uc_mcontext->__ss.__rdx; + ctx.data[4] = uctx->uc_mcontext->__ss.__rdi; + ctx.data[5] = uctx->uc_mcontext->__ss.__rsi; + ctx.data[6] = uctx->uc_mcontext->__ss.__rbp; + ctx.data[7] = uctx->uc_mcontext->__ss.__rsp; + ctx.data[8] = uctx->uc_mcontext->__ss.__r8; + ctx.data[9] = uctx->uc_mcontext->__ss.__r9; + ctx.data[10] = uctx->uc_mcontext->__ss.__r10; + ctx.data[11] = uctx->uc_mcontext->__ss.__r11; + ctx.data[12] = uctx->uc_mcontext->__ss.__r12; + ctx.data[13] = uctx->uc_mcontext->__ss.__r13; + ctx.data[14] = uctx->uc_mcontext->__ss.__r14; + ctx.data[15] = uctx->uc_mcontext->__ss.__r15; + ctx.data[16] = uctx->uc_mcontext->__ss.__rip; + + // If the IP is the same as the crash address we have a bad function + // dereference The caller's address is pointed to by %rsp, so we + // dereference that value and set it to be the next frame's IP. + if (uctx->uc_mcontext->__ss.__rip == + reinterpret_cast<__uint64_t>(error_addr())) { + ctx.data[16] = + *reinterpret_cast<__uint64_t *>(uctx->uc_mcontext->__ss.__rsp); + } + _stacktrace[index] = reinterpret_cast<void *>(ctx.data[16]); + ++index; +#elif defined(__APPLE__) + unw_getcontext(&ctx) + // TODO: Convert the ucontext_t to libunwind's unw_context_t like + // we do in 64 bits + if (ctx.uc_mcontext->__ss.__eip == + reinterpret_cast<greg_t>(error_addr())) { + ctx.uc_mcontext->__ss.__eip = ctx.uc_mcontext->__ss.__esp; + } + _stacktrace[index] = + reinterpret_cast<void *>(ctx.uc_mcontext->__ss.__eip); + ++index; +#endif + } + + unw_cursor_t cursor; + if (context()) { +#if defined(UNW_INIT_SIGNAL_FRAME) + result = unw_init_local2(&cursor, &ctx, UNW_INIT_SIGNAL_FRAME); +#else + result = unw_init_local(&cursor, &ctx); +#endif + } else { + unw_getcontext(&ctx); + ; + result = unw_init_local(&cursor, &ctx); + } + + if (result != 0) + return 1; + + unw_word_t ip = 0; + + while (index <= depth && unw_step(&cursor) > 0) { + result = unw_get_reg(&cursor, UNW_REG_IP, &ip); + if (result == 0) { + _stacktrace[index] = reinterpret_cast<void *>(--ip); + ++index; + } + } + --index; + + _stacktrace.resize(index + 1); + skip_n_firsts(0); + return size(); + } + + size_t load_from(void *addr, size_t depth = 32, void *context = nullptr, + void *error_addr = nullptr) { + load_here(depth + 8, context, error_addr); + + for (size_t i = 0; i < _stacktrace.size(); ++i) { + if (_stacktrace[i] == addr) { + skip_n_firsts(i); + _stacktrace[i] = (void *)((uintptr_t)_stacktrace[i]); + break; + } + } + + _stacktrace.resize(std::min(_stacktrace.size(), skip_n_firsts() + depth)); + return size(); + } +}; + +#elif defined(BACKWARD_HAS_BACKTRACE) + +template <> +class StackTraceImpl<system_tag::current_tag> : public StackTraceImplHolder { +public: + NOINLINE + size_t load_here(size_t depth = 32, void *context = nullptr, + void *error_addr = nullptr) { + set_context(context); + set_error_addr(error_addr); + load_thread_info(); + if (depth == 0) { + return 0; + } + _stacktrace.resize(depth + 1); + size_t trace_cnt = backtrace(&_stacktrace[0], _stacktrace.size()); + _stacktrace.resize(trace_cnt); + skip_n_firsts(1); + return size(); + } + + size_t load_from(void *addr, size_t depth = 32, void *context = nullptr, + void *error_addr = nullptr) { + load_here(depth + 8, context, error_addr); + + for (size_t i = 0; i < _stacktrace.size(); ++i) { + if (_stacktrace[i] == addr) { + skip_n_firsts(i); + _stacktrace[i] = (void *)((uintptr_t)_stacktrace[i] + 1); + break; + } + } + + _stacktrace.resize(std::min(_stacktrace.size(), skip_n_firsts() + depth)); + return size(); + } +}; + +#elif defined(BACKWARD_SYSTEM_WINDOWS) + +template <> +class StackTraceImpl<system_tag::current_tag> : public StackTraceImplHolder { +public: + // We have to load the machine type from the image info + // So we first initialize the resolver, and it tells us this info + void set_machine_type(DWORD machine_type) { machine_type_ = machine_type; } + void set_context(CONTEXT *ctx) { ctx_ = ctx; } + void set_thread_handle(HANDLE handle) { thd_ = handle; } + + NOINLINE + size_t load_here(size_t depth = 32, void *context = nullptr, + void *error_addr = nullptr) { + set_context(static_cast<CONTEXT*>(context)); + set_error_addr(error_addr); + CONTEXT localCtx; // used when no context is provided + + if (depth == 0) { + return 0; + } + + if (!ctx_) { + ctx_ = &localCtx; + RtlCaptureContext(ctx_); + } + + if (!thd_) { + thd_ = GetCurrentThread(); + } + + HANDLE process = GetCurrentProcess(); + + STACKFRAME64 s; + memset(&s, 0, sizeof(STACKFRAME64)); + + // TODO: 32 bit context capture + s.AddrStack.Mode = AddrModeFlat; + s.AddrFrame.Mode = AddrModeFlat; + s.AddrPC.Mode = AddrModeFlat; +#ifdef _M_X64 + s.AddrPC.Offset = ctx_->Rip; + s.AddrStack.Offset = ctx_->Rsp; + s.AddrFrame.Offset = ctx_->Rbp; +#else + s.AddrPC.Offset = ctx_->Eip; + s.AddrStack.Offset = ctx_->Esp; + s.AddrFrame.Offset = ctx_->Ebp; +#endif + + if (!machine_type_) { +#ifdef _M_X64 + machine_type_ = IMAGE_FILE_MACHINE_AMD64; +#else + machine_type_ = IMAGE_FILE_MACHINE_I386; +#endif + } + + for (;;) { + // NOTE: this only works if PDBs are already loaded! + SetLastError(0); + if (!StackWalk64(machine_type_, process, thd_, &s, ctx_, NULL, + SymFunctionTableAccess64, SymGetModuleBase64, NULL)) + break; + + if (s.AddrReturn.Offset == 0) + break; + + _stacktrace.push_back(reinterpret_cast<void *>(s.AddrPC.Offset)); + + if (size() >= depth) + break; + } + + return size(); + } + + size_t load_from(void *addr, size_t depth = 32, void *context = nullptr, + void *error_addr = nullptr) { + load_here(depth + 8, context, error_addr); + + for (size_t i = 0; i < _stacktrace.size(); ++i) { + if (_stacktrace[i] == addr) { + skip_n_firsts(i); + break; + } + } + + _stacktrace.resize(std::min(_stacktrace.size(), skip_n_firsts() + depth)); + return size(); + } + +private: + DWORD machine_type_ = 0; + HANDLE thd_ = 0; + CONTEXT *ctx_ = nullptr; +}; + +#endif + +class StackTrace : public StackTraceImpl<system_tag::current_tag> {}; + +/*************** TRACE RESOLVER ***************/ + +class TraceResolverImplBase { +public: + virtual ~TraceResolverImplBase() {} + + virtual void load_addresses(void *const*addresses, int address_count) { + (void)addresses; + (void)address_count; + } + + template <class ST> void load_stacktrace(ST &st) { + load_addresses(st.begin(), (int)st.size()); + } + + virtual ResolvedTrace resolve(ResolvedTrace t) { return t; } + +protected: + std::string demangle(const char *funcname) { + return _demangler.demangle(funcname); + } + +private: + details::demangler _demangler; +}; + +template <typename TAG> class TraceResolverImpl; + +#ifdef BACKWARD_SYSTEM_UNKNOWN + +template <> class TraceResolverImpl<system_tag::unknown_tag> + : public TraceResolverImplBase {}; + +#endif + +#ifdef BACKWARD_SYSTEM_LINUX + +class TraceResolverLinuxBase : public TraceResolverImplBase { +public: + TraceResolverLinuxBase() + : argv0_(get_argv0()), exec_path_(read_symlink("/proc/self/exe")) {} + std::string resolve_exec_path(Dl_info &symbol_info) const { + // mutates symbol_info.dli_fname to be filename to open and returns filename + // to display + if (symbol_info.dli_fname == argv0_) { + // dladdr returns argv[0] in dli_fname for symbols contained in + // the main executable, which is not a valid path if the + // executable was found by a search of the PATH environment + // variable; In that case, we actually open /proc/self/exe, which + // is always the actual executable (even if it was deleted/replaced!) + // but display the path that /proc/self/exe links to. + // However, this right away reduces probability of successful symbol + // resolution, because libbfd may try to find *.debug files in the + // same dir, in case symbols are stripped. As a result, it may try + // to find a file /proc/self/<exe_name>.debug, which obviously does + // not exist. /proc/self/exe is a last resort. First load attempt + // should go for the original executable file path. + symbol_info.dli_fname = "/proc/self/exe"; + return exec_path_; + } else { + return symbol_info.dli_fname; + } + } + +private: + std::string argv0_; + std::string exec_path_; + + static std::string get_argv0() { + std::string argv0; + std::ifstream ifs("/proc/self/cmdline"); + std::getline(ifs, argv0, '\0'); + return argv0; + } + + static std::string read_symlink(std::string const &symlink_path) { + std::string path; + path.resize(100); + + while (true) { + ssize_t len = + ::readlink(symlink_path.c_str(), &*path.begin(), path.size()); + if (len < 0) { + return ""; + } + if (static_cast<size_t>(len) == path.size()) { + path.resize(path.size() * 2); + } else { + path.resize(static_cast<std::string::size_type>(len)); + break; + } + } + + return path; + } +}; + +template <typename STACKTRACE_TAG> class TraceResolverLinuxImpl; + +#if BACKWARD_HAS_BACKTRACE_SYMBOL == 1 + +template <> +class TraceResolverLinuxImpl<trace_resolver_tag::backtrace_symbol> + : public TraceResolverLinuxBase { +public: + void load_addresses(void *const*addresses, int address_count) override { + if (address_count == 0) { + return; + } + _symbols.reset(backtrace_symbols(addresses, address_count)); + } + + ResolvedTrace resolve(ResolvedTrace trace) override { + char *filename = _symbols[trace.idx]; + char *funcname = filename; + while (*funcname && *funcname != '(') { + funcname += 1; + } + trace.object_filename.assign(filename, + funcname); // ok even if funcname is the ending + // \0 (then we assign entire string) + + if (*funcname) { // if it's not end of string (e.g. from last frame ip==0) + funcname += 1; + char *funcname_end = funcname; + while (*funcname_end && *funcname_end != ')' && *funcname_end != '+') { + funcname_end += 1; + } + *funcname_end = '\0'; + trace.object_function = this->demangle(funcname); + trace.source.function = trace.object_function; // we cannot do better. + } + return trace; + } + +private: + details::handle<char **> _symbols; +}; + +#endif // BACKWARD_HAS_BACKTRACE_SYMBOL == 1 + +#if BACKWARD_HAS_BFD == 1 + +template <> +class TraceResolverLinuxImpl<trace_resolver_tag::libbfd> + : public TraceResolverLinuxBase { +public: + TraceResolverLinuxImpl() : _bfd_loaded(false) {} + + ResolvedTrace resolve(ResolvedTrace trace) override { + Dl_info symbol_info; + + // trace.addr is a virtual address in memory pointing to some code. + // Let's try to find from which loaded object it comes from. + // The loaded object can be yourself btw. + if (!dladdr(trace.addr, &symbol_info)) { + return trace; // dat broken trace... + } + + // Now we get in symbol_info: + // .dli_fname: + // pathname of the shared object that contains the address. + // .dli_fbase: + // where the object is loaded in memory. + // .dli_sname: + // the name of the nearest symbol to trace.addr, we expect a + // function name. + // .dli_saddr: + // the exact address corresponding to .dli_sname. + + if (symbol_info.dli_sname) { + trace.object_function = demangle(symbol_info.dli_sname); + } + + if (!symbol_info.dli_fname) { + return trace; + } + + trace.object_filename = resolve_exec_path(symbol_info); + bfd_fileobject *fobj; + // Before rushing to resolution need to ensure the executable + // file still can be used. For that compare inode numbers of + // what is stored by the executable's file path, and in the + // dli_fname, which not necessarily equals to the executable. + // It can be a shared library, or /proc/self/exe, and in the + // latter case has drawbacks. See the exec path resolution for + // details. In short - the dli object should be used only as + // the last resort. + // If inode numbers are equal, it is known dli_fname and the + // executable file are the same. This is guaranteed by Linux, + // because if the executable file is changed/deleted, it will + // be done in a new inode. The old file will be preserved in + // /proc/self/exe, and may even have inode 0. The latter can + // happen if the inode was actually reused, and the file was + // kept only in the main memory. + // + struct stat obj_stat; + struct stat dli_stat; + if (stat(trace.object_filename.c_str(), &obj_stat) == 0 && + stat(symbol_info.dli_fname, &dli_stat) == 0 && + obj_stat.st_ino == dli_stat.st_ino) { + // The executable file, and the shared object containing the + // address are the same file. Safe to use the original path. + // this is preferable. Libbfd will search for stripped debug + // symbols in the same directory. + fobj = load_object_with_bfd(trace.object_filename); + } else{ + // The original object file was *deleted*! The only hope is + // that the debug symbols are either inside the shared + // object file, or are in the same directory, and this is + // not /proc/self/exe. + fobj = nullptr; + } + if (fobj == nullptr || !fobj->handle) { + fobj = load_object_with_bfd(symbol_info.dli_fname); + if (!fobj->handle) { + return trace; + } + } + + find_sym_result *details_selected; // to be filled. + + // trace.addr is the next instruction to be executed after returning + // from the nested stack frame. In C++ this usually relate to the next + // statement right after the function call that leaded to a new stack + // frame. This is not usually what you want to see when printing out a + // stacktrace... + find_sym_result details_call_site = + find_symbol_details(fobj, trace.addr, symbol_info.dli_fbase); + details_selected = &details_call_site; + +#if BACKWARD_HAS_UNWIND == 0 + // ...this is why we also try to resolve the symbol that is right + // before the return address. If we are lucky enough, we will get the + // line of the function that was called. But if the code is optimized, + // we might get something absolutely not related since the compiler + // can reschedule the return address with inline functions and + // tail-call optimisation (among other things that I don't even know + // or cannot even dream about with my tiny limited brain). + find_sym_result details_adjusted_call_site = find_symbol_details( + fobj, (void *)(uintptr_t(trace.addr) - 1), symbol_info.dli_fbase); + + // In debug mode, we should always get the right thing(TM). + if (details_call_site.found && details_adjusted_call_site.found) { + // Ok, we assume that details_adjusted_call_site is a better estimation. + details_selected = &details_adjusted_call_site; + trace.addr = (void *)(uintptr_t(trace.addr) - 1); + } + + if (details_selected == &details_call_site && details_call_site.found) { + // we have to re-resolve the symbol in order to reset some + // internal state in BFD... so we can call backtrace_inliners + // thereafter... + details_call_site = + find_symbol_details(fobj, trace.addr, symbol_info.dli_fbase); + } +#endif // BACKWARD_HAS_UNWIND + + if (details_selected->found) { + if (details_selected->filename) { + trace.source.filename = details_selected->filename; + } + trace.source.line = details_selected->line; + + if (details_selected->funcname) { + // this time we get the name of the function where the code is + // located, instead of the function were the address is + // located. In short, if the code was inlined, we get the + // function correspoding to the code. Else we already got in + // trace.function. + trace.source.function = demangle(details_selected->funcname); + + if (!symbol_info.dli_sname) { + // for the case dladdr failed to find the symbol name of + // the function, we might as well try to put something + // here. + trace.object_function = trace.source.function; + } + } + + // Maybe the source of the trace got inlined inside the function + // (trace.source.function). Let's see if we can get all the inlined + // calls along the way up to the initial call site. + trace.inliners = backtrace_inliners(fobj, *details_selected); + +#if 0 + if (trace.inliners.size() == 0) { + // Maybe the trace was not inlined... or maybe it was and we + // are lacking the debug information. Let's try to make the + // world better and see if we can get the line number of the + // function (trace.source.function) now. + // + // We will get the location of where the function start (to be + // exact: the first instruction that really start the + // function), not where the name of the function is defined. + // This can be quite far away from the name of the function + // btw. + // + // If the source of the function is the same as the source of + // the trace, we cannot say if the trace was really inlined or + // not. However, if the filename of the source is different + // between the function and the trace... we can declare it as + // an inliner. This is not 100% accurate, but better than + // nothing. + + if (symbol_info.dli_saddr) { + find_sym_result details = find_symbol_details(fobj, + symbol_info.dli_saddr, + symbol_info.dli_fbase); + + if (details.found) { + ResolvedTrace::SourceLoc diy_inliner; + diy_inliner.line = details.line; + if (details.filename) { + diy_inliner.filename = details.filename; + } + if (details.funcname) { + diy_inliner.function = demangle(details.funcname); + } else { + diy_inliner.function = trace.source.function; + } + if (diy_inliner != trace.source) { + trace.inliners.push_back(diy_inliner); + } + } + } + } +#endif + } + + return trace; + } + +private: + bool _bfd_loaded; + + typedef details::handle<bfd *, + details::deleter<bfd_boolean, bfd *, &bfd_close>> + bfd_handle_t; + + typedef details::handle<asymbol **> bfd_symtab_t; + + struct bfd_fileobject { + bfd_handle_t handle; + bfd_vma base_addr; + bfd_symtab_t symtab; + bfd_symtab_t dynamic_symtab; + }; + + typedef details::hashtable<std::string, bfd_fileobject>::type fobj_bfd_map_t; + fobj_bfd_map_t _fobj_bfd_map; + + bfd_fileobject *load_object_with_bfd(const std::string &filename_object) { + using namespace details; + + if (!_bfd_loaded) { + using namespace details; + bfd_init(); + _bfd_loaded = true; + } + + fobj_bfd_map_t::iterator it = _fobj_bfd_map.find(filename_object); + if (it != _fobj_bfd_map.end()) { + return &it->second; + } + + // this new object is empty for now. + bfd_fileobject *r = &_fobj_bfd_map[filename_object]; + + // we do the work temporary in this one; + bfd_handle_t bfd_handle; + + int fd = open(filename_object.c_str(), O_RDONLY); + bfd_handle.reset(bfd_fdopenr(filename_object.c_str(), "default", fd)); + if (!bfd_handle) { + close(fd); + return r; + } + + if (!bfd_check_format(bfd_handle.get(), bfd_object)) { + return r; // not an object? You lose. + } + + if ((bfd_get_file_flags(bfd_handle.get()) & HAS_SYMS) == 0) { + return r; // that's what happen when you forget to compile in debug. + } + + ssize_t symtab_storage_size = bfd_get_symtab_upper_bound(bfd_handle.get()); + + ssize_t dyn_symtab_storage_size = + bfd_get_dynamic_symtab_upper_bound(bfd_handle.get()); + + if (symtab_storage_size <= 0 && dyn_symtab_storage_size <= 0) { + return r; // weird, is the file is corrupted? + } + + bfd_symtab_t symtab, dynamic_symtab; + ssize_t symcount = 0, dyn_symcount = 0; + + if (symtab_storage_size > 0) { + symtab.reset(static_cast<bfd_symbol **>( + malloc(static_cast<size_t>(symtab_storage_size)))); + symcount = bfd_canonicalize_symtab(bfd_handle.get(), symtab.get()); + } + + if (dyn_symtab_storage_size > 0) { + dynamic_symtab.reset(static_cast<bfd_symbol **>( + malloc(static_cast<size_t>(dyn_symtab_storage_size)))); + dyn_symcount = bfd_canonicalize_dynamic_symtab(bfd_handle.get(), + dynamic_symtab.get()); + } + + if (symcount <= 0 && dyn_symcount <= 0) { + return r; // damned, that's a stripped file that you got there! + } + + r->handle = move(bfd_handle); + r->symtab = move(symtab); + r->dynamic_symtab = move(dynamic_symtab); + return r; + } + + struct find_sym_result { + bool found; + const char *filename; + const char *funcname; + unsigned int line; + }; + + struct find_sym_context { + TraceResolverLinuxImpl *self; + bfd_fileobject *fobj; + void *addr; + void *base_addr; + find_sym_result result; + }; + + find_sym_result find_symbol_details(bfd_fileobject *fobj, void *addr, + void *base_addr) { + find_sym_context context; + context.self = this; + context.fobj = fobj; + context.addr = addr; + context.base_addr = base_addr; + context.result.found = false; + bfd_map_over_sections(fobj->handle.get(), &find_in_section_trampoline, + static_cast<void *>(&context)); + return context.result; + } + + static void find_in_section_trampoline(bfd *, asection *section, void *data) { + find_sym_context *context = static_cast<find_sym_context *>(data); + context->self->find_in_section( + reinterpret_cast<bfd_vma>(context->addr), + reinterpret_cast<bfd_vma>(context->base_addr), context->fobj, section, + context->result); + } + + void find_in_section(bfd_vma addr, bfd_vma base_addr, bfd_fileobject *fobj, + asection *section, find_sym_result &result) { + if (result.found) + return; + +#ifdef bfd_get_section_flags + if ((bfd_get_section_flags(fobj->handle.get(), section) & SEC_ALLOC) == 0) +#else + if ((bfd_section_flags(section) & SEC_ALLOC) == 0) +#endif + return; // a debug section is never loaded automatically. + +#ifdef bfd_get_section_vma + bfd_vma sec_addr = bfd_get_section_vma(fobj->handle.get(), section); +#else + bfd_vma sec_addr = bfd_section_vma(section); +#endif +#ifdef bfd_get_section_size + bfd_size_type size = bfd_get_section_size(section); +#else + bfd_size_type size = bfd_section_size(section); +#endif + + // are we in the boundaries of the section? + if (addr < sec_addr || addr >= sec_addr + size) { + addr -= base_addr; // oups, a relocated object, lets try again... + if (addr < sec_addr || addr >= sec_addr + size) { + return; + } + } + +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" +#endif + if (!result.found && fobj->symtab) { + result.found = bfd_find_nearest_line( + fobj->handle.get(), section, fobj->symtab.get(), addr - sec_addr, + &result.filename, &result.funcname, &result.line); + } + + if (!result.found && fobj->dynamic_symtab) { + result.found = bfd_find_nearest_line( + fobj->handle.get(), section, fobj->dynamic_symtab.get(), + addr - sec_addr, &result.filename, &result.funcname, &result.line); + } +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + ResolvedTrace::source_locs_t + backtrace_inliners(bfd_fileobject *fobj, find_sym_result previous_result) { + // This function can be called ONLY after a SUCCESSFUL call to + // find_symbol_details. The state is global to the bfd_handle. + ResolvedTrace::source_locs_t results; + while (previous_result.found) { + find_sym_result result; + result.found = bfd_find_inliner_info(fobj->handle.get(), &result.filename, + &result.funcname, &result.line); + + if (result + .found) /* and not ( + cstrings_eq(previous_result.filename, + result.filename) and + cstrings_eq(previous_result.funcname, result.funcname) + and result.line == previous_result.line + )) */ + { + ResolvedTrace::SourceLoc src_loc; + src_loc.line = result.line; + if (result.filename) { + src_loc.filename = result.filename; + } + if (result.funcname) { + src_loc.function = demangle(result.funcname); + } + results.push_back(src_loc); + } + previous_result = result; + } + return results; + } + + bool cstrings_eq(const char *a, const char *b) { + if (!a || !b) { + return false; + } + return strcmp(a, b) == 0; + } +}; +#endif // BACKWARD_HAS_BFD == 1 + +#if BACKWARD_HAS_DW == 1 + +template <> +class TraceResolverLinuxImpl<trace_resolver_tag::libdw> + : public TraceResolverLinuxBase { +public: + TraceResolverLinuxImpl() : _dwfl_handle_initialized(false) {} + + ResolvedTrace resolve(ResolvedTrace trace) override { + using namespace details; + + Dwarf_Addr trace_addr = (Dwarf_Addr)trace.addr; + + if (!_dwfl_handle_initialized) { + // initialize dwfl... + _dwfl_cb.reset(new Dwfl_Callbacks); + _dwfl_cb->find_elf = &dwfl_linux_proc_find_elf; + _dwfl_cb->find_debuginfo = &dwfl_standard_find_debuginfo; + _dwfl_cb->debuginfo_path = 0; + + _dwfl_handle.reset(dwfl_begin(_dwfl_cb.get())); + _dwfl_handle_initialized = true; + + if (!_dwfl_handle) { + return trace; + } + + // ...from the current process. + dwfl_report_begin(_dwfl_handle.get()); + int r = dwfl_linux_proc_report(_dwfl_handle.get(), getpid()); + dwfl_report_end(_dwfl_handle.get(), NULL, NULL); + if (r < 0) { + return trace; + } + } + + if (!_dwfl_handle) { + return trace; + } + + // find the module (binary object) that contains the trace's address. + // This is not using any debug information, but the addresses ranges of + // all the currently loaded binary object. + Dwfl_Module *mod = dwfl_addrmodule(_dwfl_handle.get(), trace_addr); + if (mod) { + // now that we found it, lets get the name of it, this will be the + // full path to the running binary or one of the loaded library. + const char *module_name = dwfl_module_info(mod, 0, 0, 0, 0, 0, 0, 0); + if (module_name) { + trace.object_filename = module_name; + } + // We also look after the name of the symbol, equal or before this + // address. This is found by walking the symtab. We should get the + // symbol corresponding to the function (mangled) containing the + // address. If the code corresponding to the address was inlined, + // this is the name of the out-most inliner function. + const char *sym_name = dwfl_module_addrname(mod, trace_addr); + if (sym_name) { + trace.object_function = demangle(sym_name); + } + } + + // now let's get serious, and find out the source location (file and + // line number) of the address. + + // This function will look in .debug_aranges for the address and map it + // to the location of the compilation unit DIE in .debug_info and + // return it. + Dwarf_Addr mod_bias = 0; + Dwarf_Die *cudie = dwfl_module_addrdie(mod, trace_addr, &mod_bias); + +#if 1 + if (!cudie) { + // Sadly clang does not generate the section .debug_aranges, thus + // dwfl_module_addrdie will fail early. Clang doesn't either set + // the lowpc/highpc/range info for every compilation unit. + // + // So in order to save the world: + // for every compilation unit, we will iterate over every single + // DIEs. Normally functions should have a lowpc/highpc/range, which + // we will use to infer the compilation unit. + + // note that this is probably badly inefficient. + while ((cudie = dwfl_module_nextcu(mod, cudie, &mod_bias))) { + Dwarf_Die die_mem; + Dwarf_Die *fundie = + find_fundie_by_pc(cudie, trace_addr - mod_bias, &die_mem); + if (fundie) { + break; + } + } + } +#endif + +//#define BACKWARD_I_DO_NOT_RECOMMEND_TO_ENABLE_THIS_HORRIBLE_PIECE_OF_CODE +#ifdef BACKWARD_I_DO_NOT_RECOMMEND_TO_ENABLE_THIS_HORRIBLE_PIECE_OF_CODE + if (!cudie) { + // If it's still not enough, lets dive deeper in the shit, and try + // to save the world again: for every compilation unit, we will + // load the corresponding .debug_line section, and see if we can + // find our address in it. + + Dwarf_Addr cfi_bias; + Dwarf_CFI *cfi_cache = dwfl_module_eh_cfi(mod, &cfi_bias); + + Dwarf_Addr bias; + while ((cudie = dwfl_module_nextcu(mod, cudie, &bias))) { + if (dwarf_getsrc_die(cudie, trace_addr - bias)) { + + // ...but if we get a match, it might be a false positive + // because our (address - bias) might as well be valid in a + // different compilation unit. So we throw our last card on + // the table and lookup for the address into the .eh_frame + // section. + + handle<Dwarf_Frame *> frame; + dwarf_cfi_addrframe(cfi_cache, trace_addr - cfi_bias, &frame); + if (frame) { + break; + } + } + } + } +#endif + + if (!cudie) { + return trace; // this time we lost the game :/ + } + + // Now that we have a compilation unit DIE, this function will be able + // to load the corresponding section in .debug_line (if not already + // loaded) and hopefully find the source location mapped to our + // address. + Dwarf_Line *srcloc = dwarf_getsrc_die(cudie, trace_addr - mod_bias); + + if (srcloc) { + const char *srcfile = dwarf_linesrc(srcloc, 0, 0); + if (srcfile) { + trace.source.filename = srcfile; + } + int line = 0, col = 0; + dwarf_lineno(srcloc, &line); + dwarf_linecol(srcloc, &col); + trace.source.line = line; + trace.source.col = col; + } + + deep_first_search_by_pc(cudie, trace_addr - mod_bias, + inliners_search_cb(trace)); + if (trace.source.function.size() == 0) { + // fallback. + trace.source.function = trace.object_function; + } + + return trace; + } + +private: + typedef details::handle<Dwfl *, details::deleter<void, Dwfl *, &dwfl_end>> + dwfl_handle_t; + details::handle<Dwfl_Callbacks *, details::default_delete<Dwfl_Callbacks *>> + _dwfl_cb; + dwfl_handle_t _dwfl_handle; + bool _dwfl_handle_initialized; + + // defined here because in C++98, template function cannot take locally + // defined types... grrr. + struct inliners_search_cb { + void operator()(Dwarf_Die *die) { + switch (dwarf_tag(die)) { + const char *name; + case DW_TAG_subprogram: + if ((name = dwarf_diename(die))) { + trace.source.function = name; + } + break; + + case DW_TAG_inlined_subroutine: + ResolvedTrace::SourceLoc sloc; + Dwarf_Attribute attr_mem; + + if ((name = dwarf_diename(die))) { + sloc.function = name; + } + if ((name = die_call_file(die))) { + sloc.filename = name; + } + + Dwarf_Word line = 0, col = 0; + dwarf_formudata(dwarf_attr(die, DW_AT_call_line, &attr_mem), &line); + dwarf_formudata(dwarf_attr(die, DW_AT_call_column, &attr_mem), &col); + sloc.line = (unsigned)line; + sloc.col = (unsigned)col; + + trace.inliners.push_back(sloc); + break; + }; + } + ResolvedTrace &trace; + inliners_search_cb(ResolvedTrace &t) : trace(t) {} + }; + + static bool die_has_pc(Dwarf_Die *die, Dwarf_Addr pc) { + Dwarf_Addr low, high; + + // continuous range + if (dwarf_hasattr(die, DW_AT_low_pc) && dwarf_hasattr(die, DW_AT_high_pc)) { + if (dwarf_lowpc(die, &low) != 0) { + return false; + } + if (dwarf_highpc(die, &high) != 0) { + Dwarf_Attribute attr_mem; + Dwarf_Attribute *attr = dwarf_attr(die, DW_AT_high_pc, &attr_mem); + Dwarf_Word value; + if (dwarf_formudata(attr, &value) != 0) { + return false; + } + high = low + value; + } + return pc >= low && pc < high; + } + + // non-continuous range. + Dwarf_Addr base; + ptrdiff_t offset = 0; + while ((offset = dwarf_ranges(die, offset, &base, &low, &high)) > 0) { + if (pc >= low && pc < high) { + return true; + } + } + return false; + } + + static Dwarf_Die *find_fundie_by_pc(Dwarf_Die *parent_die, Dwarf_Addr pc, + Dwarf_Die *result) { + if (dwarf_child(parent_die, result) != 0) { + return 0; + } + + Dwarf_Die *die = result; + do { + switch (dwarf_tag(die)) { + case DW_TAG_subprogram: + case DW_TAG_inlined_subroutine: + if (die_has_pc(die, pc)) { + return result; + } + }; + bool declaration = false; + Dwarf_Attribute attr_mem; + dwarf_formflag(dwarf_attr(die, DW_AT_declaration, &attr_mem), + &declaration); + if (!declaration) { + // let's be curious and look deeper in the tree, + // function are not necessarily at the first level, but + // might be nested inside a namespace, structure etc. + Dwarf_Die die_mem; + Dwarf_Die *indie = find_fundie_by_pc(die, pc, &die_mem); + if (indie) { + *result = die_mem; + return result; + } + } + } while (dwarf_siblingof(die, result) == 0); + return 0; + } + + template <typename CB> + static bool deep_first_search_by_pc(Dwarf_Die *parent_die, Dwarf_Addr pc, + CB cb) { + Dwarf_Die die_mem; + if (dwarf_child(parent_die, &die_mem) != 0) { + return false; + } + + bool branch_has_pc = false; + Dwarf_Die *die = &die_mem; + do { + bool declaration = false; + Dwarf_Attribute attr_mem; + dwarf_formflag(dwarf_attr(die, DW_AT_declaration, &attr_mem), + &declaration); + if (!declaration) { + // let's be curious and look deeper in the tree, function are + // not necessarily at the first level, but might be nested + // inside a namespace, structure, a function, an inlined + // function etc. + branch_has_pc = deep_first_search_by_pc(die, pc, cb); + } + if (!branch_has_pc) { + branch_has_pc = die_has_pc(die, pc); + } + if (branch_has_pc) { + cb(die); + } + } while (dwarf_siblingof(die, &die_mem) == 0); + return branch_has_pc; + } + + static const char *die_call_file(Dwarf_Die *die) { + Dwarf_Attribute attr_mem; + Dwarf_Word file_idx = 0; + + dwarf_formudata(dwarf_attr(die, DW_AT_call_file, &attr_mem), &file_idx); + + if (file_idx == 0) { + return 0; + } + + Dwarf_Die die_mem; + Dwarf_Die *cudie = dwarf_diecu(die, &die_mem, 0, 0); + if (!cudie) { + return 0; + } + + Dwarf_Files *files = 0; + size_t nfiles; + dwarf_getsrcfiles(cudie, &files, &nfiles); + if (!files) { + return 0; + } + + return dwarf_filesrc(files, file_idx, 0, 0); + } +}; +#endif // BACKWARD_HAS_DW == 1 + +#if BACKWARD_HAS_DWARF == 1 + +template <> +class TraceResolverLinuxImpl<trace_resolver_tag::libdwarf> + : public TraceResolverLinuxBase { +public: + TraceResolverLinuxImpl() : _dwarf_loaded(false) {} + + ResolvedTrace resolve(ResolvedTrace trace) override { + // trace.addr is a virtual address in memory pointing to some code. + // Let's try to find from which loaded object it comes from. + // The loaded object can be yourself btw. + + Dl_info symbol_info; + int dladdr_result = 0; +#if defined(__GLIBC__) + link_map *link_map; + // We request the link map so we can get information about offsets + dladdr_result = + dladdr1(trace.addr, &symbol_info, reinterpret_cast<void **>(&link_map), + RTLD_DL_LINKMAP); +#else + // Android doesn't have dladdr1. Don't use the linker map. + dladdr_result = dladdr(trace.addr, &symbol_info); +#endif + if (!dladdr_result) { + return trace; // dat broken trace... + } + + // Now we get in symbol_info: + // .dli_fname: + // pathname of the shared object that contains the address. + // .dli_fbase: + // where the object is loaded in memory. + // .dli_sname: + // the name of the nearest symbol to trace.addr, we expect a + // function name. + // .dli_saddr: + // the exact address corresponding to .dli_sname. + // + // And in link_map: + // .l_addr: + // difference between the address in the ELF file and the address + // in memory + // l_name: + // absolute pathname where the object was found + + if (symbol_info.dli_sname) { + trace.object_function = demangle(symbol_info.dli_sname); + } + + if (!symbol_info.dli_fname) { + return trace; + } + + trace.object_filename = resolve_exec_path(symbol_info); + dwarf_fileobject &fobj = load_object_with_dwarf(symbol_info.dli_fname); + if (!fobj.dwarf_handle) { + return trace; // sad, we couldn't load the object :( + } + +#if defined(__GLIBC__) + // Convert the address to a module relative one by looking at + // the module's loading address in the link map + Dwarf_Addr address = reinterpret_cast<uintptr_t>(trace.addr) - + reinterpret_cast<uintptr_t>(link_map->l_addr); +#else + Dwarf_Addr address = reinterpret_cast<uintptr_t>(trace.addr); +#endif + + if (trace.object_function.empty()) { + symbol_cache_t::iterator it = fobj.symbol_cache.lower_bound(address); + + if (it != fobj.symbol_cache.end()) { + if (it->first != address) { + if (it != fobj.symbol_cache.begin()) { + --it; + } + } + trace.object_function = demangle(it->second.c_str()); + } + } + + // Get the Compilation Unit DIE for the address + Dwarf_Die die = find_die(fobj, address); + + if (!die) { + return trace; // this time we lost the game :/ + } + + // libdwarf doesn't give us direct access to its objects, it always + // allocates a copy for the caller. We keep that copy alive in a cache + // and we deallocate it later when it's no longer required. + die_cache_entry &die_object = get_die_cache(fobj, die); + if (die_object.isEmpty()) + return trace; // We have no line section for this DIE + + die_linemap_t::iterator it = die_object.line_section.lower_bound(address); + + if (it != die_object.line_section.end()) { + if (it->first != address) { + if (it == die_object.line_section.begin()) { + // If we are on the first item of the line section + // but the address does not match it means that + // the address is below the range of the DIE. Give up. + return trace; + } else { + --it; + } + } + } else { + return trace; // We didn't find the address. + } + + // Get the Dwarf_Line that the address points to and call libdwarf + // to get source file, line and column info. + Dwarf_Line line = die_object.line_buffer[it->second]; + Dwarf_Error error = DW_DLE_NE; + + char *filename; + if (dwarf_linesrc(line, &filename, &error) == DW_DLV_OK) { + trace.source.filename = std::string(filename); + dwarf_dealloc(fobj.dwarf_handle.get(), filename, DW_DLA_STRING); + } + + Dwarf_Unsigned number = 0; + if (dwarf_lineno(line, &number, &error) == DW_DLV_OK) { + trace.source.line = number; + } else { + trace.source.line = 0; + } + + if (dwarf_lineoff_b(line, &number, &error) == DW_DLV_OK) { + trace.source.col = number; + } else { + trace.source.col = 0; + } + + std::vector<std::string> namespace_stack; + deep_first_search_by_pc(fobj, die, address, namespace_stack, + inliners_search_cb(trace, fobj, die)); + + dwarf_dealloc(fobj.dwarf_handle.get(), die, DW_DLA_DIE); + + return trace; + } + +public: + static int close_dwarf(Dwarf_Debug dwarf) { + return dwarf_finish(dwarf, NULL); + } + +private: + bool _dwarf_loaded; + + typedef details::handle<int, details::deleter<int, int, &::close>> + dwarf_file_t; + + typedef details::handle<Elf *, details::deleter<int, Elf *, &elf_end>> + dwarf_elf_t; + + typedef details::handle<Dwarf_Debug, + details::deleter<int, Dwarf_Debug, &close_dwarf>> + dwarf_handle_t; + + typedef std::map<Dwarf_Addr, int> die_linemap_t; + + typedef std::map<Dwarf_Off, Dwarf_Off> die_specmap_t; + + struct die_cache_entry { + die_specmap_t spec_section; + die_linemap_t line_section; + Dwarf_Line *line_buffer; + Dwarf_Signed line_count; + Dwarf_Line_Context line_context; + + inline bool isEmpty() { + return line_buffer == NULL || line_count == 0 || line_context == NULL || + line_section.empty(); + } + + die_cache_entry() : line_buffer(0), line_count(0), line_context(0) {} + + ~die_cache_entry() { + if (line_context) { + dwarf_srclines_dealloc_b(line_context); + } + } + }; + + typedef std::map<Dwarf_Off, die_cache_entry> die_cache_t; + + typedef std::map<uintptr_t, std::string> symbol_cache_t; + + struct dwarf_fileobject { + dwarf_file_t file_handle; + dwarf_elf_t elf_handle; + dwarf_handle_t dwarf_handle; + symbol_cache_t symbol_cache; + + // Die cache + die_cache_t die_cache; + die_cache_entry *current_cu; + }; + + typedef details::hashtable<std::string, dwarf_fileobject>::type + fobj_dwarf_map_t; + fobj_dwarf_map_t _fobj_dwarf_map; + + static bool cstrings_eq(const char *a, const char *b) { + if (!a || !b) { + return false; + } + return strcmp(a, b) == 0; + } + + dwarf_fileobject &load_object_with_dwarf(const std::string &filename_object) { + + if (!_dwarf_loaded) { + // Set the ELF library operating version + // If that fails there's nothing we can do + _dwarf_loaded = elf_version(EV_CURRENT) != EV_NONE; + } + + fobj_dwarf_map_t::iterator it = _fobj_dwarf_map.find(filename_object); + if (it != _fobj_dwarf_map.end()) { + return it->second; + } + + // this new object is empty for now + dwarf_fileobject &r = _fobj_dwarf_map[filename_object]; + + dwarf_file_t file_handle; + file_handle.reset(open(filename_object.c_str(), O_RDONLY)); + if (file_handle.get() < 0) { + return r; + } + + // Try to get an ELF handle. We need to read the ELF sections + // because we want to see if there is a .gnu_debuglink section + // that points to a split debug file + dwarf_elf_t elf_handle; + elf_handle.reset(elf_begin(file_handle.get(), ELF_C_READ, NULL)); + if (!elf_handle) { + return r; + } + + const char *e_ident = elf_getident(elf_handle.get(), 0); + if (!e_ident) { + return r; + } + + // Get the number of sections + // We use the new APIs as elf_getshnum is deprecated + size_t shdrnum = 0; + if (elf_getshdrnum(elf_handle.get(), &shdrnum) == -1) { + return r; + } + + // Get the index to the string section + size_t shdrstrndx = 0; + if (elf_getshdrstrndx(elf_handle.get(), &shdrstrndx) == -1) { + return r; + } + + std::string debuglink; + // Iterate through the ELF sections to try to get a gnu_debuglink + // note and also to cache the symbol table. + // We go the preprocessor way to avoid having to create templated + // classes or using gelf (which might throw a compiler error if 64 bit + // is not supported +#define ELF_GET_DATA(ARCH) \ + Elf_Scn *elf_section = 0; \ + Elf_Data *elf_data = 0; \ + Elf##ARCH##_Shdr *section_header = 0; \ + Elf_Scn *symbol_section = 0; \ + size_t symbol_count = 0; \ + size_t symbol_strings = 0; \ + Elf##ARCH##_Sym *symbol = 0; \ + const char *section_name = 0; \ + \ + while ((elf_section = elf_nextscn(elf_handle.get(), elf_section)) != NULL) { \ + section_header = elf##ARCH##_getshdr(elf_section); \ + if (section_header == NULL) { \ + return r; \ + } \ + \ + if ((section_name = elf_strptr(elf_handle.get(), shdrstrndx, \ + section_header->sh_name)) == NULL) { \ + return r; \ + } \ + \ + if (cstrings_eq(section_name, ".gnu_debuglink")) { \ + elf_data = elf_getdata(elf_section, NULL); \ + if (elf_data && elf_data->d_size > 0) { \ + debuglink = \ + std::string(reinterpret_cast<const char *>(elf_data->d_buf)); \ + } \ + } \ + \ + switch (section_header->sh_type) { \ + case SHT_SYMTAB: \ + symbol_section = elf_section; \ + symbol_count = section_header->sh_size / section_header->sh_entsize; \ + symbol_strings = section_header->sh_link; \ + break; \ + \ + /* We use .dynsyms as a last resort, we prefer .symtab */ \ + case SHT_DYNSYM: \ + if (!symbol_section) { \ + symbol_section = elf_section; \ + symbol_count = section_header->sh_size / section_header->sh_entsize; \ + symbol_strings = section_header->sh_link; \ + } \ + break; \ + } \ + } \ + \ + if (symbol_section && symbol_count && symbol_strings) { \ + elf_data = elf_getdata(symbol_section, NULL); \ + symbol = reinterpret_cast<Elf##ARCH##_Sym *>(elf_data->d_buf); \ + for (size_t i = 0; i < symbol_count; ++i) { \ + int type = ELF##ARCH##_ST_TYPE(symbol->st_info); \ + if (type == STT_FUNC && symbol->st_value > 0) { \ + r.symbol_cache[symbol->st_value] = std::string( \ + elf_strptr(elf_handle.get(), symbol_strings, symbol->st_name)); \ + } \ + ++symbol; \ + } \ + } + + if (e_ident[EI_CLASS] == ELFCLASS32) { + ELF_GET_DATA(32) + } else if (e_ident[EI_CLASS] == ELFCLASS64) { + // libelf might have been built without 64 bit support +#if __LIBELF64 + ELF_GET_DATA(64) +#endif + } + + if (!debuglink.empty()) { + // We have a debuglink section! Open an elf instance on that + // file instead. If we can't open the file, then return + // the elf handle we had already opened. + dwarf_file_t debuglink_file; + debuglink_file.reset(open(debuglink.c_str(), O_RDONLY)); + if (debuglink_file.get() > 0) { + dwarf_elf_t debuglink_elf; + debuglink_elf.reset(elf_begin(debuglink_file.get(), ELF_C_READ, NULL)); + + // If we have a valid elf handle, return the new elf handle + // and file handle and discard the original ones + if (debuglink_elf) { + elf_handle = move(debuglink_elf); + file_handle = move(debuglink_file); + } + } + } + + // Ok, we have a valid ELF handle, let's try to get debug symbols + Dwarf_Debug dwarf_debug; + Dwarf_Error error = DW_DLE_NE; + dwarf_handle_t dwarf_handle; + + int dwarf_result = dwarf_elf_init(elf_handle.get(), DW_DLC_READ, NULL, NULL, + &dwarf_debug, &error); + + // We don't do any special handling for DW_DLV_NO_ENTRY specially. + // If we get an error, or the file doesn't have debug information + // we just return. + if (dwarf_result != DW_DLV_OK) { + return r; + } + + dwarf_handle.reset(dwarf_debug); + + r.file_handle = move(file_handle); + r.elf_handle = move(elf_handle); + r.dwarf_handle = move(dwarf_handle); + + return r; + } + + die_cache_entry &get_die_cache(dwarf_fileobject &fobj, Dwarf_Die die) { + Dwarf_Error error = DW_DLE_NE; + + // Get the die offset, we use it as the cache key + Dwarf_Off die_offset; + if (dwarf_dieoffset(die, &die_offset, &error) != DW_DLV_OK) { + die_offset = 0; + } + + die_cache_t::iterator it = fobj.die_cache.find(die_offset); + + if (it != fobj.die_cache.end()) { + fobj.current_cu = &it->second; + return it->second; + } + + die_cache_entry &de = fobj.die_cache[die_offset]; + fobj.current_cu = &de; + + Dwarf_Addr line_addr; + Dwarf_Small table_count; + + // The addresses in the line section are not fully sorted (they might + // be sorted by block of code belonging to the same file), which makes + // it necessary to do so before searching is possible. + // + // As libdwarf allocates a copy of everything, let's get the contents + // of the line section and keep it around. We also create a map of + // program counter to line table indices so we can search by address + // and get the line buffer index. + // + // To make things more difficult, the same address can span more than + // one line, so we need to keep the index pointing to the first line + // by using insert instead of the map's [ operator. + + // Get the line context for the DIE + if (dwarf_srclines_b(die, 0, &table_count, &de.line_context, &error) == + DW_DLV_OK) { + // Get the source lines for this line context, to be deallocated + // later + if (dwarf_srclines_from_linecontext(de.line_context, &de.line_buffer, + &de.line_count, + &error) == DW_DLV_OK) { + + // Add all the addresses to our map + for (int i = 0; i < de.line_count; i++) { + if (dwarf_lineaddr(de.line_buffer[i], &line_addr, &error) != + DW_DLV_OK) { + line_addr = 0; + } + de.line_section.insert(std::pair<Dwarf_Addr, int>(line_addr, i)); + } + } + } + + // For each CU, cache the function DIEs that contain the + // DW_AT_specification attribute. When building with -g3 the function + // DIEs are separated in declaration and specification, with the + // declaration containing only the name and parameters and the + // specification the low/high pc and other compiler attributes. + // + // We cache those specifications so we don't skip over the declarations, + // because they have no pc, and we can do namespace resolution for + // DWARF function names. + Dwarf_Debug dwarf = fobj.dwarf_handle.get(); + Dwarf_Die current_die = 0; + if (dwarf_child(die, ¤t_die, &error) == DW_DLV_OK) { + for (;;) { + Dwarf_Die sibling_die = 0; + + Dwarf_Half tag_value; + dwarf_tag(current_die, &tag_value, &error); + + if (tag_value == DW_TAG_subprogram || + tag_value == DW_TAG_inlined_subroutine) { + + Dwarf_Bool has_attr = 0; + if (dwarf_hasattr(current_die, DW_AT_specification, &has_attr, + &error) == DW_DLV_OK) { + if (has_attr) { + Dwarf_Attribute attr_mem; + if (dwarf_attr(current_die, DW_AT_specification, &attr_mem, + &error) == DW_DLV_OK) { + Dwarf_Off spec_offset = 0; + if (dwarf_formref(attr_mem, &spec_offset, &error) == + DW_DLV_OK) { + Dwarf_Off spec_die_offset; + if (dwarf_dieoffset(current_die, &spec_die_offset, &error) == + DW_DLV_OK) { + de.spec_section[spec_offset] = spec_die_offset; + } + } + } + dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); + } + } + } + + int result = dwarf_siblingof(dwarf, current_die, &sibling_die, &error); + if (result == DW_DLV_ERROR) { + break; + } else if (result == DW_DLV_NO_ENTRY) { + break; + } + + if (current_die != die) { + dwarf_dealloc(dwarf, current_die, DW_DLA_DIE); + current_die = 0; + } + + current_die = sibling_die; + } + } + return de; + } + + static Dwarf_Die get_referenced_die(Dwarf_Debug dwarf, Dwarf_Die die, + Dwarf_Half attr, bool global) { + Dwarf_Error error = DW_DLE_NE; + Dwarf_Attribute attr_mem; + + Dwarf_Die found_die = NULL; + if (dwarf_attr(die, attr, &attr_mem, &error) == DW_DLV_OK) { + Dwarf_Off offset; + int result = 0; + if (global) { + result = dwarf_global_formref(attr_mem, &offset, &error); + } else { + result = dwarf_formref(attr_mem, &offset, &error); + } + + if (result == DW_DLV_OK) { + if (dwarf_offdie(dwarf, offset, &found_die, &error) != DW_DLV_OK) { + found_die = NULL; + } + } + dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); + } + return found_die; + } + + static std::string get_referenced_die_name(Dwarf_Debug dwarf, Dwarf_Die die, + Dwarf_Half attr, bool global) { + Dwarf_Error error = DW_DLE_NE; + std::string value; + + Dwarf_Die found_die = get_referenced_die(dwarf, die, attr, global); + + if (found_die) { + char *name; + if (dwarf_diename(found_die, &name, &error) == DW_DLV_OK) { + if (name) { + value = std::string(name); + } + dwarf_dealloc(dwarf, name, DW_DLA_STRING); + } + dwarf_dealloc(dwarf, found_die, DW_DLA_DIE); + } + + return value; + } + + // Returns a spec DIE linked to the passed one. The caller should + // deallocate the DIE + static Dwarf_Die get_spec_die(dwarf_fileobject &fobj, Dwarf_Die die) { + Dwarf_Debug dwarf = fobj.dwarf_handle.get(); + Dwarf_Error error = DW_DLE_NE; + Dwarf_Off die_offset; + if (fobj.current_cu && + dwarf_die_CU_offset(die, &die_offset, &error) == DW_DLV_OK) { + die_specmap_t::iterator it = + fobj.current_cu->spec_section.find(die_offset); + + // If we have a DIE that completes the current one, check if + // that one has the pc we are looking for + if (it != fobj.current_cu->spec_section.end()) { + Dwarf_Die spec_die = 0; + if (dwarf_offdie(dwarf, it->second, &spec_die, &error) == DW_DLV_OK) { + return spec_die; + } + } + } + + // Maybe we have an abstract origin DIE with the function information? + return get_referenced_die(fobj.dwarf_handle.get(), die, + DW_AT_abstract_origin, true); + } + + static bool die_has_pc(dwarf_fileobject &fobj, Dwarf_Die die, Dwarf_Addr pc) { + Dwarf_Addr low_pc = 0, high_pc = 0; + Dwarf_Half high_pc_form = 0; + Dwarf_Form_Class return_class; + Dwarf_Error error = DW_DLE_NE; + Dwarf_Debug dwarf = fobj.dwarf_handle.get(); + bool has_lowpc = false; + bool has_highpc = false; + bool has_ranges = false; + + if (dwarf_lowpc(die, &low_pc, &error) == DW_DLV_OK) { + // If we have a low_pc check if there is a high pc. + // If we don't have a high pc this might mean we have a base + // address for the ranges list or just an address. + has_lowpc = true; + + if (dwarf_highpc_b(die, &high_pc, &high_pc_form, &return_class, &error) == + DW_DLV_OK) { + // We do have a high pc. In DWARF 4+ this is an offset from the + // low pc, but in earlier versions it's an absolute address. + + has_highpc = true; + // In DWARF 2/3 this would be a DW_FORM_CLASS_ADDRESS + if (return_class == DW_FORM_CLASS_CONSTANT) { + high_pc = low_pc + high_pc; + } + + // We have low and high pc, check if our address + // is in that range + return pc >= low_pc && pc < high_pc; + } + } else { + // Reset the low_pc, in case dwarf_lowpc failing set it to some + // undefined value. + low_pc = 0; + } + + // Check if DW_AT_ranges is present and search for the PC in the + // returned ranges list. We always add the low_pc, as it not set it will + // be 0, in case we had a DW_AT_low_pc and DW_AT_ranges pair + bool result = false; + + Dwarf_Attribute attr; + if (dwarf_attr(die, DW_AT_ranges, &attr, &error) == DW_DLV_OK) { + + Dwarf_Off offset; + if (dwarf_global_formref(attr, &offset, &error) == DW_DLV_OK) { + Dwarf_Ranges *ranges; + Dwarf_Signed ranges_count = 0; + Dwarf_Unsigned byte_count = 0; + + if (dwarf_get_ranges_a(dwarf, offset, die, &ranges, &ranges_count, + &byte_count, &error) == DW_DLV_OK) { + has_ranges = ranges_count != 0; + for (int i = 0; i < ranges_count; i++) { + if (ranges[i].dwr_addr1 != 0 && + pc >= ranges[i].dwr_addr1 + low_pc && + pc < ranges[i].dwr_addr2 + low_pc) { + result = true; + break; + } + } + dwarf_ranges_dealloc(dwarf, ranges, ranges_count); + } + } + } + + // Last attempt. We might have a single address set as low_pc. + if (!result && low_pc != 0 && pc == low_pc) { + result = true; + } + + // If we don't have lowpc, highpc and ranges maybe this DIE is a + // declaration that relies on a DW_AT_specification DIE that happens + // later. Use the specification cache we filled when we loaded this CU. + if (!result && (!has_lowpc && !has_highpc && !has_ranges)) { + Dwarf_Die spec_die = get_spec_die(fobj, die); + if (spec_die) { + result = die_has_pc(fobj, spec_die, pc); + dwarf_dealloc(dwarf, spec_die, DW_DLA_DIE); + } + } + + return result; + } + + static void get_type(Dwarf_Debug dwarf, Dwarf_Die die, std::string &type) { + Dwarf_Error error = DW_DLE_NE; + + Dwarf_Die child = 0; + if (dwarf_child(die, &child, &error) == DW_DLV_OK) { + get_type(dwarf, child, type); + } + + if (child) { + type.insert(0, "::"); + dwarf_dealloc(dwarf, child, DW_DLA_DIE); + } + + char *name; + if (dwarf_diename(die, &name, &error) == DW_DLV_OK) { + type.insert(0, std::string(name)); + dwarf_dealloc(dwarf, name, DW_DLA_STRING); + } else { + type.insert(0, "<unknown>"); + } + } + + static std::string get_type_by_signature(Dwarf_Debug dwarf, Dwarf_Die die) { + Dwarf_Error error = DW_DLE_NE; + + Dwarf_Sig8 signature; + Dwarf_Bool has_attr = 0; + if (dwarf_hasattr(die, DW_AT_signature, &has_attr, &error) == DW_DLV_OK) { + if (has_attr) { + Dwarf_Attribute attr_mem; + if (dwarf_attr(die, DW_AT_signature, &attr_mem, &error) == DW_DLV_OK) { + if (dwarf_formsig8(attr_mem, &signature, &error) != DW_DLV_OK) { + return std::string("<no type signature>"); + } + } + dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); + } + } + + Dwarf_Unsigned next_cu_header; + Dwarf_Sig8 tu_signature; + std::string result; + bool found = false; + + while (dwarf_next_cu_header_d(dwarf, 0, 0, 0, 0, 0, 0, 0, &tu_signature, 0, + &next_cu_header, 0, &error) == DW_DLV_OK) { + + if (strncmp(signature.signature, tu_signature.signature, 8) == 0) { + Dwarf_Die type_cu_die = 0; + if (dwarf_siblingof_b(dwarf, 0, 0, &type_cu_die, &error) == DW_DLV_OK) { + Dwarf_Die child_die = 0; + if (dwarf_child(type_cu_die, &child_die, &error) == DW_DLV_OK) { + get_type(dwarf, child_die, result); + found = !result.empty(); + dwarf_dealloc(dwarf, child_die, DW_DLA_DIE); + } + dwarf_dealloc(dwarf, type_cu_die, DW_DLA_DIE); + } + } + } + + if (found) { + while (dwarf_next_cu_header_d(dwarf, 0, 0, 0, 0, 0, 0, 0, 0, 0, + &next_cu_header, 0, &error) == DW_DLV_OK) { + // Reset the cu header state. Unfortunately, libdwarf's + // next_cu_header API keeps its own iterator per Dwarf_Debug + // that can't be reset. We need to keep fetching elements until + // the end. + } + } else { + // If we couldn't resolve the type just print out the signature + std::ostringstream string_stream; + string_stream << "<0x" << std::hex << std::setfill('0'); + for (int i = 0; i < 8; ++i) { + string_stream << std::setw(2) << std::hex + << (int)(unsigned char)(signature.signature[i]); + } + string_stream << ">"; + result = string_stream.str(); + } + return result; + } + + struct type_context_t { + bool is_const; + bool is_typedef; + bool has_type; + bool has_name; + std::string text; + + type_context_t() + : is_const(false), is_typedef(false), has_type(false), has_name(false) { + } + }; + + // Types are resolved from right to left: we get the variable name first + // and then all specifiers (like const or pointer) in a chain of DW_AT_type + // DIEs. Call this function recursively until we get a complete type + // string. + static void set_parameter_string(dwarf_fileobject &fobj, Dwarf_Die die, + type_context_t &context) { + char *name; + Dwarf_Error error = DW_DLE_NE; + + // typedefs contain also the base type, so we skip it and only + // print the typedef name + if (!context.is_typedef) { + if (dwarf_diename(die, &name, &error) == DW_DLV_OK) { + if (!context.text.empty()) { + context.text.insert(0, " "); + } + context.text.insert(0, std::string(name)); + dwarf_dealloc(fobj.dwarf_handle.get(), name, DW_DLA_STRING); + } + } else { + context.is_typedef = false; + context.has_type = true; + if (context.is_const) { + context.text.insert(0, "const "); + context.is_const = false; + } + } + + bool next_type_is_const = false; + bool is_keyword = true; + + Dwarf_Half tag = 0; + Dwarf_Bool has_attr = 0; + if (dwarf_tag(die, &tag, &error) == DW_DLV_OK) { + switch (tag) { + case DW_TAG_structure_type: + case DW_TAG_union_type: + case DW_TAG_class_type: + case DW_TAG_enumeration_type: + context.has_type = true; + if (dwarf_hasattr(die, DW_AT_signature, &has_attr, &error) == + DW_DLV_OK) { + // If we have a signature it means the type is defined + // in .debug_types, so we need to load the DIE pointed + // at by the signature and resolve it + if (has_attr) { + std::string type = + get_type_by_signature(fobj.dwarf_handle.get(), die); + if (context.is_const) + type.insert(0, "const "); + + if (!context.text.empty()) + context.text.insert(0, " "); + context.text.insert(0, type); + } + + // Treat enums like typedefs, and skip printing its + // base type + context.is_typedef = (tag == DW_TAG_enumeration_type); + } + break; + case DW_TAG_const_type: + next_type_is_const = true; + break; + case DW_TAG_pointer_type: + context.text.insert(0, "*"); + break; + case DW_TAG_reference_type: + context.text.insert(0, "&"); + break; + case DW_TAG_restrict_type: + context.text.insert(0, "restrict "); + break; + case DW_TAG_rvalue_reference_type: + context.text.insert(0, "&&"); + break; + case DW_TAG_volatile_type: + context.text.insert(0, "volatile "); + break; + case DW_TAG_typedef: + // Propagate the const-ness to the next type + // as typedefs are linked to its base type + next_type_is_const = context.is_const; + context.is_typedef = true; + context.has_type = true; + break; + case DW_TAG_base_type: + context.has_type = true; + break; + case DW_TAG_formal_parameter: + context.has_name = true; + break; + default: + is_keyword = false; + break; + } + } + + if (!is_keyword && context.is_const) { + context.text.insert(0, "const "); + } + + context.is_const = next_type_is_const; + + Dwarf_Die ref = + get_referenced_die(fobj.dwarf_handle.get(), die, DW_AT_type, true); + if (ref) { + set_parameter_string(fobj, ref, context); + dwarf_dealloc(fobj.dwarf_handle.get(), ref, DW_DLA_DIE); + } + + if (!context.has_type && context.has_name) { + context.text.insert(0, "void "); + context.has_type = true; + } + } + + // Resolve the function return type and parameters + static void set_function_parameters(std::string &function_name, + std::vector<std::string> &ns, + dwarf_fileobject &fobj, Dwarf_Die die) { + Dwarf_Debug dwarf = fobj.dwarf_handle.get(); + Dwarf_Error error = DW_DLE_NE; + Dwarf_Die current_die = 0; + std::string parameters; + bool has_spec = true; + // Check if we have a spec DIE. If we do we use it as it contains + // more information, like parameter names. + Dwarf_Die spec_die = get_spec_die(fobj, die); + if (!spec_die) { + has_spec = false; + spec_die = die; + } + + std::vector<std::string>::const_iterator it = ns.begin(); + std::string ns_name; + for (it = ns.begin(); it < ns.end(); ++it) { + ns_name.append(*it).append("::"); + } + + if (!ns_name.empty()) { + function_name.insert(0, ns_name); + } + + // See if we have a function return type. It can be either on the + // current die or in its spec one (usually true for inlined functions) + std::string return_type = + get_referenced_die_name(dwarf, die, DW_AT_type, true); + if (return_type.empty()) { + return_type = get_referenced_die_name(dwarf, spec_die, DW_AT_type, true); + } + if (!return_type.empty()) { + return_type.append(" "); + function_name.insert(0, return_type); + } + + if (dwarf_child(spec_die, ¤t_die, &error) == DW_DLV_OK) { + for (;;) { + Dwarf_Die sibling_die = 0; + + Dwarf_Half tag_value; + dwarf_tag(current_die, &tag_value, &error); + + if (tag_value == DW_TAG_formal_parameter) { + // Ignore artificial (ie, compiler generated) parameters + bool is_artificial = false; + Dwarf_Attribute attr_mem; + if (dwarf_attr(current_die, DW_AT_artificial, &attr_mem, &error) == + DW_DLV_OK) { + Dwarf_Bool flag = 0; + if (dwarf_formflag(attr_mem, &flag, &error) == DW_DLV_OK) { + is_artificial = flag != 0; + } + dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); + } + + if (!is_artificial) { + type_context_t context; + set_parameter_string(fobj, current_die, context); + + if (parameters.empty()) { + parameters.append("("); + } else { + parameters.append(", "); + } + parameters.append(context.text); + } + } + + int result = dwarf_siblingof(dwarf, current_die, &sibling_die, &error); + if (result == DW_DLV_ERROR) { + break; + } else if (result == DW_DLV_NO_ENTRY) { + break; + } + + if (current_die != die) { + dwarf_dealloc(dwarf, current_die, DW_DLA_DIE); + current_die = 0; + } + + current_die = sibling_die; + } + } + if (parameters.empty()) + parameters = "("; + parameters.append(")"); + + // If we got a spec DIE we need to deallocate it + if (has_spec) + dwarf_dealloc(dwarf, spec_die, DW_DLA_DIE); + + function_name.append(parameters); + } + + // defined here because in C++98, template function cannot take locally + // defined types... grrr. + struct inliners_search_cb { + void operator()(Dwarf_Die die, std::vector<std::string> &ns) { + Dwarf_Error error = DW_DLE_NE; + Dwarf_Half tag_value; + Dwarf_Attribute attr_mem; + Dwarf_Debug dwarf = fobj.dwarf_handle.get(); + + dwarf_tag(die, &tag_value, &error); + + switch (tag_value) { + char *name; + case DW_TAG_subprogram: + if (!trace.source.function.empty()) + break; + if (dwarf_diename(die, &name, &error) == DW_DLV_OK) { + trace.source.function = std::string(name); + dwarf_dealloc(dwarf, name, DW_DLA_STRING); + } else { + // We don't have a function name in this DIE. + // Check if there is a referenced non-defining + // declaration. + trace.source.function = + get_referenced_die_name(dwarf, die, DW_AT_abstract_origin, true); + if (trace.source.function.empty()) { + trace.source.function = + get_referenced_die_name(dwarf, die, DW_AT_specification, true); + } + } + + // Append the function parameters, if available + set_function_parameters(trace.source.function, ns, fobj, die); + + // If the object function name is empty, it's possible that + // there is no dynamic symbol table (maybe the executable + // was stripped or not built with -rdynamic). See if we have + // a DWARF linkage name to use instead. We try both + // linkage_name and MIPS_linkage_name because the MIPS tag + // was the unofficial one until it was adopted in DWARF4. + // Old gcc versions generate MIPS_linkage_name + if (trace.object_function.empty()) { + details::demangler demangler; + + if (dwarf_attr(die, DW_AT_linkage_name, &attr_mem, &error) != + DW_DLV_OK) { + if (dwarf_attr(die, DW_AT_MIPS_linkage_name, &attr_mem, &error) != + DW_DLV_OK) { + break; + } + } + + char *linkage; + if (dwarf_formstring(attr_mem, &linkage, &error) == DW_DLV_OK) { + trace.object_function = demangler.demangle(linkage); + dwarf_dealloc(dwarf, linkage, DW_DLA_STRING); + } + dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); + } + break; + + case DW_TAG_inlined_subroutine: + ResolvedTrace::SourceLoc sloc; + + if (dwarf_diename(die, &name, &error) == DW_DLV_OK) { + sloc.function = std::string(name); + dwarf_dealloc(dwarf, name, DW_DLA_STRING); + } else { + // We don't have a name for this inlined DIE, it could + // be that there is an abstract origin instead. + // Get the DW_AT_abstract_origin value, which is a + // reference to the source DIE and try to get its name + sloc.function = + get_referenced_die_name(dwarf, die, DW_AT_abstract_origin, true); + } + + set_function_parameters(sloc.function, ns, fobj, die); + + std::string file = die_call_file(dwarf, die, cu_die); + if (!file.empty()) + sloc.filename = file; + + Dwarf_Unsigned number = 0; + if (dwarf_attr(die, DW_AT_call_line, &attr_mem, &error) == DW_DLV_OK) { + if (dwarf_formudata(attr_mem, &number, &error) == DW_DLV_OK) { + sloc.line = number; + } + dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); + } + + if (dwarf_attr(die, DW_AT_call_column, &attr_mem, &error) == + DW_DLV_OK) { + if (dwarf_formudata(attr_mem, &number, &error) == DW_DLV_OK) { + sloc.col = number; + } + dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); + } + + trace.inliners.push_back(sloc); + break; + }; + } + ResolvedTrace &trace; + dwarf_fileobject &fobj; + Dwarf_Die cu_die; + inliners_search_cb(ResolvedTrace &t, dwarf_fileobject &f, Dwarf_Die c) + : trace(t), fobj(f), cu_die(c) {} + }; + + static Dwarf_Die find_fundie_by_pc(dwarf_fileobject &fobj, + Dwarf_Die parent_die, Dwarf_Addr pc, + Dwarf_Die result) { + Dwarf_Die current_die = 0; + Dwarf_Error error = DW_DLE_NE; + Dwarf_Debug dwarf = fobj.dwarf_handle.get(); + + if (dwarf_child(parent_die, ¤t_die, &error) != DW_DLV_OK) { + return NULL; + } + + for (;;) { + Dwarf_Die sibling_die = 0; + Dwarf_Half tag_value; + dwarf_tag(current_die, &tag_value, &error); + + switch (tag_value) { + case DW_TAG_subprogram: + case DW_TAG_inlined_subroutine: + if (die_has_pc(fobj, current_die, pc)) { + return current_die; + } + }; + bool declaration = false; + Dwarf_Attribute attr_mem; + if (dwarf_attr(current_die, DW_AT_declaration, &attr_mem, &error) == + DW_DLV_OK) { + Dwarf_Bool flag = 0; + if (dwarf_formflag(attr_mem, &flag, &error) == DW_DLV_OK) { + declaration = flag != 0; + } + dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); + } + + if (!declaration) { + // let's be curious and look deeper in the tree, functions are + // not necessarily at the first level, but might be nested + // inside a namespace, structure, a function, an inlined + // function etc. + Dwarf_Die die_mem = 0; + Dwarf_Die indie = find_fundie_by_pc(fobj, current_die, pc, die_mem); + if (indie) { + result = die_mem; + return result; + } + } + + int res = dwarf_siblingof(dwarf, current_die, &sibling_die, &error); + if (res == DW_DLV_ERROR) { + return NULL; + } else if (res == DW_DLV_NO_ENTRY) { + break; + } + + if (current_die != parent_die) { + dwarf_dealloc(dwarf, current_die, DW_DLA_DIE); + current_die = 0; + } + + current_die = sibling_die; + } + return NULL; + } + + template <typename CB> + static bool deep_first_search_by_pc(dwarf_fileobject &fobj, + Dwarf_Die parent_die, Dwarf_Addr pc, + std::vector<std::string> &ns, CB cb) { + Dwarf_Die current_die = 0; + Dwarf_Debug dwarf = fobj.dwarf_handle.get(); + Dwarf_Error error = DW_DLE_NE; + + if (dwarf_child(parent_die, ¤t_die, &error) != DW_DLV_OK) { + return false; + } + + bool branch_has_pc = false; + bool has_namespace = false; + for (;;) { + Dwarf_Die sibling_die = 0; + + Dwarf_Half tag; + if (dwarf_tag(current_die, &tag, &error) == DW_DLV_OK) { + if (tag == DW_TAG_namespace || tag == DW_TAG_class_type) { + char *ns_name = NULL; + if (dwarf_diename(current_die, &ns_name, &error) == DW_DLV_OK) { + if (ns_name) { + ns.push_back(std::string(ns_name)); + } else { + ns.push_back("<unknown>"); + } + dwarf_dealloc(dwarf, ns_name, DW_DLA_STRING); + } else { + ns.push_back("<unknown>"); + } + has_namespace = true; + } + } + + bool declaration = false; + Dwarf_Attribute attr_mem; + if (tag != DW_TAG_class_type && + dwarf_attr(current_die, DW_AT_declaration, &attr_mem, &error) == + DW_DLV_OK) { + Dwarf_Bool flag = 0; + if (dwarf_formflag(attr_mem, &flag, &error) == DW_DLV_OK) { + declaration = flag != 0; + } + dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); + } + + if (!declaration) { + // let's be curious and look deeper in the tree, function are + // not necessarily at the first level, but might be nested + // inside a namespace, structure, a function, an inlined + // function etc. + branch_has_pc = deep_first_search_by_pc(fobj, current_die, pc, ns, cb); + } + + if (!branch_has_pc) { + branch_has_pc = die_has_pc(fobj, current_die, pc); + } + + if (branch_has_pc) { + cb(current_die, ns); + } + + int result = dwarf_siblingof(dwarf, current_die, &sibling_die, &error); + if (result == DW_DLV_ERROR) { + return false; + } else if (result == DW_DLV_NO_ENTRY) { + break; + } + + if (current_die != parent_die) { + dwarf_dealloc(dwarf, current_die, DW_DLA_DIE); + current_die = 0; + } + + if (has_namespace) { + has_namespace = false; + ns.pop_back(); + } + current_die = sibling_die; + } + + if (has_namespace) { + ns.pop_back(); + } + return branch_has_pc; + } + + static std::string die_call_file(Dwarf_Debug dwarf, Dwarf_Die die, + Dwarf_Die cu_die) { + Dwarf_Attribute attr_mem; + Dwarf_Error error = DW_DLE_NE; + Dwarf_Unsigned file_index; + + std::string file; + + if (dwarf_attr(die, DW_AT_call_file, &attr_mem, &error) == DW_DLV_OK) { + if (dwarf_formudata(attr_mem, &file_index, &error) != DW_DLV_OK) { + file_index = 0; + } + dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); + + if (file_index == 0) { + return file; + } + + char **srcfiles = 0; + Dwarf_Signed file_count = 0; + if (dwarf_srcfiles(cu_die, &srcfiles, &file_count, &error) == DW_DLV_OK) { + if (file_count > 0 && file_index <= static_cast<Dwarf_Unsigned>(file_count)) { + file = std::string(srcfiles[file_index - 1]); + } + + // Deallocate all strings! + for (int i = 0; i < file_count; ++i) { + dwarf_dealloc(dwarf, srcfiles[i], DW_DLA_STRING); + } + dwarf_dealloc(dwarf, srcfiles, DW_DLA_LIST); + } + } + return file; + } + + Dwarf_Die find_die(dwarf_fileobject &fobj, Dwarf_Addr addr) { + // Let's get to work! First see if we have a debug_aranges section so + // we can speed up the search + + Dwarf_Debug dwarf = fobj.dwarf_handle.get(); + Dwarf_Error error = DW_DLE_NE; + Dwarf_Arange *aranges; + Dwarf_Signed arange_count; + + Dwarf_Die returnDie; + bool found = false; + if (dwarf_get_aranges(dwarf, &aranges, &arange_count, &error) != + DW_DLV_OK) { + aranges = NULL; + } + + if (aranges) { + // We have aranges. Get the one where our address is. + Dwarf_Arange arange; + if (dwarf_get_arange(aranges, arange_count, addr, &arange, &error) == + DW_DLV_OK) { + + // We found our address. Get the compilation-unit DIE offset + // represented by the given address range. + Dwarf_Off cu_die_offset; + if (dwarf_get_cu_die_offset(arange, &cu_die_offset, &error) == + DW_DLV_OK) { + // Get the DIE at the offset returned by the aranges search. + // We set is_info to 1 to specify that the offset is from + // the .debug_info section (and not .debug_types) + int dwarf_result = + dwarf_offdie_b(dwarf, cu_die_offset, 1, &returnDie, &error); + + found = dwarf_result == DW_DLV_OK; + } + dwarf_dealloc(dwarf, arange, DW_DLA_ARANGE); + } + } + + if (found) + return returnDie; // The caller is responsible for freeing the die + + // The search for aranges failed. Try to find our address by scanning + // all compilation units. + Dwarf_Unsigned next_cu_header; + Dwarf_Half tag = 0; + returnDie = 0; + + while (!found && + dwarf_next_cu_header_d(dwarf, 1, 0, 0, 0, 0, 0, 0, 0, 0, + &next_cu_header, 0, &error) == DW_DLV_OK) { + + if (returnDie) + dwarf_dealloc(dwarf, returnDie, DW_DLA_DIE); + + if (dwarf_siblingof(dwarf, 0, &returnDie, &error) == DW_DLV_OK) { + if ((dwarf_tag(returnDie, &tag, &error) == DW_DLV_OK) && + tag == DW_TAG_compile_unit) { + if (die_has_pc(fobj, returnDie, addr)) { + found = true; + } + } + } + } + + if (found) { + while (dwarf_next_cu_header_d(dwarf, 1, 0, 0, 0, 0, 0, 0, 0, 0, + &next_cu_header, 0, &error) == DW_DLV_OK) { + // Reset the cu header state. Libdwarf's next_cu_header API + // keeps its own iterator per Dwarf_Debug that can't be reset. + // We need to keep fetching elements until the end. + } + } + + if (found) + return returnDie; + + // We couldn't find any compilation units with ranges or a high/low pc. + // Try again by looking at all DIEs in all compilation units. + Dwarf_Die cudie; + while (dwarf_next_cu_header_d(dwarf, 1, 0, 0, 0, 0, 0, 0, 0, 0, + &next_cu_header, 0, &error) == DW_DLV_OK) { + if (dwarf_siblingof(dwarf, 0, &cudie, &error) == DW_DLV_OK) { + Dwarf_Die die_mem = 0; + Dwarf_Die resultDie = find_fundie_by_pc(fobj, cudie, addr, die_mem); + + if (resultDie) { + found = true; + break; + } + } + } + + if (found) { + while (dwarf_next_cu_header_d(dwarf, 1, 0, 0, 0, 0, 0, 0, 0, 0, + &next_cu_header, 0, &error) == DW_DLV_OK) { + // Reset the cu header state. Libdwarf's next_cu_header API + // keeps its own iterator per Dwarf_Debug that can't be reset. + // We need to keep fetching elements until the end. + } + } + + if (found) + return cudie; + + // We failed. + return NULL; + } +}; +#endif // BACKWARD_HAS_DWARF == 1 + +template <> +class TraceResolverImpl<system_tag::linux_tag> + : public TraceResolverLinuxImpl<trace_resolver_tag::current> {}; + +#endif // BACKWARD_SYSTEM_LINUX + +#ifdef BACKWARD_SYSTEM_DARWIN + +template <typename STACKTRACE_TAG> class TraceResolverDarwinImpl; + +template <> +class TraceResolverDarwinImpl<trace_resolver_tag::backtrace_symbol> + : public TraceResolverImplBase { +public: + void load_addresses(void *const*addresses, int address_count) override { + if (address_count == 0) { + return; + } + _symbols.reset(backtrace_symbols(addresses, address_count)); + } + + ResolvedTrace resolve(ResolvedTrace trace) override { + // parse: + // <n> <file> <addr> <mangled-name> + <offset> + char *filename = _symbols[trace.idx]; + + // skip "<n> " + while (*filename && *filename != ' ') + filename++; + while (*filename == ' ') + filename++; + + // find start of <mangled-name> from end (<file> may contain a space) + char *p = filename + strlen(filename) - 1; + // skip to start of " + <offset>" + while (p > filename && *p != ' ') + p--; + while (p > filename && *p == ' ') + p--; + while (p > filename && *p != ' ') + p--; + while (p > filename && *p == ' ') + p--; + char *funcname_end = p + 1; + + // skip to start of "<manged-name>" + while (p > filename && *p != ' ') + p--; + char *funcname = p + 1; + + // skip to start of " <addr> " + while (p > filename && *p == ' ') + p--; + while (p > filename && *p != ' ') + p--; + while (p > filename && *p == ' ') + p--; + + // skip "<file>", handling the case where it contains a + char *filename_end = p + 1; + if (p == filename) { + // something went wrong, give up + filename_end = filename + strlen(filename); + funcname = filename_end; + } + trace.object_filename.assign( + filename, filename_end); // ok even if filename_end is the ending \0 + // (then we assign entire string) + + if (*funcname) { // if it's not end of string + *funcname_end = '\0'; + + trace.object_function = this->demangle(funcname); + trace.object_function += " "; + trace.object_function += (funcname_end + 1); + trace.source.function = trace.object_function; // we cannot do better. + } + return trace; + } + +private: + details::handle<char **> _symbols; +}; + +template <> +class TraceResolverImpl<system_tag::darwin_tag> + : public TraceResolverDarwinImpl<trace_resolver_tag::current> {}; + +#endif // BACKWARD_SYSTEM_DARWIN + +#ifdef BACKWARD_SYSTEM_WINDOWS + +// Load all symbol info +// Based on: +// https://stackoverflow.com/questions/6205981/windows-c-stack-trace-from-a-running-app/28276227#28276227 + +struct module_data { + std::string image_name; + std::string module_name; + void *base_address; + DWORD load_size; +}; + +class get_mod_info { + HANDLE process; + static const int buffer_length = 4096; + +public: + get_mod_info(HANDLE h) : process(h) {} + + module_data operator()(HMODULE module) { + module_data ret; + char temp[buffer_length]; + MODULEINFO mi; + + GetModuleInformation(process, module, &mi, sizeof(mi)); + ret.base_address = mi.lpBaseOfDll; + ret.load_size = mi.SizeOfImage; + + GetModuleFileNameExA(process, module, temp, sizeof(temp)); + ret.image_name = temp; + GetModuleBaseNameA(process, module, temp, sizeof(temp)); + ret.module_name = temp; + std::vector<char> img(ret.image_name.begin(), ret.image_name.end()); + std::vector<char> mod(ret.module_name.begin(), ret.module_name.end()); + SymLoadModule64(process, 0, &img[0], &mod[0], (DWORD64)ret.base_address, + ret.load_size); + return ret; + } +}; + +template <> class TraceResolverImpl<system_tag::windows_tag> + : public TraceResolverImplBase { +public: + TraceResolverImpl() { + + HANDLE process = GetCurrentProcess(); + + std::vector<module_data> modules; + DWORD cbNeeded; + std::vector<HMODULE> module_handles(1); + SymInitialize(process, NULL, false); + DWORD symOptions = SymGetOptions(); + symOptions |= SYMOPT_LOAD_LINES | SYMOPT_UNDNAME; + SymSetOptions(symOptions); + EnumProcessModules(process, &module_handles[0], + module_handles.size() * sizeof(HMODULE), &cbNeeded); + module_handles.resize(cbNeeded / sizeof(HMODULE)); + EnumProcessModules(process, &module_handles[0], + module_handles.size() * sizeof(HMODULE), &cbNeeded); + std::transform(module_handles.begin(), module_handles.end(), + std::back_inserter(modules), get_mod_info(process)); + void *base = modules[0].base_address; + IMAGE_NT_HEADERS *h = ImageNtHeader(base); + image_type = h->FileHeader.Machine; + } + + static const int max_sym_len = 255; + struct symbol_t { + SYMBOL_INFO sym; + char buffer[max_sym_len]; + } sym; + + DWORD64 displacement; + + ResolvedTrace resolve(ResolvedTrace t) override { + HANDLE process = GetCurrentProcess(); + + char name[256]; + + memset(&sym, 0, sizeof(sym)); + sym.sym.SizeOfStruct = sizeof(SYMBOL_INFO); + sym.sym.MaxNameLen = max_sym_len; + + if (!SymFromAddr(process, (ULONG64)t.addr, &displacement, &sym.sym)) { + // TODO: error handling everywhere + char* lpMsgBuf; + DWORD dw = GetLastError(); + + if (FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + (char*)&lpMsgBuf, 0, NULL)) { + std::fprintf(stderr, "%s\n", lpMsgBuf); + LocalFree(lpMsgBuf); + } + + // abort(); + } + UnDecorateSymbolName(sym.sym.Name, (PSTR)name, 256, UNDNAME_COMPLETE); + + DWORD offset = 0; + IMAGEHLP_LINE line; + if (SymGetLineFromAddr(process, (ULONG64)t.addr, &offset, &line)) { + t.object_filename = line.FileName; + t.source.filename = line.FileName; + t.source.line = line.LineNumber; + t.source.col = offset; + } + + t.source.function = name; + t.object_filename = ""; + t.object_function = name; + + return t; + } + + DWORD machine_type() const { return image_type; } + +private: + DWORD image_type; +}; + +#endif + +class TraceResolver : public TraceResolverImpl<system_tag::current_tag> {}; + +/*************** CODE SNIPPET ***************/ + +class SourceFile { +public: + typedef std::vector<std::pair<unsigned, std::string>> lines_t; + + SourceFile() {} + SourceFile(const std::string &path) { + // 1. If BACKWARD_CXX_SOURCE_PREFIXES is set then assume it contains + // a colon-separated list of path prefixes. Try prepending each + // to the given path until a valid file is found. + const std::vector<std::string> &prefixes = get_paths_from_env_variable(); + for (size_t i = 0; i < prefixes.size(); ++i) { + // Double slashes (//) should not be a problem. + std::string new_path = prefixes[i] + '/' + path; + _file.reset(new std::ifstream(new_path.c_str())); + if (is_open()) + break; + } + // 2. If no valid file found then fallback to opening the path as-is. + if (!_file || !is_open()) { + _file.reset(new std::ifstream(path.c_str())); + } + } + bool is_open() const { return _file->is_open(); } + + lines_t &get_lines(unsigned line_start, unsigned line_count, lines_t &lines) { + using namespace std; + // This function make uses of the dumbest algo ever: + // 1) seek(0) + // 2) read lines one by one and discard until line_start + // 3) read line one by one until line_start + line_count + // + // If you are getting snippets many time from the same file, it is + // somewhat a waste of CPU, feel free to benchmark and propose a + // better solution ;) + + _file->clear(); + _file->seekg(0); + string line; + unsigned line_idx; + + for (line_idx = 1; line_idx < line_start; ++line_idx) { + std::getline(*_file, line); + if (!*_file) { + return lines; + } + } + + // think of it like a lambda in C++98 ;) + // but look, I will reuse it two times! + // What a good boy am I. + struct isspace { + bool operator()(char c) { return std::isspace(c); } + }; + + bool started = false; + for (; line_idx < line_start + line_count; ++line_idx) { + getline(*_file, line); + if (!*_file) { + return lines; + } + if (!started) { + if (std::find_if(line.begin(), line.end(), not_isspace()) == line.end()) + continue; + started = true; + } + lines.push_back(make_pair(line_idx, line)); + } + + lines.erase( + std::find_if(lines.rbegin(), lines.rend(), not_isempty()).base(), + lines.end()); + return lines; + } + + lines_t get_lines(unsigned line_start, unsigned line_count) { + lines_t lines; + return get_lines(line_start, line_count, lines); + } + + // there is no find_if_not in C++98, lets do something crappy to + // workaround. + struct not_isspace { + bool operator()(char c) { return !std::isspace(c); } + }; + // and define this one here because C++98 is not happy with local defined + // struct passed to template functions, fuuuu. + struct not_isempty { + bool operator()(const lines_t::value_type &p) { + return !(std::find_if(p.second.begin(), p.second.end(), not_isspace()) == + p.second.end()); + } + }; + + void swap(SourceFile &b) { _file.swap(b._file); } + +#ifdef BACKWARD_ATLEAST_CXX11 + SourceFile(SourceFile &&from) : _file(nullptr) { swap(from); } + SourceFile &operator=(SourceFile &&from) { + swap(from); + return *this; + } +#else + explicit SourceFile(const SourceFile &from) { + // some sort of poor man's move semantic. + swap(const_cast<SourceFile &>(from)); + } + SourceFile &operator=(const SourceFile &from) { + // some sort of poor man's move semantic. + swap(const_cast<SourceFile &>(from)); + return *this; + } +#endif + +private: + details::handle<std::ifstream *, details::default_delete<std::ifstream *>> + _file; + + std::vector<std::string> get_paths_from_env_variable_impl() { + std::vector<std::string> paths; + const char *prefixes_str = std::getenv("BACKWARD_CXX_SOURCE_PREFIXES"); + if (prefixes_str && prefixes_str[0]) { + paths = details::split_source_prefixes(prefixes_str); + } + return paths; + } + + const std::vector<std::string> &get_paths_from_env_variable() { + static std::vector<std::string> paths = get_paths_from_env_variable_impl(); + return paths; + } + +#ifdef BACKWARD_ATLEAST_CXX11 + SourceFile(const SourceFile &) = delete; + SourceFile &operator=(const SourceFile &) = delete; +#endif +}; + +class SnippetFactory { +public: + typedef SourceFile::lines_t lines_t; + + lines_t get_snippet(const std::string &filename, unsigned line_start, + unsigned context_size) { + + SourceFile &src_file = get_src_file(filename); + unsigned start = line_start - context_size / 2; + return src_file.get_lines(start, context_size); + } + + lines_t get_combined_snippet(const std::string &filename_a, unsigned line_a, + const std::string &filename_b, unsigned line_b, + unsigned context_size) { + SourceFile &src_file_a = get_src_file(filename_a); + SourceFile &src_file_b = get_src_file(filename_b); + + lines_t lines = + src_file_a.get_lines(line_a - context_size / 4, context_size / 2); + src_file_b.get_lines(line_b - context_size / 4, context_size / 2, lines); + return lines; + } + + lines_t get_coalesced_snippet(const std::string &filename, unsigned line_a, + unsigned line_b, unsigned context_size) { + SourceFile &src_file = get_src_file(filename); + + using std::max; + using std::min; + unsigned a = min(line_a, line_b); + unsigned b = max(line_a, line_b); + + if ((b - a) < (context_size / 3)) { + return src_file.get_lines((a + b - context_size + 1) / 2, context_size); + } + + lines_t lines = src_file.get_lines(a - context_size / 4, context_size / 2); + src_file.get_lines(b - context_size / 4, context_size / 2, lines); + return lines; + } + +private: + typedef details::hashtable<std::string, SourceFile>::type src_files_t; + src_files_t _src_files; + + SourceFile &get_src_file(const std::string &filename) { + src_files_t::iterator it = _src_files.find(filename); + if (it != _src_files.end()) { + return it->second; + } + SourceFile &new_src_file = _src_files[filename]; + new_src_file = SourceFile(filename); + return new_src_file; + } +}; + +/*************** PRINTER ***************/ + +namespace ColorMode { +enum type { automatic, never, always }; +} + +class cfile_streambuf : public std::streambuf { +public: + cfile_streambuf(FILE *_sink) : sink(_sink) {} + int_type underflow() override { return traits_type::eof(); } + int_type overflow(int_type ch) override { + if (traits_type::not_eof(ch) && fputc(ch, sink) != EOF) { + return ch; + } + return traits_type::eof(); + } + + std::streamsize xsputn(const char_type *s, std::streamsize count) override { + return static_cast<std::streamsize>( + fwrite(s, sizeof *s, static_cast<size_t>(count), sink)); + } + +#ifdef BACKWARD_ATLEAST_CXX11 +public: + cfile_streambuf(const cfile_streambuf &) = delete; + cfile_streambuf &operator=(const cfile_streambuf &) = delete; +#else +private: + cfile_streambuf(const cfile_streambuf &); + cfile_streambuf &operator=(const cfile_streambuf &); +#endif + +private: + FILE *sink; + std::vector<char> buffer; +}; + +#ifdef BACKWARD_SYSTEM_LINUX + +namespace Color { +enum type { yellow = 33, purple = 35, reset = 39 }; +} // namespace Color + +class Colorize { +public: + Colorize(std::ostream &os) : _os(os), _reset(false), _enabled(false) {} + + void activate(ColorMode::type mode) { _enabled = mode == ColorMode::always; } + + void activate(ColorMode::type mode, FILE *fp) { activate(mode, fileno(fp)); } + + void set_color(Color::type ccode) { + if (!_enabled) + return; + + // I assume that the terminal can handle basic colors. Seriously I + // don't want to deal with all the termcap shit. + _os << "\033[" << static_cast<int>(ccode) << "m"; + _reset = (ccode != Color::reset); + } + + ~Colorize() { + if (_reset) { + set_color(Color::reset); + } + } + +private: + void activate(ColorMode::type mode, int fd) { + activate(mode == ColorMode::automatic && isatty(fd) ? ColorMode::always + : mode); + } + + std::ostream &_os; + bool _reset; + bool _enabled; +}; + +#else // ndef BACKWARD_SYSTEM_LINUX + +namespace Color { +enum type { yellow = 0, purple = 0, reset = 0 }; +} // namespace Color + +class Colorize { +public: + Colorize(std::ostream &) {} + void activate(ColorMode::type) {} + void activate(ColorMode::type, FILE *) {} + void set_color(Color::type) {} +}; + +#endif // BACKWARD_SYSTEM_LINUX + +class Printer { +public: + bool snippet; + ColorMode::type color_mode; + bool address; + bool object; + int inliner_context_size; + int trace_context_size; + + Printer() + : snippet(true), color_mode(ColorMode::automatic), address(false), + object(false), inliner_context_size(5), trace_context_size(7) {} + + template <typename ST> FILE *print(ST &st, FILE *fp = stderr) { + cfile_streambuf obuf(fp); + std::ostream os(&obuf); + Colorize colorize(os); + colorize.activate(color_mode, fp); + print_stacktrace(st, os, colorize); + return fp; + } + + template <typename ST> std::ostream &print(ST &st, std::ostream &os) { + Colorize colorize(os); + colorize.activate(color_mode); + print_stacktrace(st, os, colorize); + return os; + } + + template <typename IT> + FILE *print(IT begin, IT end, FILE *fp = stderr, size_t thread_id = 0) { + cfile_streambuf obuf(fp); + std::ostream os(&obuf); + Colorize colorize(os); + colorize.activate(color_mode, fp); + print_stacktrace(begin, end, os, thread_id, colorize); + return fp; + } + + template <typename IT> + std::ostream &print(IT begin, IT end, std::ostream &os, + size_t thread_id = 0) { + Colorize colorize(os); + colorize.activate(color_mode); + print_stacktrace(begin, end, os, thread_id, colorize); + return os; + } + + TraceResolver const &resolver() const { return _resolver; } + +private: + TraceResolver _resolver; + SnippetFactory _snippets; + + template <typename ST> + void print_stacktrace(ST &st, std::ostream &os, Colorize &colorize) { + print_header(os, st.thread_id()); + _resolver.load_stacktrace(st); + for (size_t trace_idx = st.size(); trace_idx > 0; --trace_idx) { + print_trace(os, _resolver.resolve(st[trace_idx - 1]), colorize); + } + } + + template <typename IT> + void print_stacktrace(IT begin, IT end, std::ostream &os, size_t thread_id, + Colorize &colorize) { + print_header(os, thread_id); + for (; begin != end; ++begin) { + print_trace(os, *begin, colorize); + } + } + + void print_header(std::ostream &os, size_t thread_id) { + os << "Stack trace (most recent call last)"; + if (thread_id) { + os << " in thread " << thread_id; + } + os << ":\n"; + } + + void print_trace(std::ostream &os, const ResolvedTrace &trace, + Colorize &colorize) { + os << "#" << std::left << std::setw(2) << trace.idx << std::right; + bool already_indented = true; + + if (!trace.source.filename.size() || object) { + os << " Object \"" << trace.object_filename << "\", at " << trace.addr + << ", in " << trace.object_function << "\n"; + already_indented = false; + } + + for (size_t inliner_idx = trace.inliners.size(); inliner_idx > 0; + --inliner_idx) { + if (!already_indented) { + os << " "; + } + const ResolvedTrace::SourceLoc &inliner_loc = + trace.inliners[inliner_idx - 1]; + print_source_loc(os, " | ", inliner_loc); + if (snippet) { + print_snippet(os, " | ", inliner_loc, colorize, Color::purple, + inliner_context_size); + } + already_indented = false; + } + + if (trace.source.filename.size()) { + if (!already_indented) { + os << " "; + } + print_source_loc(os, " ", trace.source, trace.addr); + if (snippet) { + print_snippet(os, " ", trace.source, colorize, Color::yellow, + trace_context_size); + } + } + } + + void print_snippet(std::ostream &os, const char *indent, + const ResolvedTrace::SourceLoc &source_loc, + Colorize &colorize, Color::type color_code, + int context_size) { + using namespace std; + typedef SnippetFactory::lines_t lines_t; + + lines_t lines = _snippets.get_snippet(source_loc.filename, source_loc.line, + static_cast<unsigned>(context_size)); + + for (lines_t::const_iterator it = lines.begin(); it != lines.end(); ++it) { + if (it->first == source_loc.line) { + colorize.set_color(color_code); + os << indent << ">"; + } else { + os << indent << " "; + } + os << std::setw(4) << it->first << ": " << it->second << "\n"; + if (it->first == source_loc.line) { + colorize.set_color(Color::reset); + } + } + } + + void print_source_loc(std::ostream &os, const char *indent, + const ResolvedTrace::SourceLoc &source_loc, + void *addr = nullptr) { + os << indent << "Source \"" << source_loc.filename << "\", line " + << source_loc.line << ", in " << source_loc.function; + + if (address && addr != nullptr) { + os << " [" << addr << "]"; + } + os << "\n"; + } +}; + +/*************** SIGNALS HANDLING ***************/ + +#if defined(BACKWARD_SYSTEM_LINUX) || defined(BACKWARD_SYSTEM_DARWIN) + +class SignalHandling { +public: + static std::vector<int> make_default_signals() { + const int posix_signals[] = { + // Signals for which the default action is "Core". + SIGABRT, // Abort signal from abort(3) + SIGBUS, // Bus error (bad memory access) + SIGFPE, // Floating point exception + SIGILL, // Illegal Instruction + SIGIOT, // IOT trap. A synonym for SIGABRT + SIGQUIT, // Quit from keyboard + SIGSEGV, // Invalid memory reference + SIGSYS, // Bad argument to routine (SVr4) + SIGTRAP, // Trace/breakpoint trap + SIGXCPU, // CPU time limit exceeded (4.2BSD) + SIGXFSZ, // File size limit exceeded (4.2BSD) +#if defined(BACKWARD_SYSTEM_DARWIN) + SIGEMT, // emulation instruction executed +#endif + }; + return std::vector<int>(posix_signals, + posix_signals + + sizeof posix_signals / sizeof posix_signals[0]); + } + + SignalHandling(const std::vector<int> &posix_signals = make_default_signals()) + : _loaded(false) { + bool success = true; + + const size_t stack_size = 1024 * 1024 * 8; + _stack_content.reset(static_cast<char *>(malloc(stack_size))); + if (_stack_content) { + stack_t ss; + ss.ss_sp = _stack_content.get(); + ss.ss_size = stack_size; + ss.ss_flags = 0; + if (sigaltstack(&ss, nullptr) < 0) { + success = false; + } + } else { + success = false; + } + + for (size_t i = 0; i < posix_signals.size(); ++i) { + struct sigaction action; + memset(&action, 0, sizeof action); + action.sa_flags = + static_cast<int>(SA_SIGINFO | SA_ONSTACK | SA_NODEFER | SA_RESETHAND); + sigfillset(&action.sa_mask); + sigdelset(&action.sa_mask, posix_signals[i]); +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdisabled-macro-expansion" +#endif + action.sa_sigaction = &sig_handler; +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + + int r = sigaction(posix_signals[i], &action, nullptr); + if (r < 0) + success = false; + } + + _loaded = success; + } + + bool loaded() const { return _loaded; } + + static void handleSignal(int, siginfo_t *info, void *_ctx) { + ucontext_t *uctx = static_cast<ucontext_t *>(_ctx); + + StackTrace st; + void *error_addr = nullptr; +#ifdef REG_RIP // x86_64 + error_addr = reinterpret_cast<void *>(uctx->uc_mcontext.gregs[REG_RIP]); +#elif defined(REG_EIP) // x86_32 + error_addr = reinterpret_cast<void *>(uctx->uc_mcontext.gregs[REG_EIP]); +#elif defined(__arm__) + error_addr = reinterpret_cast<void *>(uctx->uc_mcontext.arm_pc); +#elif defined(__aarch64__) + #if defined(__APPLE__) + error_addr = reinterpret_cast<void *>(uctx->uc_mcontext->__ss.__pc); + #else + error_addr = reinterpret_cast<void *>(uctx->uc_mcontext.pc); + #endif +#elif defined(__mips__) + error_addr = reinterpret_cast<void *>( + reinterpret_cast<struct sigcontext *>(&uctx->uc_mcontext)->sc_pc); +#elif defined(__ppc__) || defined(__powerpc) || defined(__powerpc__) || \ + defined(__POWERPC__) + error_addr = reinterpret_cast<void *>(uctx->uc_mcontext.regs->nip); +#elif defined(__riscv) + error_addr = reinterpret_cast<void *>(uctx->uc_mcontext.__gregs[REG_PC]); +#elif defined(__s390x__) + error_addr = reinterpret_cast<void *>(uctx->uc_mcontext.psw.addr); +#elif defined(__APPLE__) && defined(__x86_64__) + error_addr = reinterpret_cast<void *>(uctx->uc_mcontext->__ss.__rip); +#elif defined(__APPLE__) + error_addr = reinterpret_cast<void *>(uctx->uc_mcontext->__ss.__eip); +#else +#warning ":/ sorry, ain't know no nothing none not of your architecture!" +#endif + if (error_addr) { + st.load_from(error_addr, 32, reinterpret_cast<void *>(uctx), + info->si_addr); + } else { + st.load_here(32, reinterpret_cast<void *>(uctx), info->si_addr); + } + + Printer printer; + printer.address = true; + printer.print(st, stderr); + +#if _XOPEN_SOURCE >= 700 || _POSIX_C_SOURCE >= 200809L + psiginfo(info, nullptr); +#else + (void)info; +#endif + } + +private: + details::handle<char *> _stack_content; + bool _loaded; + +#ifdef __GNUC__ + __attribute__((noreturn)) +#endif + static void + sig_handler(int signo, siginfo_t *info, void *_ctx) { + handleSignal(signo, info, _ctx); + + // try to forward the signal. + raise(info->si_signo); + + // terminate the process immediately. + puts("watf? exit"); + _exit(EXIT_FAILURE); + } +}; + +#endif // BACKWARD_SYSTEM_LINUX || BACKWARD_SYSTEM_DARWIN + +#ifdef BACKWARD_SYSTEM_WINDOWS + +class SignalHandling { +public: + SignalHandling(const std::vector<int> & = std::vector<int>()) + : reporter_thread_([]() { + /* We handle crashes in a utility thread: + backward structures and some Windows functions called here + need stack space, which we do not have when we encounter a + stack overflow. + To support reporting stack traces during a stack overflow, + we create a utility thread at startup, which waits until a + crash happens or the program exits normally. */ + + { + std::unique_lock<std::mutex> lk(mtx()); + cv().wait(lk, [] { return crashed() != crash_status::running; }); + } + if (crashed() == crash_status::crashed) { + handle_stacktrace(skip_recs()); + } + { + std::unique_lock<std::mutex> lk(mtx()); + crashed() = crash_status::ending; + } + cv().notify_one(); + }) { + SetUnhandledExceptionFilter(crash_handler); + + signal(SIGABRT, signal_handler); + _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT); + + std::set_terminate(&terminator); +#ifndef BACKWARD_ATLEAST_CXX17 + std::set_unexpected(&terminator); +#endif + _set_purecall_handler(&terminator); + _set_invalid_parameter_handler(&invalid_parameter_handler); + } + bool loaded() const { return true; } + + ~SignalHandling() { + { + std::unique_lock<std::mutex> lk(mtx()); + crashed() = crash_status::normal_exit; + } + + cv().notify_one(); + + reporter_thread_.join(); + } + +private: + static CONTEXT *ctx() { + static CONTEXT data; + return &data; + } + + enum class crash_status { running, crashed, normal_exit, ending }; + + static crash_status &crashed() { + static crash_status data; + return data; + } + + static std::mutex &mtx() { + static std::mutex data; + return data; + } + + static std::condition_variable &cv() { + static std::condition_variable data; + return data; + } + + static HANDLE &thread_handle() { + static HANDLE handle; + return handle; + } + + std::thread reporter_thread_; + + // TODO: how not to hardcode these? + static const constexpr int signal_skip_recs = +#ifdef __clang__ + // With clang, RtlCaptureContext also captures the stack frame of the + // current function Below that, there ar 3 internal Windows functions + 4 +#else + // With MSVC cl, RtlCaptureContext misses the stack frame of the current + // function The first entries during StackWalk are the 3 internal Windows + // functions + 3 +#endif + ; + + static int &skip_recs() { + static int data; + return data; + } + + static inline void terminator() { + crash_handler(signal_skip_recs); + abort(); + } + + static inline void signal_handler(int) { + crash_handler(signal_skip_recs); + abort(); + } + + static inline void __cdecl invalid_parameter_handler(const wchar_t *, + const wchar_t *, + const wchar_t *, + unsigned int, + uintptr_t) { + crash_handler(signal_skip_recs); + abort(); + } + + NOINLINE static LONG WINAPI crash_handler(EXCEPTION_POINTERS *info) { + // The exception info supplies a trace from exactly where the issue was, + // no need to skip records + crash_handler(0, info->ContextRecord); + return EXCEPTION_CONTINUE_SEARCH; + } + + NOINLINE static void crash_handler(int skip, CONTEXT *ct = nullptr) { + + if (ct == nullptr) { + RtlCaptureContext(ctx()); + } else { + memcpy(ctx(), ct, sizeof(CONTEXT)); + } + DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), + GetCurrentProcess(), &thread_handle(), 0, FALSE, + DUPLICATE_SAME_ACCESS); + + skip_recs() = skip; + + { + std::unique_lock<std::mutex> lk(mtx()); + crashed() = crash_status::crashed; + } + + cv().notify_one(); + + { + std::unique_lock<std::mutex> lk(mtx()); + cv().wait(lk, [] { return crashed() != crash_status::crashed; }); + } + } + + static void handle_stacktrace(int skip_frames = 0) { + // printer creates the TraceResolver, which can supply us a machine type + // for stack walking. Without this, StackTrace can only guess using some + // macros. + // StackTrace also requires that the PDBs are already loaded, which is done + // in the constructor of TraceResolver + Printer printer; + + StackTrace st; + st.set_machine_type(printer.resolver().machine_type()); + st.set_thread_handle(thread_handle()); + st.load_here(32 + skip_frames, ctx()); + st.skip_n_firsts(skip_frames); + + printer.address = true; + printer.print(st, std::cerr); + } +}; + +#endif // BACKWARD_SYSTEM_WINDOWS + +#ifdef BACKWARD_SYSTEM_UNKNOWN + +class SignalHandling { +public: + SignalHandling(const std::vector<int> & = std::vector<int>()) {} + bool init() { return false; } + bool loaded() { return false; } +}; + +#endif // BACKWARD_SYSTEM_UNKNOWN + +} // namespace backward + +#endif /* H_GUARD */ diff --git a/debian/control b/debian/control index c6363e50d..1ef10c0ad 100644 --- a/debian/control +++ b/debian/control @@ -13,6 +13,7 @@ Build-Depends: cmake, libsqlite3-dev, libssl-dev (>= 1.0), libunwind-dev | libunwind-13-dev, + binutils-dev, perl, ragel, zlib1g-dev diff --git a/interface/js/app/rspamd.js b/interface/js/app/rspamd.js index fd618e6b3..67b60d973 100644 --- a/interface/js/app/rspamd.js +++ b/interface/js/app/rspamd.js @@ -59,7 +59,7 @@ function ($, visibility, NProgress, stickyTabs, tab_stat, tab_graph, tab_config, var neighbours = []; // list of clusters var checked_server = "All SERVERS"; var timer_id = []; - var locale = null; + var locale = (localStorage.getItem("selected_locale") === "custom") ? localStorage.getItem("custom_locale") : null; var selData = null; // Graph's dataset selector state NProgress.configure({ diff --git a/lualib/rspamadm/configwizard.lua b/lualib/rspamadm/configwizard.lua index fb8bd0d35..2637036f1 100644 --- a/lualib/rspamadm/configwizard.lua +++ b/lualib/rspamadm/configwizard.lua @@ -382,7 +382,10 @@ local function setup_dkim_signing(cfg, changes) end printf("--") end - + local function print_public_key(pk) + local base64_pk = tostring(rspamd_util.encode_base64(pk)) + printf('v=DKIM1; k=rsa; p=%s\n', base64_pk) + end repeat if has_domains then print_domains() @@ -406,22 +409,12 @@ local function setup_dkim_signing(cfg, changes) if not rspamd_util.file_exists(privkey_file) then if ask_yes_no("Do you want to create privkey " .. highlight(privkey_file), true) then - local pubkey_file = privkey_file .. ".pub" - local rspamd_cryptobox = require "rspamd_cryptobox" - local sk, pk = rspamd_cryptobox.generate_keypair("rsa", 2048) - pk:save_to_file(pubkey_file) - sk:save_to_file(privkey_file, tonumber('0600', 8)) - - local f = io.open(pubkey_file) - if not f then - printf("Cannot open pubkey file %s, fatal error", highlight(pubkey_file)) - os.exit(1) - end - - local content = f:read("*all") - f:close() - print("To make dkim signing working, you need to place the following record in your DNS zone:") - print(content) + local rsa = require "rspamd_rsa" + local sk, pk = rsa.keypair(2048) + sk:save(privkey_file, 'pem') + print("You need to chown private key file to rspamd user!!") + print("To make dkim signing working, to place the following record in your DNS zone:") + print_public_key(tostring(pk)) end end @@ -854,4 +847,3 @@ return { name = 'configwizard', description = parser._description, } - diff --git a/rpm/rspamd.spec b/rpm/rspamd.spec index de68eb285..c2c028d37 100644 --- a/rpm/rspamd.spec +++ b/rpm/rspamd.spec @@ -65,6 +65,7 @@ BuildRequires: pcre2-devel BuildRequires: ragel BuildRequires: sqlite-devel BuildRequires: systemd +BuildRequires: binutils-devel Requires(pre): shadow-utils Requires(post): systemd Requires(preun): systemd @@ -136,7 +137,6 @@ rm -f %{_builddir}/luajit-build/lib/*.so || true -DWANT_SYSTEMD_UNITS=ON \ -DNO_SHARED=ON \ -DDEBIAN_BUILD=1 \ - -DENABLE_LIBUNWIND=ON \ %ifarch x86_64 amd64 arm64 aarch64 -DENABLE_HYPERSCAN=ON \ %endif diff --git a/rules/regexp/headers.lua b/rules/regexp/headers.lua index b634dd909..c4411e53a 100644 --- a/rules/regexp/headers.lua +++ b/rules/regexp/headers.lua @@ -642,12 +642,14 @@ local has_msmail_pri = 'header_exists(X-MSMail-Priority)' local has_mimeole = 'header_exists(X-MimeOLE)' local has_squirrelmail_in_mailer = 'X-Mailer=/SquirrelMail\\b/H' local has_office_version_in_mailer = [[X-Mailer=/^Microsoft (?:Office )?Outlook [12]\d\.0/]] +local has_x_android_message_id = 'header_exists(X-Android-Message-Id)' reconf['MISSING_MIMEOLE'] = { - re = string.format('(%s) & !(%s) & !(%s) & !(%s)', + re = string.format('(%s) & !(%s) & !(%s) & !(%s) & !(%s)', has_msmail_pri, has_mimeole, has_squirrelmail_in_mailer, - has_office_version_in_mailer), + has_office_version_in_mailer, + has_x_android_message_id), score = 2.0, description = 'Mime-OLE is needed but absent (e.g. fake Outlook or fake Exchange)', group = 'headers' diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 5dee8e610..173917703 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -165,7 +165,8 @@ IF(ENABLE_STATIC MATCHES "ON") "${RAGEL_ragel_content_disposition_OUTPUTS}" "${RAGEL_ragel_rfc2047_OUTPUTS}" "${RAGEL_ragel_smtp_date_OUTPUTS}" - "${RAGEL_ragel_smtp_ip_OUTPUTS}") + "${RAGEL_ragel_smtp_ip_OUTPUTS}" + ${BACKWARD_ENABLE}) ELSE() ADD_LIBRARY(rspamd-server SHARED ${RSPAMD_CRYPTOBOX} @@ -182,7 +183,8 @@ ELSE() "${RAGEL_ragel_content_disposition_OUTPUTS}" "${RAGEL_ragel_rfc2047_OUTPUTS}" "${RAGEL_ragel_smtp_date_OUTPUTS}" - "${RAGEL_ragel_smtp_ip_OUTPUTS}") + "${RAGEL_ragel_smtp_ip_OUTPUTS}" + ${BACKWARD_ENABLE}) ENDIF() FOREACH(_DEP ${LIBSERVER_DEPENDS}) @@ -227,8 +229,10 @@ IF(WITH_BLAS) ENDIF() TARGET_LINK_LIBRARIES(rspamd-server ${RSPAMD_REQUIRED_LIBRARIES}) +ADD_BACKWARD(rspamd-server) ADD_EXECUTABLE(rspamd ${RSPAMDSRC} ${CMAKE_CURRENT_BINARY_DIR}/workers.c ${CMAKE_CURRENT_BINARY_DIR}/config.h) +ADD_BACKWARD(rspamd) SET_TARGET_PROPERTIES(rspamd PROPERTIES LINKER_LANGUAGE CXX) SET_TARGET_PROPERTIES(rspamd-server PROPERTIES LINKER_LANGUAGE CXX) IF(NOT DEBIAN_BUILD) diff --git a/src/libmime/mime_expressions.c b/src/libmime/mime_expressions.c index 20f2c754e..e51539ed0 100644 --- a/src/libmime/mime_expressions.c +++ b/src/libmime/mime_expressions.c @@ -854,6 +854,9 @@ set: if (lua_cbref != -1) { msg_info_config("added condition for regexp %s", mime_atom->str); + /* Add SOM_LEFTMOST_FLAG implicitly */ + rspamd_regexp_set_flags(mime_atom->d.re->regexp, rspamd_regexp_get_flags(mime_atom->d.re->regexp) | + RSPAMD_REGEXP_FLAG_LEFTMOST); } /* Register new item in the cache */ diff --git a/src/libserver/CMakeLists.txt b/src/libserver/CMakeLists.txt index 56cc2444d..dd17865de 100644 --- a/src/libserver/CMakeLists.txt +++ b/src/libserver/CMakeLists.txt @@ -43,6 +43,7 @@ SET(LIBRSPAMDSERVERSRC ${CMAKE_CURRENT_SOURCE_DIR}/html/html.cxx ${CMAKE_CURRENT_SOURCE_DIR}/html/html_tests.cxx ${CMAKE_CURRENT_SOURCE_DIR}/hyperscan_tools.cxx + ${CMAKE_CURRENT_SOURCE_DIR}/backtrace.cxx ${LIBCSSSRC}) # Librspamd-server diff --git a/src/libserver/backtrace.cxx b/src/libserver/backtrace.cxx new file mode 100644 index 000000000..6507b964e --- /dev/null +++ b/src/libserver/backtrace.cxx @@ -0,0 +1,61 @@ +/* + * Copyright 2023 Vsevolod Stakhov + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "config.h" + +#ifdef BACKWARD_ENABLE + +#include "contrib/backward-cpp/backward.hpp" +#include "fmt/core.h" +#include "logger.h" + +namespace rspamd { + +void log_backtrace(void) +{ + using namespace backward; + StackTrace st; + st.load_here(128); + + TraceResolver tr; + tr.load_stacktrace(st); + + for (auto i = 0ul; i < st.size(); ++i) { + auto trace = tr.resolve(st[i]); + auto trace_line = fmt::format("#{}: [{}]: ", i, trace.addr); + + if (!trace.source.filename.empty()) { + trace_line += fmt::format("{}:{} in {}", trace.source.filename, trace.source.line, trace.source.function); + } + else { + trace_line += fmt::format("{} in {}", trace.object_filename, trace.object_function); + } + + msg_err("%s", trace_line.c_str()); + } +} + +}// namespace rspamd +#endif + +extern "C" void rspamd_print_crash(void); + +void rspamd_print_crash(void) +{ +#ifdef BACKWARD_ENABLE + rspamd::log_backtrace(); +#endif +}
\ No newline at end of file diff --git a/src/libserver/dns.c b/src/libserver/dns.c index abe47dfdc..be2d5a3dd 100644 --- a/src/libserver/dns.c +++ b/src/libserver/dns.c @@ -20,6 +20,7 @@ #include "dns.h" #include "rspamd.h" #include "utlist.h" +#include "contrib/libev/ev.h" #include "contrib/librdns/rdns.h" #include "contrib/librdns/dns_private.h" #include "contrib/librdns/rdns_ev.h" diff --git a/src/libserver/dns.h b/src/libserver/dns.h index d6977d0c0..acf8d0908 100644 --- a/src/libserver/dns.h +++ b/src/libserver/dns.h @@ -1,11 +1,11 @@ -/*- - * Copyright 2016 Vsevolod Stakhov +/* + * Copyright 2023 Vsevolod Stakhov * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * - * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, @@ -31,13 +31,14 @@ extern "C" { struct rspamd_config; struct rspamd_task; +struct event_loop; struct rspamd_dns_resolver { struct rdns_resolver *r; struct ev_loop *event_loop; rspamd_lru_hash_t *fails_cache; void *uidna; - ev_tstamp fails_cache_time; + double fails_cache_time; struct upstream_list *ups; struct rspamd_config *cfg; gdouble request_timeout; diff --git a/src/libserver/logger/logger.c b/src/libserver/logger/logger.c index b62048c86..9b9d302f2 100644 --- a/src/libserver/logger/logger.c +++ b/src/libserver/logger/logger.c @@ -1,11 +1,11 @@ -/*- - * Copyright 2016 Vsevolod Stakhov +/* + * Copyright 2023 Vsevolod Stakhov * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * - * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, @@ -27,6 +27,8 @@ static rspamd_logger_t *default_logger = NULL; static rspamd_logger_t *emergency_logger = NULL; static struct rspamd_log_modules *log_modules = NULL; +static const gchar lf_chr = '\n'; + guint rspamd_task_log_id = (guint) -1; RSPAMD_CONSTRUCTOR(rspamd_task_log_init) { @@ -1003,4 +1005,196 @@ rspamd_get_log_severity_string(gint level_flags) bitnum = ffs(level_flags) - 1; #endif return level_strs[bitnum]; +} + +static inline void +log_time(gdouble now, rspamd_logger_t *rspamd_log, gchar *timebuf, + size_t len) +{ + time_t sec = (time_t) now; + gsize r; + struct tm tms; + + rspamd_localtime(sec, &tms); + r = strftime(timebuf, len, "%F %H:%M:%S", &tms); + + if (rspamd_log->flags & RSPAMD_LOG_FLAG_USEC) { + gchar usec_buf[16]; + + rspamd_snprintf(usec_buf, sizeof(usec_buf), "%.5f", + now - (gdouble) sec); + rspamd_snprintf(timebuf + r, len - r, + "%s", usec_buf + 1); + } +} + +gsize rspamd_log_fill_iov(struct iovec *iov, + double ts, + const gchar *module, + const gchar *id, + const gchar *function, + gint level_flags, + const gchar *message, + gsize mlen, + rspamd_logger_t *logger) +{ + bool log_color = (logger->flags & RSPAMD_LOG_FLAG_COLOR); + bool log_severity = (logger->flags & RSPAMD_LOG_FLAG_SEVERITY); + bool log_rspamadm = (logger->flags & RSPAMD_LOG_FLAG_RSPAMADM); + bool log_systemd = (logger->flags & RSPAMD_LOG_FLAG_SYSTEMD); + + gint r; + + if (iov == NULL) { + if (log_rspamadm) { + if (logger->log_level == G_LOG_LEVEL_DEBUG) { + return 4; + } + else { + return 3; /* No time component */ + } + } + else if (log_systemd) { + return 3; + } + else { + if (log_color) { + return 5; + } + else { + return 4; + } + } + } + else { + static gchar timebuf[64], modulebuf[64]; + static gchar tmpbuf[256]; + + if (!log_systemd) { + log_time(ts, logger, timebuf, sizeof(timebuf)); + } + + if (!log_rspamadm) { + if (!log_systemd) { + if (log_color) { + if (level_flags & (G_LOG_LEVEL_INFO | G_LOG_LEVEL_MESSAGE)) { + /* White */ + r = rspamd_snprintf(tmpbuf, sizeof(tmpbuf), "\033[0;37m"); + } + else if (level_flags & G_LOG_LEVEL_WARNING) { + /* Magenta */ + r = rspamd_snprintf(tmpbuf, sizeof(tmpbuf), "\033[0;32m"); + } + else if (level_flags & G_LOG_LEVEL_CRITICAL) { + /* Red */ + r = rspamd_snprintf(tmpbuf, sizeof(tmpbuf), "\033[1;31m"); + } + else { + r = 0; + } + } + else { + r = 0; + } + + if (log_severity) { + r += rspamd_snprintf(tmpbuf + r, + sizeof(tmpbuf) - r, + "%s [%s] #%P(%s) ", + timebuf, + rspamd_get_log_severity_string(level_flags), + logger->pid, + logger->process_type); + } + else { + r += rspamd_snprintf(tmpbuf + r, + sizeof(tmpbuf) - r, + "%s #%P(%s) ", + timebuf, + logger->pid, + logger->process_type); + } + } + else { + r = 0; + r += rspamd_snprintf(tmpbuf + r, + sizeof(tmpbuf) - r, + "(%s) ", + logger->process_type); + } + + int mremain, mr; + char *m; + + modulebuf[0] = '\0'; + mremain = sizeof(modulebuf); + m = modulebuf; + + if (id != NULL) { + guint slen = strlen(id); + slen = MIN(RSPAMD_LOG_ID_LEN, slen); + mr = rspamd_snprintf(m, mremain, "<%*.s>; ", slen, + id); + m += mr; + mremain -= mr; + } + if (module != NULL) { + mr = rspamd_snprintf(m, mremain, "%s; ", module); + m += mr; + mremain -= mr; + } + if (function != NULL) { + mr = rspamd_snprintf(m, mremain, "%s: ", function); + m += mr; + mremain -= mr; + } + else { + mr = rspamd_snprintf(m, mremain, ": "); + m += mr; + mremain -= mr; + } + + /* Ensure that we have a space at the end */ + if (m > modulebuf && *(m - 1) != ' ') { + *(m - 1) = ' '; + } + + /* Construct IOV for log line */ + iov[0].iov_base = tmpbuf; + iov[0].iov_len = r; + iov[1].iov_base = modulebuf; + iov[1].iov_len = m - modulebuf; + iov[2].iov_base = (void *) message; + iov[2].iov_len = mlen; + iov[3].iov_base = (void *) &lf_chr; + iov[3].iov_len = 1; + + if (log_color) { + iov[4].iov_base = "\033[0m"; + iov[4].iov_len = sizeof("\033[0m") - 1; + + return 5; + } + + return 4; + } + else { + /* Rspamadm case */ + int niov = 0; + + if (logger->log_level == G_LOG_LEVEL_DEBUG) { + iov[niov].iov_base = (void *) timebuf; + iov[niov++].iov_len = strlen(timebuf); + iov[niov].iov_base = (void *) " "; + iov[niov++].iov_len = 1; + } + + iov[niov].iov_base = (void *) message; + iov[niov++].iov_len = mlen; + iov[niov].iov_base = (void *) &lf_chr; + iov[niov++].iov_len = 1; + + return niov; + } + } }
\ No newline at end of file diff --git a/src/libserver/logger/logger_console.c b/src/libserver/logger/logger_console.c index b5250f657..691566ab9 100644 --- a/src/libserver/logger/logger_console.c +++ b/src/libserver/logger/logger_console.c @@ -1,11 +1,11 @@ -/*- - * Copyright 2020 Vsevolod Stakhov +/* + * Copyright 2023 Vsevolod Stakhov * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * - * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, @@ -153,13 +153,8 @@ bool rspamd_log_console_log(const gchar *module, const gchar *id, gpointer arg) { struct rspamd_console_logger_priv *priv = (struct rspamd_console_logger_priv *) arg; - static gchar timebuf[64], modulebuf[64]; - gchar tmpbuf[256]; - gchar *m; - struct iovec iov[6]; - gulong r = 0, mr = 0; - size_t mremain; - gint fd, niov = 0; + gint fd, r; + double now; if (level_flags & G_LOG_LEVEL_CRITICAL) { fd = priv->crit_fd; @@ -184,119 +179,13 @@ bool rspamd_log_console_log(const gchar *module, const gchar *id, rspamd_file_lock(fd, FALSE); #endif - if (!(rspamd_log->flags & RSPAMD_LOG_FLAG_SYSTEMD)) { - log_time(rspamd_get_calendar_ticks(), - rspamd_log, timebuf, sizeof(timebuf)); - } - - if (priv->log_color) { - if (level_flags & (G_LOG_LEVEL_INFO | G_LOG_LEVEL_MESSAGE)) { - /* White */ - r = rspamd_snprintf(tmpbuf, sizeof(tmpbuf), "\033[0;37m"); - } - else if (level_flags & G_LOG_LEVEL_WARNING) { - /* Magenta */ - r = rspamd_snprintf(tmpbuf, sizeof(tmpbuf), "\033[0;32m"); - } - else if (level_flags & G_LOG_LEVEL_CRITICAL) { - /* Red */ - r = rspamd_snprintf(tmpbuf, sizeof(tmpbuf), "\033[1;31m"); - } - } - else { - r = 0; - } - - if (priv->log_rspamadm) { - if (rspamd_log->log_level == G_LOG_LEVEL_DEBUG) { - log_time(rspamd_get_calendar_ticks(), - rspamd_log, timebuf, sizeof(timebuf)); - iov[niov].iov_base = (void *) timebuf; - iov[niov++].iov_len = strlen(timebuf); - iov[niov].iov_base = (void *) " "; - iov[niov++].iov_len = 1; - } - - iov[niov].iov_base = (void *) message; - iov[niov++].iov_len = mlen; - iov[niov].iov_base = (void *) &lf_chr; - iov[niov++].iov_len = 1; - } - else { - if (!(rspamd_log->flags & RSPAMD_LOG_FLAG_SYSTEMD)) { - if (priv->log_severity) { - r += rspamd_snprintf(tmpbuf + r, - sizeof(tmpbuf) - r, - "%s [%s] #%P(%s) ", - timebuf, - rspamd_get_log_severity_string(level_flags), - rspamd_log->pid, - rspamd_log->process_type); - } - else { - r += rspamd_snprintf(tmpbuf + r, - sizeof(tmpbuf) - r, - "%s #%P(%s) ", - timebuf, - rspamd_log->pid, - rspamd_log->process_type); - } - } - else { - r += rspamd_snprintf(tmpbuf + r, - sizeof(tmpbuf) - r, - "#%P(%s) ", - rspamd_log->pid, - rspamd_log->process_type); - } - - modulebuf[0] = '\0'; - mremain = sizeof(modulebuf); - m = modulebuf; - - if (id != NULL) { - guint slen = strlen(id); - slen = MIN(RSPAMD_LOG_ID_LEN, slen); - mr = rspamd_snprintf(m, mremain, "<%*.s>; ", slen, - id); - m += mr; - mremain -= mr; - } - if (module != NULL) { - mr = rspamd_snprintf(m, mremain, "%s; ", module); - m += mr; - mremain -= mr; - } - if (function != NULL) { - mr = rspamd_snprintf(m, mremain, "%s: ", function); - m += mr; - mremain -= mr; - } - else { - mr = rspamd_snprintf(m, mremain, ": "); - m += mr; - mremain -= mr; - } - - /* Ensure that we have a space at the end */ - if (m > modulebuf && *(m - 1) != ' ') { - *(m - 1) = ' '; - } - - iov[niov].iov_base = tmpbuf; - iov[niov++].iov_len = r; - iov[niov].iov_base = modulebuf; - iov[niov++].iov_len = m - modulebuf; - iov[niov].iov_base = (void *) message; - iov[niov++].iov_len = mlen; - iov[niov].iov_base = (void *) &lf_chr; - iov[niov++].iov_len = 1; - } - - if (priv->log_color) { - iov[niov].iov_base = "\033[0m"; - iov[niov++].iov_len = sizeof("\033[0m") - 1; - } + now = rspamd_get_calendar_ticks(); + gsize niov = rspamd_log_fill_iov(NULL, now, module, id, + function, level_flags, message, + mlen, rspamd_log); + struct iovec *iov = g_alloca(sizeof(struct iovec) * niov); + rspamd_log_fill_iov(iov, now, module, id, function, level_flags, message, + mlen, rspamd_log); again: r = writev(fd, iov, niov); diff --git a/src/libserver/logger/logger_file.c b/src/libserver/logger/logger_file.c index 91ae1956c..490cf0b65 100644 --- a/src/libserver/logger/logger_file.c +++ b/src/libserver/logger/logger_file.c @@ -1,11 +1,11 @@ -/*- - * Copyright 2020 Vsevolod Stakhov +/* + * Copyright 2023 Vsevolod Stakhov * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * - * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, @@ -24,8 +24,6 @@ #define FILE_LOG_QUARK g_quark_from_static_string("file_logger") -static const gchar lf_chr = '\n'; - struct rspamd_file_logger_priv { gint fd; struct { @@ -57,28 +55,6 @@ rspamd_log_calculate_cksum(const gchar *message, size_t mlen) return rspamd_cryptobox_fast_hash(message, mlen, rspamd_hash_seed()); } -static inline void -log_time(gdouble now, rspamd_logger_t *rspamd_log, gchar *timebuf, - size_t len) -{ - time_t sec = (time_t) now; - gsize r; - struct tm tms; - - rspamd_localtime(sec, &tms); - r = strftime(timebuf, len, "%F %H:%M:%S", &tms); - - if (rspamd_log->flags & RSPAMD_LOG_FLAG_USEC) { - gchar usec_buf[16]; - - rspamd_snprintf(usec_buf, sizeof(usec_buf), "%.5f", - now - (gdouble) sec); - rspamd_snprintf(timebuf + r, len - r, - "%s", usec_buf + 1); - } -} - - /* * Write a line to log file (unbuffered) */ @@ -399,15 +375,8 @@ bool rspamd_log_file_log(const gchar *module, const gchar *id, gpointer arg) { struct rspamd_file_logger_priv *priv = (struct rspamd_file_logger_priv *) arg; - static gchar timebuf[64], modulebuf[64]; - gchar tmpbuf[256]; - gchar *m; gdouble now; - struct iovec iov[6]; - gulong r = 0, mr = 0; guint64 cksum; - size_t mremain; - const gchar *cptype = NULL; gboolean got_time = FALSE; @@ -496,84 +465,13 @@ bool rspamd_log_file_log(const gchar *module, const gchar *id, now = rspamd_get_calendar_ticks(); } - /* Format time */ - if (!(rspamd_log->flags & RSPAMD_LOG_FLAG_SYSTEMD)) { - log_time(now, rspamd_log, timebuf, sizeof(timebuf)); - } - - cptype = rspamd_log->process_type; - r = 0; - - if (!(rspamd_log->flags & RSPAMD_LOG_FLAG_SYSTEMD)) { - if (priv->log_severity) { - r += rspamd_snprintf(tmpbuf + r, - sizeof(tmpbuf) - r, - "%s [%s] #%P(%s) ", - timebuf, - rspamd_get_log_severity_string(level_flags), - rspamd_log->pid, - cptype); - } - else { - r += rspamd_snprintf(tmpbuf + r, - sizeof(tmpbuf) - r, - "%s #%P(%s) ", - timebuf, - rspamd_log->pid, - cptype); - } - } - else { - r += rspamd_snprintf(tmpbuf + r, - sizeof(tmpbuf) - r, - "(%s) ", - cptype); - } - - modulebuf[0] = '\0'; - mremain = sizeof(modulebuf); - m = modulebuf; - - if (id != NULL) { - guint slen = strlen(id); - slen = MIN(RSPAMD_LOG_ID_LEN, slen); - mr = rspamd_snprintf(m, mremain, "<%*.s>; ", slen, - id); - m += mr; - mremain -= mr; - } - if (module != NULL) { - mr = rspamd_snprintf(m, mremain, "%s; ", module); - m += mr; - mremain -= mr; - } - if (function != NULL) { - mr = rspamd_snprintf(m, mremain, "%s: ", function); - m += mr; - mremain -= mr; - } - else { - mr = rspamd_snprintf(m, mremain, ": "); - m += mr; - mremain -= mr; - } - - /* Ensure that we have a space at the end */ - if (m > modulebuf && *(m - 1) != ' ') { - *(m - 1) = ' '; - } + gsize niov = rspamd_log_fill_iov(NULL, now, module, id, function, level_flags, message, + mlen, rspamd_log); + struct iovec *iov = g_alloca(sizeof(struct iovec) * niov); + rspamd_log_fill_iov(iov, now, module, id, function, level_flags, message, + mlen, rspamd_log); - /* Construct IOV for log line */ - iov[0].iov_base = tmpbuf; - iov[0].iov_len = r; - iov[1].iov_base = modulebuf; - iov[1].iov_len = m - modulebuf; - iov[2].iov_base = (void *) message; - iov[2].iov_len = mlen; - iov[3].iov_base = (void *) &lf_chr; - iov[3].iov_len = 1; - - return file_log_helper(rspamd_log, priv, iov, 4, level_flags); + return file_log_helper(rspamd_log, priv, iov, niov, level_flags); } void * diff --git a/src/libserver/logger/logger_private.h b/src/libserver/logger/logger_private.h index a5ce1cdc3..138f8df91 100644 --- a/src/libserver/logger/logger_private.h +++ b/src/libserver/logger/logger_private.h @@ -1,11 +1,11 @@ -/*- - * Copyright 2020 Vsevolod Stakhov +/* + * Copyright 2023 Vsevolod Stakhov * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * - * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, @@ -102,6 +102,28 @@ bool rspamd_log_file_log(const gchar *module, const gchar *id, gpointer arg); bool rspamd_log_file_on_fork(rspamd_logger_t *logger, struct rspamd_config *cfg, gpointer arg, GError **err); + +/** + * Fills IOV of logger (usable for file/console logging) + * Warning: this function is NOT reentrant, do not call it twice from a single moment of execution + * @param iov if NULL just returns the number of elements required in IOV array + * @param module + * @param id + * @param function + * @param level_flags + * @param message + * @param mlen + * @param rspamd_log + * @return number of iov elements being filled + */ +gsize rspamd_log_fill_iov(struct iovec *iov, + double ts, + const gchar *module, const gchar *id, + const gchar *function, + gint level_flags, + const gchar *message, + gsize mlen, + rspamd_logger_t *rspamd_log); /** * Escape log line by replacing unprintable characters to hex escapes like \xNN * @param src diff --git a/src/libserver/worker_util.c b/src/libserver/worker_util.c index a0abe63b1..8edfe0cdb 100644 --- a/src/libserver/worker_util.c +++ b/src/libserver/worker_util.c @@ -43,12 +43,6 @@ #endif #include "zlib.h" -#ifdef WITH_LIBUNWIND -#define UNW_LOCAL_ONLY 1 -#include <libunwind.h> -#define UNWIND_BACKTRACE_DEPTH 256 -#endif - #ifdef HAVE_UCONTEXT_H #include <ucontext.h> #elif defined(HAVE_SYS_UCONTEXT_H) @@ -1610,69 +1604,6 @@ void rspamd_worker_init_monitored(struct rspamd_worker *worker, #ifdef HAVE_SA_SIGINFO -#ifdef WITH_LIBUNWIND -static void -rspamd_print_crash(ucontext_t *uap) -{ - unw_cursor_t cursor; - unw_word_t ip, off; - guint level; - gint ret; - - if ((ret = unw_init_local(&cursor, uap)) != 0) { - msg_err("unw_init_local: %d", ret); - - return; - } - - level = 0; - ret = 0; - - for (;;) { - char name[128]; - - if (level >= UNWIND_BACKTRACE_DEPTH) { - break; - } - - unw_get_reg(&cursor, UNW_REG_IP, &ip); - ret = unw_get_proc_name(&cursor, name, sizeof(name), &off); - - if (ret == 0) { - msg_err("%d: 0x%xl: %s()+0x%xl", - level, (unsigned long)ip, name, (unsigned long)off); - } - else { - msg_err("%d: %0x%xl: <unknown>", level, (unsigned long)ip); - } - - level++; - ret = unw_step(&cursor); - - if (ret <= 0) { - break; - } - } - - if (ret < 0) { - msg_err("unw_step_ptr: %d", ret); - } -} -#elif defined(HAVE_BACKTRACE) -#include <execinfo.h> -static void -rspamd_print_crash(ucontext_t *_uap) -{ - void *callstack[128]; - int i, frames = backtrace(callstack, 128); - char **strs = backtrace_symbols(callstack, frames); - for (i = 0; i < frames; ++i) { - msg_err("%d: %s", i, strs[i]); - } - free(strs); -} -#endif - static struct rspamd_main *saved_main = NULL; static gboolean rspamd_crash_propagate(gpointer key, gpointer value, gpointer unused) @@ -1685,6 +1616,11 @@ rspamd_crash_propagate(gpointer key, gpointer value, gpointer unused) return TRUE; } +#ifdef BACKWARD_ENABLE +/* See backtrace.cxx */ +extern void rspamd_print_crash(void); +#endif + static void rspamd_crash_sig_handler(int sig, siginfo_t *info, void *ctx) { @@ -1697,8 +1633,8 @@ rspamd_crash_sig_handler(int sig, siginfo_t *info, void *ctx) "pid: %P, trace: ", sig, strsignal(sig), pid); (void) uap; -#if defined(WITH_LIBUNWIND) || defined(HAVE_BACKTRACE) - rspamd_print_crash(uap); +#ifdef BACKWARD_ENABLE + rspamd_print_crash(); #endif msg_err("please see Rspamd FAQ to learn how to dump core files and how to " "fill a bug report"); diff --git a/src/libutil/regexp.c b/src/libutil/regexp.c index a242fcb98..9f143acfc 100644 --- a/src/libutil/regexp.c +++ b/src/libutil/regexp.c @@ -1,11 +1,11 @@ -/*- - * Copyright 2016 Vsevolod Stakhov +/* + * Copyright 2023 Vsevolod Stakhov * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * - * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, @@ -164,11 +164,8 @@ rspamd_regexp_post_process(rspamd_regexp_t *r) rspamd_regexp_library_init(NULL); } #if defined(WITH_PCRE2) - gsize jsz; static const guint max_recursion_depth = 100000, max_backtrack = 1000000; - guint jit_flags = can_jit ? PCRE2_JIT_COMPLETE : 0; - /* Create match context */ r->mcontext = pcre2_match_context_create(NULL); g_assert(r->mcontext != NULL); @@ -189,14 +186,20 @@ rspamd_regexp_post_process(rspamd_regexp_t *r) } #ifdef HAVE_PCRE_JIT + guint jit_flags = can_jit ? PCRE2_JIT_COMPLETE : 0; + gsize jsz; + PCRE2_UCHAR errstr[128]; + int errcode; + if (can_jit) { - if (pcre2_jit_compile(r->re, jit_flags) < 0) { - msg_err("jit compilation of %s is not supported: %d", r->pattern, jit_flags); + if ((errcode = pcre2_jit_compile(r->re, jit_flags)) < 0) { + pcre2_get_error_message(errcode, errstr, G_N_ELEMENTS(errstr)); + msg_err("jit compilation is not supported: %s; pattern: \"%s\"", errstr, r->pattern); r->flags |= RSPAMD_REGEXP_FLAG_DISABLE_JIT; } else { if (!(pcre2_pattern_info(r->re, PCRE2_INFO_JITSIZE, &jsz) >= 0 && jsz > 0)) { - msg_err("jit compilation of %s is not supported", r->pattern); + msg_err("cannot exec pcre2_pattern_info(PCRE2_INFO_JITSIZE) on \"%s\"", r->pattern); r->flags |= RSPAMD_REGEXP_FLAG_DISABLE_JIT; } } @@ -210,17 +213,19 @@ rspamd_regexp_post_process(rspamd_regexp_t *r) } if (r->raw_re && r->re != r->raw_re && !(r->flags & RSPAMD_REGEXP_FLAG_DISABLE_JIT)) { - if (pcre2_jit_compile(r->raw_re, jit_flags) < 0) { - msg_debug("jit compilation of %s is not supported", r->pattern); + if ((errcode = pcre2_jit_compile(r->raw_re, jit_flags)) < 0) { + pcre2_get_error_message(errcode, errstr, G_N_ELEMENTS(errstr)); + msg_debug("jit compilation is not supported for raw regexp: %s; pattern: \"%s\"", errstr, r->pattern); r->flags |= RSPAMD_REGEXP_FLAG_DISABLE_JIT; } - - if (!(pcre2_pattern_info(r->raw_re, PCRE2_INFO_JITSIZE, &jsz) >= 0 && jsz > 0)) { - msg_debug("jit compilation of raw %s is not supported", r->pattern); - } - else if (!(r->flags & RSPAMD_REGEXP_FLAG_DISABLE_JIT)) { - g_assert(r->raw_mcontext != NULL); - pcre2_jit_stack_assign(r->raw_mcontext, NULL, global_re_cache->jstack); + else { + if (!(pcre2_pattern_info(r->raw_re, PCRE2_INFO_JITSIZE, &jsz) >= 0 && jsz > 0)) { + msg_err("cannot exec pcre2_pattern_info(PCRE2_INFO_JITSIZE) on \"%s\"", r->pattern); + } + else if (!(r->flags & RSPAMD_REGEXP_FLAG_DISABLE_JIT)) { + g_assert(r->raw_mcontext != NULL); + pcre2_jit_stack_assign(r->raw_mcontext, NULL, global_re_cache->jstack); + } } } #endif diff --git a/src/libutil/upstream.c b/src/libutil/upstream.c index a62bf293d..f536a2c6d 100644 --- a/src/libutil/upstream.c +++ b/src/libutil/upstream.c @@ -1,11 +1,11 @@ -/*- - * Copyright 2016 Vsevolod Stakhov +/* + * Copyright 2023 Vsevolod Stakhov * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * - * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, @@ -21,6 +21,7 @@ #include "rdns.h" #include "cryptobox.h" #include "utlist.h" +#include "contrib/libev/ev.h" #include "logger.h" #include "contrib/librdns/rdns.h" #include "contrib/mumhash/mum.h" diff --git a/src/libutil/upstream.h b/src/libutil/upstream.h index 08796a1f9..22a020c9c 100644 --- a/src/libutil/upstream.h +++ b/src/libutil/upstream.h @@ -1,3 +1,19 @@ +/* + * Copyright 2023 Vsevolod Stakhov + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + #ifndef UPSTREAM_H #define UPSTREAM_H @@ -10,6 +26,9 @@ extern "C" { #endif +/* Forward declaration */ +struct ev_loop; + enum rspamd_upstream_rotation { RSPAMD_UPSTREAM_RANDOM = 0, RSPAMD_UPSTREAM_HASHED, diff --git a/src/libutil/util.c b/src/libutil/util.c index d3c4721bd..f7e22e1bd 100644 --- a/src/libutil/util.c +++ b/src/libutil/util.c @@ -19,6 +19,7 @@ #include "ottery.h" #include "cryptobox.h" +#include "contrib/libev/ev.h" #ifdef HAVE_TERMIOS_H #include <termios.h> diff --git a/src/libutil/util.h b/src/libutil/util.h index 662f4e819..4842b890e 100644 --- a/src/libutil/util.h +++ b/src/libutil/util.h @@ -1,3 +1,19 @@ +/* + * Copyright 2023 Vsevolod Stakhov + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + #ifndef RSPAMD_UTIL_H #define RSPAMD_UTIL_H @@ -12,7 +28,6 @@ #include <netdb.h> #endif -#include "contrib/libev/ev.h" #include <time.h> #ifdef __cplusplus diff --git a/src/lua/lua_common.c b/src/lua/lua_common.c index bafe8ea93..9bf9514f6 100644 --- a/src/lua/lua_common.c +++ b/src/lua/lua_common.c @@ -475,15 +475,20 @@ rspamd_lua_rspamd_version_numeric(lua_State *L) type = lua_tostring(L, 1); if (g_ascii_strcasecmp(type, "short") == 0) { version_num = RSPAMD_VERSION_MAJOR_NUM * 1000 + - RSPAMD_VERSION_MINOR_NUM * 100; + RSPAMD_VERSION_MINOR_NUM * 100 + + RSPAMD_VERSION_PATCH_NUM * 10; } else if (g_ascii_strcasecmp(type, "main") == 0) { version_num = RSPAMD_VERSION_MAJOR_NUM * 1000 + - RSPAMD_VERSION_MINOR_NUM * 100; + RSPAMD_VERSION_MINOR_NUM * 100 + + RSPAMD_VERSION_PATCH_NUM * 10; } else if (g_ascii_strcasecmp(type, "major") == 0) { version_num = RSPAMD_VERSION_MAJOR_NUM; } + else if (g_ascii_strcasecmp(type, "patch") == 0) { + version_num = RSPAMD_VERSION_PATCH_NUM; + } else if (g_ascii_strcasecmp(type, "minor") == 0) { version_num = RSPAMD_VERSION_MINOR_NUM; } @@ -511,7 +516,7 @@ rspamd_lua_rspamd_version(lua_State *L) "." RSPAMD_VERSION_MINOR; } else if (g_ascii_strcasecmp(type, "main") == 0) { - result = RSPAMD_VERSION_MAJOR "." RSPAMD_VERSION_MINOR; + result = RSPAMD_VERSION_MAJOR "." RSPAMD_VERSION_MINOR "." RSPAMD_VERSION_PATCH; } else if (g_ascii_strcasecmp(type, "major") == 0) { result = RSPAMD_VERSION_MAJOR; @@ -519,6 +524,9 @@ rspamd_lua_rspamd_version(lua_State *L) else if (g_ascii_strcasecmp(type, "minor") == 0) { result = RSPAMD_VERSION_MINOR; } + else if (g_ascii_strcasecmp(type, "patch") == 0) { + result = RSPAMD_VERSION_PATCH; + } else if (g_ascii_strcasecmp(type, "id") == 0) { result = RID; } diff --git a/src/lua/lua_util.c b/src/lua/lua_util.c index 40f6f6c48..152c02d1e 100644 --- a/src/lua/lua_util.c +++ b/src/lua/lua_util.c @@ -984,37 +984,25 @@ lua_util_encode_base64(lua_State *L) { LUA_TRACE_POINT; struct rspamd_lua_text *t; - const gchar *s = NULL; gchar *out; - gsize inlen, outlen; - guint str_lim = 0; + gsize outlen; + long str_lim = 0; gboolean fold = FALSE; - if (lua_type(L, 1) == LUA_TSTRING) { - s = luaL_checklstring(L, 1, &inlen); - } - else if (lua_type(L, 1) == LUA_TUSERDATA) { - t = lua_check_text(L, 1); - - if (t != NULL) { - s = t->start; - inlen = t->len; - } - } + t = lua_check_text_or_string(L, 1); if (lua_gettop(L) > 1) { - str_lim = luaL_checknumber(L, 2); - - fold = !!(str_lim > 0); + str_lim = luaL_checkinteger(L, 2); + fold = str_lim > 0; } - if (s == NULL) { - lua_pushnil(L); + if (t == NULL) { + return luaL_error(L, "invalid arguments"); } else { if (fold) { - out = rspamd_encode_base64(s, inlen, str_lim, &outlen); + out = rspamd_encode_base64(t->start, t->len, str_lim, &outlen); } else { enum rspamd_newlines_type how = RSPAMD_TASK_NEWLINES_CRLF; @@ -1033,16 +1021,11 @@ lua_util_encode_base64(lua_State *L) } } - out = rspamd_encode_base64_fold(s, inlen, str_lim, &outlen, how); + out = rspamd_encode_base64_fold(t->start, t->len, str_lim, &outlen, how); } if (out != NULL) { - t = lua_newuserdata(L, sizeof(*t)); - rspamd_lua_setclass(L, "rspamd{text}", -1); - t->start = out; - t->len = outlen; - /* Need destruction */ - t->flags = RSPAMD_TEXT_FLAG_OWN; + lua_new_text(L, out, outlen, TRUE); } else { lua_pushnil(L); diff --git a/src/plugins/lua/rbl.lua b/src/plugins/lua/rbl.lua index c5cdbef1c..837707b3f 100644 --- a/src/plugins/lua/rbl.lua +++ b/src/plugins/lua/rbl.lua @@ -563,7 +563,31 @@ local function gen_rbl_callback(rule) no_cache = true, } - if not rule.urls then + if rule.numeric_urls then + if rule.content_urls then + if not rule.images then + ex_params.flags_mode = 'explicit' + ex_params.flags = {'numeric'} + ex_params.filter = function(url) + return (bit.band(url:get_flags_num(), url_flag_bits.image) == 0) + end + else + ex_params.filter = function(url) + return (bit.band(url:get_flags_num(), url_flag_bits.numeric) ~= 0) + end + end + elseif rule.images then + ex_params.filter = function(url) + return (bit.band(url:get_flags_num(), url_flag_bits.numeric) ~= 0) + end + else + ex_params.flags_mode = 'explicit' + ex_params.flags = {'numeric'} + ex_params.filter = function(url) + return (bit.band(url:get_flags_num(), url_flag_bits.content) == 0) + end + end + elseif not rule.urls and (rule.content_urls or rule.images) then ex_params.flags_mode = 'explicit' ex_params.flags = {} if rule.content_urls then @@ -572,9 +596,6 @@ local function gen_rbl_callback(rule) if rule.images then table.insert(ex_params.flags, 'image') end - if rule.numeric_urls then - table.insert(ex_params.flags, 'numeric') - end end local urls = lua_util.extract_specific_urls(ex_params) diff --git a/src/rspamadm/CMakeLists.txt b/src/rspamadm/CMakeLists.txt index 125e04804..5e88ec8dd 100644 --- a/src/rspamadm/CMakeLists.txt +++ b/src/rspamadm/CMakeLists.txt @@ -27,4 +27,5 @@ IF (NOT DEBIAN_BUILD) ENDIF (NOT DEBIAN_BUILD) SET_TARGET_PROPERTIES(rspamadm PROPERTIES LINKER_LANGUAGE CXX) +ADD_BACKWARD(rspamadm) INSTALL(TARGETS rspamadm RUNTIME DESTINATION bin) diff --git a/test/functional/cases/001_merged/300_rbl.robot b/test/functional/cases/001_merged/300_rbl.robot index c0e7fde95..61c02c26b 100644 --- a/test/functional/cases/001_merged/300_rbl.robot +++ b/test/functional/cases/001_merged/300_rbl.robot @@ -80,3 +80,18 @@ NUMERIC URLS Scan File ${RSPAMD_TESTDIR}/messages/numeric_urls.eml ... Settings={symbols_enabled = [URIBL_NUMERIC]} Expect Symbol With Exact Options URIBL_NUMERIC 4.3.2.1:url + +NUMERIC URLS WITH IMAGES + Scan File ${RSPAMD_TESTDIR}/messages/numeric_urls.eml + ... Settings={symbols_enabled = [URIBL_NUMERIC_IMAGES]} + Expect Symbol With Exact Options URIBL_NUMERIC_IMAGES 4.3.2.1:url 12.11.10.9:url + +NUMERIC URLS WITH CONTENT + Scan File ${RSPAMD_TESTDIR}/messages/numeric_urls.eml + ... Settings={symbols_enabled = [URIBL_NUMERIC_CONTENT]} + Expect Symbol With Exact Options URIBL_NUMERIC_CONTENT 4.3.2.1:url 8.7.6.5:url + +NUMERIC URLS WITH EVERYTHING + Scan File ${RSPAMD_TESTDIR}/messages/numeric_urls.eml + ... Settings={symbols_enabled = [URIBL_NUMERIC_EVERYTHING]} + Expect Symbol With Exact Options URIBL_NUMERIC_EVERYTHING 12.11.10.9:url 4.3.2.1:url 8.7.6.5:url diff --git a/test/functional/configs/merged-local.conf b/test/functional/configs/merged-local.conf index 82d609730..0708e3c0b 100644 --- a/test/functional/configs/merged-local.conf +++ b/test/functional/configs/merged-local.conf @@ -881,6 +881,21 @@ options = { replies = ["127.0.0.2"]; }, { + name = "judo.za.org.test9.uribl"; + type = a; + replies = ["127.0.0.2"]; + }, + { + name = "12.11.10.9.test9.uribl"; + type = a; + replies = ["127.0.0.2"]; + }, + { + name = "8.7.6.5.test9.uribl"; + type = a; + replies = ["127.0.0.2"]; + }, + { name = "8.8.8.8.test9.uribl"; type = a; replies = ["127.0.0.2"]; diff --git a/test/functional/configs/merged-override.conf b/test/functional/configs/merged-override.conf index 04b879db6..28d554b83 100644 --- a/test/functional/configs/merged-override.conf +++ b/test/functional/configs/merged-override.conf @@ -302,6 +302,22 @@ rbl { checks = ["numeric_urls"]; rbl = "test9.uribl"; } + URIBL_NUMERIC_IMAGES { + checks = ["numeric_urls"]; + images = true; + rbl = "test9.uribl"; + } + URIBL_NUMERIC_CONTENT { + checks = ["numeric_urls"]; + content_urls = true; + rbl = "test9.uribl"; + } + URIBL_NUMERIC_EVERYTHING { + checks = ["numeric_urls"]; + images = true; + content_urls = true; + rbl = "test9.uribl"; + } URIBL_NOCONTENT { rbl = "test9.uribl"; ignore_defaults = true; diff --git a/test/functional/messages/numeric_urls.eml b/test/functional/messages/numeric_urls.eml index 139a52c66..0c19d30b7 100644 --- a/test/functional/messages/numeric_urls.eml +++ b/test/functional/messages/numeric_urls.eml @@ -1,3 +1,226 @@ -Content-type: text/plain
+Message-ID: <d43f3739f0715907677646a64b86a748af9bbe68.camel@judo.za.org>
+Subject: behold I am you, lame content etc
+From: Andrew Lewis <nerf@judo.za.org>
+To: nerf@judo.za.org
+Date: Thu, 14 Sep 2023 16:33:56 +0200
+Content-Type: multipart/mixed; boundary="=-Px1ozcNocF27wUUNNZPj"
+User-Agent: Evolution 3.46.4-2
+MIME-Version: 1.0
+X-Evolution-Source: aae8aac68f6b9ca5aed2a266fd87af0026cd80f5
+
+--=-Px1ozcNocF27wUUNNZPj
+Content-Type: text/html
+Content-Transfer-Encoding: 8bit
+
+
+look these URLs:
+<a href="http://1.2.3.4">1</a> AND
+<a href="http://example.org">2</a> thx
+<img src="http://9.10.11.12/lol.png">
+<img src="http://judo.za.org/lol.png">
+
+--=-Px1ozcNocF27wUUNNZPj
+Content-Type: application/pdf; name="lamecontent.pdf"
+Content-Disposition: attachment; filename="lamecontent.pdf"
+Content-Transfer-Encoding: base64
+
+JVBERi0xLjYKJcOkw7zDtsOfCjIgMCBvYmoKPDwvTGVuZ3RoIDMgMCBSL0ZpbHRlci9GbGF0ZURl
+Y29kZT4+CnN0cmVhbQp4nJ1RTUtDMRC851fsWXhxJ58bCIFWW8Fb9YGH4smvixXspX/f5L1KfbSF
+ImGXTTLJzM6yBu3UNzGxZiPkk9cmehIHLQG0fVNPV/Q1Iurafqh5r3zQQjFanSRR/0rXSxAM9e/r
+zChBMpviM1t27EtXq1CQORaTWUoXcj1PDTDj+bC9KTXdluf+Xi16tfpl056RAkdxdkIcWOOYeMHL
+RtASuP5WeYG2GZKBhavha4S/TBi4QJOvXzaKdaTdsY6HO8XUodq2oQAdxvqTHg+y91oB0f6cWDdY
+gghhd0HfaOP4V+Oj4UiHEVTMOBRpCixm7cKOVxge709sxZ0waqrlMqeAoNN5q4yX8+25k3pW9AO2
+GJL3CmVuZHN0cmVhbQplbmRvYmoKCjMgMCBvYmoKMjc0CmVuZG9iagoKNyAwIG9iago8PC9MZW5n
+dGggOCAwIFIvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aDEgMTM0NjQ+PgpzdHJlYW0KeJzlemt4
+W9WV6F7n6C3b0pElWbJi6SiKnTh+W3aI8/KJY8vO03JsByuBWIolP4htCUtJGmgaAwlQQ0oIzwC3
+eNoMl9LcQSZpJ6UMuAXa2+mlhCm0pZQhU8KFO4XBUEr7AZZn7a0jWwmUfne+++8e+5yz9nrttdda
+e++1j50Y2xchOWSc8ETqGwnFRrvb9xBC/hchYOrbnxDXtltWI3yBEO5f+mMDIw/841UfEaI4S4j6
+7MDwwf6W5f+6iJCcQUIK3h2MhMKN1XdWELKkC3WsGEREKHVQje3bsb1kcCTxlRbVc30IJrE9PBzt
+C92467NNhBSjDrJyJPSV2HJFB4dtKi+OhkYif/nms2FsJwjRx2PReCJMbp0jpPodSo+NRWJbHtjz
+PCE1GkL444gD/KFXDoIq2uZ4hVKl1mh1+pzcPINRMOWbLdYCm72Q/P9xKY8RC2lTriUGEmPPSy7+
+NLGTk4TMvUtbC8/UlrlP/l9aoUm/7iePkLPkGHmVXC0TfMRPhsg+xGRfPyIvIZZefrKTPEYm/ora
+0+Qc0tN8QXIHHckXXn5yHzlDfnpJL34yQq5HW75HXoUa8jNMlSj5EDTkBvI8av0QcVu/SBWXh49+
+BvZnYV8jD3K3kU3cRWycpBSuijOS58hDsBs1J3Ccx+ZHvOZzSm8hh/DZSQbJfoTZpVz72W+Jdu6P
+OKpDZBO5kawnw1kST8HDvA7j10UeRp/+iOGqMkR1G38N932Om70LG3eSAbxDgGPnjvHr/4qH/q8v
+vpvkQilfTLRfROXqiCH1CVc79xG/hOhI99xMBje3ee6PfCg1quhVLFKuVfz8y/pQ3akYQWky91bq
++lRYuU35CEbrUUKk1l07Az3dXZ3bO/zt27Zu2bxpY1urr6V5Q9N6qXHd2jWrVzWsvGJFfU11VWVF
++bKlJcVLPIvdLptZMBrycvU6rUatUip4Dki5mIRgS5IvFgVfyNPiCbVVlIsttsHmivIWjy+YFENi
+El+KEk9bG0N5QkkxKCZL8BXKQgeTEnL2X8YppTmleU4wimvIGtqFR0y+0OwRz8HOjh6EjzV7AmLy
+PQZvZbCihDVyseF2owSzilortiR9+wcnWoJoI0zpdRs8GyK6inIypdMjqEcoucwTm4Jl64AB3LKW
+VVMc0eTSbnGkLaFw0t/R09LscLsDFeUbk3meZkYiG5jKpGpDUs1UikPUdHKbOFU+PXH7OSPZEyzL
+CXvCoat6knwIZSf4lomJW5JCWbLU05wsve6iDUceSZZ7mluSZVTr5u3z/Wxe6BKSymKjR5z4E8Hh
+eN5791JMSMaoio1/IhRMchuSsL3HTS+HD309MeHziL6J4ETo3Nz4Ho9o9ExM5eRMxFrQ3cTfgyrO
+zT15myPpuz2QNAYHYVVAHrpv++ZkfseuniRX7BMHQ4jB30aPe6XDLczz+P8amaBb0DnoYbebuuG2
+cxLZg43keEdPui2SPY4niFRVFkhyQUqZzlAs3ZQynqHMiwc9GNvNnT0TSUXxxrCnBT1+Wyg5vgez
+6xoaGI8xmfexw+2ZMAliQ1WA8Ypo1cbwkJhUlqCTUCpbAPOGikwYWSPv4/TrPQd2UCKYxAYPqqF6
+WjwtQfl3/6ANFYjo6LaydCJ09SSlZgSkkByxlqnqKpQIBTFgQ80smMkqTyxp9jTNR5ea1TLU2cNE
+ZLGkeUOSBPtkqWRVC5tXYstEsDltAtXl6ej5AfHOXZiqEx1nvKSOBJops3UDZllJy0RPuD/pCjrC
+OO/6xR6HOykFMMIBT08kQNMOPVR6wcGSI8Bypatnc6dnc8fOnpWyIWkCVacobrlMjafHkVaDCZjU
+FGvEHs7BB5DRiAjRh4CnaQ0+k+piDd5GdDjD0sRtWiP2gINkuNGMZKnYEmmW+Wj7EqVKmk4b2jLa
+VLSJeja0OdwBd/qqKOeQLModo4SGOrUtQ8JlCgkazM8NbQxFfWmjSS/2eCKegGdQTEr+Hjo26h7m
+ZdkZzOdyrLouaWU5C91E3EjONKgzk74yR7Zzk62sPd9su4y8MUMWJzSezZ0TVLlHVkjQ8o1JQlNY
+Wik42FpAJ7QH117RiFOaTeiJKUmik3lwFVXi2Rie8HT2rGHcuJ4cclxH+zKRzbC5q6miHJe2pikP
+3NoxJcGtnTt7fmDEuvDWrp4nOOA2BJsCU0uQ1vMDETcNhuUoliJpQ6QNqmk7NjSM3/EDiZBxRlUw
+BGv3nQPCcJoMDkjfOS6NM6Y7KmEdSYRDiiJNkTLcCsRp0rhxhmPXFKEuk3RKSSNppRwul3NMAUU9
+gZgnsY7VAjmTA7ngmEKp7Qx9DsantJIjzTGOHFLawlu7F7ru3tlzJgd3Zwd7YkdN9MJ0sQ1isHFb
+aRHDNFG+GhicCAboZCNWDA3+QhI86zBMnnVoiConqfNEmpJ6TxPFN1J8Yxqvong1pihYAcXHMfb+
+JNAM2NXjxikpFv7MMWF8j0YqgIvKhPGtCvRYMZ4bfoQ1qBnWSK+bOD2n4S3WHKIBLa/RaAVeywcD
+Wt7EEa43QEyNVjBY4YIVnrHCHVY4bIVeKyBSZPi9M1Z40QqTjBazQrsVXIyQxiet8DAjRZmYZIVq
+xkCs8AajjjN8NcOsnmP9pMXuYIR2Rpth+GSmj7SAyGRmmKJp1s04o6JpVZk+rp6/rs1cY/K1+zL8
+5yiURhrLBOK1safgtVX17r7aK5igoEHw1lS7668QPIsN4BHcgmdpJZSBUGCB1a94Z692bFA81Oxw
+/vNXal6pdyjuM78Eq1PPv6TWf7rXUU8LKiDc3LvKp7HqN5M/Sk6d0mBW4nGI0+hy27jcXLNBp1Qr
+/QFBbcjT68/N/UW6CQl6HojC2mWFZisssYLRCgorfGSFs8z9d1vhiBUSjFrNGE4xZNgKXcwXDch6
+kTUwClzagUZGQb8FreDPhAfx51m0JzMu7WXISzxJHdW74K1LnUgavXiVCd5GL/UcXrYqhEzQgI6j
+rlN69OCBpfVui9oBXkcaUji2vfPWptQPo/DMQ2+82fX7Vx6A/kEzNzx7N3+dvaLCMXuUi8zex92A
+sIWWtmTb3Lv8E/zzWJlayZPSDYJST5SkwKbJ8wc0Rs7sD3BW0QbEBhds4LdBtQ2MNphhzfM2mLZB
+0gaTNjhug3EbxGwQtIFkg7TI6ocZys9Q1QxrZIRs+UkmmRbD59V/NZPmfUR9U0ZoQi04A4zuxSX1
+dSu8tVZ1XYlnscpitnprV/BPpNpe/s1vfver35792s037Ttww5FxeC0lpD74j8/+/Mff/PjJC2/+
+03PpXCpFZxjxfKkl35JiSqyrVf4AngaUPKYQb3lZD8/p4aweTunhbj0c0UNCD2E9LNGDWQ8KPSYG
+4ziuBy6mh6Ae/HqQ9DCth6QeJlnTqAeihxnWRL5sti/MiuyBL8whHHJNdXGBhU4cjDhE/y5ln5wE
+nw8jaldytgqMaRvG9Fr+R8SBq9SI1ChoiosVYk6OXcHj8WGxbnFHwGYRhEX+gEFwCVwOLwhEo7Oq
+Ff6A2kIs/gAxji+F3qUgLQUErl5wON5eUwOdwWgIaWAzOj2T6Q8NQ63VghPYvVTlWSzUrYNGqKfR
+wPldvwLUeWAxY1CugJceuHNfKpU/NvXBxsn7j7VuCncuXvktIDfd3HtHc18t/6Ov3Th71F6xewxs
+u69fzyvuCl1Vte8FT8qpUO4eTbpsNF5leKKyY97WwBPSnJCjWrTITZYtq6hw5/De2ppKf6DGsMy9
+SMipKKvwB1yGMotdpdJqzdsDWuNSPPDxxdsDvHG/F3Z4YYUXlnjB6gWVFz72wkUvvOyFn3jhlBfu
+9cIeL4DfC81eqGZ8Zi8ovDA4k2E864WEFyQv1DEy0j7ywmtemPZCkuk44oWwV1aR5jFm2M574Tkv
+fNcLxxnbXi+s9oKY6WNluoNJLwS90JXpw8wkLzLJu70wjt1LZVl0B5O9yAzgkowhxrrHXg1e0Mhp
+1fvly/alq/oCw9iCeBYTySzu829vZtGSkzaTI/JsXQc4UQvo0w7pXK7zLM7j1OnsoU3MGrWwkOa+
+zY9KLfuKtr7YPHMw1X37ZGFLS6NFOJZquq27u+emY6kdBw5APh8sW1XXUNaU+sPsvXQ6cD2ncTNQ
+rFifaXYGimbtFORFewU72hM/zhUf5pGFLCLHpJ12AEOhxmKwFDntBCeI3WXHCWK355hMVn/AZMxR
+dgRyrNNOSDph0gnHnTDuhJgTgk7wO4E4YR2+JCdUO0F0gtEJM4wPmTJO3J09qdOrGGmwyXOKrWcZ
+J1nMTqDTxZIHnsUlAi5uomABXNrcdSWgWHt4YMXd1dV/v+O1n//iGRhK3TcYhRNXwaumiZN+k36l
+q/JdUH78Yap/Ozz06KkzJ9mcwf3yIaxZbOQuKZifY1PlqOyFJiXJNeT2BjgDr7VgzZKvKITGcCF0
+FUJzIdQVwpJCMBfC2UI4VQh3F8KRQkhk8MZCQO6PCuFCIXDnCyFZCJOFECsEfyF8Lssy+ZMetpwf
+2Us428AEs8IjLqkX0g2ju3ZFveKWs/Cz06k/f5b6U+rPpznbaeibfkHxH4X19YWfvfHBzAev83UM
+fi111/fP0JiuxnW7E8dpIU4yKq2zGI2OXAeAypprFkxCrkrhEo24OAYDDodWobXjoNW9WKwJoFKo
+egNmhckownkRYiJIIh0H3YuZuRgtOVyXLX34Y2L1DCzkLC6FZpWaprcW6kqwsMFYwqM/n33l4dPc
+hs9mTtwAe+9MPZO6BXT3/PC7U2fu47akFI56LHW+WVj/2FM3P1sy+46jntsCh07eMPvsURo/HJdi
+kH73hJXSbzm1Xi8YIScvpzeQx2v1WGaqIY9Xq7Ws9DSdFeCUAHcLcESAhAD9AuwQwCdAiQBWHKkA
+HwnwvwV4WYCfCPB9AR4RYD9j68qw/UqA5wTI1jPP0CxArQAgCmAWgAi4/QlwkSlDxrAAdRkCNyPA
+BQHOCzAtQEwASYBqgcoZs/BJASYZ1c8YPrcA9WYvPr1XL1xftECxzYpulmxKEXlJwjQTGmh81IK7
+9op8Ly8HiTvwImheCa9bb/r0rdOnuTVKTeGng2YoSB1OB4LVBl1z73K/xDViGQlIdW61uTAXS87S
+5bluvqDA6Q84Coy8HvdO3jq+HGLLIbgc/MtBXA6PL4fe5dC+HDKm0jxK5z4mUcPCdKeGmXHLLFla
+7y3AuqW+rgoqOVbOFFg8S+V6psDJc7+c+h++71RX1Gz+yo9PBiJX1X7n+MCDVcvrxzq6t267a2ej
+BzS3Hy8yvX1T8yPX1RW5m/t8X73D9cJIlb+5YVthbeWGHWzN+9bcm3AX1gd6UkCS0sEcQkwqlc1u
+MTy4y2LktQ/u4vNftsNzdjhrh1N2OGKHhB3CdpDsUG2HJXYw20Fhx6AzpvEMucsOzXY4nyUp2oEz
+2oHYYcYOk3Y4boeYHYJ28DNl81HszQ7hJQVfVqXHPIW1D3NUutQTsmC4q8Vb1+Lz1vp8tV5fS523
+5aqatrYaBLlzXp/Piw0aSzNu/m9hnVeE1e5BYjbbc/PytHat01VU6A8UETM2Cuz+QE6BJZ/jlEph
+e0BpnHTBBRdMu8DoAuKCBmwcd0HMBUEX+F0guaDaBaILXIyMpPEMFUnnmWTSBZNZ+Oz8XUhcNvKs
+zVReI7MrXXmpNKvZDjq/W162Warb/rHxuq+OpfYeemT3TYdT4QO3Qy3/8WBl6Zpv3CLvhbtPF83m
+z9eM6BfM8QrFDXgKaJWW6vLy1Pk8X2BT5OhzsA5W6w3oN6EjQKwPs4q/0QZVNnlpTFem6Q2f2mlq
+qK1l5xOMjOCpbwSvxWvxCLQep1sZbAv2Xn8o0vjrX6+uXtXpOWIeG+Duqlj6yitds4fXNxnX21ws
+R92pLXwS51wBcZOjUofToDCZCmy6At1iT4HJbPIHzI5c0R/ItRY51I6OgEJt5HG/5g2SB8Y9QDzQ
+UO2BCx6YZu2gB6QsGOfJgvt3p0eR2ZNsjdmLRqa0xfHko2sL0m43c57FS61F6dIF0rUKDu/+vaDh
+lh/bePb5X//82n7VqZR0gAsfOrxvW+Caz/h+e8UVS8o/+ff3U59Y20pTtqoqG79t+ofuWay+6d/5
+0P8NSh/hyWLJxINSwSlIPlHCmkklBJVYPdCNs5GZVFNd4AFvOAy/3mNW7kTZA1jDJHFfcJIxqaXI
+ZtMKPO/Q8i6xAMv5eMBAXASLGFow2xftD2AhnBcPxHTjOs6gA51OZcddjohwQYRJEYKZTY+d3L1V
+V199eZFyycaXLvnpNFzKewtYvVJfV4n1ihpP9Ba3sALeeufNj996+h59U0X59Su/eY90+/5dVwa5
+R2efGOaNTz/7z6+WQeFTNuc9U189vMbGnTyZ6rKxNfcWXKMOkldwjbJJeqJS5eSmFyaSWQwuXQng
+YEsdnf1enzzrfZhDPeiXZ5VbiJ0sIV+RWi2LF6uKcomKFJcgKBaIiYChwFWAriko4HU6UzxA8ox5
+Im6mfF6eTs0XxgO8XSoBUgIXSmCyBIIlgM35rxo0Y+bPQgvO8V5WxlErOaHOJC/m1Dkcz2ymvqK5
+YzTxz/7yp79//2tv3nPiziaPO1Zx4tuab5+aejK15+DwQOzrD0zA5EtvQhA2/QZWnfK8/XWTI/VW
+ambHT2ff+G/fO3WiNvVi6jXmM1zbnsc80JAOqUqpUoGaB16rU9oUnIbT7A/cQfMMfzmVpAOigws6
+mNRBUAfYvCTibECN8jjShU0+jSd4wP2zJn7d7GM3cJtnzygIrN36qVFxCrOWfUdQbsf1YzGpJAPS
+6qJSwYP25AkKfYFKr6qq5vPKC8vRp+XlotlcEg+Y1VoxHtDapWog1XChGiarIVgN2Mz28Hy9lbVj
+mtLZV8ucq3YCzT8R6+MrKiGdDXz2J4Bs+Ot7d40d+tXvU13jI1eO/Hz6yRduO3TLkcT+G48eLh0e
+uWYgPBIb4j8ePbls+Znxp6fha0cfL112f/SR73/vsxcmj3/9v3/n5tv46okbv/aN2w5eTx1ZheP7
+N1yjFpFp6RDJz7fpc3LUNnWRcxHuIIsM+diw2vwBndViokdOIz1ynnLCRSc85wQs7hVOaMDG3U5I
+OCHshC4nNDuhzglLnOBgZDxlcNlnDDxZnHfC/PFjHp+9n/T+l3aUS/eTy05fzVv/YVV6P+no3okb
+yjXXXgs5fLC8YX476enslfcTdrTiyCbMh7dxn83HnXZcajcr9MRuNyqMTle+0R/ItxhwXzEQ9SKs
+m4x2TEmuoCPAWXH7bM3eUQnbPMcZJg0EGV4e7MKJInP8JLbLPg2lawaWHyacgCVr6TGDDg3YhiSU
+eETul9felzr825eHo6pvQnMi9ZeUa/zItTsDY6nPfDvh3/4MUOA++pGt4pMf2Cvghad/uJR7W2Br
+FI3q2/xpPEq8LEVUelNujrIw32xXOBx2C5+vFNS5et2ioiIpFG5TFJmLuCVFdUXNReGiI0Wnip4r
+ernoYpGW4pcgkqLOIvJi0UdFugYF4ijb3YhVLWHclKAsOjc3fabI3Ubf0nJDQZtUBBwpqi7itLzd
+bMJznD+gzCnMV2itBoNDpdBrsS7ltBayEHg6edIw4ILVe3VZGd0Brx1Dj2Wf0ZnXaPz16U1Om/nQ
+yF5a4N9O7Tj0auqG1D+MQH1qJgqPHfre+Rtg+3DqL1BfUVFRAFtTU5aKCiPcD3fSD4+pD8FIPzqm
+HktVUt/R9WIbzh0rCUprBKXeqrQW2DQGrLw0RquZN3cEeCuxwbrsL4cz7Jth+oMh4h+3QS8tQuar
+qN3z38ku+VBajOdnujxg+AVaTIvpWoTfVnN6Z+qK//PqLZNXlHUmUh99+7snhhuWlMIHf5h1pT55
+pCo1+PL33GzBJJz9ZNe/736117DmT8SV/v+P/9l8/hcLf91PbVHZlfS/IjSY++kL5dTuVAu5cp4J
+LvuXAIeqAU90b5Ji5U8JbvdkGxXlGkgpf4y0Ia0M336klSl3kNXIt5ovIl1I/xbymvFtxrebozoI
+OYCyt+C7R5F+b8O7Cu9NeJtQzzbW448hDO/AO9w2bpq/qNip+IVylfJj1W7V79SD6qRmmcanSWr+
+RbtJe6uO0x3Xc/pJ/cfMagepxTU+/cXEiOveVQg8y/8EcZTqhNH5se2YHycg5w4Z5oia9Mswj9pG
+ZFiBPLfKsJLkkvtlWEUM5O9lWE2uI2dlWEPMUCnDWpIHTTKsg1Hwy7CeLOKenv/PqUrutzKcS+p5
+jQznkUJ+LbVeQf/j4zR/pQxjHaTgZZgjeQqPDPNkhaJGhhXIMyDDSlKouEWGVcSp+DsZVpOPFM/I
+sIYsU56RYS1ZpHxNhnXc75R/lmE9Wan5pQznkKu0ehnOJddoM33lkTrtS81DA0OJoesiYTEcSoTE
+vmjs4NjQwGBCXNZXKtZW11SLrdHowHBE3BAdi0XHQomh6GilbsPlbLXidlTRFkqUixtH+yq3DO2J
+pHnFzsjYUP/2yMC+4dDY+nhfZDQcGRMrxMs5Lm/viIzFaaO2sqayfoF4Oe9QXAyJibFQODISGtsr
+RvsvtUMciwwMxRORMUQOjYrdlZ2Voj+UiIwmxNBoWOyaF2zv7x/qizBkX2QsEULmaGIQLb1m39hQ
+PDzUR3uLV84PIMsbnYnI/oi4NZRIROLR0aZQHPtCy7qGRqPxcvHA4FDfoHggFBfDkfjQwCgS9xwU
+L5URkRrCsYyORvejyv2RcrS7fywSHxwaHRDjdMiytJgYDCXooEciibGhvtDw8EEM2UgMpfZgjA4M
+JQax45FIXNwWOSBuj46ERh+rTJuCvulHn4pDI7Gx6H5mY0W8bywSGcXOQuHQnqHhoQRqGwyNhfrQ
+Y+i2ob448wg6QoyFRita9o1FYxG09MrWLQuMaGDam/Ho8H7smXKPRiJh2iOavT8yjELY8XA0upeO
+pz86hoaGE4MVWZb3R0cTKBoVQ+EwDhy9Fe3bN0LjhG5OZIwL9Y1FkRYbDiVQy0i8cjCRiK2qqjpw
+4EBlSA5NH0amEjVXfRktcTAWkeMxRrWMDG/B8I/S0O1j8aWD6Ny4RWyPoX98aJwoM5SLmcysqayR
+u0A3DsUS8cr40HBldGygqt23hTSTITKAdwLv60iEhImIdwjbIYT6SJTEyEEyxrgGESuSZYgtxXct
+qSY1eIukFbmiSB9GeZFsQHgMpegzxPRGySiWxjpG+XJttQhtl61oY9LlCG1E+T7UsAXl9iA1W69I
+OhlmCJdZKjlA9qEdIcSsJ3GUiiBPmHGIpALvv6Xjb9F3MCg+T6lFu2rwrv9Cyb+ldwg1iczTCUah
+lo4w6/ciLopyX+YPEfkiLHpxpERYK8y0Ut3dyNHJuPxMknoiwXobZVxdX9BjO/bYj/J9LJIZzj6m
+m2ZEWnMU4UHZp9egv8eYBWEmlxlbHHv+fAS+ODc6mXX7WZ9bGZ6244zWhO24PK60z7qYFVHEUl8c
+QEtov4MMDjF/hpk0zbFRWXIPZp34pf2IsmxIjsso62O/bCWVKZf93c+ecdbvKPYhMvvSUb60b5H5
+KcS8no70CFITjLcP8cP4c1CeZSPolXRfe+R5dIDNykF5xCNMr4jlTAQpNCuiLG6j7sUsxgteSedN
+v5ynIpONIRxlo8j4sYLFho4kwiylUIjN/D0oMcz6Tts2yLIjxGIbkWOdYCPI+Cssj5RaHWOYCtLC
+8oLO94js0ytxndjyhRrTHszOTRqTYWZvPEv3KLM2PD/GtLcp17DcU3rEw2w92jsfn36Wb2mPhpm2
+ir/i837mm4Tca5RZFMafdMTTuRVF2X0sHun5lM7mxOc8F2L+jcpyMbYqJWRbRtj8GGQZGCOrsLCs
+QuvoTyXLw+xZ0yfPmUrZ5qr/shy1K8Y8mD0/xuZtGUEbt8izf3R+1u3Lmr+ZSHTiGrSFrRcxOX98
+sufEyzTQWXP5mlnD1sxLR5HOxiFsJ5g9cebLSjaGAaS3Yw9biFyLk7mjaNIXXFNa//o9ECEAgzCA
+R3A8NpNt0Eu6YT1ZCxK+JaQ14XsDtum7EtaSceRbi/h12F6D+NW4drrw2Yh3O9534K3AO81RjRxV
++K6S2xXYLkeJF/EJ7KbYRsTS9yZst+G7VX77EN+C7xa5vRHb+CZBUGMR3siez4BCOgMXZuHFWRBn
+4fCn4P8Uxj88/iH3wUyp6/GZZ2a49vd733/8fb76fTC8DxrynvE9/3vB92LvTb6n0hnehRzyBxDe
+vLDS9cba17v/de3vusnrOLLXq1/3vz7+evJ15evAd/+Ot7qM0+J09XRsenz6/PSF6ZlpzfjTx5/m
+/umpKpfhKddTnOtM+5nDZ/jgo2B41PUo538w+CB3/CEwPOR6qOoh/oGTla6TrU7XffcudV24d+Ze
+jh7S780VfE9BO2wha9GH287wc67H11tgKw7LgE8X3lV4t+MdxfsOvPHMg+wuvKtgi7SS770H9Ccc
+J8pOXH/ithPK2M3jNx+/mR8/evwo9/j+Z/ZzcX+pKzpa5hptXe6ye23dai/frcJu6KeBjXuKl/mC
+vZKrF5l27ax27WwtdeV7Td1KHLACGQ28i2/k2/kofwf/DK/WbPc7XR14X/DP+DnJr83xGdpd7VXt
+/Lm5C1Jksxu1bYptGt/Eb/SVutpaV7oMra7WqtYXW99ofb9V1dsKD+Ov73HfMz5e8pVW+SSf0+1b
+1Obotnot3QIYuo1eQzcHGGgv6a4yzBk4g6HXcNjAG0gj4catoIRzcHyqq7OsbPM59dz2zUmNf1cS
+bk0Wd9Kn1LEzqbo1Sbp37uqZAvhG4OixY6SpaHOytrMnGSwKbE6GEZAoMI6AsWjKSpoC8XiijF1Q
+VobwPnySsn1liNwdT2PJPJ2UxSGOS1ScCUEZZUi3AZ9llIYIKgcovTtO6IMSy9JCVDouq2PC6QcD
+bLv/E/0U414KZW5kc3RyZWFtCmVuZG9iagoKOCAwIG9iago4MTY1CmVuZG9iagoKOSAwIG9iago8
+PC9UeXBlL0ZvbnREZXNjcmlwdG9yL0ZvbnROYW1lL0JBQUFBQStMaWJlcmF0aW9uU2VyaWYKL0Zs
+YWdzIDQKL0ZvbnRCQm94Wy01NDMgLTMwMyAxMjc3IDk4MV0vSXRhbGljQW5nbGUgMAovQXNjZW50
+IDAKL0Rlc2NlbnQgMAovQ2FwSGVpZ2h0IDk4MQovU3RlbVYgODAKL0ZvbnRGaWxlMiA3IDAgUgo+
+PgplbmRvYmoKCjEwIDAgb2JqCjw8L0xlbmd0aCAzNDEvRmlsdGVyL0ZsYXRlRGVjb2RlPj4Kc3Ry
+ZWFtCnicXZLNboMwDIDvPEWO3aGCJC1sEkLqaJE47EdjewBKTIc0QhTogbdfbHebtAPoM7Gdjzhx
+WR9rOyzxq5+6BhbRD9Z4mKer70Cc4TLYSCphhm65RfTuxtZFcaht1nmBsbb9lOdR/BbW5sWvYnMw
+0xnuovjFG/CDvYjNR9mEuLk69wUj2EUkUVEIA33o89S653aEmKq2tQnLw7JuQ8lfwvvqQCiKJat0
+k4HZtR341l4gypOkEHlVFRFY829NpVxy7rvP1odUGVKTZL8rAiviLEPWxGmFvCNWCfKev5fIKbNE
+zpiPyPfMe+QH7k98YFbIj8Q76lPyvhr5SKwPyCfuc49ccQ56yoQZfST7K/SU7K9xL8n+6oTM/jpF
+Zn+N/yjZX2N/efOn/Js/7cX+GeWwf6rpYG8niEeMd+BndKK7eh/GRheF5oWTGiz83iU3Oayi5xsJ
+U6gUCmVuZHN0cmVhbQplbmRvYmoKCjExIDAgb2JqCjw8L1R5cGUvRm9udC9TdWJ0eXBlL1RydWVU
+eXBlL0Jhc2VGb250L0JBQUFBQStMaWJlcmF0aW9uU2VyaWYKL0ZpcnN0Q2hhciAwCi9MYXN0Q2hh
+ciAyNgovV2lkdGhzWzAgNjEwIDcyMiA1MDAgMjUwIDI3NyA0NDMgNzc3IDQ0MyA3MjIgNjY2IDYx
+MCAzODkgMjc3IDUwMCAyNzcKNTAwIDI3NyA1MDAgMjUwIDUwMCA1MDAgNTAwIDUwMCA1MDAgNTAw
+IDQ0MyBdCi9Gb250RGVzY3JpcHRvciA5IDAgUgovVG9Vbmljb2RlIDEwIDAgUgo+PgplbmRvYmoK
+CjEyIDAgb2JqCjw8L0YxIDExIDAgUgo+PgplbmRvYmoKCjEzIDAgb2JqCjw8L0ZvbnQgMTIgMCBS
+Ci9Qcm9jU2V0Wy9QREYvVGV4dF0KPj4KZW5kb2JqCgoxIDAgb2JqCjw8L1R5cGUvUGFnZS9QYXJl
+bnQgNiAwIFIvUmVzb3VyY2VzIDEzIDAgUi9NZWRpYUJveFswIDAgNTk1LjMwMzkzNzAwNzg3NCA4
+NDEuODg5NzYzNzc5NTI4XS9Bbm5vdHNbCjQgMCBSIDUgMCBSIF0KL1RhYnMoUykKL0NvbnRlbnRz
+IDIgMCBSPj4KZW5kb2JqCgo2IDAgb2JqCjw8L1R5cGUvUGFnZXMKL1Jlc291cmNlcyAxMyAwIFIK
+L01lZGlhQm94WyAwIDAgNTk1LjMwMzkzNzAwNzg3NCA4NDEuODg5NzYzNzc5NTI4IF0KL0tpZHNb
+IDEgMCBSIF0KL0NvdW50IDE+PgplbmRvYmoKCjQgMCBvYmoKPDwvVHlwZS9Bbm5vdC9TdWJ0eXBl
+L0xpbmsvQm9yZGVyWzAgMCAwXS9SZWN0WzU2LjY5MyA3NTcuNTg5IDExOC40MDcgNzcxLjM4OV0v
+Q29udGVudHM8RkVGRjAwNjgwMDc0MDA3NDAwNzAwMDNBMDAyRjAwMkYwMDM1MDAyRTAwMzYwMDJF
+MDAzNzAwMkUwMDM4Pi9BPDwvVHlwZS9BY3Rpb24vUy9VUkkvVVJJKGh0dHA6Ly81LjYuNy44Lyk+
+Pgo+PgplbmRvYmoKCjUgMCBvYmoKPDwvVHlwZS9Bbm5vdC9TdWJ0eXBlL0xpbmsvQm9yZGVyWzAg
+MCAwXS9SZWN0WzE0MS42OTMgNzU3LjU4OSAyNTguNzA3IDc3MS4zODldL0NvbnRlbnRzPEZFRkYw
+MDY4MDA3NDAwNzQwMDcwMDAzQTAwMkYwMDJGMDA2NTAwNzgwMDYxMDA2RDAwNzAwMDZDMDA2NTAw
+MkUwMDYzMDA2RjAwNkQwMDJGMDA2MzAwNkYwMDZGMDA2Qz4vQTw8L1R5cGUvQWN0aW9uL1MvVVJJ
+L1VSSShodHRwOi8vZXhhbXBsZS5jb20vY29vbCk+Pgo+PgplbmRvYmoKCjE0IDAgb2JqCjw8L1R5
+cGUvQ2F0YWxvZy9QYWdlcyA2IDAgUgovT3BlbkFjdGlvblsxIDAgUiAvWFlaIG51bGwgbnVsbCAw
+XQovTGFuZyhlbi1aQSkKPj4KZW5kb2JqCgoxNSAwIG9iago8PC9DcmVhdG9yPEZFRkYwMDU3MDA3
+MjAwNjkwMDc0MDA2NTAwNzI+Ci9Qcm9kdWNlcjxGRUZGMDA0QzAwNjkwMDYyMDA3MjAwNjUwMDRG
+MDA2NjAwNjYwMDY5MDA2MzAwNjUwMDIwMDAzNzAwMkUwMDM0PgovQ3JlYXRpb25EYXRlKEQ6MjAy
+MzA5MTQxNjMxNTgrMDInMDAnKT4+CmVuZG9iagoKeHJlZgowIDE2CjAwMDAwMDAwMDAgNjU1MzUg
+ZiAKMDAwMDAwOTYwOCAwMDAwMCBuIAowMDAwMDAwMDE5IDAwMDAwIG4gCjAwMDAwMDAzNjQgMDAw
+MDAgbiAKMDAwMDAwOTg4OSAwMDAwMCBuIAowMDAwMDEwMTAyIDAwMDAwIG4gCjAwMDAwMDk3NjQg
+MDAwMDAgbiAKMDAwMDAwMDM4NCAwMDAwMCBuIAowMDAwMDA4NjM0IDAwMDAwIG4gCjAwMDAwMDg2
+NTUgMDAwMDAgbiAKMDAwMDAwODg0NSAwMDAwMCBuIAowMDAwMDA5MjU2IDAwMDAwIG4gCjAwMDAw
+MDk1MjAgMDAwMDAgbiAKMDAwMDAwOTU1MyAwMDAwMCBuIAowMDAwMDEwMzYwIDAwMDAwIG4gCjAw
+MDAwMTA0NTcgMDAwMDAgbiAKdHJhaWxlcgo8PC9TaXplIDE2L1Jvb3QgMTQgMCBSCi9JbmZvIDE1
+IDAgUgovSUQgWyA8NjJEQzZBMUZGNjdGMDM3NzdENTRBQzA5QTdCRjZCN0M+Cjw2MkRDNkExRkY2
+N0YwMzc3N0Q1NEFDMDlBN0JGNkI3Qz4gXQovRG9jQ2hlY2tzdW0gLzI4MjNGODg2OUFCRDZFMzU4
+NEVCMjg3QURDRkVEQ0RGCj4+CnN0YXJ0eHJlZgoxMDYzMgolJUVPRgo=
+
+
+--=-Px1ozcNocF27wUUNNZPj--
-numeric http://1.2.3.4 and not http://example.org ok
|