rohit/Orthanc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
ca33816a8c
Orthanc/OrthancFramework/Sources/SystemToolbox.cpp
rohit 1fe2b563f2 DICOM test1
2025-06-23 19:07:37 +05:30

1270 lines
32 KiB
C++
Raw Blame History

/**
* Orthanc - A Lightweight, RESTful DICOM Store
* Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
* Department, University Hospital of Liege, Belgium
* Copyright (C) 2017-2023 Osimis S.A., Belgium
* Copyright (C) 2024-2025 Orthanc Team SRL, Belgium
* Copyright (C) 2021-2025 Sebastien Jodogne, ICTEAM UCLouvain, Belgium
*
* This program is free software: you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation, either version 3 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program. If not, see
* <http://www.gnu.org/licenses/>.
**/
#include "PrecompiledHeaders.h"
#include "SystemToolbox.h"
#if defined(_WIN32)
# include <winsock2.h> // For GetMacAddresses(), must be included before "windows.h"
# include <windows.h>
# include <iphlpapi.h> // For GetMacAddresses()
# include <process.h> // For "_spawnvp()" and "_getpid()"
# include <stdlib.h> // For "environ"
#else
# include <net/if.h> // For GetMacAddresses()
# include <netinet/in.h> // For GetMacAddresses()
# include <sys/ioctl.h> // For GetMacAddresses()
# include <sys/wait.h> // For "waitpid()"
# include <unistd.h> // For "execvp()"
#endif
#if defined(__APPLE__) && defined(__MACH__)
# include <limits.h> // PATH_MAX
# include <mach-o/dyld.h> // _NSGetExecutablePath
#endif
#if (defined(__APPLE__) && defined(__MACH__)) || defined(__FreeBSD_kernel__) || defined(__FreeBSD__)
# include <net/if_dl.h> // For GetMacAddresses()
# include <net/if_types.h> // For GetMacAddresses()
# include <sys/sysctl.h> // For GetMacAddresses()
#endif
#if defined(__linux__) || defined(__FreeBSD_kernel__) || defined(__FreeBSD__)
# include <limits.h> // PATH_MAX
# include <signal.h>
# include <unistd.h>
#endif
#if defined(__OpenBSD__)
# include <sys/sysctl.h> // For "sysctl", "CTL_KERN" and "KERN_PROC_ARGS"
#endif
#include "Logging.h"
#include "OrthancException.h"
#include "Toolbox.h"
#include <boost/iostreams/device/file_descriptor.hpp>
#include <boost/iostreams/stream.hpp>
#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/thread.hpp>
#include <cassert>
#include <string.h>
/*=========================================================================
The section below comes from the Boost 1.68.0 project:
https://github.com/boostorg/program_options/blob/boost-1.68.0/src/parsers.cpp
Copyright Vladimir Prus 2002-2004.
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt
or copy at http://www.boost.org/LICENSE_1_0.txt)
=========================================================================*/
// The 'environ' should be declared in some cases. E.g. Linux man page says:
// (This variable must be declared in the user program, but is declared in
// the header file unistd.h in case the header files came from libc4 or libc5,
// and in case they came from glibc and _GNU_SOURCE was defined.)
// To be safe, declare it here.
// It appears that on Mac OS X the 'environ' variable is not
// available to dynamically linked libraries.
// See: http://article.gmane.org/gmane.comp.lib.boost.devel/103843
// See: http://lists.gnu.org/archive/html/bug-guile/2004-01/msg00013.html
#if defined(__APPLE__) && defined(__DYNAMIC__)
// The proper include for this is crt_externs.h, however it's not
// available on iOS. The right replacement is not known. See
// https://svn.boost.org/trac/boost/ticket/5053
extern "C"
{
extern char ***_NSGetEnviron(void);
}
# define environ (*_NSGetEnviron())
#else
# if defined(__MWERKS__)
# include <crtl.h>
# else
# if !defined(_WIN32) || defined(__COMO_VERSION__)
extern char** environ;
# endif
# endif
#endif
/*=========================================================================
End of section from the Boost 1.68.0 project
=========================================================================*/
namespace Orthanc
{
static bool finish_;
static ServerBarrierEvent barrierEvent_;
#if defined(_WIN32)
static BOOL WINAPI ConsoleControlHandler(DWORD dwCtrlType)
{
// http://msdn.microsoft.com/en-us/library/ms683242(v=vs.85).aspx
finish_ = true;
return true;
}
#else
static void SignalHandler(int signal)
{
if (signal == SIGHUP)
{
barrierEvent_ = ServerBarrierEvent_Reload;
}
finish_ = true;
}
#endif
static ServerBarrierEvent ServerBarrierInternal(const bool* stopFlag)
{
#if defined(_WIN32)
SetConsoleCtrlHandler(ConsoleControlHandler, true);
#else
signal(SIGINT, SignalHandler);
signal(SIGQUIT, SignalHandler);
signal(SIGTERM, SignalHandler);
signal(SIGHUP, SignalHandler);
#endif
// Active loop that awakens every 100ms
finish_ = false;
barrierEvent_ = ServerBarrierEvent_Stop;
while (!(*stopFlag || finish_))
{
SystemToolbox::USleep(100 * 1000);
}
#if defined(_WIN32)
SetConsoleCtrlHandler(ConsoleControlHandler, false);
#else
signal(SIGINT, NULL);
signal(SIGQUIT, NULL);
signal(SIGTERM, NULL);
signal(SIGHUP, NULL);
#endif
return barrierEvent_;
}
ServerBarrierEvent SystemToolbox::ServerBarrier(const bool& stopFlag)
{
return ServerBarrierInternal(&stopFlag);
}
ServerBarrierEvent SystemToolbox::ServerBarrier()
{
const bool stopFlag = false;
return ServerBarrierInternal(&stopFlag);
}
void SystemToolbox::USleep(uint64_t microSeconds)
{
#if defined(_WIN32)
::Sleep(static_cast<DWORD>(microSeconds / static_cast<uint64_t>(1000)));
#elif defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD_kernel__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__native_client__)
usleep(microSeconds);
#else
#error Support your platform here
#endif
}
static std::streamsize GetStreamSize(std::istream& f)
{
// http://www.cplusplus.com/reference/iostream/istream/tellg/
f.seekg(0, std::ios::end);
std::streamsize size = f.tellg();
f.seekg(0, std::ios::beg);
return size;
}
void SystemToolbox::ReadFile(std::string& content,
const std::string& path,
bool log)
{
if (!IsRegularFile(path))
{
throw OrthancException(ErrorCode_RegularFileExpected,
"The path does not point to a regular file: " + path,
log);
}
try
{
boost::filesystem::ifstream f;
f.open(path, std::ifstream::in | std::ifstream::binary);
if (!f.good())
{
throw OrthancException(ErrorCode_InexistentFile,
"File not found: " + path,
log);
}
std::streamsize size = GetStreamSize(f);
content.resize(static_cast<size_t>(size));
if (static_cast<std::streamsize>(content.size()) != size)
{
throw OrthancException(ErrorCode_InternalError,
"Reading a file that is too large for a 32bit architecture");
}
if (size != 0)
{
f.read(&content[0], size);
}
f.close();
}
catch (boost::filesystem::filesystem_error&)
{
throw OrthancException(ErrorCode_InexistentFile);
}
catch (...) // To catch "std::system_error&" in C++11
{
throw OrthancException(ErrorCode_InexistentFile);
}
}
void SystemToolbox::ReadFile(std::string &content, const std::string &path)
{
ReadFile(content, path, true /* log */);
}
bool SystemToolbox::ReadHeader(std::string& header,
const std::string& path,
size_t headerSize)
{
if (!IsRegularFile(path))
{
throw OrthancException(ErrorCode_RegularFileExpected,
"The path does not point to a regular file: " + path);
}
try
{
boost::filesystem::ifstream f;
f.open(path, std::ifstream::in | std::ifstream::binary);
if (!f.good())
{
throw OrthancException(ErrorCode_InexistentFile);
}
bool full = true;
{
std::streamsize size = GetStreamSize(f);
if (size <= 0)
{
headerSize = 0;
full = false;
}
else if (static_cast<size_t>(size) < headerSize)
{
headerSize = static_cast<size_t>(size); // Truncate to the size of the file
full = false;
}
}
header.resize(headerSize);
if (headerSize != 0)
{
f.read(&header[0], headerSize);
}
f.close();
return full;
}
catch (boost::filesystem::filesystem_error&)
{
throw OrthancException(ErrorCode_InexistentFile);
}
catch (...) // To catch "std::system_error&" in C++11
{
throw OrthancException(ErrorCode_InexistentFile);
}
}
void SystemToolbox::WriteFile(const void* content,
size_t size,
const std::string& path,
bool callFsync)
{
try
{
//boost::filesystem::ofstream f;
boost::iostreams::stream<boost::iostreams::file_descriptor_sink> f;
f.open(path, std::ofstream::out | std::ofstream::binary);
if (!f.good())
{
throw OrthancException(ErrorCode_CannotWriteFile);
}
if (size != 0)
{
f.write(reinterpret_cast<const char*>(content), size);
if (!f.good())
{
f.close();
throw OrthancException(ErrorCode_CannotWriteFile);
}
}
if (callFsync)
{
// https://stackoverflow.com/a/23826489/881731
f.flush();
bool success;
/**
* "f->handle()" corresponds to "FILE*" (aka "HANDLE") on
* Microsoft Windows, and to "int" (file descriptor) on other
* systems:
* https://github.com/boostorg/iostreams/blob/develop/include/boost/iostreams/detail/file_handle.hpp
**/
#if defined(_WIN32)
// https://docs.microsoft.com/fr-fr/windows/win32/api/fileapi/nf-fileapi-flushfilebuffers
success = (::FlushFileBuffers(f->handle()) != 0);
#elif (_POSIX_C_SOURCE >= 199309L || _XOPEN_SOURCE >= 500)
success = (::fdatasync(f->handle()) == 0);
#else
success = (::fsync(f->handle()) == 0);
#endif
if (!success)
{
throw OrthancException(ErrorCode_CannotWriteFile, "Cannot force flush to disk");
}
}
f.close();
}
catch (boost::filesystem::filesystem_error&)
{
throw OrthancException(ErrorCode_CannotWriteFile);
}
catch (...) // To catch "std::system_error&" in C++11
{
throw OrthancException(ErrorCode_CannotWriteFile);
}
}
void SystemToolbox::WriteFile(const void *content, size_t size, const std::string &path)
{
WriteFile(content, size, path, false /* don't automatically call fsync */);
}
void SystemToolbox::WriteFile(const std::string& content,
const std::string& path,
bool callFsync)
{
WriteFile(content.size() > 0 ? content.c_str() : NULL,
content.size(), path, callFsync);
}
void SystemToolbox::WriteFile(const std::string &content, const std::string &path)
{
WriteFile(content, path, false /* don't automatically call fsync */);
}
void SystemToolbox::RemoveFile(const std::string& path)
{
if (boost::filesystem::exists(path))
{
if (IsRegularFile(path))
{
boost::filesystem::remove(path);
}
else
{
throw OrthancException(ErrorCode_RegularFileExpected);
}
}
}
uint64_t SystemToolbox::GetFileSize(const std::string& path)
{
try
{
return static_cast<uint64_t>(boost::filesystem::file_size(path));
}
catch (boost::filesystem::filesystem_error&)
{
throw OrthancException(ErrorCode_InexistentFile);
}
catch (...) // To catch "std::system_error&" in C++11
{
throw OrthancException(ErrorCode_InexistentFile);
}
}
#if ORTHANC_ENABLE_MD5 == 1
void SystemToolbox::ComputeStreamMD5(std::string& result,
std::istream& inputStream)
{
Toolbox::MD5Context context;
const size_t bufferSize = 1024;
char buffer[bufferSize];
while (inputStream.good())
{
inputStream.read(buffer, bufferSize);
std::streamsize bytesRead = inputStream.gcount();
if (bytesRead > 0)
{
context.Append(buffer, bytesRead);
}
}
context.Export(result);
}
void SystemToolbox::ComputeFileMD5(std::string& result,
const std::string& path)
{
boost::filesystem::ifstream fileStream;
fileStream.open(path, std::ifstream::in | std::ifstream::binary);
if (!fileStream.good())
{
throw OrthancException(ErrorCode_InexistentFile, "File not found: " + path);
}
ComputeStreamMD5(result, fileStream);
}
bool SystemToolbox::CompareFilesMD5(const std::string& path1,
const std::string& path2)
{
if (GetFileSize(path1) != GetFileSize(path2))
{
return false;
}
else
{
std::string path1md5, path2md5;
ComputeFileMD5(path1md5, path1);
ComputeFileMD5(path2md5, path2);
return path1md5 == path2md5;
}
}
#endif
void SystemToolbox::MakeDirectory(const std::string& path)
{
if (boost::filesystem::exists(path))
{
if (!boost::filesystem::is_directory(path))
{
throw OrthancException(ErrorCode_DirectoryOverFile);
}
}
else
{
if (!boost::filesystem::create_directories(path))
{
throw OrthancException(ErrorCode_MakeDirectory);
}
}
}
bool SystemToolbox::IsExistingFile(const std::string& path)
{
return boost::filesystem::exists(path);
}
#if defined(_WIN32)
static std::string GetPathToExecutableInternal()
{
// Yes, this is ugly, but there is no simple way to get the
// required buffer size, so we use a big constant
std::vector<char> buffer(32768);
/*int bytes =*/ GetModuleFileNameA(NULL, &buffer[0], static_cast<DWORD>(buffer.size() - 1));
return std::string(&buffer[0]);
}
#elif defined(__linux__) || defined(__FreeBSD_kernel__) || defined(__FreeBSD__)
static std::string GetPathToExecutableInternal()
{
// NOTE: For FreeBSD, using KERN_PROC_PATHNAME might be a better alternative
std::vector<char> buffer(PATH_MAX + 1);
ssize_t bytes = readlink("/proc/self/exe", &buffer[0], buffer.size() - 1);
if (bytes == 0)
{
throw OrthancException(ErrorCode_PathToExecutable);
}
return std::string(&buffer[0]);
}
#elif defined(__APPLE__) && defined(__MACH__)
static std::string GetPathToExecutableInternal()
{
char pathbuf[PATH_MAX + 1];
unsigned int bufsize = static_cast<int>(sizeof(pathbuf));
_NSGetExecutablePath( pathbuf, &bufsize);
return std::string(pathbuf);
}
#elif defined(__OpenBSD__)
static std::string GetPathToExecutableInternal()
{
// This is an adapted version of the patch proposed in issue #64
// without an explicit call to "malloc()" to prevent memory leak
// https://orthanc.uclouvain.be/bugs/show_bug.cgi?id=64
// https://stackoverflow.com/q/31494901/881731
const int mib[4] = { CTL_KERN, KERN_PROC_ARGS, getpid(), KERN_PROC_ARGV };
size_t len;
if (sysctl(mib, 4, NULL, &len, NULL, 0) == -1)
{
throw OrthancException(ErrorCode_PathToExecutable);
}
std::string tmp;
tmp.resize(len);
char** buffer = reinterpret_cast<char**>(&tmp[0]);
if (sysctl(mib, 4, buffer, &len, NULL, 0) == -1)
{
throw OrthancException(ErrorCode_PathToExecutable);
}
else
{
return std::string(buffer[0]);
}
}
#else
#error Support your platform here
#endif
std::string SystemToolbox::GetPathToExecutable()
{
boost::filesystem::path p(GetPathToExecutableInternal());
return boost::filesystem::absolute(p).string();
}
std::string SystemToolbox::GetDirectoryOfExecutable()
{
boost::filesystem::path p(GetPathToExecutableInternal());
return boost::filesystem::absolute(p.parent_path()).string();
}
void SystemToolbox::ExecuteSystemCommand(const std::string& command,
const std::vector<std::string>& arguments)
{
// Convert the arguments as a C array
std::vector<char*> args(arguments.size() + 2);
args.front() = const_cast<char*>(command.c_str());
for (size_t i = 0; i < arguments.size(); i++)
{
args[i + 1] = const_cast<char*>(arguments[i].c_str());
}
args.back() = NULL;
int status;
#if defined(_WIN32)
// http://msdn.microsoft.com/en-us/library/275khfab.aspx
status = static_cast<int>(_spawnvp(_P_OVERLAY, command.c_str(), &args[0]));
#else
int pid = fork();
if (pid == -1)
{
// Error in fork()
throw OrthancException(ErrorCode_SystemCommand, "Cannot fork a child process");
}
else if (pid == 0)
{
// Execute the system command in the child process
execvp(command.c_str(), &args[0]);
// We should never get here
_exit(1);
}
else
{
// Wait for the system command to exit
waitpid(pid, &status, 0);
}
#endif
if (status != 0)
{
throw OrthancException(ErrorCode_SystemCommand,
"System command failed with status code " +
boost::lexical_cast<std::string>(status));
}
}
int SystemToolbox::GetProcessId()
{
#if defined(_WIN32)
return static_cast<int>(_getpid());
#else
return static_cast<int>(getpid());
#endif
}
bool SystemToolbox::IsRegularFile(const std::string& path)
{
try
{
if (boost::filesystem::exists(path))
{
boost::filesystem::file_status status = boost::filesystem::status(path);
return (status.type() == boost::filesystem::regular_file ||
status.type() == boost::filesystem::reparse_file); // Fix BitBucket issue #11
}
}
catch (boost::filesystem::filesystem_error&)
{
}
return false;
}
FILE* SystemToolbox::OpenFile(const std::string& path,
FileMode mode)
{
#if defined(_WIN32)
// TODO Deal with special characters by converting to the current locale
#endif
const char* m;
switch (mode)
{
case FileMode_ReadBinary:
m = "rb";
break;
case FileMode_WriteBinary:
m = "wb";
break;
default:
throw OrthancException(ErrorCode_ParameterOutOfRange);
}
return fopen(path.c_str(), m);
}
static boost::posix_time::ptime GetNow(bool utc)
{
if (utc)
{
return boost::posix_time::second_clock::universal_time();
}
else
{
return boost::posix_time::second_clock::local_time();
}
}
std::string SystemToolbox::GetNowIsoString(bool utc)
{
return boost::posix_time::to_iso_string(GetNow(utc));
}
void SystemToolbox::GetNowDicom(std::string& date,
std::string& time,
bool utc)
{
boost::posix_time::ptime now = GetNow(utc);
tm tm = boost::posix_time::to_tm(now);
char s[32];
sprintf(s, "%04d%02d%02d", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
date.assign(s);
// TODO milliseconds
sprintf(s, "%02d%02d%02d.%06d", tm.tm_hour, tm.tm_min, tm.tm_sec, 0);
time.assign(s);
}
unsigned int SystemToolbox::GetHardwareConcurrency()
{
// Get the number of available hardware threads (e.g. number of
// CPUs or cores or hyperthreading units)
unsigned int threads = boost::thread::hardware_concurrency();
if (threads == 0)
{
return 1;
}
else
{
return threads;
}
}
bool SystemToolbox::IsContentCompressible(MimeType mime)
{
switch (mime)
{
case MimeType_Css:
case MimeType_Html:
case MimeType_JavaScript:
case MimeType_Json:
case MimeType_Pam:
case MimeType_Pdf:
case MimeType_PlainText:
case MimeType_WebAssembly:
case MimeType_Xml:
case MimeType_PrometheusText:
case MimeType_DicomWebJson:
case MimeType_DicomWebXml:
return true;
default: // for all other (JPEG, DICOM, binary, ...)
return false;
}
}
bool SystemToolbox::IsContentCompressible(const std::string& contentType)
{
if (contentType.empty())
{
return false;
}
if (contentType.find(MIME_JSON) != std::string::npos ||
contentType.find(MIME_XML) != std::string::npos ||
contentType.find(MIME_DICOM_WEB_JSON) != std::string::npos ||
contentType.find(MIME_DICOM_WEB_XML) != std::string::npos ||
contentType.find(MIME_PDF) != std::string::npos ||
contentType.find(MIME_CSS) != std::string::npos ||
contentType.find(MIME_HTML) != std::string::npos ||
contentType.find(MIME_JAVASCRIPT) != std::string::npos ||
contentType.find(MIME_PLAIN_TEXT) != std::string::npos ||
contentType.find(MIME_WEB_ASSEMBLY) != std::string::npos ||
contentType.find(MIME_XML_2) != std::string::npos)
{
return true;
}
return false;
}
MimeType SystemToolbox::AutodetectMimeType(const std::string& path)
{
std::string extension = boost::filesystem::path(path).extension().string();
Toolbox::ToLowerCase(extension);
// http://en.wikipedia.org/wiki/Mime_types
// Text types
if (extension == ".txt")
{
return MimeType_PlainText;
}
else if (extension == ".html")
{
return MimeType_Html;
}
else if (extension == ".xml")
{
return MimeType_Xml;
}
else if (extension == ".css")
{
return MimeType_Css;
}
// Application types
else if (extension == ".js")
{
return MimeType_JavaScript;
}
else if (extension == ".json" ||
extension == ".nmf" /* manifest */)
{
return MimeType_Json;
}
else if (extension == ".pdf")
{
return MimeType_Pdf;
}
else if (extension == ".wasm")
{
return MimeType_WebAssembly;
}
else if (extension == ".nexe")
{
return MimeType_NaCl;
}
else if (extension == ".pexe")
{
return MimeType_PNaCl;
}
// Images types
else if (extension == ".dcm")
{
return MimeType_Dicom;
}
else if (extension == ".jpg" ||
extension == ".jpeg")
{
return MimeType_Jpeg;
}
else if (extension == ".gif")
{
return MimeType_Gif;
}
else if (extension == ".png")
{
return MimeType_Png;
}
else if (extension == ".pam")
{
return MimeType_Pam;
}
else if (extension == ".svg")
{
return MimeType_Svg;
}
// Various types
else if (extension == ".woff")
{
return MimeType_Woff;
}
else if (extension == ".woff2")
{
return MimeType_Woff2;
}
else if (extension == ".ico")
{
return MimeType_Ico;
}
else if (extension == ".gz")
{
return MimeType_Gzip;
}
else if (extension == ".zip")
{
return MimeType_Zip;
}
else if (extension == ".mtl")
{
return MimeType_Mtl;
}
else if (extension == ".obj")
{
return MimeType_Obj;
}
else if (extension == ".stl")
{
return MimeType_Stl;
}
// Default type
else
{
LOG(INFO) << "Unknown MIME type for extension \"" << extension << "\"";
return MimeType_Binary;
}
}
void SystemToolbox::GetEnvironmentVariables(std::map<std::string, std::string>& env)
{
env.clear();
for (char **p = environ; *p != NULL; p++)
{
std::string v(*p);
size_t pos = v.find('=');
if (pos != std::string::npos)
{
std::string key = v.substr(0, pos);
std::string value = v.substr(pos + 1);
env[key] = value;
}
}
}
std::string SystemToolbox::InterpretRelativePath(const std::string& baseDirectory,
const std::string& relativePath)
{
boost::filesystem::path base(baseDirectory);
boost::filesystem::path relative(relativePath);
/**
The following lines should be equivalent to this one:
return (base / relative).string();
However, for some unknown reason, some versions of Boost do not
make the proper path resolution when "baseDirectory" is an
absolute path. So, a hack is used below.
**/
if (relative.is_absolute())
{
return relative.string();
}
else
{
return (base / relative).string();
}
}
void SystemToolbox::ReadFileRange(std::string& content,
const std::string& path,
uint64_t start, // Inclusive
uint64_t end, // Exclusive
bool throwIfOverflow)
{
if (start > end)
{
throw OrthancException(ErrorCode_ParameterOutOfRange);
}
if (!IsRegularFile(path))
{
throw OrthancException(ErrorCode_RegularFileExpected,
"The path does not point to a regular file: " + path);
}
boost::filesystem::ifstream f;
f.open(path, std::ifstream::in | std::ifstream::binary);
if (!f.good())
{
throw OrthancException(ErrorCode_InexistentFile,
"File not found: " + path);
}
uint64_t fileSize = static_cast<uint64_t>(GetStreamSize(f));
if (end > fileSize)
{
if (throwIfOverflow)
{
throw OrthancException(ErrorCode_ParameterOutOfRange,
"Reading beyond the end of a file");
}
else
{
end = fileSize;
}
}
if (start <= end)
{
content.resize(static_cast<size_t>(end - start));
if (static_cast<uint64_t>(content.size()) != (end - start))
{
throw OrthancException(ErrorCode_InternalError,
"Reading a file that is too large for a 32bit architecture");
}
if (!content.empty())
{
f.seekg(start, std::ios::beg);
f.read(&content[0], static_cast<std::streamsize>(content.size()));
}
}
else
{
content.clear();
}
f.close();
}
#if defined(_WIN32)
void SystemToolbox::GetMacAddresses(std::set<std::string>& target)
{
target.clear();
// 15Ko is the recommanded size to start with
std::vector<char> buffer(15 * 1024);
for (unsigned int iteration = 0; iteration < 3; iteration++)
{
ULONG outBufLen = static_cast<ULONG>(buffer.size());
DWORD result = GetAdaptersAddresses
(AF_UNSPEC, 0, NULL,
reinterpret_cast<IP_ADAPTER_ADDRESSES*>(&buffer[0]), &outBufLen);
if (result == NO_ERROR)
{
IP_ADAPTER_ADDRESSES* current =
reinterpret_cast<IP_ADAPTER_ADDRESSES*>(&buffer[0]);
while (current != NULL)
{
if (current->PhysicalAddressLength == 6 &&
(current->PhysicalAddress[0] != 0 ||
current->PhysicalAddress[1] != 0 ||
current->PhysicalAddress[2] != 0 ||
current->PhysicalAddress[3] != 0 ||
current->PhysicalAddress[4] != 0 ||
current->PhysicalAddress[5] != 0))
{
char tmp[32];
sprintf(tmp, "%02x:%02x:%02x:%02x:%02x:%02x",
(unsigned char) current->PhysicalAddress[0],
(unsigned char) current->PhysicalAddress[1],
(unsigned char) current->PhysicalAddress[2],
(unsigned char) current->PhysicalAddress[3],
(unsigned char) current->PhysicalAddress[4],
(unsigned char) current->PhysicalAddress[5]);
target.insert(tmp);
}
current = current->Next;
}
return;
}
else if (result != ERROR_BUFFER_OVERFLOW ||
iteration >= 3 ||
outBufLen == 0)
{
return;
}
else
{
buffer.resize(outBufLen);
iteration++;
}
}
}
#else
namespace
{
class SocketRaii : public boost::noncopyable
{
private:
int socket_;
public:
SocketRaii()
{
socket_ = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
}
~SocketRaii()
{
if (socket_ != -1)
{
close(socket_);
}
}
int GetDescriptor() const
{
return socket_;
}
};
class NetworkInterfaces : public boost::noncopyable
{
private:
struct if_nameindex* list_;
struct if_nameindex* current_;
public:
NetworkInterfaces()
{
list_ = if_nameindex();
current_ = list_;
}
~NetworkInterfaces()
{
if (list_ != NULL)
{
if_freenameindex(list_);
}
}
bool IsDone() const
{
return (current_ == NULL ||
(current_->if_index == 0 &&
current_->if_name == NULL));
}
const char* GetCurrentName() const
{
assert(!IsDone());
return current_->if_name;
}
unsigned int GetCurrentIndex() const
{
assert(!IsDone());
return current_->if_index;
}
void Next()
{
assert(!IsDone());
current_++;
}
};
}
void SystemToolbox::GetMacAddresses(std::set<std::string>& target)
{
target.clear();
SocketRaii socket;
if (socket.GetDescriptor() != 1)
{
NetworkInterfaces interfaces;
while (!interfaces.IsDone())
{
#if (defined(__APPLE__) && defined(__MACH__)) || defined(__FreeBSD_kernel__) || defined(__FreeBSD__)
int mib[6];
mib[0] = CTL_NET;
mib[1] = AF_ROUTE;
mib[2] = 0;
mib[3] = AF_LINK;
mib[4] = NET_RT_IFLIST;
mib[5] = interfaces.GetCurrentIndex();
size_t len;
if (sysctl(mib, 6, NULL, &len, NULL, 0) == 0 &&
len > 0)
{
std::string tmp;
tmp.resize(len);
if (sysctl(mib, 6, &tmp[0], &len, NULL, 0) == 0)
{
struct if_msghdr* ifm = reinterpret_cast<struct if_msghdr*>(&tmp[0]);
struct sockaddr_dl* sdl = reinterpret_cast<struct sockaddr_dl*>(ifm + 1);
if (sdl->sdl_type == IFT_ETHER) // Only consider Ethernet interfaces
{
const unsigned char* mac = reinterpret_cast<const unsigned char*>(LLADDR(sdl));
char tmp[32];
sprintf(tmp, "%02x:%02x:%02x:%02x:%02x:%02x",
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
target.insert(tmp);
}
}
}
#else
struct ifreq ifr;
strcpy(ifr.ifr_name, interfaces.GetCurrentName());
if (ioctl(socket.GetDescriptor(), SIOCGIFFLAGS, &ifr) == 0 &&
!(ifr.ifr_flags & IFF_LOOPBACK) && // ignore loopback interface
ioctl(socket.GetDescriptor(), SIOCGIFHWADDR, &ifr) == 0)
{
const unsigned char* mac = reinterpret_cast<const unsigned char*>(ifr.ifr_hwaddr.sa_data);
char tmp[32];
sprintf(tmp, "%02x:%02x:%02x:%02x:%02x:%02x",
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
target.insert(tmp);
}
#endif
interfaces.Next();
}
}
}
#endif
}
Reference in New Issue View Git Blame Copy Permalink