ModuleInfo.cpp

Go to the documentation of this file.

//====================================================================
//  ModuleInfo.cpp
//--------------------------------------------------------------------
//
//  Package    : System (The LHCb System service)
//
//  Description: Implementation of Systems internals
//
//  Author     : M.Frank
//      Created    : 13/1/99
//  Changes    :
//====================================================================
#define SYSTEM_MODULEINFO_CPP

//#include <ctime>
#include <cstring>
#include <cstdlib>
//#include <iostream>
//#include <typeinfo>

#include "GaudiKernel/ModuleInfo.h"
#include "GaudiKernel/System.h"

#ifdef _WIN32
  #define NOMSG
  #define NOGDI
  #  define strcasecmp _stricmp
  #  define strncasecmp _strnicmp
  #include "process.h"
  #include "windows.h"
  #include "Win32PsApi.h"
static PsApiFunctions _psApi;
  #define getpid _getpid
  #undef NOMSG
  #undef NOGDI
  #ifndef PATH_MAX
  #  define PATH_MAX 1024
  #endif
#else  // UNIX...: first the EGCS stuff, then the OS dependent includes
  #include <errno.h>
  #include <string.h>
  #include "sys/times.h"
  #include "sys/param.h"
  #include "unistd.h"
  #include "libgen.h"
  #include <cstdio>
  #include <dlfcn.h>
#endif

static System::ImageHandle      ModuleHandle = nullptr;
static std::vector<std::string> s_linkedModules;

const std::string& System::moduleName()   {
  static std::string module("");
  if ( module == "" )   {
    if ( processHandle() && moduleHandle() )    {
#ifdef _WIN32
      char moduleName[256] = {"Unknown.module"};
      moduleName[0] = 0;
      if ( _psApi ) {
        _psApi.GetModuleBaseNameA( processHandle(), (HINSTANCE)moduleHandle(), moduleName, sizeof(moduleName) );
      }
      std::string mod = moduleName;
#elif defined(__linux) || defined(__APPLE__)
      std::string mod = ::basename((char*)((Dl_info*)moduleHandle())->dli_fname);
#elif __hpux
      std::string mod = ::basename(((HMODULE*)moduleHandle())->dsc.filename);
#endif
      module = mod.substr(0, mod.rfind('.'));
    }
  }
  return module;
}

const std::string& System::moduleNameFull()   {
  static std::string module("");
  if ( module == "" )   {
    if ( processHandle() && moduleHandle() )    {
      char name[PATH_MAX] = {"Unknown.module"};
      name[0] = 0;
#ifdef _WIN32
      if ( _psApi )   {
        _psApi.GetModuleFileNameExA( processHandle(), (HINSTANCE)moduleHandle(), name,sizeof(name) );
        module = name;
      }
#else
      const char *path =
#  if defined(__linux) || defined(__APPLE__)
          ((Dl_info*)moduleHandle())->dli_fname;
#  elif __hpux
          ((HMODULE*)moduleHandle())->dsc.filename;
#  endif
      if (::realpath(path, name))
        module = name;
#endif
    }
  }
  return module;
}

System::ModuleType System::moduleType()   {
  static ModuleType type = UNKNOWN;
  if ( type == UNKNOWN )    {
    const std::string& module = moduleNameFull();
    int loc = module.rfind('.')+1;
    if ( loc == 0 )
      type = EXECUTABLE;
    else if ( module[loc] == 'e' || module[loc] == 'E' )
      type = EXECUTABLE;
#ifdef _WIN32
    else if ( module[loc] == 'd' || module[loc] == 'D' )
#else
    else if ( module[loc] == 's' && module[loc+1] == 'o' )
#endif
      type = SHAREDLIB;
    else
      type = UNKNOWN;
  }
  return type;
}

void* System::processHandle()   {
  static long pid = ::getpid();
#ifdef _WIN32
  static HANDLE hP = ::OpenProcess(PROCESS_QUERY_INFORMATION|PROCESS_VM_READ,FALSE,pid);
#else
  static void* hP = (void*)pid;
#endif
  return hP;
}

void System::setModuleHandle(System::ImageHandle handle)    {
  ModuleHandle = handle;
}

