From 1c18dbea1cbd759aaf42a7e78afe0d8781065a50 Mon Sep 17 00:00:00 2001
From: gcontini <1121667+gcontini@users.noreply.github.com>
Date: 周日, 10 11月 2019 22:25:22 +0800
Subject: [PATCH] improvements for issue #42
---
src/library/LicenseReader.cpp | 336 +++++++++++++++++++++----------------------------------
1 files changed, 130 insertions(+), 206 deletions(-)
diff --git a/src/library/LicenseReader.cpp b/src/library/LicenseReader.cpp
index 093b276..5ae8390 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
@@ -10,6 +10,7 @@
#else
# include <unistd.h>
#endif
+
#include <cstring>
#include <ctime>
#include <vector>
@@ -17,21 +18,28 @@
#include <iterator>
#include <fstream>
#include <sstream>
-#include <stdlib.h>
-#include "LicenseReader.h"
-#include "base/StringUtils.h"
-#include "base/public-key.h"
-#include <build_properties.h>
-#include "os/os-cpp.h"
+#include <stdlib.h>
+#include <math.h>
+
+#include <public_key.h>
+
+#include "pc-identifiers.h"
+#include "build_properties.h"
+#include "LicenseReader.hpp"
+#include "base/StringUtils.h"
+#include "base/logger.h"
+#include "locate/LocatorFactory.hpp"
namespace license {
-FullLicenseInfo::FullLicenseInfo(const string& source, const string& product,
- const string& license_signature, int licenseVersion, string from_date,
- string to_date, const string& client_signature,
+const char *FullLicenseInfo::UNUSED_TIME = "0000-00-00";
+
+FullLicenseInfo::FullLicenseInfo(const string &source, const string &product,
+ 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) :
+ const string &extra_data) :
source(source), product(product), //
license_signature(license_signature), license_version(licenseVersion), //
from_date(from_date), to_date(to_date), //
@@ -45,30 +53,46 @@
extra_data(extra_data) {
}
-EventRegistry FullLicenseInfo::validate(int sw_version) {
- EventRegistry er;
+bool FullLicenseInfo::validate(int sw_version,
+ EventRegistry &eventRegistryOut) {
os_initialize();
- bool sigVerified = OsFunctions::verifySignature(printForSign().c_str(),
+ const FUNCTION_RETURN sigVer = verifySignature(printForSign().c_str(),
license_signature.c_str());
- if (sigVerified) {
- er.addEvent(LICENSE_VERIFIED, INFO);
+ bool is_valid = (sigVer == FUNC_RET_OK);
+ if (is_valid) {
+ eventRegistryOut.addEvent(SIGNATURE_VERIFIED, source);
} else {
- er.addEvent(LICENSE_CORRUPTED, SEVERITY_ERROR);
+ eventRegistryOut.addEvent(LICENSE_CORRUPTED, source);
}
if (has_expiry) {
- time_t now = time(NULL);
+ cout<<source<<endl;
+ const time_t now = time(nullptr);
if (expires_on() < now) {
- er.addEvent(PRODUCT_EXPIRED, SEVERITY_ERROR, "");
+/*
+ eventRegistryOut.addEvent(PRODUCT_EXPIRED, source.c_str(),
+ string("Expired on: " + this->to_date).c_str());*/
+ eventRegistryOut.addEvent(PRODUCT_EXPIRED, source.c_str(),nullptr);
+ is_valid = false;
}
if (valid_from() > now) {
- er.addEvent(PRODUCT_EXPIRED, SEVERITY_ERROR);
+ /*eventRegistryOut.addEvent(PRODUCT_EXPIRED, source.c_str(),
+ string("Valid from " + this->from_date).c_str());*/
+ eventRegistryOut.addEvent(PRODUCT_EXPIRED, source.c_str(),nullptr);
+ is_valid = false;
}
}
- return er;
+ 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);
+ eventRegistryOut.addEvent(event, source);
+ is_valid = is_valid && (event == LICENSE_OK);
+ }
+ return is_valid;
}
-void FullLicenseInfo::toLicenseInfo(LicenseInfo* license) const {
- if (license != NULL) {
+void FullLicenseInfo::toLicenseInfo(LicenseInfo *license) const {
+ if (license != nullptr) {
strncpy(license->proprietary_data, extra_data.c_str(),
PROPRIETARY_DATA_SIZE);
@@ -79,212 +103,112 @@
license->days_left = 999999;
} else {
strncpy(license->expiry_date, to_date.c_str(), 11);
- double secs = difftime(time(NULL),
- seconds_from_epoch(to_date.c_str()));
- license->days_left = (int) secs / 60 * 60 * 24;
+ 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) {
+LicenseReader::LicenseReader(const LicenseLocation* licenseLocation) :
+ licenseLocation(licenseLocation) {
}
EventRegistry LicenseReader::readLicenses(const string &product,
- vector<FullLicenseInfo>& licenseInfoOut) {
+ vector<FullLicenseInfo> &licenseInfoOut) {
vector<string> diskFiles;
- EventRegistry result = getLicenseDiskFiles(diskFiles);
- if (!result.isGood()) {
- return result;
+ vector<unique_ptr<locate::LocatorStrategy>> locator_strategies;
+ FUNCTION_RETURN ret = locate::LocatorFactory::get_active_strategies(
+ locator_strategies, licenseLocation);
+ EventRegistry eventRegistry;
+ if (ret != FUNC_RET_OK) {
+ eventRegistry.addEvent(LICENSE_FILE_NOT_FOUND);
+ eventRegistry.turnWarningsIntoErrors();
+ return eventRegistry;
}
- bool loadAtLeastOneFile = false;
- bool atLeastOneProductLicensed = false;
+
bool atLeastOneLicenseComplete = false;
- CSimpleIniA ini;
- for (auto it = diskFiles.begin(); it != diskFiles.end(); it++) {
- ini.Reset();
- SI_Error rc = ini.LoadFile((*it).c_str());
- if (rc < 0) {
- result.addEvent(FILE_FORMAT_NOT_RECOGNIZED, SEVERITY_WARN, *it);
+ for (unique_ptr<locate::LocatorStrategy> &locator : locator_strategies) {
+ vector<string> licenseLocations = locator->license_locations(
+ eventRegistry);
+ if (licenseLocations.size() == 0) {
continue;
- } else {
- loadAtLeastOneFile = true;
}
- const char* productNamePtr = product.c_str();
- int sectionSize = ini.GetSectionSize(productNamePtr);
- if (sectionSize <= 0) {
- result.addEvent(PRODUCT_NOT_LICENSED, SEVERITY_WARN, *it);
- continue;
- } else {
- atLeastOneProductLicensed = true;
+ CSimpleIniA ini;
+ for (auto it = licenseLocations.begin(); it != licenseLocations.end();
+ it++) {
+ ini.Reset();
+ string license = locator->retrieve_license_content((*it).c_str());
+ const SI_Error rc = ini.LoadData(license.c_str(), license.size());
+ if (rc < 0) {
+ eventRegistry.addEvent(FILE_FORMAT_NOT_RECOGNIZED, *it);
+ continue;
+ }
+ const char *productNamePtr = product.c_str();
+ const int sectionSize = ini.GetSectionSize(productNamePtr);
+ if (sectionSize <= 0) {
+ eventRegistry.addEvent(PRODUCT_NOT_LICENSED, *it);
+ continue;
+ } else {
+ eventRegistry.addEvent(PRODUCT_FOUND, *it);
+ }
+ /*
+ * sw_version_from = (optional int)
+ * sw_version_to = (optional int)
+ * from_date = YYYY-MM-DD (optional)
+ * to_date = YYYY-MM-DD (optional)
+ * 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", nullptr);
+ long license_version = ini.GetLongValue(productNamePtr,
+ "license_version", -1);
+ 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,
+ client_signature, from_sw_version, to_sw_version,
+ extra_data);
+ licenseInfoOut.push_back(licInfo);
+ atLeastOneLicenseComplete = true;
+ } else {
+ eventRegistry.addEvent(LICENSE_MALFORMED, *it);
+ }
}
- /*
- * sw_version_from = (optional int)
- * sw_version_to = (optional int)
- * from_date = YYYY-MM-DD (optional)
- * to_date = YYYY-MM-DD (optional)
- * client_signature = XXXXXXXX (optional string 16)
- * license_signature = XXXXXXXXXX (mandatory, 1024)
- * application_data = xxxxxxxxx (optional string 16)
- */
- const char * license_signature = ini.GetValue(productNamePtr,
- "license_signature", NULL);
- long license_version = ini.GetLongValue(productNamePtr,
- "license_version", -1);
- if (license_signature != NULL && license_version > 0) {
- string from_date = trim_copy(
- ini.GetValue(productNamePtr, "from_date",
- FullLicenseInfo::UNUSED_TIME));
- string to_date = trim_copy(
- ini.GetValue(productNamePtr, "to_date",
- FullLicenseInfo::UNUSED_TIME));
- FullLicenseInfo licInfo(*it, product, license_signature,
- (int) license_version, from_date, to_date);
- licenseInfoOut.push_back(licInfo);
- atLeastOneLicenseComplete = true;
- } else {
- result.addEvent(LICENSE_MALFORMED, SEVERITY_WARN, *it);
- }
- }
- if (!loadAtLeastOneFile) {
- result.turnEventIntoError(FILE_FORMAT_NOT_RECOGNIZED);
- }
- if (!atLeastOneProductLicensed) {
- result.turnEventIntoError(PRODUCT_NOT_LICENSED);
}
if (!atLeastOneLicenseComplete) {
- result.turnEventIntoError(LICENSE_MALFORMED);
- }
- return result;
-}
-
-bool LicenseReader::findLicenseWithExplicitLocation(vector<string>& diskFiles,
- EventRegistry& eventRegistry) {
-//bool hasFileLocation = false;
- bool licenseFoundWithExplicitLocation = false;
- if (licenseLocation.licenseFileLocation != NULL
- && licenseLocation.licenseFileLocation[0] != '\0') {
- //hasFileLocation = true;
- string varName(licenseLocation.licenseFileLocation);
- vector<string> declared_positions = splitLicensePositions(varName);
- vector<string> existing_pos = filterExistingFiles(declared_positions);
- if (existing_pos.size() > 0) {
- if (existing_pos.size() > 0) {
- licenseFoundWithExplicitLocation = true;
- for (auto it = existing_pos.begin(); it != existing_pos.end();
- ++it) {
- diskFiles.push_back(*it);
- eventRegistry.addEvent(LICENSE_FILE_FOUND, INFO, *it);
- }
- }
- } else {
- eventRegistry.addEvent(LICENSE_FILE_NOT_FOUND, SEVERITY_WARN,
- varName);
- }
- }
- return licenseFoundWithExplicitLocation;
-}
-
-bool LicenseReader::findFileWithEnvironmentVariable(vector<string>& diskFiles,
- EventRegistry& eventRegistry) {
- bool licenseFileFoundWithEnvVariable = false;
- if (licenseLocation.environmentVariableName != NULL
- && licenseLocation.environmentVariableName[0] != '\0') {
- 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(
- string(env_var_value));
- vector<string> existing_pos = filterExistingFiles(
- declared_positions);
- if (existing_pos.size() > 0) {
- licenseFileFoundWithEnvVariable = true;
- for (auto it = existing_pos.begin();
- it != existing_pos.end(); ++it) {
- diskFiles.push_back(*it);
- eventRegistry.addEvent(LICENSE_FILE_FOUND, INFO, *it);
- }
- } else {
- eventRegistry.addEvent(LICENSE_FILE_NOT_FOUND,
- SEVERITY_WARN, env_var_value);
- }
- } else {
- eventRegistry.addEvent(ENVIRONMENT_VARIABLE_NOT_DEFINED,
- SEVERITY_WARN);
- }
- } else {
- eventRegistry.addEvent(ENVIRONMENT_VARIABLE_NOT_DEFINED,
- SEVERITY_WARN);
- }
- }
- return licenseFileFoundWithEnvVariable;
-}
-
-EventRegistry LicenseReader::getLicenseDiskFiles(vector<string>& diskFiles) {
- EventRegistry eventRegistry;
- 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);
- } else {
- eventRegistry.addEvent(LICENSE_FILE_NOT_FOUND, SEVERITY_WARN,
- temptativeLicense);
- }
- f.close();
- }
- bool licenseFileFoundWithEnvVariable = findFileWithEnvironmentVariable(
- diskFiles, eventRegistry);
-
- if (!foundNearModule && !licenseFoundWithExplicitLocation
- && !licenseFileFoundWithEnvVariable) {
- eventRegistry.turnEventIntoError(ENVIRONMENT_VARIABLE_NOT_DEFINED);
- eventRegistry.turnEventIntoError(LICENSE_FILE_NOT_FOUND);
+ eventRegistry.turnWarningsIntoErrors();
}
return eventRegistry;
}
-vector<string> LicenseReader::filterExistingFiles(
- vector<string> licensePositions) {
- vector<string> existingFiles;
- for (auto it = licensePositions.begin(); it != licensePositions.end();
- it++) {
- ifstream f(it->c_str());
- if (f.good()) {
- existingFiles.push_back(*it);
- }
- f.close();
- }
- return existingFiles;
-}
-
-vector<string> LicenseReader::splitLicensePositions(string licensePositions) {
- std::stringstream streamToSplit(licensePositions);
- std::string segment;
- std::vector<string> seglist;
-
- while (std::getline(streamToSplit, segment, ';')) {
- seglist.push_back(segment);
- }
- return seglist;
-}
-
LicenseReader::~LicenseReader() {
-
}
string FullLicenseInfo::printForSign() const {
ostringstream oss;
oss << toupper_copy(trim_copy(this->product));
- oss << SHARED_RANDOM
- ;
+ //oss << SHARED_RANDOM;
if (has_client_sig) {
oss << trim_copy(this->client_signature);
}
@@ -304,10 +228,10 @@
}
-void FullLicenseInfo::printAsIni(ostream & a_ostream) const {
+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);
--
Gitblit v1.9.1