299 lines
7.8 KiB
C++
299 lines
7.8 KiB
C++
#ifndef GERMANAIRLINESVA_GACONNECTOR_UTIL_H
|
|
#define GERMANAIRLINESVA_GACONNECTOR_UTIL_H
|
|
|
|
#ifdef IBM
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#endif
|
|
|
|
#define BUFSIZE 1024
|
|
#define MD5LEN 16
|
|
#define EARTH_M 6371000
|
|
|
|
#ifdef IBM
|
|
// clang-format off
|
|
#include <wtypes.h>
|
|
#include <wincrypt.h>
|
|
// clang-format on
|
|
#endif
|
|
#ifdef APL
|
|
#include <CommonCrypto/CommonDigest.h>
|
|
#include <sys/mman.h>
|
|
#endif
|
|
#ifdef LIN
|
|
#include <openssl/md5.h>
|
|
#include <sys/mman.h>
|
|
#endif
|
|
|
|
#if defined APL || defined LIN
|
|
#include <fcntl.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#include <cmath>
|
|
#include <functional>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
namespace util
|
|
{
|
|
static inline double to_feet(double value) { return value * 3.280839895; }
|
|
|
|
static inline double to_degrees(double value) { return value * 180 / M_PI; }
|
|
|
|
static inline double to_radians(double value) { return value * M_PI / 180; }
|
|
|
|
static inline double normalize(double value)
|
|
{
|
|
return fmod(value + 360, 360);
|
|
}
|
|
|
|
static inline double bearing(double fromLatitude,
|
|
double fromLongitude,
|
|
double toLatitude,
|
|
double toLongitude)
|
|
{
|
|
double y = sin(to_radians(toLongitude) - to_radians(fromLongitude)) *
|
|
cos(to_radians(toLatitude));
|
|
double x = cos(to_radians(fromLatitude)) * sin(to_radians(toLatitude)) -
|
|
sin(to_radians(fromLatitude)) * cos(to_radians(toLatitude)) *
|
|
cos(to_radians(toLongitude) - to_radians(fromLongitude));
|
|
|
|
return normalize(to_degrees(atan2(y, x)));
|
|
}
|
|
|
|
static inline double distanceEarth(double fromLatitude,
|
|
double fromLongitude,
|
|
double toLatitude,
|
|
double toLongitude)
|
|
{
|
|
double lat1r, lon1r, lat2r, lon2r, u, v;
|
|
lat1r = to_radians(fromLatitude);
|
|
lon1r = to_radians(fromLongitude);
|
|
lat2r = to_radians(toLatitude);
|
|
lon2r = to_radians(toLongitude);
|
|
u = sin((lat2r - lat1r) / 2);
|
|
v = sin((lon2r - lon1r) / 2);
|
|
return 2.0 * EARTH_M * asin(sqrt(u * u + cos(lat1r) * cos(lat2r) * v * v));
|
|
}
|
|
|
|
template <typename T>
|
|
static inline std::vector<T>
|
|
select_T(const std::vector<T> &inVec,
|
|
std::function<bool(const T &)> predicate)
|
|
{
|
|
std::vector<T> result;
|
|
copy_if(inVec.begin(), inVec.end(), back_inserter(result), predicate);
|
|
return result;
|
|
}
|
|
|
|
#if defined APL || defined LIN
|
|
static unsigned long get_size_by_fd(int fd)
|
|
{
|
|
struct stat buf {
|
|
};
|
|
if (fstat(fd, &buf) < 0)
|
|
return 0;
|
|
return buf.st_size;
|
|
}
|
|
#endif
|
|
|
|
static void to_hex(const char *hash, char *buffer)
|
|
{
|
|
for (int i = 0; i < MD5LEN; i++) {
|
|
if (buffer != nullptr) {
|
|
sprintf(&buffer[2 * i], "%02x", hash[i] & 0xff);
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef IBM
|
|
static inline int
|
|
generateMD5(const char *filepath,
|
|
char *lastHash,
|
|
const std::function<void(const std::string)> toLog)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
HCRYPTPROV hProv = 0;
|
|
HCRYPTHASH hHash = 0;
|
|
HANDLE hFile;
|
|
BYTE rgbFile[BUFSIZE] = {0};
|
|
DWORD cbRead = 0;
|
|
BYTE rgbHash[MD5LEN] = {0};
|
|
DWORD cbHash = 0;
|
|
|
|
// Logic to check usage goes here.
|
|
hFile = CreateFile(filepath,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ,
|
|
nullptr,
|
|
OPEN_EXISTING,
|
|
FILE_FLAG_SEQUENTIAL_SCAN,
|
|
nullptr);
|
|
|
|
// Get handle to the crypto provider
|
|
if (!CryptAcquireContext(&hProv,
|
|
nullptr,
|
|
nullptr,
|
|
PROV_RSA_FULL,
|
|
CRYPT_VERIFYCONTEXT)) {
|
|
std::stringstream debug_msg;
|
|
debug_msg << "CryptAcquireContext returned with error " << GetLastError();
|
|
toLog(debug_msg.str());
|
|
|
|
CloseHandle(hFile);
|
|
return 1;
|
|
}
|
|
|
|
if (!CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash)) {
|
|
std::stringstream debug_msg;
|
|
debug_msg << "CryptCreateHash returned with error " << GetLastError();
|
|
toLog(debug_msg.str());
|
|
|
|
CloseHandle(hFile);
|
|
CryptReleaseContext(hProv, 0);
|
|
return 1;
|
|
}
|
|
|
|
while ((bResult = ReadFile(hFile, rgbFile, BUFSIZE, &cbRead, nullptr))) {
|
|
if (0 == cbRead) {
|
|
break;
|
|
}
|
|
|
|
if (!CryptHashData(hHash, rgbFile, cbRead, 0)) {
|
|
std::stringstream debug_msg;
|
|
debug_msg << "CryptHashData returned with error " << GetLastError();
|
|
toLog(debug_msg.str());
|
|
|
|
CryptReleaseContext(hProv, 0);
|
|
CryptDestroyHash(hHash);
|
|
CloseHandle(hFile);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if (!bResult) {
|
|
std::stringstream debug_msg;
|
|
debug_msg << "ReadFile returned with error " << GetLastError();
|
|
toLog(debug_msg.str());
|
|
|
|
CryptReleaseContext(hProv, 0);
|
|
CryptDestroyHash(hHash);
|
|
CloseHandle(hFile);
|
|
return 1;
|
|
}
|
|
|
|
cbHash = MD5LEN;
|
|
if (CryptGetHashParam(hHash, HP_HASHVAL, rgbHash, &cbHash, 0)) {
|
|
to_hex((char *)rgbHash, lastHash);
|
|
} else {
|
|
std::stringstream debug_msg;
|
|
debug_msg << "CryptGetHashParam returned with error " << GetLastError();
|
|
toLog(debug_msg.str());
|
|
}
|
|
|
|
CryptDestroyHash(hHash);
|
|
CryptReleaseContext(hProv, 0);
|
|
CloseHandle(hFile);
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
#ifdef APL
|
|
#pragma clang diagnostic push
|
|
#pragma clang diagnostic ignored "-Wunused-parameter"
|
|
static inline int
|
|
generateMD5(const char *filepath,
|
|
char *lastHash,
|
|
const std::function<void(const std::string)> &toLog)
|
|
{
|
|
int file_descript;
|
|
unsigned long file_size;
|
|
char *file_buffer;
|
|
unsigned char result[MD5LEN];
|
|
|
|
file_descript = open(filepath, O_RDONLY);
|
|
if (file_descript < 0)
|
|
return 1;
|
|
|
|
file_size = get_size_by_fd(file_descript);
|
|
|
|
file_buffer =
|
|
(char *)mmap(0, file_size, PROT_READ, MAP_SHARED, file_descript, 0);
|
|
|
|
CC_MD5_CTX context;
|
|
CC_MD5_Init(&context);
|
|
CC_MD5_Update(&context, file_buffer, (CC_LONG)file_size);
|
|
CC_MD5_Final(result, &context);
|
|
|
|
munmap(file_buffer, file_size);
|
|
close(file_descript);
|
|
|
|
to_hex((char *)result, lastHash);
|
|
return 0;
|
|
}
|
|
#pragma clang diagnostic pop
|
|
#endif
|
|
#ifdef LIN
|
|
#pragma clang diagnostic push
|
|
#pragma clang diagnostic ignored "-Wunused-parameter"
|
|
static inline int
|
|
generateMD5(const char *filepath,
|
|
char *buffer,
|
|
const std::function<void(const std::string)> &toLog)
|
|
{
|
|
int file_descriptor;
|
|
unsigned long file_size;
|
|
char *file_buffer;
|
|
unsigned char result[MD5LEN];
|
|
|
|
file_descriptor = open(filepath, O_RDONLY);
|
|
if (file_descriptor < 0)
|
|
return 1;
|
|
|
|
file_size = get_size_by_fd(file_descriptor);
|
|
if (file_size == 0)
|
|
return 1;
|
|
|
|
file_buffer = (char *)
|
|
mmap(nullptr, file_size, PROT_READ, MAP_SHARED, file_descriptor, 0);
|
|
|
|
MD5((unsigned char *)file_buffer, file_size, result);
|
|
|
|
munmap(file_buffer, file_size);
|
|
close(file_descriptor);
|
|
|
|
to_hex((char *)result, buffer);
|
|
return 0;
|
|
}
|
|
#pragma clang diagnostic pop
|
|
#endif
|
|
#pragma clang diagnostic push
|
|
#pragma clang diagnostic ignored "-Wunused-parameter"
|
|
static inline void setThreadName(const std::string &name)
|
|
{
|
|
#ifdef APL
|
|
//
|
|
// Apple reserves 16 bytes for its thread names
|
|
// Notice that the Apple version of pthread_setname_np
|
|
// does not take a pthread_t argument
|
|
//
|
|
pthread_setname_np(name.substr(0, 63).c_str());
|
|
#endif
|
|
#ifdef LIN
|
|
//
|
|
// Linux only reserves 16 bytes for its thread names
|
|
// See prctl and PR_SET_NAME property in
|
|
// http://man7.org/linux/man-pages/man2/prctl.2.html
|
|
//
|
|
pthread_setname_np(pthread_self(), name.substr(0, 15).c_str());
|
|
#endif
|
|
}
|
|
#pragma clang diagnostic pop
|
|
|
|
} // namespace util
|
|
|
|
#endif
|