mirror of
https://github.com/Telecominfraproject/wlan-cloud-ucentralgw.git
synced 2025-11-02 19:57:49 +00:00
599 lines
16 KiB
C++
599 lines
16 KiB
C++
//
|
|
// Created by stephane bourque on 2022-10-25.
|
|
//
|
|
|
|
#include "Poco/Path.h"
|
|
|
|
#include "framework/AppServiceRegistry.h"
|
|
#include "framework/utils.h"
|
|
|
|
namespace OpenWifi::Utils {
|
|
|
|
bool NormalizeMac(std::string &Mac) {
|
|
Poco::replaceInPlace(Mac, ":", "");
|
|
Poco::replaceInPlace(Mac, "-", "");
|
|
if (Mac.size() != 12)
|
|
return false;
|
|
for (const auto &i : Mac) {
|
|
if (!std::isxdigit(i))
|
|
return false;
|
|
}
|
|
Poco::toLowerInPlace(Mac);
|
|
return true;
|
|
}
|
|
|
|
[[nodiscard]] bool ValidSerialNumber(const std::string &Serial) {
|
|
return ((Serial.size() < uCentralProtocol::SERIAL_NUMBER_LENGTH) &&
|
|
std::all_of(Serial.begin(), Serial.end(), [](auto i) { return std::isxdigit(i); }));
|
|
}
|
|
|
|
[[nodiscard]] bool ValidUUID(const std::string &UUID) {
|
|
if (UUID.size() > 36)
|
|
return false;
|
|
uint dashes = 0;
|
|
return (std::all_of(UUID.begin(), UUID.end(),
|
|
[&](auto i) {
|
|
if (i == '-')
|
|
dashes++;
|
|
return i == '-' || std::isxdigit(i);
|
|
})) &&
|
|
(dashes > 0);
|
|
}
|
|
|
|
[[nodiscard]] std::vector<std::string> Split(const std::string &List, char Delimiter) {
|
|
std::vector<std::string> ReturnList;
|
|
|
|
unsigned long P = 0;
|
|
|
|
while (P < List.size()) {
|
|
unsigned long P2 = List.find_first_of(Delimiter, P);
|
|
if (P2 == std::string::npos) {
|
|
ReturnList.push_back(List.substr(P));
|
|
break;
|
|
} else
|
|
ReturnList.push_back(List.substr(P, P2 - P));
|
|
P = P2 + 1;
|
|
}
|
|
return ReturnList;
|
|
}
|
|
|
|
[[nodiscard]] std::string FormatIPv6(const std::string &I) {
|
|
if (I.substr(0, 8) == "[::ffff:") {
|
|
unsigned long PClosingBracket = I.find_first_of(']');
|
|
|
|
std::string ip = I.substr(8, PClosingBracket - 8);
|
|
std::string port = I.substr(PClosingBracket + 1);
|
|
return ip + port;
|
|
}
|
|
|
|
return I;
|
|
}
|
|
|
|
void padTo(std::string &str, size_t num, char paddingChar) {
|
|
str.append(num - str.length() % num, paddingChar);
|
|
}
|
|
|
|
[[nodiscard]] std::string SerialToMAC(const std::string &Serial) {
|
|
std::string R = Serial;
|
|
|
|
if (R.size() < 12)
|
|
padTo(R, 12, '0');
|
|
else if (R.size() > 12)
|
|
R = R.substr(0, 12);
|
|
|
|
char buf[18];
|
|
|
|
buf[0] = R[0];
|
|
buf[1] = R[1];
|
|
buf[2] = ':';
|
|
buf[3] = R[2];
|
|
buf[4] = R[3];
|
|
buf[5] = ':';
|
|
buf[6] = R[4];
|
|
buf[7] = R[5];
|
|
buf[8] = ':';
|
|
buf[9] = R[6];
|
|
buf[10] = R[7];
|
|
buf[11] = ':';
|
|
buf[12] = R[8];
|
|
buf[13] = R[9];
|
|
buf[14] = ':';
|
|
buf[15] = R[10];
|
|
buf[16] = R[11];
|
|
buf[17] = 0;
|
|
|
|
return buf;
|
|
}
|
|
|
|
uint64_t MACToInt(const std::string &MAC) {
|
|
uint64_t Result = 0;
|
|
for (const auto &c : MAC) {
|
|
if (c == ':')
|
|
continue;
|
|
Result <<= 4;
|
|
if (c >= '0' && c <= '9') {
|
|
Result += (c - '0');
|
|
} else if (c >= 'a' && c <= 'f') {
|
|
Result += (c - 'a' + 10);
|
|
} else if (c >= 'A' && c <= 'F') {
|
|
Result += (c - 'A' + 10);
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
|
|
[[nodiscard]] bool ValidHostname(const std::string &Hostname) {
|
|
static std::regex HostNameRegex(
|
|
"^(?!-)[A-Za-z0-9-]+([\\-\\.]{1}[a-z0-9]+)*\\.[A-Za-z]{2,6}$");
|
|
return std::regex_match(Hostname, HostNameRegex);
|
|
}
|
|
|
|
[[nodiscard]] std::string ToHex(const std::vector<unsigned char> &B) {
|
|
std::string R;
|
|
R.reserve(B.size() * 2);
|
|
|
|
static const char hex[] = "0123456789abcdef";
|
|
|
|
for (const auto &i : B) {
|
|
R += (hex[(i & 0xf0) >> 4]);
|
|
R += (hex[(i & 0x0f)]);
|
|
}
|
|
|
|
return R;
|
|
}
|
|
|
|
inline static const char kEncodeLookup[] =
|
|
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
inline static const char kPadCharacter = '=';
|
|
|
|
using byte = std::uint8_t;
|
|
|
|
[[nodiscard]] std::string base64encode(const byte *input, uint32_t size) {
|
|
std::string encoded;
|
|
encoded.reserve(((size / 3) + (size % 3 > 0)) * 4);
|
|
|
|
std::uint32_t temp, i, ee;
|
|
ee = (size / 3);
|
|
|
|
for (i = 0; i < 3 * ee; ++i) {
|
|
temp = input[i++] << 16;
|
|
temp += input[i++] << 8;
|
|
temp += input[i];
|
|
encoded.append(1, kEncodeLookup[(temp & 0x00FC0000) >> 18]);
|
|
encoded.append(1, kEncodeLookup[(temp & 0x0003F000) >> 12]);
|
|
encoded.append(1, kEncodeLookup[(temp & 0x00000FC0) >> 6]);
|
|
encoded.append(1, kEncodeLookup[(temp & 0x0000003F)]);
|
|
}
|
|
|
|
switch (size % 3) {
|
|
case 1:
|
|
temp = input[i] << 16;
|
|
encoded.append(1, kEncodeLookup[(temp & 0x00FC0000) >> 18]);
|
|
encoded.append(1, kEncodeLookup[(temp & 0x0003F000) >> 12]);
|
|
encoded.append(2, kPadCharacter);
|
|
break;
|
|
case 2:
|
|
temp = input[i++] << 16;
|
|
temp += input[i] << 8;
|
|
encoded.append(1, kEncodeLookup[(temp & 0x00FC0000) >> 18]);
|
|
encoded.append(1, kEncodeLookup[(temp & 0x0003F000) >> 12]);
|
|
encoded.append(1, kEncodeLookup[(temp & 0x00000FC0) >> 6]);
|
|
encoded.append(1, kPadCharacter);
|
|
break;
|
|
}
|
|
|
|
return encoded;
|
|
}
|
|
|
|
[[nodiscard]] std::vector<byte> base64decode(const std::string &input) {
|
|
if (input.length() % 4)
|
|
throw std::runtime_error("Invalid base64 length!");
|
|
|
|
std::size_t padding = 0;
|
|
|
|
if (input.length()) {
|
|
if (input[input.length() - 1] == kPadCharacter)
|
|
padding++;
|
|
if (input[input.length() - 2] == kPadCharacter)
|
|
padding++;
|
|
}
|
|
|
|
std::vector<byte> decoded;
|
|
decoded.reserve(((input.length() / 4) * 3) - padding);
|
|
|
|
std::uint32_t temp = 0;
|
|
auto it = input.begin();
|
|
|
|
while (it < input.end()) {
|
|
for (std::size_t i = 0; i < 4; ++i) {
|
|
temp <<= 6;
|
|
if (*it >= 0x41 && *it <= 0x5A)
|
|
temp |= *it - 0x41;
|
|
else if (*it >= 0x61 && *it <= 0x7A)
|
|
temp |= *it - 0x47;
|
|
else if (*it >= 0x30 && *it <= 0x39)
|
|
temp |= *it + 0x04;
|
|
else if (*it == 0x2B)
|
|
temp |= 0x3E;
|
|
else if (*it == 0x2F)
|
|
temp |= 0x3F;
|
|
else if (*it == kPadCharacter) {
|
|
switch (input.end() - it) {
|
|
case 1:
|
|
decoded.push_back((temp >> 16) & 0x000000FF);
|
|
decoded.push_back((temp >> 8) & 0x000000FF);
|
|
return decoded;
|
|
case 2:
|
|
decoded.push_back((temp >> 10) & 0x000000FF);
|
|
return decoded;
|
|
default:
|
|
throw std::runtime_error("Invalid padding in base64!");
|
|
}
|
|
} else
|
|
throw std::runtime_error("Invalid character in base64!");
|
|
|
|
++it;
|
|
}
|
|
|
|
decoded.push_back((temp >> 16) & 0x000000FF);
|
|
decoded.push_back((temp >> 8) & 0x000000FF);
|
|
decoded.push_back((temp)&0x000000FF);
|
|
}
|
|
|
|
return decoded;
|
|
}
|
|
|
|
bool ParseTime(const std::string &Time, int &Hours, int &Minutes, int &Seconds) {
|
|
Poco::StringTokenizer TimeTokens(Time, ":", Poco::StringTokenizer::TOK_TRIM);
|
|
|
|
Hours = Minutes = Seconds = 0;
|
|
if (TimeTokens.count() == 1) {
|
|
Hours = std::atoi(TimeTokens[0].c_str());
|
|
} else if (TimeTokens.count() == 2) {
|
|
Hours = std::atoi(TimeTokens[0].c_str());
|
|
Minutes = std::atoi(TimeTokens[1].c_str());
|
|
} else if (TimeTokens.count() == 3) {
|
|
Hours = std::atoi(TimeTokens[0].c_str());
|
|
Minutes = std::atoi(TimeTokens[1].c_str());
|
|
Seconds = std::atoi(TimeTokens[2].c_str());
|
|
} else
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool ParseDate(const std::string &Time, int &Year, int &Month, int &Day) {
|
|
Poco::StringTokenizer DateTokens(Time, "-", Poco::StringTokenizer::TOK_TRIM);
|
|
|
|
Year = Month = Day = 0;
|
|
if (DateTokens.count() == 3) {
|
|
Year = std::atoi(DateTokens[0].c_str());
|
|
Month = std::atoi(DateTokens[1].c_str());
|
|
Day = std::atoi(DateTokens[2].c_str());
|
|
} else
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool CompareTime(int H1, int H2, int M1, int M2, int S1, int S2) {
|
|
if (H1 < H2)
|
|
return true;
|
|
if (H1 > H2)
|
|
return false;
|
|
if (M1 < M2)
|
|
return true;
|
|
if (M2 > M1)
|
|
return false;
|
|
if (S1 <= S2)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
[[nodiscard]] std::string LogLevelToString(int Level) {
|
|
switch (Level) {
|
|
case Poco::Message::PRIO_DEBUG:
|
|
return "debug";
|
|
case Poco::Message::PRIO_INFORMATION:
|
|
return "information";
|
|
case Poco::Message::PRIO_FATAL:
|
|
return "fatal";
|
|
case Poco::Message::PRIO_WARNING:
|
|
return "warning";
|
|
case Poco::Message::PRIO_NOTICE:
|
|
return "notice";
|
|
case Poco::Message::PRIO_CRITICAL:
|
|
return "critical";
|
|
case Poco::Message::PRIO_ERROR:
|
|
return "error";
|
|
case Poco::Message::PRIO_TRACE:
|
|
return "trace";
|
|
default:
|
|
return "none";
|
|
}
|
|
}
|
|
|
|
[[nodiscard]] uint64_t SerialNumberToInt(const std::string &S) {
|
|
return std::stoull(S, nullptr, 16);
|
|
}
|
|
|
|
[[nodiscard]] std::string IntToSerialNumber(uint64_t S) {
|
|
char b[16];
|
|
for (int i = 0; i < 12; ++i) {
|
|
int B = (S & 0x0f);
|
|
if (B < 10)
|
|
b[11 - i] = B + '0';
|
|
else
|
|
b[11 - i] = B - 10 + 'a';
|
|
S >>= 4;
|
|
}
|
|
b[12] = 0;
|
|
return b;
|
|
}
|
|
|
|
[[nodiscard]] bool SerialNumberMatch(const std::string &S1, const std::string &S2, int Bits) {
|
|
auto S1_i = SerialNumberToInt(S1);
|
|
auto S2_i = SerialNumberToInt(S2);
|
|
return ((S1_i >> Bits) == (S2_i >> Bits));
|
|
}
|
|
|
|
[[nodiscard]] uint64_t SerialNumberToOUI(const std::string &S) {
|
|
uint64_t Result = 0;
|
|
int Digits = 0;
|
|
|
|
for (const auto &i : S) {
|
|
if (std::isxdigit(i)) {
|
|
if (i >= '0' && i <= '9') {
|
|
Result <<= 4;
|
|
Result += i - '0';
|
|
} else if (i >= 'A' && i <= 'F') {
|
|
Result <<= 4;
|
|
Result += i - 'A' + 10;
|
|
} else if (i >= 'a' && i <= 'f') {
|
|
Result <<= 4;
|
|
Result += i - 'a' + 10;
|
|
}
|
|
Digits++;
|
|
if (Digits == 6)
|
|
break;
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
|
|
[[nodiscard]] uint64_t GetDefaultMacAsInt64() {
|
|
uint64_t Result = 0;
|
|
auto IFaceList = Poco::Net::NetworkInterface::list();
|
|
|
|
for (const auto &iface : IFaceList) {
|
|
if (iface.isRunning() && !iface.isLoopback()) {
|
|
auto MAC = iface.macAddress();
|
|
for (auto const &i : MAC) {
|
|
Result <<= 8;
|
|
Result += (uint8_t)i;
|
|
}
|
|
if (Result != 0)
|
|
break;
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
|
|
[[nodiscard]] uint64_t InitializeSystemId() {
|
|
std::random_device RDev;
|
|
std::srand(RDev());
|
|
std::chrono::high_resolution_clock Clock;
|
|
auto Now = Clock.now().time_since_epoch().count();
|
|
auto S = (GetDefaultMacAsInt64() + std::rand() + Now);
|
|
OpenWifi::AppServiceRegistry().Set("systemid", S);
|
|
return S;
|
|
}
|
|
|
|
[[nodiscard]] uint64_t GetSystemId() {
|
|
uint64_t ID = 0;
|
|
if (!AppServiceRegistry().Get("systemid", ID)) {
|
|
return InitializeSystemId();
|
|
}
|
|
return ID;
|
|
}
|
|
|
|
[[nodiscard]] bool ValidEMailAddress(const std::string &email) {
|
|
// define a regular expression
|
|
static const std::regex pattern(
|
|
"[_a-z0-9-]+(\\.[_a-z0-9-]+)*(\\+[a-z0-9-]+)?@[a-z0-9-]+(\\.[a-z0-9-]+)*");
|
|
// try to match the string with the regular expression
|
|
return std::regex_match(email, pattern);
|
|
}
|
|
|
|
[[nodiscard]] std::string LoadFile(const Poco::File &F) {
|
|
std::string Result;
|
|
try {
|
|
std::ostringstream OS;
|
|
std::ifstream IF(F.path());
|
|
Poco::StreamCopier::copyStream(IF, OS);
|
|
Result = OS.str();
|
|
} catch (...) {
|
|
}
|
|
return Result;
|
|
}
|
|
|
|
void ReplaceVariables(std::string &Content, const Types::StringPairVec &P) {
|
|
for (const auto &[Variable, Value] : P) {
|
|
Poco::replaceInPlace(Content, "${" + Variable + "}", Value);
|
|
}
|
|
}
|
|
|
|
[[nodiscard]] MediaTypeEncoding FindMediaType(const Poco::File &F) {
|
|
const auto E = Poco::Path(F.path()).getExtension();
|
|
if (E == "png")
|
|
return MediaTypeEncoding{.Encoding = BINARY, .ContentType = "image/png"};
|
|
if (E == "gif")
|
|
return MediaTypeEncoding{.Encoding = BINARY, .ContentType = "image/gif"};
|
|
if (E == "jpeg" || E == "jpg")
|
|
return MediaTypeEncoding{.Encoding = BINARY, .ContentType = "image/jpeg"};
|
|
if (E == "svg" || E == "svgz")
|
|
return MediaTypeEncoding{.Encoding = PLAIN, .ContentType = "image/svg+xml"};
|
|
if (E == "html")
|
|
return MediaTypeEncoding{.Encoding = PLAIN, .ContentType = "text/html"};
|
|
if (E == "css")
|
|
return MediaTypeEncoding{.Encoding = PLAIN, .ContentType = "text/css"};
|
|
if (E == "js")
|
|
return MediaTypeEncoding{.Encoding = PLAIN, .ContentType = "application/javascript"};
|
|
if (E == "pcap")
|
|
return MediaTypeEncoding{.Encoding = BINARY, .ContentType = "application/vnd.tcpdump.pcap"};
|
|
if (E == "txt")
|
|
return MediaTypeEncoding{.Encoding = PLAIN, .ContentType = "text/plain"};
|
|
if (E == "tgz")
|
|
return MediaTypeEncoding{.Encoding = BINARY, .ContentType = "application/tar+gzip"};
|
|
if (E == "gz" || E=="gzip")
|
|
return MediaTypeEncoding{.Encoding = BINARY, .ContentType = "application/gzip"};
|
|
|
|
return MediaTypeEncoding{.Encoding = BINARY, .ContentType = "application/octet-stream"};
|
|
}
|
|
|
|
[[nodiscard]] std::string BinaryFileToHexString(const Poco::File &F) {
|
|
static const char hex[] = "0123456789abcdef";
|
|
std::string Result;
|
|
try {
|
|
std::ifstream IF(F.path());
|
|
|
|
int Count = 0;
|
|
while (IF.good()) {
|
|
if (Count)
|
|
Result += ", ";
|
|
if ((Count % 32) == 0)
|
|
Result += "\r\n";
|
|
Count++;
|
|
unsigned char C = IF.get();
|
|
Result += "0x";
|
|
Result += (char)(hex[(C & 0xf0) >> 4]);
|
|
Result += (char)(hex[(C & 0x0f)]);
|
|
}
|
|
} catch (...) {
|
|
}
|
|
return Result;
|
|
}
|
|
|
|
[[nodiscard]] std::string SecondsToNiceText(uint64_t Seconds) {
|
|
std::string Result;
|
|
int Days = Seconds / (24 * 60 * 60);
|
|
Seconds -= Days * (24 * 60 * 60);
|
|
int Hours = Seconds / (60 * 60);
|
|
Seconds -= Hours * (60 * 60);
|
|
int Minutes = Seconds / 60;
|
|
Seconds -= Minutes * 60;
|
|
Result = std::to_string(Days) + " days, " + std::to_string(Hours) + ":" +
|
|
std::to_string(Minutes) + ":" + std::to_string(Seconds);
|
|
return Result;
|
|
}
|
|
|
|
[[nodiscard]] bool wgets(const std::string &URL, std::string &Response) {
|
|
try {
|
|
Poco::URI uri(URL);
|
|
Poco::Net::HTTPSClientSession session(uri.getHost(), uri.getPort());
|
|
|
|
// prepare path
|
|
std::string path(uri.getPathAndQuery());
|
|
if (path.empty()) {
|
|
path = "/";
|
|
}
|
|
|
|
// send request
|
|
Poco::Net::HTTPRequest req(Poco::Net::HTTPRequest::HTTP_GET, path,
|
|
Poco::Net::HTTPMessage::HTTP_1_1);
|
|
session.sendRequest(req);
|
|
|
|
Poco::Net::HTTPResponse res;
|
|
std::istream &is = session.receiveResponse(res);
|
|
std::ostringstream os;
|
|
|
|
Poco::StreamCopier::copyStream(is, os);
|
|
Response = os.str();
|
|
|
|
return true;
|
|
} catch (...) {
|
|
}
|
|
return false;
|
|
}
|
|
|
|
[[nodiscard]] bool wgetfile(const Poco::URI &uri, const std::string &FileName) {
|
|
try {
|
|
Poco::Net::HTTPSClientSession session(uri.getHost(), uri.getPort());
|
|
|
|
// send request
|
|
Poco::Net::HTTPRequest req(Poco::Net::HTTPRequest::HTTP_GET, uri.getPath(),
|
|
Poco::Net::HTTPMessage::HTTP_1_1);
|
|
session.sendRequest(req);
|
|
|
|
Poco::Net::HTTPResponse res;
|
|
std::istream &is = session.receiveResponse(res);
|
|
std::fstream os(FileName,
|
|
std::ios_base::trunc | std::ios_base::binary | std::ios_base::out);
|
|
Poco::StreamCopier::copyStream(is, os);
|
|
return true;
|
|
} catch (...) {
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool ExtractBase64CompressedData(const std::string &CompressedData,
|
|
std::string &UnCompressedData, uint64_t compress_sz) {
|
|
std::istringstream ifs(CompressedData);
|
|
Poco::Base64Decoder b64in(ifs);
|
|
std::ostringstream ofs;
|
|
Poco::StreamCopier::copyStream(b64in, ofs);
|
|
|
|
int factor = 20;
|
|
unsigned long MaxSize = compress_sz ? (unsigned long)(compress_sz + 5000)
|
|
: (unsigned long)(ofs.str().size() * factor);
|
|
while (true) {
|
|
std::vector<uint8_t> UncompressedBuffer(MaxSize);
|
|
unsigned long FinalSize = MaxSize;
|
|
auto status = uncompress((uint8_t *)&UncompressedBuffer[0], &FinalSize,
|
|
(uint8_t *)ofs.str().c_str(), ofs.str().size());
|
|
if (status == Z_OK) {
|
|
UncompressedBuffer[FinalSize] = 0;
|
|
UnCompressedData = (char *)&UncompressedBuffer[0];
|
|
return true;
|
|
}
|
|
if (status == Z_BUF_ERROR) {
|
|
if (factor < 300) {
|
|
factor += 10;
|
|
MaxSize = ofs.str().size() * factor;
|
|
continue;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool IsAlphaNumeric(const std::string &s) {
|
|
return std::all_of(s.begin(), s.end(), [](char c) -> bool { return isalnum(c); });
|
|
}
|
|
|
|
std::string SanitizeToken(const std::string &Token) {
|
|
if (Token.size() > 8) {
|
|
return Token.substr(0, 4) + "****" + Token.substr(Token.size() - 4, 4);
|
|
}
|
|
return "*******";
|
|
}
|
|
|
|
[[nodiscard]] bool ValidateURI(const std::string &uri) {
|
|
try {
|
|
Poco::URI u(uri);
|
|
return true;
|
|
} catch (...) {
|
|
}
|
|
return false;
|
|
}
|
|
|
|
[[nodiscard]] std::uint64_t ConvertDate(const std::string &Date) {
|
|
Poco::DateTime DT;
|
|
int TZ;
|
|
Poco::DateTimeParser::parse(Poco::DateTimeFormat::ISO8601_FORMAT, Date, DT, TZ);
|
|
return DT.timestamp().epochTime();
|
|
}
|
|
|
|
} // namespace OpenWifi::Utils
|