os_functions.cpp File Reference

#include <mutex>
#include <thread>
#include <ctime>
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cstdlib>
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include <memory>
#include "../icedb/error.h"
#include "../icedb/error_context.h"
#include "../icedb/misc/os_functions.h"
#include "../icedb/misc/os_functions.hpp"
#include "../icedb/util.h"

Include dependency graph for os_functions.cpp:

Go to the source code of this file.

Namespaces
	icedb
	icedb::os_functions
	icedb::os_functions::vars
	icedb::os_functions::win
	icedb::os_functions::unix

Functions
bool	icedb::os_functions::populateOSstrings ()
bool	ICEDB_pidExists (int pid, bool &res)
int	ICEDB_getPID ()
int	ICEDB_getPPID (int pid)
bool	ICEDB_waitOnExitGetDefault ()
void	ICEDB_waitOnExitSet (bool val)
bool	ICEDB_waitOnExitGet ()
const char *	ICEDB_getUserName ()
const char *	ICEDB_getHostName ()
const char *	ICEDB_getAppConfigDir ()
const char *	ICEDB_getHomeDir ()
void	ICEDB_free_enumModulesRes (ICEDB_enumModulesRes *p)
ICEDB_enumModulesRes *	ICEDB_enumModules (int pid)
char *	ICEDB_findModuleByFunc (void *ptr, size_t sz, char *res)
void	ICEDB_getLibDirI ()
char *	ICEDB_getLibDir (size_t sz, char *res)
const char *	ICEDB_getLibDirC ()
void	ICEDB_getAppDirI ()
char *	ICEDB_getAppDir (size_t sz, char *res)
const char *	ICEDB_getAppDirC ()
void	ICEDB_getCWDI ()
char *	ICEDB_getCWD (size_t ssz, char *res)
const char *	ICEDB_getCWDC ()
char *	ICEDB_getLibPath (size_t sz, char *res)
const char *	ICEDB_getLibPathC ()
char *	ICEDB_getAppPath (size_t sz, char *res)
const char *	ICEDB_getAppPathC ()
void	ICEDB_getPluginDirI ()
char *	ICEDB_getPluginDir (size_t sz, char *res)
const char *	ICEDB_getPluginDirC ()
void	ICEDB_libEntry (int, char **)
	Entry function that gets called when a debugged application first loads. More...
void	ICEDB_libExit ()
void	ICEDB_writeDebugString (const char *c)
bool	icedb::os_functions::pidExists (int pid)
int	icedb::os_functions::getPID ()
int	icedb::os_functions::getPPID (int pid)
void	icedb::os_functions::libEntry (int argc, char **argv)
void	icedb::os_functions::waitOnExit (bool val)
bool	icedb::os_functions::waitOnExit ()
const char *	icedb::os_functions::getUserName ()
const char *	icedb::os_functions::getHostName ()
const char *	icedb::os_functions::getAppConfigDir ()
const char *	icedb::os_functions::getHomeDir ()
const char *	icedb::os_functions::getLibDir ()
const char *	icedb::os_functions::getAppDir ()
const char *	icedb::os_functions::getPluginDir ()
const char *	icedb::os_functions::getLibPath ()
const char *	icedb::os_functions::getAppPath ()
const char *	icedb::os_functions::getCWD ()

Variables
std::mutex	icedb::os_functions::vars::m_sys_names
std::string	icedb::os_functions::vars::hostname
std::string	icedb::os_functions::vars::username
std::string	icedb::os_functions::vars::homeDir
std::string	icedb::os_functions::vars::appConfigDir
std::string	icedb::os_functions::vars::moduleCallbackBuffer
std::string	icedb::os_functions::vars::libDir
std::string	icedb::os_functions::vars::libPath
std::string	icedb::os_functions::vars::appDir
std::string	icedb::os_functions::vars::appPath
std::string	icedb::os_functions::vars::CWD
std::string	icedb::os_functions::vars::pluginDir
bool	icedb::os_functions::vars::_consoleTerminated = false
std::vector< std::pair< std::string, std::string > >	icedb::os_functions::vars::loadedModulesList
bool	icedb::os_functions::vars::doWaitOnExit = false
	Private flag that determines if the app waits for the user to press 'Enter' to terminate it at the end of execution. More...
