1101 lines
27 KiB
C++
Executable File
1101 lines
27 KiB
C++
Executable File
#include "os.h"
|
|
#include "lib/utils/bts_assert.h"
|
|
#include "lib/utils/bts_debugger.h"
|
|
#include "lib/config/config.h"
|
|
#include "lib/utils/bts_array_size.h"
|
|
#include "lib/utils/helper_macros.h"
|
|
|
|
#include <boost/asio.hpp>
|
|
#include <boost/algorithm/string/replace.hpp>
|
|
|
|
#ifdef _WIN32
|
|
#include <ObjBase.h>
|
|
#include <windows.h>
|
|
#ifdef GetMessage
|
|
#undef GetMessage
|
|
#endif
|
|
#include <Winsock2.h>
|
|
#include <Ws2tcpip.h>
|
|
#include <direct.h>
|
|
#include <iphlpapi.h>
|
|
#include <comdef.h>
|
|
#include <Wbemidl.h>
|
|
#else
|
|
#include <unistd.h>
|
|
#include <uuid/uuid.h>
|
|
#include <dlfcn.h>
|
|
#include <netdb.h>
|
|
#include <arpa/inet.h>
|
|
#include <sys/types.h>
|
|
#include <ifaddrs.h>
|
|
#include <netinet/in.h>
|
|
#include <sys/prctl.h>
|
|
#include <pwd.h>
|
|
#endif
|
|
|
|
#include <stdexcept>
|
|
|
|
#include <cstdlib>
|
|
#include <fstream>
|
|
#include <vector>
|
|
#include <string.h> // strlcpy
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <limits>
|
|
#include <mutex>
|
|
|
|
#ifndef NO_CPP0X
|
|
#include <thread>
|
|
#endif
|
|
|
|
#include <boost/filesystem.hpp>
|
|
|
|
#ifdef WIN32
|
|
# pragma comment(lib, "wbemuuid.lib")
|
|
#endif
|
|
|
|
namespace bts {
|
|
namespace os {
|
|
|
|
unsigned int process_id ()
|
|
{
|
|
#ifdef _WIN32
|
|
return GetCurrentProcessId ();
|
|
#else
|
|
return getpid ();
|
|
#endif
|
|
}
|
|
|
|
bool is_running(unsigned int pid) {
|
|
#ifdef _WIN32
|
|
HANDLE handle = OpenProcess(SYNCHRONIZE, false, pid);
|
|
auto err = GetLastError();
|
|
// ERROR_INVALID_PARAMETER is returned when the pid is not valid
|
|
// If we're out of memory a different error code is returned but I'm having a hard time figuring out what it is...
|
|
if (!handle && err == ERROR_INVALID_PARAMETER) return false;
|
|
CloseHandle(handle);
|
|
return true;
|
|
#else
|
|
return kill(pid,0) != -1;
|
|
#endif
|
|
}
|
|
|
|
bool parse_int(const std::string& str, int *result) {
|
|
std::stringstream conv;
|
|
conv << str;
|
|
conv >> *result;
|
|
return conv.eof();
|
|
}
|
|
|
|
std::vector<std::string> parse_cmd_line(std::string const &cmd_line) {
|
|
const int ws = 0;
|
|
const int qt = 1;
|
|
const int t = 2;
|
|
|
|
std::vector<std::string> result;
|
|
size_t n = 0;
|
|
int state = ws;
|
|
while (n < cmd_line.size()) {
|
|
switch (state) {
|
|
case ws:
|
|
if (isspace (cmd_line[n]))
|
|
n++;
|
|
else if (cmd_line[n] == '"')
|
|
{
|
|
n++;
|
|
result.push_back("");
|
|
state = qt;
|
|
}
|
|
else {
|
|
result.push_back("");
|
|
result.back().push_back(cmd_line[n]);
|
|
n++;
|
|
state = t;
|
|
}
|
|
break;
|
|
case qt:
|
|
if (cmd_line[n] == '"') {
|
|
n++;
|
|
state = ws;
|
|
}
|
|
else {
|
|
result.back().push_back(cmd_line[n]);
|
|
n++;
|
|
}
|
|
break;
|
|
case t:
|
|
if (isspace (cmd_line[n])) {
|
|
n++;
|
|
state = ws;
|
|
}
|
|
else {
|
|
result.back().push_back(cmd_line[n]);
|
|
n++;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
std::string ConvertWCSToMBS(const wchar_t* pstr, long wslen)
|
|
{
|
|
int len = ::WideCharToMultiByte(CP_ACP, 0, pstr, wslen, NULL, 0, NULL, NULL);
|
|
|
|
std::string dblstr(len, '\0');
|
|
len = ::WideCharToMultiByte(CP_ACP, 0 /* no flags */,
|
|
pstr, wslen /* not necessary NULL-terminated */,
|
|
&dblstr[0], len,
|
|
NULL, NULL /* no default char */);
|
|
|
|
return dblstr;
|
|
}
|
|
|
|
std::string bstr_to_str (BSTR const &bstr)
|
|
{
|
|
int wslen = ::SysStringLen(bstr);
|
|
return ConvertWCSToMBS((wchar_t*)bstr, wslen);
|
|
}
|
|
#endif
|
|
|
|
#ifdef _WIN32
|
|
struct RunningProcessesQuerier::PImpl
|
|
{
|
|
PImpl() : pLoc (NULL),pSvc (NULL), where ()
|
|
{}
|
|
IWbemLocator *pLoc;
|
|
IWbemServices *pSvc;
|
|
std::string where;
|
|
};
|
|
|
|
RunningProcessesQuerier::RunningProcessesQuerier (std::vector<std::string> const&exes)
|
|
: me (new PImpl()) {
|
|
|
|
for (size_t i = 0; i < exes.size ();i++) {
|
|
if (me->where.size ())
|
|
me->where += " or " ;
|
|
me->where += "Name='" + exes[i] +".exe'";
|
|
}
|
|
|
|
HRESULT hres;
|
|
CoInitializeEx(0, COINIT_MULTITHREADED);
|
|
CoInitializeSecurity(
|
|
NULL,
|
|
-1, // COM authentication
|
|
NULL, // Authentication services
|
|
NULL, // Reserved
|
|
RPC_C_AUTHN_LEVEL_DEFAULT, // Default authentication
|
|
RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation
|
|
NULL, // Authentication info
|
|
EOAC_NONE, // Additional capabilities
|
|
NULL // Reserved
|
|
);
|
|
hres = CoCreateInstance(
|
|
CLSID_WbemLocator,
|
|
0,
|
|
CLSCTX_INPROC_SERVER,
|
|
IID_IWbemLocator, (LPVOID *) &me->pLoc);
|
|
|
|
assert (!FAILED(hres));
|
|
|
|
hres = me->pLoc->ConnectServer(
|
|
_bstr_t(L"ROOT\\CIMV2"),
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
&me->pSvc
|
|
);
|
|
|
|
assert (!FAILED(hres));
|
|
|
|
|
|
hres = CoSetProxyBlanket(
|
|
me->pSvc, // Indicates the proxy to set
|
|
RPC_C_AUTHN_WINNT, // RPC_C_AUTHN_xxx
|
|
RPC_C_AUTHZ_NONE, // RPC_C_AUTHZ_xxx
|
|
NULL, // Server principal name
|
|
RPC_C_AUTHN_LEVEL_CALL, // RPC_C_AUTHN_LEVEL_xxx
|
|
RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
|
|
NULL, // client identity
|
|
EOAC_NONE // proxy capabilities
|
|
);
|
|
|
|
assert (!FAILED(hres));
|
|
}
|
|
|
|
std::vector<ProcInfo> RunningProcessesQuerier::query () {
|
|
std::vector<ProcInfo> result;
|
|
IEnumWbemClassObject* pEnumerator = NULL;
|
|
std::string query = "Select Name,ProcessId,CommandLine from Win32_Process";
|
|
if (me->where.size ())
|
|
query += " Where " + me->where;
|
|
|
|
HRESULT hres = me->pSvc->ExecQuery(
|
|
bstr_t("WQL"),
|
|
bstr_t(query.c_str ()),
|
|
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
|
|
NULL,
|
|
&pEnumerator);
|
|
|
|
assert (!FAILED(hres));
|
|
|
|
IWbemClassObject *pclsObj = 0;
|
|
ULONG uReturn = 0;
|
|
|
|
while (pEnumerator)
|
|
{
|
|
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);
|
|
if(0 == uReturn)
|
|
break;
|
|
|
|
ProcInfo i;
|
|
|
|
VARIANT vtProp;
|
|
// Get the value of the Name property
|
|
pclsObj->Get(L"Name", 0, &vtProp, 0, 0);
|
|
i.exe = bstr_to_str (vtProp.bstrVal);
|
|
boost::replace_all(i.exe, ".exe", "");
|
|
VariantClear(&vtProp);
|
|
|
|
pclsObj->Get(L"CommandLine", 0, &vtProp, 0, 0);
|
|
i.args = parse_cmd_line(bstr_to_str (vtProp.bstrVal));
|
|
VariantClear(&vtProp);
|
|
|
|
pclsObj->Get(L"ProcessId", 0, &vtProp, 0, 0);
|
|
i.pid = vtProp.intVal;
|
|
VariantClear(&vtProp);
|
|
|
|
pclsObj->Release();
|
|
result.push_back(i);
|
|
}
|
|
pEnumerator->Release();
|
|
return result;
|
|
}
|
|
|
|
RunningProcessesQuerier::~RunningProcessesQuerier ()
|
|
{
|
|
me->pSvc->Release();
|
|
me->pLoc->Release();
|
|
}
|
|
|
|
#else
|
|
struct RunningProcessesQuerier::PImpl {};
|
|
RunningProcessesQuerier::RunningProcessesQuerier (std::vector<std::string> const&) : me () {}
|
|
RunningProcessesQuerier::~RunningProcessesQuerier () {}
|
|
std::vector<ProcInfo> RunningProcessesQuerier::query () {return os::running_processes ();}
|
|
#endif
|
|
|
|
std::vector<ProcInfo> running_processes ()
|
|
{
|
|
std::vector<ProcInfo> result;
|
|
#ifdef _WIN32
|
|
HRESULT hres;
|
|
CoInitializeEx(0, COINIT_MULTITHREADED);
|
|
CoInitializeSecurity(
|
|
NULL,
|
|
-1, // COM authentication
|
|
NULL, // Authentication services
|
|
NULL, // Reserved
|
|
RPC_C_AUTHN_LEVEL_DEFAULT, // Default authentication
|
|
RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation
|
|
NULL, // Authentication info
|
|
EOAC_NONE, // Additional capabilities
|
|
NULL // Reserved
|
|
);
|
|
IWbemLocator *pLoc = NULL;
|
|
|
|
hres = CoCreateInstance(
|
|
CLSID_WbemLocator,
|
|
0,
|
|
CLSCTX_INPROC_SERVER,
|
|
IID_IWbemLocator, (LPVOID *) &pLoc);
|
|
|
|
assert (!FAILED(hres));
|
|
|
|
IWbemServices *pSvc = NULL;
|
|
|
|
hres = pLoc->ConnectServer(
|
|
_bstr_t(L"ROOT\\CIMV2"),
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
&pSvc
|
|
);
|
|
|
|
assert (!FAILED(hres));
|
|
|
|
|
|
hres = CoSetProxyBlanket(
|
|
pSvc, // Indicates the proxy to set
|
|
RPC_C_AUTHN_WINNT, // RPC_C_AUTHN_xxx
|
|
RPC_C_AUTHZ_NONE, // RPC_C_AUTHZ_xxx
|
|
NULL, // Server principal name
|
|
RPC_C_AUTHN_LEVEL_CALL, // RPC_C_AUTHN_LEVEL_xxx
|
|
RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
|
|
NULL, // client identity
|
|
EOAC_NONE // proxy capabilities
|
|
);
|
|
|
|
assert (!FAILED(hres));
|
|
|
|
IEnumWbemClassObject* pEnumerator = NULL;
|
|
hres = pSvc->ExecQuery(
|
|
bstr_t("WQL"),
|
|
bstr_t("Select * from Win32_Process"),
|
|
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
|
|
NULL,
|
|
&pEnumerator);
|
|
|
|
assert (!FAILED(hres));
|
|
|
|
IWbemClassObject *pclsObj = 0;
|
|
ULONG uReturn = 0;
|
|
|
|
while (pEnumerator)
|
|
{
|
|
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);
|
|
if(0 == uReturn)
|
|
break;
|
|
|
|
ProcInfo i;
|
|
|
|
VARIANT vtProp;
|
|
// Get the value of the Name property
|
|
pclsObj->Get(L"Name", 0, &vtProp, 0, 0);
|
|
i.exe = bstr_to_str (vtProp.bstrVal);
|
|
boost::replace_all(i.exe, ".exe", "");
|
|
VariantClear(&vtProp);
|
|
|
|
pclsObj->Get(L"CommandLine", 0, &vtProp, 0, 0);
|
|
i.args = parse_cmd_line(bstr_to_str (vtProp.bstrVal));
|
|
VariantClear(&vtProp);
|
|
|
|
pclsObj->Get(L"ProcessId", 0, &vtProp, 0, 0);
|
|
i.pid = vtProp.intVal;
|
|
VariantClear(&vtProp);
|
|
|
|
pclsObj->Release();
|
|
result.push_back(i);
|
|
}
|
|
|
|
pSvc->Release();
|
|
pLoc->Release();
|
|
pEnumerator->Release();
|
|
|
|
#else
|
|
boost::filesystem::directory_iterator p ("/proc");
|
|
for (;p != boost::filesystem::directory_iterator (); p++) {
|
|
ProcInfo pi;
|
|
int pid;
|
|
if (parse_int (p->path ().filename ().string (),&pid)) {
|
|
pi.pid =pid;
|
|
std::string file_name (p->path ().string ()+"/cmdline");
|
|
std::ifstream fs (file_name.c_str ());
|
|
std::stringstream sstr;
|
|
sstr << fs.rdbuf();
|
|
if (!fs.bad ()) {
|
|
std::string cmd_line = sstr.str();
|
|
bool first_char = true;
|
|
std::string *current = 0;
|
|
for (size_t i = 0; i < cmd_line.size ();i++)
|
|
if (cmd_line[i] != 0) {
|
|
if (first_char) {
|
|
pi.args.push_back ("");
|
|
current = &(pi.args.back ());
|
|
}
|
|
first_char = false;
|
|
current->push_back (cmd_line[i]);
|
|
}
|
|
else
|
|
first_char = true;
|
|
// shamelessly copied from get_application_path
|
|
char buffer[1024];
|
|
char temp[32];
|
|
sprintf(temp, "/proc/%d/exe", pi.pid);
|
|
int bytes = readlink(temp, buffer, sizeof(buffer));
|
|
if (bytes>0) {
|
|
buffer[bytes] = 0;
|
|
pi.exe =boost::filesystem::path (buffer).filename ().string ();
|
|
}
|
|
result.push_back (pi);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return result;
|
|
}
|
|
|
|
char const* platform_name ()
|
|
{
|
|
#ifdef _WIN32
|
|
return "Windows";
|
|
#elif __linux__
|
|
return "Linux";
|
|
#else
|
|
#error This function needs to be implemented for your platform
|
|
#endif
|
|
}
|
|
|
|
std::string host_name ()
|
|
{
|
|
char buffer[128];
|
|
bts_assert(gethostname(buffer,BTS_ARRAYSIZE(buffer)) == 0);
|
|
return std::string (buffer);
|
|
}
|
|
|
|
std::string get_application_path(const char* module_name)
|
|
{
|
|
char buffer[1024];
|
|
#ifdef _WIN32
|
|
int bytes = GetModuleFileName(GetModuleHandle(module_name), buffer, sizeof(buffer));
|
|
#elif __linux__
|
|
UNUSED(module_name);
|
|
// I'm not completely happy with this solution but there doesn't seem to be anything
|
|
// more standard.
|
|
char temp[32];
|
|
sprintf(temp, "/proc/%d/exe", getpid());
|
|
int bytes = readlink(temp, buffer, sizeof(buffer));
|
|
#else
|
|
// Most unixes don't have /proc
|
|
#error This function needs to be implemented for your platform
|
|
#endif
|
|
if (bytes > 0)
|
|
{
|
|
buffer[bytes] = 0;
|
|
return std::string(buffer);
|
|
}
|
|
else
|
|
{
|
|
throw std::runtime_error("Cannot read application directory");
|
|
}
|
|
}
|
|
|
|
std::string get_install_path()
|
|
{
|
|
// The install path is the location of spark_lib (on Windows) since there may be an api client or other entry point (nunit?)
|
|
auto result = get_application_path("spark_lib");
|
|
// Trim the filename
|
|
size_t last = result.find_last_of("/\\");
|
|
result.erase(last);
|
|
return result;
|
|
}
|
|
|
|
std::string get_application_name()
|
|
{
|
|
std::string app_path = get_application_path(nullptr);
|
|
size_t last = app_path.find_last_of("/\\");
|
|
if (last + 1 >= app_path.size())
|
|
return "";
|
|
return app_path.substr(last + 1, app_path.size() - last);
|
|
}
|
|
|
|
std::string get_cwd()
|
|
{
|
|
#ifdef _WIN32
|
|
#define GET_CURRENT_DIR _getcwd
|
|
#else
|
|
#define GET_CURRENT_DIR getcwd
|
|
#endif
|
|
|
|
char current_path[1024];
|
|
if (!GET_CURRENT_DIR(current_path, sizeof(current_path)))
|
|
{
|
|
throw std::runtime_error("current directory unreadable");
|
|
}
|
|
return std::string(current_path);
|
|
#undef GET_CURRENT_DIR
|
|
}
|
|
|
|
|
|
std::string& normalize_path(std::string& path, char separator)
|
|
{
|
|
size_t len = path.length();
|
|
for (size_t x = 0; x < len; x++)
|
|
{
|
|
if (path[x] == '/' || path[x] == '\\')
|
|
{
|
|
path[x] = separator;
|
|
}
|
|
}
|
|
return path;
|
|
}
|
|
|
|
std::string sanitize_file_name(std::string const& file_name)
|
|
{
|
|
#ifndef NO_CPP0X
|
|
const std::string forbidden = "\\/:?\"<>|";
|
|
std::string result = file_name;
|
|
std::transform (result.begin (), result.end (),result.begin (),
|
|
[&forbidden](char c) -> char {
|
|
if(forbidden.find(c) != std::string::npos)
|
|
return '_';
|
|
else
|
|
return c;
|
|
});
|
|
return result;
|
|
#else
|
|
return file_name;
|
|
#endif
|
|
}
|
|
|
|
void gen_uuid (unsigned char out [16])
|
|
{
|
|
#ifdef _WIN32
|
|
GUID out_guid;
|
|
/*
|
|
typedef struct _GUID {
|
|
unsigned long Data1;
|
|
unsigned short Data2;
|
|
unsigned short Data3;
|
|
unsigned char Data4[ 8 ];
|
|
} GUID;
|
|
|
|
I don't think C++ guarantees the above structure is packed, so I
|
|
do the safe thing below and copy each member in turn. -pp
|
|
*/
|
|
CoCreateGuid(&out_guid);
|
|
int idx = 0;
|
|
memcpy (out + idx,&out_guid.Data1,sizeof(out_guid.Data1));
|
|
idx += sizeof(out_guid.Data1);
|
|
|
|
memcpy (out + idx,&out_guid.Data2,sizeof(out_guid.Data2));
|
|
idx += sizeof(out_guid.Data2);
|
|
|
|
memcpy (out + idx,&out_guid.Data3,sizeof(out_guid.Data3));
|
|
idx += sizeof(out_guid.Data3);
|
|
|
|
memcpy (out + idx,&out_guid.Data4,sizeof(out_guid.Data4));
|
|
idx += sizeof(out_guid.Data4);
|
|
bts_assert (idx == 16);
|
|
#else
|
|
uuid_generate(out);
|
|
#endif
|
|
}
|
|
|
|
uint64_t tick_count ()
|
|
{
|
|
#ifdef _WIN32
|
|
LARGE_INTEGER qpcnt;
|
|
QueryPerformanceCounter(&qpcnt);
|
|
return qpcnt.QuadPart;
|
|
#else
|
|
struct timespec ts;
|
|
clock_gettime( CLOCK_REALTIME, &ts );
|
|
return
|
|
static_cast<int64_t>(1000000000UL)*
|
|
static_cast<int64_t>(ts.tv_sec) +
|
|
static_cast<int64_t>(ts.tv_nsec);
|
|
#endif
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
std::vector<std::string> g_cmd_args;
|
|
bool g_cmd_args_set;
|
|
|
|
// For compat with langues that don't follow normal CRT init or use a different CRT
|
|
extern "C" BTS_EXPORT void provide_command_line(const char** argv, int argc)
|
|
{
|
|
if (!g_cmd_args_set) {
|
|
g_cmd_args.reserve(argc);
|
|
for (int x = 0; x < argc; x++)
|
|
{
|
|
g_cmd_args.push_back(argv[x]);
|
|
}
|
|
g_cmd_args_set = true;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
std::vector<std::string> get_command_line()
|
|
{
|
|
#ifdef _WIN32
|
|
if (g_cmd_args_set)
|
|
{
|
|
// return cached copy
|
|
return g_cmd_args;
|
|
}
|
|
for (int index = 0; index < __argc; index++)
|
|
{
|
|
if (__argv != nullptr)
|
|
{
|
|
g_cmd_args.push_back(__argv[index]);
|
|
}
|
|
else if (__wargv != nullptr)
|
|
{
|
|
char temp[1024];
|
|
WideCharToMultiByte(CP_ACP, 0, __wargv[index], -1, temp, BTS_ARRAYSIZE(temp), nullptr, nullptr);
|
|
g_cmd_args.push_back(temp);
|
|
}
|
|
else
|
|
{
|
|
bts_assert(__argv != nullptr || __wargv != nullptr);
|
|
}
|
|
}
|
|
g_cmd_args_set = true;
|
|
return g_cmd_args;
|
|
#elif __linux__
|
|
std::vector<std::string> args;
|
|
std::ifstream in("/proc/self/cmdline", std::ios::in);
|
|
if (!in.fail())
|
|
{
|
|
std::string current;
|
|
do
|
|
{
|
|
char ch = in.get();
|
|
if (ch == '\0')
|
|
{
|
|
args.push_back(current);
|
|
current.clear();
|
|
}
|
|
else
|
|
{
|
|
current += ch;
|
|
}
|
|
} while(!in.eof());
|
|
}
|
|
return args;
|
|
#else
|
|
#error This function needs to be implemented for your platform
|
|
#endif
|
|
}
|
|
|
|
std::string get_qualifier()
|
|
{
|
|
std::vector<std::string> cmd_line = get_command_line();
|
|
if (cmd_line.size() > 0)
|
|
return cmd_line.back();
|
|
return "";
|
|
}
|
|
|
|
int get_random_port ()
|
|
{
|
|
srand ( os::tick_count () );
|
|
return rand() % 10000 + 20000;
|
|
}
|
|
|
|
int num_cores() {
|
|
#ifdef WIN32
|
|
SYSTEM_INFO sysinfo;
|
|
GetSystemInfo(&sysinfo);
|
|
return sysinfo.dwNumberOfProcessors;
|
|
#else
|
|
return sysconf(_SC_NPROCESSORS_ONLN);
|
|
#endif
|
|
}
|
|
|
|
std::string bts_user_path()
|
|
{
|
|
#ifdef _WIN32
|
|
const char* path = getenv("APPDATA");
|
|
bts_assert(path);
|
|
return std::string(path) + "/bts/";
|
|
#else
|
|
const char* path = getenv("HOME");
|
|
bts_assert_msg(path, "Environment variable $HOME must be defined");
|
|
return std::string(path) + "/.bts/";
|
|
#endif
|
|
}
|
|
|
|
std::string bts_system_path()
|
|
{
|
|
#ifdef _WIN32
|
|
const char* path = getenv("PROGRAMDATA");
|
|
bts_assert(path);
|
|
return std::string(path) + "/bts/";
|
|
#else
|
|
return "/etc/bts/";
|
|
#endif
|
|
}
|
|
|
|
std::string bts_data_path()
|
|
{
|
|
std::string path = bts_user_path() + "data/";
|
|
|
|
if (!boost::filesystem::is_directory(path))
|
|
{
|
|
boost::filesystem::create_directories(path);
|
|
}
|
|
return normalize_path(path);
|
|
}
|
|
|
|
std::string username() {
|
|
#ifdef _WIN32
|
|
char buffer[1024];
|
|
DWORD buffer_size = BTS_ARRAYSIZE(buffer);
|
|
if (GetUserNameA((LPSTR)&buffer, &buffer_size)) {
|
|
return buffer;
|
|
}
|
|
#else
|
|
uid_t uid = geteuid();
|
|
struct passwd* pw = getpwuid(uid);
|
|
if (pw) { return pw->pw_name; }
|
|
#endif
|
|
return "";
|
|
}
|
|
|
|
char* strncpy(char* dest, const char* src, size_t count)
|
|
{
|
|
#ifdef _WIN32
|
|
::strncpy_s(dest, count, src, count);
|
|
#else
|
|
// could use strlcpy but that isn't supported on orc
|
|
::strncpy(dest, src, count);
|
|
dest[count-1] = '\0';
|
|
#endif
|
|
return dest;
|
|
}
|
|
|
|
void setenv(const char* name, const char* value)
|
|
{
|
|
#ifdef _WIN32
|
|
SetEnvironmentVariable(name, value);
|
|
#else
|
|
::setenv(name, value, true);
|
|
#endif
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
|
|
// Link with Iphlpapi.lib
|
|
#pragma comment(lib, "IPHLPAPI.lib")
|
|
|
|
#define WORKING_BUFFER_SIZE 15000
|
|
#define MAX_TRIES 3
|
|
|
|
#define MALLOC(x) HeapAlloc(GetProcessHeap(), 0, (x))
|
|
#define FREE(x) HeapFree(GetProcessHeap(), 0, (x))
|
|
|
|
// inline std::wstring convert( const std::string& as )
|
|
// {
|
|
// wchar_t* buf = new wchar_t[as.size() * 2 + 2];
|
|
// swprintf( buf, L"%S", as.c_str() );
|
|
// std::wstring rval = buf;
|
|
// delete[] buf;
|
|
// return rval;
|
|
// }
|
|
|
|
std::map<std::string,std::string> get_windows_ips ()
|
|
{
|
|
std::map<std::string,std::string> result;
|
|
|
|
char address_buffer[256];
|
|
bool success = false;
|
|
|
|
DWORD dwSize = 0;
|
|
DWORD dwRetVal = 0;
|
|
|
|
unsigned int i = 0;
|
|
ULONG flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER;
|
|
ULONG family = AF_UNSPEC;
|
|
LPVOID lpMsgBuf = NULL;
|
|
PIP_ADAPTER_ADDRESSES pAddresses = NULL;
|
|
ULONG outBufLen = 0;
|
|
ULONG Iterations = 0;
|
|
PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;
|
|
PIP_ADAPTER_UNICAST_ADDRESS pUnicast = NULL;
|
|
|
|
family = AF_INET;
|
|
outBufLen = WORKING_BUFFER_SIZE;
|
|
|
|
do {
|
|
pAddresses = (IP_ADAPTER_ADDRESSES *) MALLOC(outBufLen);
|
|
if (pAddresses == NULL) {
|
|
bts_assert(false);
|
|
}
|
|
|
|
dwRetVal =
|
|
GetAdaptersAddresses(family, flags, NULL, pAddresses, &outBufLen);
|
|
|
|
if (dwRetVal == ERROR_BUFFER_OVERFLOW) {
|
|
FREE(pAddresses);
|
|
pAddresses = NULL;
|
|
} else {
|
|
break;
|
|
}
|
|
|
|
Iterations++;
|
|
|
|
} while ((dwRetVal == ERROR_BUFFER_OVERFLOW) && (Iterations < MAX_TRIES));
|
|
|
|
if (dwRetVal == NO_ERROR) {
|
|
pCurrAddresses = pAddresses;
|
|
while (pCurrAddresses) {
|
|
if ((pCurrAddresses->OperStatus == IfOperStatusUp) &&
|
|
(pCurrAddresses->FirstUnicastAddress)) {
|
|
DWORD length = 256;
|
|
WSAAddressToStringA (
|
|
pCurrAddresses->FirstUnicastAddress->Address.lpSockaddr,
|
|
pCurrAddresses->FirstUnicastAddress->Address.iSockaddrLength,
|
|
NULL,
|
|
address_buffer,
|
|
&length);
|
|
|
|
char friendly_name_buffer[256];
|
|
wcstombs (friendly_name_buffer,
|
|
pCurrAddresses->FriendlyName,
|
|
256);
|
|
result[std::string (friendly_name_buffer)] = std::string (address_buffer);
|
|
}
|
|
pCurrAddresses = pCurrAddresses->Next;
|
|
}
|
|
}
|
|
|
|
if (pAddresses)
|
|
FREE(pAddresses);
|
|
|
|
return result;
|
|
}
|
|
|
|
#endif
|
|
|
|
BTS_EXPORT std::string default_host_ip ()
|
|
{
|
|
return host_ip ("");
|
|
}
|
|
|
|
BTS_EXPORT std::map<std::string,std::string> host_ips ()
|
|
{
|
|
static std::mutex cache_lock;
|
|
static std::map<std::string,std::string> active_interfaces;
|
|
static bool first_time = true;
|
|
|
|
std::lock_guard<std::mutex> l (cache_lock);
|
|
if (!first_time)
|
|
return active_interfaces;
|
|
else
|
|
first_time = false;
|
|
|
|
#ifdef _WIN32
|
|
active_interfaces = get_windows_ips ();
|
|
#else
|
|
std::string result;
|
|
struct ifaddrs * ifAddrStruct=NULL;
|
|
struct ifaddrs * ifa=NULL;
|
|
void * tmpAddrPtr=NULL;
|
|
getifaddrs(&ifAddrStruct);
|
|
|
|
for (ifa = ifAddrStruct; ifa != NULL; ifa = ifa->ifa_next) {
|
|
if (ifa->ifa_addr != NULL && ifa->ifa_addr->sa_family==AF_INET) { // check it is IP4
|
|
// is a valid IP4 Address
|
|
tmpAddrPtr=&((struct sockaddr_in *)ifa->ifa_addr)->sin_addr;
|
|
char addressBuffer[INET_ADDRSTRLEN];
|
|
inet_ntop(AF_INET, tmpAddrPtr, addressBuffer, INET_ADDRSTRLEN);
|
|
|
|
if (ifa->ifa_flags & IFF_UP) {
|
|
std::string interface (ifa->ifa_name);
|
|
std::string address (addressBuffer);
|
|
|
|
// LOG (Info,gen) << "Interface: "
|
|
// << interface << " is active and has ip "
|
|
// << address;
|
|
active_interfaces[interface] = address;
|
|
}
|
|
}
|
|
}
|
|
if (ifAddrStruct!=NULL)
|
|
freeifaddrs(ifAddrStruct);
|
|
#endif
|
|
return active_interfaces;
|
|
}
|
|
|
|
void remove_loopback (std::map<std::string,std::string> &interfaces)
|
|
{
|
|
std::map<std::string,std::string>::iterator i ;
|
|
for (i = interfaces.begin () ; i != interfaces.end ();i++)
|
|
if (i->second == "127.0.0.1") {
|
|
interfaces.erase (i->first);
|
|
return;
|
|
}
|
|
}
|
|
|
|
BTS_EXPORT std::string host_ip (std::string const &src_interface_name)
|
|
{
|
|
static std::mutex cache_lock;
|
|
static std::map<std::string,std::string> interface_ips;
|
|
std::lock_guard<std::mutex> l (cache_lock);
|
|
|
|
std::map<std::string,std::string>::const_iterator it = interface_ips.find (src_interface_name);
|
|
if (it != interface_ips.end ())
|
|
return it->second;
|
|
|
|
auto interface_name = src_interface_name;
|
|
|
|
std::string default_interface;
|
|
std::string default_ip;
|
|
std::map<std::string,std::string> ips = host_ips ();
|
|
std::vector<std::string> interface_order;
|
|
|
|
#ifdef _WIN32
|
|
interface_order.push_back ("Local Area Connection 1");
|
|
#else
|
|
interface_order.push_back ("eth0");
|
|
interface_order.push_back ("br0");
|
|
interface_order.push_back ("wlan0");
|
|
#endif
|
|
|
|
if (interface_name.size ()) {
|
|
default_interface = interface_name;
|
|
default_ip = ips[interface_name];
|
|
}
|
|
else {
|
|
if (ips.empty ()) {
|
|
default_interface= "";
|
|
default_ip = "";
|
|
}
|
|
else if (ips.size () == 1) {
|
|
default_interface = ips.begin ()->first;
|
|
default_ip = ips.begin ()->second;
|
|
} else {
|
|
remove_loopback (ips);
|
|
if (ips.size () == 1) {
|
|
default_interface = ips.begin ()->first;
|
|
default_ip = ips.begin ()->second;
|
|
} else {
|
|
for (std::string &in : interface_order)
|
|
if (ips[in].size ()) {
|
|
default_interface = in;
|
|
default_ip = ips[in];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (default_ip.empty ()) {
|
|
|
|
if (src_interface_name.empty ()) {
|
|
std::ostringstream msg;
|
|
std::pair<std::string,std::string> p;
|
|
for (auto p : ips)
|
|
msg << p.first << " ";
|
|
// LOG (Fatal,gen) << "Cannot pick default interface. Too many options: "
|
|
// << msg.str ();
|
|
}
|
|
// else
|
|
// LOG (Fatal,gen) << "Could not find interface '" << interface_name;
|
|
bts_assert (false);
|
|
}
|
|
// else
|
|
// LOG (Info,gen) << "Selecting default interface: " << default_interface
|
|
// << " ip is " << default_ip;
|
|
|
|
interface_ips[src_interface_name] = default_ip;
|
|
return default_ip;
|
|
}
|
|
|
|
BTS_EXPORT void debug_break()
|
|
{
|
|
DEBUG_BREAK();
|
|
}
|
|
|
|
BTS_EXPORT void set_thread_name(std::string const&n)
|
|
{set_thread_name(n.c_str());}
|
|
|
|
BTS_EXPORT void set_thread_name(const char* name)
|
|
{
|
|
#ifdef _WIN32
|
|
if (!IsDebuggerPresent()) return;
|
|
|
|
const DWORD MS_VC_EXCEPTION=0x406D1388;
|
|
#pragma pack(push,8)
|
|
struct tagTHREADNAME_INFO
|
|
{
|
|
DWORD dwType; // Must be 0x1000.
|
|
LPCSTR szName; // Pointer to name (in user addr space).
|
|
DWORD dwThreadID; // Thread ID (-1=caller thread).
|
|
DWORD dwFlags; // Reserved for future use, must be zero.
|
|
} info;
|
|
#pragma pack(pop)
|
|
|
|
info.dwType = 0x1000;
|
|
info.szName = name;
|
|
info.dwThreadID = -1;
|
|
info.dwFlags = 0;
|
|
|
|
#ifdef _MSC_VER
|
|
__try
|
|
{
|
|
#endif
|
|
RaiseException(MS_VC_EXCEPTION, 0, sizeof(info)/sizeof(ULONG_PTR), (ULONG_PTR*)&info);
|
|
#ifdef _MSC_VER
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
}
|
|
#endif
|
|
#else
|
|
prctl(PR_SET_NAME, name, 0,0,0);
|
|
#endif
|
|
}
|
|
|
|
BTS_EXPORT bool is_nan(double d)
|
|
{
|
|
#ifdef _WIN32
|
|
return (::_isnan(d) != 0);
|
|
#else
|
|
return (std::isnan(d) != 0);
|
|
#endif
|
|
}
|
|
|
|
BTS_EXPORT bool is_nan(float f)
|
|
{
|
|
#ifdef _WIN32
|
|
return (::_isnan(f) != 0);
|
|
#else
|
|
return (std::isnan(f));
|
|
#endif
|
|
}
|
|
|
|
BTS_EXPORT double nan ()
|
|
{
|
|
return std::numeric_limits<double>::quiet_NaN();
|
|
}
|
|
|
|
BTS_EXPORT float fnan ()
|
|
{
|
|
return std::numeric_limits<float>::quiet_NaN();
|
|
}
|
|
|
|
BTS_EXPORT bool is_finite(double d)
|
|
{
|
|
#ifdef _WIN32
|
|
return (::_finite(d) != 0);
|
|
#else
|
|
return (::finite(d) != 0);
|
|
#endif
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Interop functions
|
|
//
|
|
namespace interop
|
|
{
|
|
|
|
extern "C" BTS_EXPORT char* bts_data_path ()
|
|
{
|
|
std::string p = os::bts_data_path ();
|
|
char * result = new char [p.size ()+1];
|
|
result[p.size ()] = '\0';
|
|
std::copy (p.begin (),p.end (),result);
|
|
return result;
|
|
}
|
|
|
|
extern "C" BTS_EXPORT void free_bts_data_path (char *dp)
|
|
{
|
|
delete [] dp;
|
|
}
|
|
|
|
}
|
|
|
|
}} // end namespaces
|