pc id

open-license-manager

2014-05-26 b5001a9a6e6d0f63f2f2d26a2f710519a6fcc6a0

 src/library/LicenseReader.cpp

@@ -23,15 +23,15 @@
#include "base/public-key.h"
#include <build_properties.h>

#include "os/os.hpp"
#include "os/os-cpp.h"

namespace license {

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,6 +47,7 @@

EventRegistry FullLicenseInfo::validate(int sw_version) {
   EventRegistry er;
   os_initialize();
   bool sigVerified = OsFunctions::verifySignature(printForSign().c_str(),
         license_signature.c_str());
   if (sigVerified) {
@@ -56,11 +57,19 @@
   }
   if (has_expiry) {
      time_t now = time(NULL);
      if (this->to_date < now) {
      if (expires_on() < now) {
         er.addEvent(PRODUCT_EXPIRED, SEVERITY_ERROR, "");
      }
      if (this->from_date > now) {
      if (valid_from() > now) {
         er.addEvent(PRODUCT_EXPIRED, SEVERITY_ERROR);
      }
   }
   if (has_client_sig) {
      UserPcIdentifier str_code;
      strncpy(str_code, client_signature.c_str(), sizeof(str_code));
      EVENT_TYPE event = validate_user_pc_identifier(str_code);
      if (event != OK) {
         er.addEvent(event, SEVERITY_ERROR);
      }
   }
   return er;
@@ -77,9 +86,9 @@
         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);
         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;
      }
   }
@@ -87,16 +96,6 @@
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,
@@ -132,7 +131,7 @@
       *  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)
       */
@@ -141,10 +140,25 @@
      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);
         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));
         string client_signature = trim_copy(
               ini.GetValue(productNamePtr, "client_signature", ""));
         client_signature.erase(
               std::remove(client_signature.begin(),
                     client_signature.end(), "-"),
               client_signature.end());
         int from_sw_version = ini.GetLongValue(productNamePtr,
               "from_sw_version", FullLicenseInfo::UNUSED_SOFTWARE_VERSION);
         int to_sw_version = ini.GetLongValue(productNamePtr,
               "to_sw_version", FullLicenseInfo::UNUSED_SOFTWARE_VERSION);
         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);
         licenseInfoOut.push_back(licInfo);
         atLeastOneLicenseComplete = true;
      } else {
@@ -297,12 +311,16 @@
      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 {
@@ -323,15 +341,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 +353,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());
}

}