bool	icedb::os_functions::vars::doWaitOnExitQueriedDefault = false
std::map< std::string, std::string >	icedb::os_functions::vars::mmods

Function Documentation

ICEDB_enumModules()

ICEDB_enumModulesRes* ICEDB_enumModules

(

int

pid

)

Definition at line 607 of file os_functions.cpp.

References icedb::free(), icedb::os_functions::getPID(), ICEDB_COMPAT_strdup_s(), ICEDB_error_context_add_string2, ICEDB_error_context_create, ICEDB_error_getOSname, ICEDB_ERRORCODES_OS, ICEDB_malloc(), icedb::os_functions::vars::mmods, icedb::os_functions::vars::moduleCallbackBuffer, ICEDB_enumModulesRes::modules, and ICEDB_enumModulesRes::sz.

                                                 {
    ICEDB_enumModulesRes *p = (ICEDB_enumModulesRes*)ICEDB_malloc(sizeof (ICEDB_enumModulesRes));
    
#if defined(_WIN32)
    HANDLE h = NULL, snapshot = NULL;
        h = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pid);
        std::shared_ptr<MODULEENTRY32> mod(new MODULEENTRY32);
        if (!h || h == INVALID_HANDLE_VALUE) goto err;
        snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid);
        if (!snapshot || snapshot == INVALID_HANDLE_VALUE) goto err;
        mod->dwSize = sizeof(MODULEENTRY32); // Annoying requirement
        if (!Module32First(snapshot, mod.get())) goto err;
        do {
            std::string modName = icedb::os_functions::win::convertStr(mod->szModule);
            std::string modPath = icedb::os_functions::win::convertStr(mod->szExePath);
            icedb::os_functions::vars::mmods[modName] = modPath;
        } while (Module32Next(snapshot, mod.get()));

        goto done;
    err:
        auto ctxerr = ICEDB_error_context_create(ICEDB_ERRORCODES_OS);
        const char* cosname = ICEDB_error_getOSname();
        ICEDB_error_context_add_string2(ctxerr, "OS_id", cosname);
        if (!h || h == INVALID_HANDLE_VALUE)
            ICEDB_error_context_add_string2(ctxerr, "Description", "Error in getting handle for process!");
        else if (!snapshot || snapshot == INVALID_HANDLE_VALUE)
            ICEDB_error_context_add_string2(ctxerr, "Description", "Cannot get handle snapshot!");
        else ICEDB_error_context_add_string2(ctxerr, "Description", "Cannot list first modle!");
    done:

    if (snapshot && snapshot != INVALID_HANDLE_VALUE) CloseHandle(snapshot);
    if (h && h != INVALID_HANDLE_VALUE) CloseHandle(h);
#elif defined(__linux__) || defined(__unix__)
    if (pid != icedb::os_functions::getPID()) {
        auto ctxerr = ICEDB_error_context_create(ICEDB_ERRORCODES_OS);
        const char* cosname = ICEDB_error_getOSname();
        ICEDB_error_context_add_string2(ctxerr, "OS_id", cosname);
        ICEDB_error_context_add_string2(ctxerr, "Description", "This function only works for the pid of the main process.");
        return NULL;
    }
    if (!moduleCallbackBuffer.size()) {
        dl_iterate_phdr(icedb::os_functions::unix::moduleCallback, NULL);
    }
#elif defined(__APPLE__)
    uint32_t count = _dyld_image_count();
    for (uint32_t i=0; i<count; ++i) {
        std::string modName(_dyld_get_image_name(i));
        char cmodPath[2048];
        char *ccmodPath = realpath(modName.c_str(), NULL);
        if (ccmodPath != NULL) {
            strncpy(cmodPath,ccmodPath,2048);
            free(ccmodPath);
        }
        std::string modPath(ccmodPath);
        icedb::os_functions::vars::mmods[modPath] = modPath;
    }
#else
#endif
    // Convert the map to the resultant structure.
    p->sz = icedb::os_functions::vars::mmods.size();
    char **nmods = (char**)ICEDB_malloc(p->sz*sizeof (char**));
    size_t i = 0;
    for (auto &s : mmods) {
        nmods[i] = ICEDB_COMPAT_strdup_s(s.second.c_str(), s.second.size());
        ++i;
    }
    p->modules = const_cast<const char**>(nmods);
    return p;
}

