From 88ee57b6320822dd54429128489f9f2a388f3331 Mon Sep 17 00:00:00 2001
From: lurumdare <8020186+lurumdare@users.noreply.github.com>
Date: 周六, 07 9月 2019 22:00:55 +0800
Subject: [PATCH] NULL to nullptr (#34)
---
src/library/LicenseReader.cpp | 189 ++++++++++++++++++++++++++++-------------------
1 files changed, 112 insertions(+), 77 deletions(-)
diff --git a/src/library/LicenseReader.cpp b/src/library/LicenseReader.cpp
index 7ad0ede..9927426 100644
--- a/src/library/LicenseReader.cpp
+++ b/src/library/LicenseReader.cpp
@@ -2,7 +2,7 @@
* LicenseReader.cpp
*
* Created on: Mar 30, 2014
- * Author: devel
+ *
*/
#ifdef _WIN32
@@ -18,20 +18,23 @@
#include <fstream>
#include <sstream>
#include <stdlib.h>
+#include <math.h>
+#include "pc-identifiers.h"
#include "LicenseReader.h"
#include "base/StringUtils.h"
-#include "base/public-key.h"
+#include "base/logger.h"
+#include "public-key.h"
#include <build_properties.h>
-
-#include "os/os.hpp"
namespace license {
+const char *FullLicenseInfo::UNUSED_TIME = "0000-00-00";
+
FullLicenseInfo::FullLicenseInfo(const string& source, const string& product,
- const string& license_signature, int licenseVersion, //
- time_t from_date, time_t to_date, //
- const string& client_signature, unsigned int from_sw_version,
- unsigned int to_sw_version, const string& extra_data) :
+ const string& license_signature, int licenseVersion, string from_date,
+ string to_date, const string& client_signature,
+ unsigned int from_sw_version, unsigned int to_sw_version,
+ const string& extra_data) :
source(source), product(product), //
license_signature(license_signature), license_version(licenseVersion), //
from_date(from_date), to_date(to_date), //
@@ -47,27 +50,37 @@
EventRegistry FullLicenseInfo::validate(int sw_version) {
EventRegistry er;
- bool sigVerified = OsFunctions::verifySignature(printForSign().c_str(),
+ os_initialize();
+ const FUNCTION_RETURN sigVer = verifySignature(printForSign().c_str(),
license_signature.c_str());
+ const bool sigVerified = sigVer == FUNC_RET_OK;
if (sigVerified) {
- er.addEvent(LICENSE_VERIFIED, INFO);
+ er.addEvent(LICENSE_VERIFIED, SVRT_INFO);
} else {
- er.addEvent(LICENSE_CORRUPTED, SEVERITY_ERROR);
+ er.addEvent(LICENSE_CORRUPTED, SVRT_ERROR);
}
if (has_expiry) {
- time_t now = time(NULL);
- if (this->to_date < now) {
- er.addEvent(PRODUCT_EXPIRED, SEVERITY_ERROR, "");
+ const time_t now = time(nullptr);
+ if (expires_on() < now) {
+ er.addEvent(PRODUCT_EXPIRED, SVRT_ERROR, "");
}
- if (this->from_date > now) {
- er.addEvent(PRODUCT_EXPIRED, SEVERITY_ERROR);
+ if (valid_from() > now) {
+ er.addEvent(PRODUCT_EXPIRED, SVRT_ERROR);
+ }
+ }
+ if (has_client_sig) {
+ PcSignature str_code;
+ strncpy(str_code, client_signature.c_str(), sizeof(str_code)-1);
+ const EVENT_TYPE event = validate_pc_signature(str_code);
+ if (event != LICENSE_OK) {
+ er.addEvent(event, SVRT_ERROR);
}
}
return er;
}
void FullLicenseInfo::toLicenseInfo(LicenseInfo* license) const {
- if (license != NULL) {
+ if (license != nullptr) {
strncpy(license->proprietary_data, extra_data.c_str(),
PROPRIETARY_DATA_SIZE);
@@ -77,26 +90,17 @@
license->expiry_date[0] = '\0';
license->days_left = 999999;
} else {
- tm * timeinfo = localtime(&to_date);
- strftime(license->expiry_date, 11, "%Y-%m-%d", timeinfo);
- double secs = difftime(time(NULL), to_date);
- license->days_left = (int) secs / 60 * 60 * 24;
+ strncpy(license->expiry_date, to_date.c_str(), 11);
+ const double secs = difftime(
+ seconds_from_epoch(to_date.c_str()),
+ time(nullptr));
+ license->days_left = round(secs / (60 * 60 * 24));
}
}
}
LicenseReader::LicenseReader(const LicenseLocation& licenseLocation) :
licenseLocation(licenseLocation) {
-}
-
-time_t LicenseReader::read_date(const char * productName, const char * ini_key,
- const CSimpleIniA& ini) const {
- string from_date_str = ini.GetValue(productName, ini_key);
- time_t from_date = FullLicenseInfo::UNUSED_TIME;
- if (from_date_str.length() > 0) {
- from_date = seconds_from_epoch(from_date_str.c_str());
- }
- return from_date;
}
EventRegistry LicenseReader::readLicenses(const string &product,
@@ -112,17 +116,17 @@
CSimpleIniA ini;
for (auto it = diskFiles.begin(); it != diskFiles.end(); it++) {
ini.Reset();
- SI_Error rc = ini.LoadFile((*it).c_str());
+ const SI_Error rc = ini.LoadFile((*it).c_str());
if (rc < 0) {
- result.addEvent(FILE_FORMAT_NOT_RECOGNIZED, SEVERITY_WARN, *it);
+ result.addEvent(FILE_FORMAT_NOT_RECOGNIZED, SVRT_WARN, *it);
continue;
} else {
loadAtLeastOneFile = true;
}
const char* productNamePtr = product.c_str();
- int sectionSize = ini.GetSectionSize(productNamePtr);
+ const int sectionSize = ini.GetSectionSize(productNamePtr);
if (sectionSize <= 0) {
- result.addEvent(PRODUCT_NOT_LICENSED, SEVERITY_WARN, *it);
+ result.addEvent(PRODUCT_NOT_LICENSED, SVRT_WARN, *it);
continue;
} else {
atLeastOneProductLicensed = true;
@@ -132,23 +136,40 @@
* sw_version_to = (optional int)
* from_date = YYYY-MM-DD (optional)
* to_date = YYYY-MM-DD (optional)
- * client_signature = XXXXXXXX (optional string 16)
+ * client_signature = XXXX-XXXX-XXXX-XXXX (optional string 16)
* license_signature = XXXXXXXXXX (mandatory, 1024)
* application_data = xxxxxxxxx (optional string 16)
*/
const char * license_signature = ini.GetValue(productNamePtr,
- "license_signature", NULL);
+ "license_signature", nullptr);
long license_version = ini.GetLongValue(productNamePtr,
"license_version", -1);
- if (license_signature != NULL && license_version > 0) {
- time_t from_date = read_date(productNamePtr, "from_date", ini);
- time_t to_date = read_date(productNamePtr, "to_date", ini);
+ if (license_signature != nullptr && license_version > 0) {
+ const string from_date = trim_copy(
+ ini.GetValue(productNamePtr, "from_date",
+ FullLicenseInfo::UNUSED_TIME));
+ const string to_date = trim_copy(
+ ini.GetValue(productNamePtr, "to_date",
+ FullLicenseInfo::UNUSED_TIME));
+ string client_signature = trim_copy(
+ ini.GetValue(productNamePtr, "client_signature", ""));
+ /*client_signature.erase(
+ std::remove(client_signature.begin(), client_signature.end(), '-'),
+ client_signature.end());*/
+ const int from_sw_version = ini.GetLongValue(productNamePtr,
+ "from_sw_version",
+ FullLicenseInfo::UNUSED_SOFTWARE_VERSION);
+ const int to_sw_version = ini.GetLongValue(productNamePtr,
+ "to_sw_version", FullLicenseInfo::UNUSED_SOFTWARE_VERSION);
+ string extra_data = trim_copy(
+ ini.GetValue(productNamePtr, "extra_data", ""));
FullLicenseInfo licInfo(*it, product, license_signature,
- (int) license_version, from_date, to_date);
+ (int) license_version, from_date, to_date, client_signature,
+ from_sw_version, to_sw_version, extra_data);
licenseInfoOut.push_back(licInfo);
atLeastOneLicenseComplete = true;
} else {
- result.addEvent(LICENSE_MALFORMED, SEVERITY_WARN, *it);
+ result.addEvent(LICENSE_MALFORMED, SVRT_WARN, *it);
}
}
if (!loadAtLeastOneFile) {
@@ -167,11 +188,11 @@
EventRegistry& eventRegistry) {
//bool hasFileLocation = false;
bool licenseFoundWithExplicitLocation = false;
- if (licenseLocation.licenseFileLocation != NULL
+ if (licenseLocation.licenseFileLocation != nullptr
&& licenseLocation.licenseFileLocation[0] != '\0') {
//hasFileLocation = true;
- string varName(licenseLocation.licenseFileLocation);
- vector<string> declared_positions = splitLicensePositions(varName);
+ const string varName(licenseLocation.licenseFileLocation);
+ const vector<string> declared_positions = splitLicensePositions(varName);
vector<string> existing_pos = filterExistingFiles(declared_positions);
if (existing_pos.size() > 0) {
if (existing_pos.size() > 0) {
@@ -179,12 +200,11 @@
for (auto it = existing_pos.begin(); it != existing_pos.end();
++it) {
diskFiles.push_back(*it);
- eventRegistry.addEvent(LICENSE_FILE_FOUND, INFO, *it);
+ eventRegistry.addEvent(LICENSE_FILE_FOUND, SVRT_INFO, *it);
}
}
} else {
- eventRegistry.addEvent(LICENSE_FILE_NOT_FOUND, SEVERITY_WARN,
- varName);
+ eventRegistry.addEvent(LICENSE_FILE_NOT_FOUND, SVRT_WARN, varName);
}
}
return licenseFoundWithExplicitLocation;
@@ -193,14 +213,14 @@
bool LicenseReader::findFileWithEnvironmentVariable(vector<string>& diskFiles,
EventRegistry& eventRegistry) {
bool licenseFileFoundWithEnvVariable = false;
- if (licenseLocation.environmentVariableName != NULL
+ if (licenseLocation.environmentVariableName != nullptr
&& licenseLocation.environmentVariableName[0] != '\0') {
- string varName(licenseLocation.environmentVariableName);
+ const string varName(licenseLocation.environmentVariableName);
if (varName.length() > 0) {
//var name is passed in by the calling application.
char* env_var_value = getenv(varName.c_str());
- if (env_var_value != NULL && env_var_value[0] != '\0') {
- vector<string> declared_positions = splitLicensePositions(
+ if (env_var_value != nullptr && env_var_value[0] != '\0') {
+ const vector<string> declared_positions = splitLicensePositions(
string(env_var_value));
vector<string> existing_pos = filterExistingFiles(
declared_positions);
@@ -209,19 +229,19 @@
for (auto it = existing_pos.begin();
it != existing_pos.end(); ++it) {
diskFiles.push_back(*it);
- eventRegistry.addEvent(LICENSE_FILE_FOUND, INFO, *it);
+ eventRegistry.addEvent(LICENSE_FILE_FOUND, SVRT_INFO,
+ *it);
}
} else {
- eventRegistry.addEvent(LICENSE_FILE_NOT_FOUND,
- SEVERITY_WARN, env_var_value);
+ eventRegistry.addEvent(LICENSE_FILE_NOT_FOUND, SVRT_WARN,
+ env_var_value);
}
} else {
eventRegistry.addEvent(ENVIRONMENT_VARIABLE_NOT_DEFINED,
- SEVERITY_WARN);
+ SVRT_WARN);
}
} else {
- eventRegistry.addEvent(ENVIRONMENT_VARIABLE_NOT_DEFINED,
- SEVERITY_WARN);
+ eventRegistry.addEvent(ENVIRONMENT_VARIABLE_NOT_DEFINED, SVRT_WARN);
}
}
return licenseFileFoundWithEnvVariable;
@@ -229,23 +249,30 @@
EventRegistry LicenseReader::getLicenseDiskFiles(vector<string>& diskFiles) {
EventRegistry eventRegistry;
- bool licenseFoundWithExplicitLocation = findLicenseWithExplicitLocation(
+ const bool licenseFoundWithExplicitLocation = findLicenseWithExplicitLocation(
diskFiles, eventRegistry);
bool foundNearModule = false;
if (licenseLocation.openFileNearModule) {
- string temptativeLicense = OsFunctions::getModuleName() + ".lic";
- ifstream f(temptativeLicense.c_str());
- if (f.good()) {
- foundNearModule = true;
- diskFiles.push_back(temptativeLicense);
- eventRegistry.addEvent(LICENSE_FILE_FOUND, INFO, temptativeLicense);
+ char fname[MAX_PATH] = { 0 };
+ const FUNCTION_RETURN fret = getModuleName(fname);
+ if (fret == FUNC_RET_OK) {
+ const string temptativeLicense = string(fname) + ".lic";
+ ifstream f(temptativeLicense.c_str());
+ if (f.good()) {
+ foundNearModule = true;
+ diskFiles.push_back(temptativeLicense);
+ eventRegistry.addEvent(LICENSE_FILE_FOUND, SVRT_INFO,
+ temptativeLicense);
+ } else {
+ eventRegistry.addEvent(LICENSE_FILE_NOT_FOUND, SVRT_WARN,
+ temptativeLicense);
+ }
+ f.close();
} else {
- eventRegistry.addEvent(LICENSE_FILE_NOT_FOUND, SEVERITY_WARN,
- temptativeLicense);
+ LOG_WARN("Error determining module name.");
}
- f.close();
}
- bool licenseFileFoundWithEnvVariable = findFileWithEnvironmentVariable(
+ const bool licenseFileFoundWithEnvVariable = findFileWithEnvironmentVariable(
diskFiles, eventRegistry);
if (!foundNearModule && !licenseFoundWithExplicitLocation
@@ -297,18 +324,22 @@
oss << "|" << this->from_sw_version << "-" << this->to_sw_version;
}
if (has_expiry) {
- oss << "|" << this->from_date << "-" << this->to_date;
+ oss << "|" << this->from_date << "|" << this->to_date;
}
if (this->extra_data.length() > 0) {
oss << "|" << extra_data;
}
+#ifdef _DEBUG
+ cout << "[" << oss.str() << "]" << endl;
+#endif
return oss.str();
+
}
void FullLicenseInfo::printAsIni(ostream & a_ostream) const {
CSimpleIniA ini;
string result;
- string product = toupper_copy(trim_copy(this->product));
+ const string product = toupper_copy(trim_copy(this->product));
CSimpleIniA::StreamWriter sw(a_ostream);
ini.SetLongValue(product.c_str(), "license_version",
PROJECT_INT_VERSION);
@@ -323,15 +354,11 @@
ini.SetLongValue(product.c_str(), "to_sw_version", to_sw_version);
}
- char buff[20];
if (this->from_date != UNUSED_TIME) {
- strftime(buff, 20, "%Y-%m-%d", localtime(&this->from_date));
- ini.SetValue(product.c_str(), "from_date", buff);
+ ini.SetValue(product.c_str(), "from_date", from_date.c_str());
}
- char buff2[20];
if (this->to_date != UNUSED_TIME) {
- strftime(buff2, 20, "%Y-%m-%d", localtime(&this->to_date));
- ini.SetValue(product.c_str(), "to_date", buff2);
+ ini.SetValue(product.c_str(), "to_date", to_date.c_str());
}
if (this->extra_data.length() > 0) {
ini.SetValue(product.c_str(), "extra_data", this->extra_data.c_str());
@@ -339,5 +366,13 @@
ini.Save(sw);
}
+time_t FullLicenseInfo::expires_on() const {
+ return seconds_from_epoch(this->to_date.c_str());
+}
+
+time_t FullLicenseInfo::valid_from() const {
+ return seconds_from_epoch(this->from_date.c_str());
+}
+
}
--
Gitblit v1.9.1