catch_debugger.cpp

// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)

// SPDX-License-Identifier: BSL-1.0
#include<catch2/internal/catch_debugger.hpp>
#include<catch2/internal/catch_errno_guard.hpp>
#include<catch2/internal/catch_platform.hpp>
#include<catch2/internal/catch_stdstreams.hpp>

#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)

# include<cassert>
# include<sys/types.h>
# include<unistd.h>
# include<cstddef>
# include<ostream>

#ifdef __apple_build_version__
// These headers will only compile with AppleClang (XCode)
// For other compilers (Clang, GCC, ... ) we need to exclude them
# include<sys/sysctl.h>
#endif

namespaceCatch {
 #ifdef __apple_build_version__
// The following function is taken directly from the following technical note:
// https://developer.apple.com/library/archive/qa/qa1361/_index.html

// Returns true if the current process is being debugged (either
// running under the debugger or has a debugger attached post facto).
boolisDebuggerActive(){
int mib[4];
structkinfo_proc info;
 std::size_t size;

// Initialize the flags so that, if sysctl fails for some bizarre
// reason, we get a predictable result.

 info.kp_proc.p_flag = 0;

// Initialize mib, which tells sysctl the info we want, in this case
// we're looking for information about a specific process ID.

 mib[0] = CTL_KERN;
 mib[1] = KERN_PROC;
 mib[2] = KERN_PROC_PID;
 mib[3] = getpid();

// Call sysctl.

 size = sizeof(info);
if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) {
Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n\n" << std::flush;
returnfalse;
 }

// We're being debugged if the P_TRACED flag is set.

return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
 }
 #else
boolisDebuggerActive() {
// We need to find another way to determine this for non-appleclang compilers on macOS
returnfalse;
 }
 #endif
 } // namespace Catch

#elif defined(CATCH_PLATFORM_LINUX)
 #include<fstream>
 #include<string>

namespaceCatch{
// The standard POSIX way of detecting a debugger is to attempt to
// ptrace() the process, but this needs to be done from a child and not
// this process itself to still allow attaching to this process later
// if wanted, so is rather heavy. Under Linux we have the PID of the
// "debugger" (which doesn't need to be gdb, of course, it could also
// be strace, for example) in /proc/$PID/status, so just get it from
// there instead.
boolisDebuggerActive(){
// Libstdc++ has a bug, where std::ifstream sets errno to 0
// This way our users can properly assert over errno values
 ErrnoGuard guard;
 std::ifstream in("/proc/self/status");
for( std::string line; std::getline(in, line); ) {
staticconstint PREFIX_LEN = 11;
if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
// We're traced if the PID is not 0 and no other PID starts
// with 0 digit, so it's enough to check for just a single
// character.
return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
 }
 }

returnfalse;
 }
 } // namespace Catch
#elif defined(_MSC_VER)
extern"C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
namespaceCatch {
boolisDebuggerActive() {
returnIsDebuggerPresent() != 0;
 }
 }
#elif defined(__MINGW32__)
extern"C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
namespaceCatch {
boolisDebuggerActive() {
returnIsDebuggerPresent() != 0;
 }
 }
#else
namespaceCatch {
boolisDebuggerActive() { returnfalse; }
 }
#endif// Platform