Here is the call graph for this function:

ICEDB_findModuleByFunc()

char* ICEDB_findModuleByFunc	(	void *	ptr,
		size_t	sz,
		char *	res
	)

Find the file that contains the symbol.

Parameters

ptr	is the symbol. Can be any pointer.
sz	is the size of the output buffer (bytes).
res	is the output buffer, of size at least sz. Gets null terminated.

Returns

res for convenience

Definition at line 677 of file os_functions.cpp.

References ICEDB_COMPAT_strncpy_s(), and ICEDB_DEBUG_RAISE_EXCEPTION.

                                                              {
    std::string modpath;
#if defined(_WIN32)
    BOOL success = false;
    if (ptr)
    {
        DWORD flags = GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS;
        LPCTSTR lpModuleName = (LPCTSTR)ptr;
        HMODULE mod;
        success = GetModuleHandleEx(flags, lpModuleName, &mod);
        if (!success) return nullptr;
        modpath = icedb::os_functions::win::GetModulePath(mod);
        FreeLibrary(mod);
    } else modpath = icedb::os_functions::win::GetModulePath(NULL);
#elif defined(__unix__) || defined(__APPLE__)
    modpath = icedb::os_functions::unix::GetModulePath(ptr);
#else
    ICEDB_DEBUG_RAISE_EXCEPTION();
#endif
    ICEDB_COMPAT_strncpy_s(res, sz, modpath.c_str(), modpath.size());
    return res;
}

Here is the call graph for this function:

ICEDB_free_enumModulesRes()

void ICEDB_free_enumModulesRes

(

ICEDB_enumModulesRes *

p

)

Definition at line 596 of file os_functions.cpp.

References ICEDB_free(), ICEDB_enumModulesRes::modules, and ICEDB_enumModulesRes::sz.

                                                        {
    if (!p) return;
    if (p->sz) {
        for (int i = 0; i < p->sz; ++i) {
            ICEDB_free((void*)p->modules[i]);
            p->modules[i] = nullptr;
        }
    }
    ICEDB_free(p->modules);
    ICEDB_free(p);
}

Here is the call graph for this function:

ICEDB_getAppConfigDir()

const char* ICEDB_getAppConfigDir

(

)

Definition at line 587 of file os_functions.cpp.

References icedb::os_functions::vars::appConfigDir, and icedb::os_functions::populateOSstrings().

