System.cpp

Go to the documentation of this file.

// $Id: System.cpp,v 1.20.2.1 2006/10/06 11:28:02 hmd Exp $
//====================================================================
//  System.cpp
//--------------------------------------------------------------------
//
//  Package    : System (The LHCb System service)
//
//  Description: Implementation of Systems internals
//
//  Author     : M.Frank
//  Created    : 13/1/99
//  Changes    : 
//====================================================================
#define SYSTEM_CPP
#include <ctime>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <typeinfo>

#include "System.h"
  const char* SHLIB_SUFFIX = ".so";
  #include <errno.h>
  #include <string.h>
  #include "sys/times.h"
  #include "unistd.h"
  #include "libgen.h"
  #include <cstdio>
  #include <cxxabi.h>
  #include "dlfcn.h"
  #include <sys/utsname.h>
  #include <unistd.h>
  extern char** environ;

static std::vector<std::string> s_argvStrings;
static std::vector<const char*> s_argvChars;

const std::string& System::hostName() {
  static std::string host = "";
  if ( host == "" ) {
    char buffer[512];
    memset(buffer,0,sizeof(buffer));
    ::gethostname(buffer, sizeof(buffer));
    host = buffer;
  }
  return host;
}

const std::string& System::osName() {
  static std::string osname = "";
  struct utsname ut;
  if (uname(&ut) == 0) {
    osname = ut.sysname;
  } else {
    osname = "UNKNOWN";
  }
  return osname;
}


const std::string& System::osVersion() {
  static std::string osver = "";
  struct utsname ut;
  if (uname(&ut) == 0) {
    osver = ut.release;
  } else {
    osver = "UNKNOWN";
  }
  return osver;
}

const std::string& System::machineType() {
  static std::string mach = "";
  struct utsname ut;
  if (uname(&ut) == 0) {
    mach = ut.machine;
  } else {
    mach = "UNKNOWN";
  }
  return mach;
}

const std::string& System::accountName() {
  static std::string account = "";
  if ( account == "" ) {
    const char* acct = ::getlogin();
    if ( 0 == acct ) acct = ::getenv("LOGNAME");
    if ( 0 == acct ) acct = ::getenv("USER");
    account = (acct) ? acct : "Unknown";
  }
  return account;
}

long System::numCmdLineArgs()   {
  return cmdLineArgs().size();
}

long System::argc()    {
  return cmdLineArgs().size();
}

const std::vector<std::string> System::cmdLineArgs()    {
  if ( s_argvChars.size() == 0 )    {
    char exe[1024];
    sprintf(exe, "/proc/%d/cmdline", ::getpid());
    FILE *cmdLine = ::fopen(exe,"r");
    char cmd[1024];
    if ( cmdLine )   {
      long len = fread(cmd, sizeof(char), sizeof(cmd), cmdLine);
      if ( len > 0 )   {
        cmd[len] = 0;
        for ( char* token = cmd; token-cmd < len; token += strlen(token)+1 )  {
          s_argvStrings.push_back(token);
          s_argvChars.push_back( s_argvStrings.back().c_str());
        }
        s_argvStrings[0] = exeName();
        s_argvChars[0]   = s_argvStrings[0].c_str();
      }
    }
    ::fclose(cmdLine);
  }
  return s_argvStrings;
}

char** System::argv()    {
  if( s_argvChars.empty() ) { cmdLineArgs(); }  
  // We rely here on the fact that a vector's allocation table is contiguous
  return (char**)&s_argvChars[0];
}

const std::string System::getEnv(const char* var) {
  char* env;
  if  ( (env = getenv(var)) != 0 ) {
    return env;
  } else {
    return "UNKNOWN";
  }
}

const std::vector<std::string> System::getEnv() {
  std::vector<std::string> vars;
  for (int i=0; environ[i] != 0; ++i) {
    vars.push_back(environ[i]);
  }
  return vars;
}
 
int System::setEnv(const std::string &name, const std::string &value, int overwrite) 
{
  // UNIX version
  return value.empty() ?
    // remove if set to nothing (and return success)
    ::unsetenv(name.c_str()) , 0 :
    // set the value
    ::setenv(name.c_str(),value.c_str(), overwrite);
}