System::ImageHandle System::moduleHandle()    {
  if ( !ModuleHandle )    {
    if ( processHandle() )    {
#ifdef _WIN32
      static HINSTANCE handle = 0;
      DWORD   cbNeeded;
      if ( 0 == handle && _psApi )    {
        if ( _psApi.EnumProcessModules( processHandle(), &handle, sizeof(ModuleHandle), &cbNeeded) )   {
        }
      }
      return handle;
#elif defined(__linux) || defined(__APPLE__)
      static Dl_info info;
      if ( 0 !=
           ::dladdr(
#if __GNUC__ < 4
               (void*)System::moduleHandle
#else
               FuncPtrCast<void*>(System::moduleHandle)
#endif
               , &info) ) {
    return &info;
      }
#elif __hpux
      return 0;  // Don't know how to solve this .....
#endif
    }
  }
  return ModuleHandle;
}

System::ImageHandle System::exeHandle()    {
#ifdef _WIN32
  if ( processHandle() )    {
    static HINSTANCE handle = 0;
    DWORD   cbNeeded;
    if ( 0 == handle && _psApi )    {
      if ( _psApi.EnumProcessModules( processHandle(), &handle, sizeof(ModuleHandle), &cbNeeded) )   {
      }
    }
    return handle;
  }
  return 0;
#elif defined(__linux) || defined(__APPLE__)
  // This does NOT work!
  static Dl_info infoBuf, *info = &infoBuf;
  if ( !info ) {
    void* handle = ::dlopen(nullptr, RTLD_LAZY);
    //printf("Exe handle:%X\n", handle);
    if ( handle ) {
      void* func = ::dlsym(handle, "main");
      //printf("Exe:Func handle:%X\n", func);
      if ( func ) {
        if ( 0 != ::dladdr(func, &infoBuf) ) {
            //std::cout << "All OK" << std::endl;
          info = &infoBuf;
        }
      }
    }
  }
  return info;
#elif __hpux
  // Don't know how to solve this .....
  return 0;
#endif
}

const std::string& System::exeName()    {
  static std::string module("");
  if ( module.length() == 0 )    {
    char name[PATH_MAX] = {"Unknown.module"};
    name[0] = 0;
#ifdef _WIN32
    if ( _psApi && processHandle() )   {
      _psApi.GetModuleFileNameExA( processHandle(), (HINSTANCE)exeHandle(), name,sizeof(name) );
      module = name;
    }
#elif defined(__linux) || defined(__APPLE__)
    char cmd[512];
    ::sprintf(cmd, "/proc/%d/exe", ::getpid());
    module = "Unknown";
    if (::readlink(cmd, name, sizeof(name)) >= 0)
      module = name;
#elif __hpux
    if (::realpath(((HMODULE*)exeHandle())->dsc.filename, name))
      module = name;
#endif
  }
  return module;
}

const std::vector<std::string> System::linkedModules()    {
  if ( s_linkedModules.size() == 0 )    {
#ifdef _WIN32
    char   name[255];  // Maximum file name length on NT 4.0
    DWORD  cbNeeded;
    HINSTANCE handle[1024];
    if ( _psApi )    {
      if ( _psApi.EnumProcessModules(processHandle(),handle,sizeof(handle),&cbNeeded) )   {
        for (size_t i = 0; i < cbNeeded/sizeof(HANDLE); i++ )    {
          if ( 0 < _psApi.GetModuleFileNameExA( processHandle(), handle[i], name, sizeof(name)) )   {
            s_linkedModules.push_back(name);
          }
        }
      }
    }
#elif defined(__linux) || defined(__APPLE__)
    char ff[512], cmd[1024], fname[1024], buf1[64], buf2[64], buf3[64], buf4[64];
    ::sprintf(ff, "/proc/%d/maps", ::getpid());
    FILE* maps = ::fopen(ff, "r");
    while( ::fgets(cmd, sizeof(cmd), maps) ) {
      int len;
      sscanf(cmd, "%s %s %s %s %d %s", buf1, buf2, buf3, buf4, &len, fname);
      if ( len > 0 && strncmp(buf2,"r-xp",strlen("r-xp")) == 0 ) {
        s_linkedModules.push_back(fname);
      }
    }
    ::fclose(maps);
#endif
  }
  return s_linkedModules;
}