Referenced by icedb::os_functions::getAppConfigDir().

                                    {
    icedb::os_functions::populateOSstrings();
    return appConfigDir.c_str();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ICEDB_getAppDir()

char* ICEDB_getAppDir	(	size_t	sz,
		char *	res
	)

Definition at line 765 of file os_functions.cpp.

References icedb::os_functions::vars::appDir, ICEDB_COMPAT_strncpy_s(), and ICEDB_getAppDirI().

                                            {
    ICEDB_getAppDirI();
    ICEDB_COMPAT_strncpy_s(res, sz, appDir.c_str(), appDir.size());
    return res;
}

Here is the call graph for this function:

ICEDB_getAppDirC()

const char* ICEDB_getAppDirC

(

)

Definition at line 770 of file os_functions.cpp.

References icedb::os_functions::vars::appDir, and ICEDB_getAppDirI().

                               {
    ICEDB_getAppDirI();
    return appDir.c_str();
}

Here is the call graph for this function:

ICEDB_getAppDirI()

void ICEDB_getAppDirI

(

)

Definition at line 723 of file os_functions.cpp.

References icedb::os_functions::vars::appDir, icedb::os_functions::vars::appPath, icedb::free(), ICEDB_DEBUG_RAISE_EXCEPTION, and ICEDB_getPID().

Referenced by icedb::os_functions::getAppDir(), icedb::os_functions::getAppPath(), ICEDB_getAppDir(), ICEDB_getAppDirC(), ICEDB_getAppPath(), and ICEDB_getAppPathC().

                        {
    std::string &appd = appDir;
#if defined(_WIN32)
    DWORD pid = (DWORD)ICEDB_getPID(); // int always fits in DWORD
    std::string filename;
    icedb::os_functions::win::getPathWIN32(pid, appPath, filename);
    appd = appPath.substr(0, appPath.find_last_of("/\\"));
#elif defined(__APPLE__)
    char exePath[PATH_MAX];
    uint32_t len = sizeof(exePath);
    if (_NSGetExecutablePath(exePath, &len) != 0) {
        exePath[0] = '\0'; // buffer too small (!)
    }
    else {
        // resolve symlinks, ., .. if possible
        char *canonicalPath = realpath(exePath, NULL);
        if (canonicalPath != NULL) {
            strncpy(exePath, canonicalPath, len);
            free(canonicalPath);
        }
    }
    appPath = std::string(exePath);
    appd = appPath.substr(0, appPath.find_last_of("/\\"));
#elif defined(__linux__)
    char exePath[PATH_MAX];
    ssize_t len = ::readlink("/proc/self/exe", exePath, sizeof(exePath));
    if (len == -1 || len == sizeof(exePath)) len = 0;
    exePath[len] = '\0';
    appPath = std::string(exePath);
    appd = appPath.substr(0, appPath.find_last_of("/\\"));
#elif defined(__unix__)
    char exePath[2048];
    int mib[4];  mib[0] = CTL_KERN;  mib[1] = KERN_PROC;  mib[2] = KERN_PROC_PATHNAME;  mib[3] = -1;
    size_t len = sizeof(exePath);
    if (sysctl(mib, 4, exePath, &len, NULL, 0) != 0)
        exePath[0] = '\0';
    appPath = std::string(exePath);
    appd = appPath.substr(0, appPath.find_last_of("/\\"));
#else
    ICEDB_DEBUG_RAISE_EXCEPTION();
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

ICEDB_getAppPath()

char* ICEDB_getAppPath	(	size_t	sz,
		char *	res
	)

Definition at line 813 of file os_functions.cpp.

References icedb::os_functions::vars::appPath, ICEDB_COMPAT_strncpy_s(), and ICEDB_getAppDirI().

                                             {
    ICEDB_getAppDirI();
    ICEDB_COMPAT_strncpy_s(res, sz, appPath.c_str(), appPath.size());
    return res;
}

Here is the call graph for this function:

ICEDB_getAppPathC()

const char* ICEDB_getAppPathC

(

)

Definition at line 818 of file os_functions.cpp.

References icedb::os_functions::vars::appPath, and ICEDB_getAppDirI().

                                {
    ICEDB_getAppDirI(); 
    return appPath.c_str();
}

Here is the call graph for this function:

ICEDB_getCWD()

char* ICEDB_getCWD	(	size_t	ssz,
		char *	res
	)

Definition at line 794 of file os_functions.cpp.

References icedb::os_functions::vars::CWD, ICEDB_COMPAT_strncpy_s(), and ICEDB_getCWDI().

                                          {
    ICEDB_getCWDI();
    ICEDB_COMPAT_strncpy_s(res, ssz, CWD.c_str(), CWD.size());
    return res;
}

Here is the call graph for this function:

ICEDB_getCWDC()

const char* ICEDB_getCWDC

(

)

Definition at line 799 of file os_functions.cpp.

References icedb::os_functions::vars::CWD, and ICEDB_getCWDI().

                            {
    ICEDB_getCWDI();
    return CWD.c_str();
}

Here is the call graph for this function:

ICEDB_getCWDI()

void ICEDB_getCWDI

(

)

Definition at line 774 of file os_functions.cpp.

References icedb::os_functions::vars::CWD, ICEDB_DEBUG_RAISE_EXCEPTION, ICEDB_error_context_create, and ICEDB_ERRORCODES_OS.

Referenced by icedb::os_functions::getCWD(), ICEDB_getCWD(), and ICEDB_getCWDC().

                     {
    std::string &cwd = CWD;
#if defined(_WIN32)
    DWORD sz = GetCurrentDirectory(0, NULL);
    LPTSTR cd = new TCHAR[sz];
    DWORD result = GetCurrentDirectory(2500, cd);
    cwd = std::string(cd);
    delete[] cd;
#else
    char ccwd[4096];
    char* res = getcwd(ccwd, 4096);
    if (!res) {
        auto err = ICEDB_error_context_create(ICEDB_ERRORCODES_OS);
        ICEDB_DEBUG_RAISE_EXCEPTION();

        return ;
    }
    cwd = std::string(ccwd);
#endif
}

Here is the caller graph for this function:

ICEDB_getHomeDir()

const char* ICEDB_getHomeDir

(

)

Definition at line 591 of file os_functions.cpp.

References icedb::os_functions::vars::homeDir, and icedb::os_functions::populateOSstrings().

Referenced by icedb::os_functions::getHomeDir().

                               {
    icedb::os_functions::populateOSstrings();
    return homeDir.c_str();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ICEDB_getHostName()

const char* ICEDB_getHostName

(

)

Definition at line 583 of file os_functions.cpp.

References icedb::os_functions::vars::hostname, and icedb::os_functions::populateOSstrings().

Referenced by icedb::os_functions::getHostName().

                                {
    icedb::os_functions::populateOSstrings();
    return hostname.c_str();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ICEDB_getLibDir()

char* ICEDB_getLibDir	(	size_t	sz,
		char *	res
	)

Definition at line 714 of file os_functions.cpp.

References ICEDB_COMPAT_strncpy_s(), ICEDB_getLibDirI(), and icedb::os_functions::vars::libDir.

                                            {
    ICEDB_getLibDirI();
    ICEDB_COMPAT_strncpy_s(res, sz, libDir.c_str(), libDir.size());
    return res;
}

Here is the call graph for this function:

ICEDB_getLibDirC()

const char* ICEDB_getLibDirC

(

)

Definition at line 719 of file os_functions.cpp.

References ICEDB_getLibDirI(), and icedb::os_functions::vars::libDir.

                               {
    ICEDB_getLibDirI();
    return libDir.c_str();
}

Here is the call graph for this function:

ICEDB_getLibDirI()

void ICEDB_getLibDirI

(

)

Definition at line 706 of file os_functions.cpp.

References icedb::os_functions::vars::libDir, and icedb::os_functions::vars::libPath.

Referenced by icedb::os_functions::getLibDir(), icedb::os_functions::getLibPath(), ICEDB_getLibDir(), ICEDB_getLibDirC(), ICEDB_getLibPath(), ICEDB_getLibPathC(), and ICEDB_getPluginDirI().

                        {
#if defined(_WIN32)
    libPath = icedb::os_functions::win::GetModulePath(NULL);
#elif defined(__unix__) || defined(__APPLE__)
    libPath = icedb::os_functions::unix::GetModulePath((void*)ICEDB_getLibDirI);
#endif
    libDir = libPath.substr(0, libPath.find_last_of("/\\"));
}

Here is the caller graph for this function:

ICEDB_getLibPath()

char* ICEDB_getLibPath	(	size_t	sz,
		char *	res
	)

Definition at line 804 of file os_functions.cpp.

References ICEDB_COMPAT_strncpy_s(), ICEDB_getLibDirI(), and icedb::os_functions::vars::libPath.

                                             {
    ICEDB_getLibDirI();
    ICEDB_COMPAT_strncpy_s(res, sz, libPath.c_str(), libPath.size());
    return res;
}

Here is the call graph for this function:

ICEDB_getLibPathC()

const char* ICEDB_getLibPathC

(

)

Definition at line 809 of file os_functions.cpp.

References ICEDB_getLibDirI(), and icedb::os_functions::vars::libPath.

                                {
    ICEDB_getLibDirI();
    return libPath.c_str();
}

Here is the call graph for this function:

ICEDB_getPID()

int ICEDB_getPID

(

)

Definition at line 481 of file os_functions.cpp.

References ICEDB_error_context_add_string2, ICEDB_error_context_create, ICEDB_error_getOSname, and ICEDB_ERRORCODES_UNIMPLEMENTED.

Referenced by icedb::os_functions::getPID(), and ICEDB_getAppDirI().

                   {
#if defined(__unix__)
    return (int)getpid();
#elif defined(ICEDB_OS_WINDOWS)
    DWORD pid = 0;
    HANDLE h = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (NULL == h) return false;
    PROCESSENTRY32 pe = { 0 };
    pe.dwSize = sizeof(PROCESSENTRY32);
    pid = GetCurrentProcessId();
    CloseHandle(h);
    return (int)pid;
#endif
    auto err = ICEDB_error_context_create(ICEDB_ERRORCODES_UNIMPLEMENTED);
    const char* osname = ICEDB_error_getOSname();
    ICEDB_error_context_add_string2(err, "OS_id", osname);
    return -1;
}

Here is the caller graph for this function:

ICEDB_getPluginDir()

char* ICEDB_getPluginDir	(	size_t	sz,
		char *	res
	)

Definition at line 827 of file os_functions.cpp.

References ICEDB_COMPAT_strncpy_s(), ICEDB_getPluginDirI(), and icedb::os_functions::vars::pluginDir.

                                               {
    ICEDB_getPluginDirI();
    ICEDB_COMPAT_strncpy_s(res, sz, pluginDir.c_str(), pluginDir.size());
    return res;
}

Here is the call graph for this function:

ICEDB_getPluginDirC()

const char* ICEDB_getPluginDirC

(

)

Definition at line 832 of file os_functions.cpp.

References ICEDB_getPluginDirI(), and icedb::os_functions::vars::pluginDir.

                                  {
    ICEDB_getPluginDirI();
    return pluginDir.c_str();
}

Here is the call graph for this function:

ICEDB_getPluginDirI()

void ICEDB_getPluginDirI

(

)

Definition at line 823 of file os_functions.cpp.

References ICEDB_getLibDirI(), icedb::os_functions::vars::libDir, and icedb::os_functions::vars::pluginDir.

Referenced by icedb::os_functions::getPluginDir(), ICEDB_getPluginDir(), and ICEDB_getPluginDirC().

                           {
    ICEDB_getLibDirI();
    pluginDir = libDir + "/icedb-plugins";
}

Here is the call graph for this function:

Here is the caller graph for this function:

ICEDB_getPPID()

int ICEDB_getPPID

(

int

pid

)

Definition at line 501 of file os_functions.cpp.

References ICEDB_error_context_add_string2, ICEDB_error_context_create, ICEDB_error_getOSname, and ICEDB_ERRORCODES_UNIMPLEMENTED.

Referenced by icedb::os_functions::getPPID().

                           {
#if defined(__unix__)
    return (int)getppid();
#elif defined(ICEDB_OS_WINDOWS)
    DWORD Dpid = pid, ppid = 0;
    HANDLE h = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (NULL == h) return false;
    PROCESSENTRY32 pe = { 0 };
    pe.dwSize = sizeof(PROCESSENTRY32);
    if (!pid) Dpid = GetCurrentProcessId();
    if (Process32First(h, &pe)) {
        do {
            if (pe.th32ProcessID == Dpid) {
                ppid = pe.th32ParentProcessID;
                //printf("PID: %i; PPID: %i\n", pid, pe.th32ParentProcessID);
            }
        } while (Process32Next(h, &pe));
    }

    //std::cout << "Pid " << pid << "\nPPID " << ppid << std::endl;
    CloseHandle(h);
    return (int)ppid;
#endif
    auto err = ICEDB_error_context_create(ICEDB_ERRORCODES_UNIMPLEMENTED);
    const char* osname = ICEDB_error_getOSname();
    ICEDB_error_context_add_string2(err, "OS_id", osname);
    return -1;
}

Here is the caller graph for this function:

ICEDB_getUserName()

const char* ICEDB_getUserName

(

)

Definition at line 579 of file os_functions.cpp.

References icedb::os_functions::populateOSstrings(), and icedb::os_functions::vars::username.

Referenced by icedb::os_functions::getUserName().

                                {
    icedb::os_functions::populateOSstrings();
    return username.c_str();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ICEDB_libEntry()

void ICEDB_libEntry	(	int	,
		char **
	)

Entry function that gets called when a debugged application first loads.

This function gets called at the beginning of an application's execution (generally). It:

• determines if the app should wait on exit (to keep the console open)
• resets the console title in case any other library overrides it. A good example of this is the CERN ROOT image lobraries.
• Overrides the console control key handlers on Windows. This lets a user exit with CTRL-C without the debug code causing the app to crash.

Definition at line 848 of file os_functions.cpp.

References ICEDB_libExit().

Referenced by icedb::os_functions::libEntry().

                                 {
#ifdef _WIN32
    // Get PID
    DWORD pid = 0;
    HANDLE h = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (NULL == h) return;
    PROCESSENTRY32 pe = { 0 };
    pe.dwSize = sizeof(PROCESSENTRY32);
    pid = GetCurrentProcessId();
    CloseHandle(h);

    // Get parent process name
    h = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION
        //| PROCESS_VM_READ
        , FALSE, pid);
    if (NULL == h) return;
    TCHAR szModName[600];
    DWORD success = 0;
    DWORD sz = sizeof(szModName) / sizeof(TCHAR);
    success = QueryFullProcessImageName(h, 0, szModName, &sz);

    // Set Console Title
    SetConsoleTitle(szModName);


    // Also, set the window closing routine
    // This allows for the user to click the X (or press ctrl-c)
    // without causing a fault.
    // The fault is because the window closes before the atexit 
    // functions can write output.
    SetConsoleCtrlHandler(icedb::os_functions::win::_CloseHandlerRoutine, true);
    CloseHandle(h);
#endif


    // Set appexit
    atexit(ICEDB_libExit);
    // Static registration of i/o objects

    // Load the appropriate filesystem plugin
    //std::string pDir(ICEDB_getPluginDirC());
    //const size_t mangledNameSz = 200;
    //char mangledName[mangledNameSz] = "";
#if defined(_WIN32)
    //ICEDB_dll_name_mangle_simple("fs-win", mangledName, mangledNameSz);
#else
    //ICEDB_dll_name_mangle_simple("fs-posix", mangledName, mangledNameSz);
#endif
    //std::string testP = pDir + "/" + std::string(mangledName);
    //ICEDB_load_plugin(testP.c_str());


    // Query the filesystem to load the remaining plugins

}

Here is the call graph for this function:

Here is the caller graph for this function:

ICEDB_libExit()

void ICEDB_libExit

(

)

Definition at line 904 of file os_functions.cpp.

References icedb::os_functions::vars::_consoleTerminated, and ICEDB_waitOnExitGet().

Referenced by ICEDB_libEntry().

                     {
    using namespace std;
    if (_consoleTerminated) return;
    if (ICEDB_waitOnExitGet())
    {
        cerr << endl << "Program terminated. Press return to exit." << endl;
        //std::getchar();
        // Ignore to the end of file
//#ifdef max
//#undef max
//#endif
        cin.clear();
        //cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
        std::string ln;
        std::getline(cin, ln);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ICEDB_pidExists()

bool ICEDB_pidExists	(	int	pid,
		bool &	res
	)

Definition at line 401 of file os_functions.cpp.

References ICEDB_error_context_add_string2, ICEDB_error_context_create, ICEDB_error_getOSname, ICEDB_ERRORCODES_OS, and ICEDB_ERRORCODES_UNIMPLEMENTED.

Referenced by icedb::os_functions::pidExists().

{
    // Function needed because Qt is insufficient, and Windows / Unix have 
    // different methods of ascertaining this.
#if defined(ICEDB_OS_WINDOWS)
    HANDLE h = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pid);
    if (h)
    {
        DWORD code = 0;
        if (GetExitCodeProcess(h, &code))
        {
            CloseHandle(h);
            if (code == STILL_ACTIVE)
            {
                res = true;
                return true;
            }
            else {
                res = false;
                return true;
            }
        }
        else {
            CloseHandle(h);
            res = false;
            return true;
        }
        CloseHandle(h);
        res = true;
        return true;
    }
    return false;
#elif defined(ICEDB_OS_LINUX)
    // Need to check existence of directory /proc/pid
    std::ostringstream pname;
    pname << "/proc/" << pid;
    if (icedb::os_functions::unix::dirExists(pname.str().c_str())) {
        res = true;
        return true;
    }
    res = false;
    return true;
#elif defined(__FreeBSD__) || defined (__APPLE__)
    // Works for both freebsd and mac os
    res = false;
    int mib[4];
    size_t len;
    struct kinfo_proc kp;

    /* Fill out the first three components of the mib */
    len = 4;
    sysctlnametomib("kern.proc.pid", mib, &len);
    mib[3] = pid;
    len = sizeof(kp);
    int sres = sysctl(mib, 4, &kp, &len, NULL, 0);
    if (sres == -1) {
        // Either the pid does not exist, or some other error
        if (errno == ENOENT) {
            res = false; return true;
        }
        auto err = ICEDB_error_context_create(ICEDB_ERRORCODES_OS);
        const char* osname = ICEDB_error_getOSname();
        ICEDB_error_context_add_string2(err, "OS_id", osname);
        const int buflen = 200;
        char strerrbuf[buflen] = "\0";
        snprintf(strerrbuf, buflen, "%d", errno);
        ICEDB_error_context_add_string2(err, "errno", strerrbuf);

        // strerror_r will always yield a null-terminated string.
        //int ebufres = strerror_r(err, strerrbuf, buflen);
    }
    else if ((sres == 0) && (len > 0)) res = true;
    return true;
#endif
    auto err = ICEDB_error_context_create(ICEDB_ERRORCODES_UNIMPLEMENTED);
    const char* osname = ICEDB_error_getOSname();
    ICEDB_error_context_add_string2(err, "OS_id", osname);
    return false;
}

Here is the caller graph for this function:

ICEDB_waitOnExitGet()

bool ICEDB_waitOnExitGet

(

)

Definition at line 570 of file os_functions.cpp.

References icedb::os_functions::vars::doWaitOnExit, icedb::os_functions::vars::doWaitOnExitQueriedDefault, ICEDB_waitOnExitGetDefault(), and icedb::os_functions::vars::m_sys_names.

Referenced by ICEDB_libExit(), and icedb::os_functions::waitOnExit().

                           {
    std::lock_guard<std::mutex> lock(m_sys_names);
    if (!doWaitOnExitQueriedDefault) {
        doWaitOnExitQueriedDefault = true;
        doWaitOnExit = ICEDB_waitOnExitGetDefault();
    }
    return doWaitOnExit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ICEDB_waitOnExitGetDefault()

bool ICEDB_waitOnExitGetDefault

(

)

Definition at line 530 of file os_functions.cpp.

Referenced by ICEDB_waitOnExitGet().

                                  {
#if defined(ICEDB_OS_WINDOWS)
    // Get pid and parent pid. Duplicated getPID and getPPID, but combines the calls.
    DWORD pid = 0, ppid = 0;
    HANDLE h = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (NULL == h) return false;
    PROCESSENTRY32 pe = { 0 };
    pe.dwSize = sizeof(PROCESSENTRY32);
    pid = GetCurrentProcessId();
    if (Process32First(h, &pe)) {
        do {
            if (pe.th32ProcessID == pid) {
                ppid = pe.th32ParentProcessID;
            }
        } while (Process32Next(h, &pe));
    }
    CloseHandle(h);

    // Get parent process name
    std::string filepath, filename;
    icedb::os_functions::win::getPathWIN32(ppid, filepath, filename);

    //std::cout << filename.string() << std::endl;
    // If run from cmd, no need to wait
    if (filename == "cmd.exe") return false;
    // Cygwin
    if (filename == "bash.exe") return false;
    if (filename == "tcsh.exe") return false;
    // Don't need these due to end return. Just for reference.
    //if (filename == "devenv.exe") return true;
    //if (filename == "explorer.exe") return true;
    return true;
#endif
    return false;
}

Here is the caller graph for this function:

ICEDB_waitOnExitSet()

void ICEDB_waitOnExitSet

(

bool

val

)

Definition at line 565 of file os_functions.cpp.

References icedb::os_functions::vars::doWaitOnExit, icedb::os_functions::vars::doWaitOnExitQueriedDefault, and icedb::os_functions::vars::m_sys_names.

Referenced by icedb::os_functions::waitOnExit().

                                   {
    std::lock_guard<std::mutex> lock(m_sys_names);
    doWaitOnExitQueriedDefault = true;
    doWaitOnExit = val;
}

Here is the caller graph for this function:

ICEDB_writeDebugString()

void ICEDB_writeDebugString

(

const char *

c

)

Definition at line 922 of file os_functions.cpp.

References ICEDB_COMPAT_fprintf_s.

Referenced by icedb::logging::emit_log().

                                           {
#ifdef _WIN32
    OutputDebugStringA(c);
#else
    // Just write to CERR
    ICEDB_COMPAT_fprintf_s(stderr, "%s", c);
#endif
}

Here is the caller graph for this function: