Ajoute le plugin Acrobat Pro d'imposition (acrobat-plugin/)
Suite d'imposition professionnelle en Folder-Level Scripts JS (7 modules + verification de licence Vision), avec un plugin natif hybride optionnel (WinINet + Registre) pour deplacer la verification de licence en code compile. Installeur install.bat sur le meme modele que celui du projet desktop (git portable, detection automatique des dossiers Acrobat).
This commit is contained in:
Jules
225
acrobat-plugin/native/LicenceVerifier.cpp
Executable file
225
acrobat-plugin/native/LicenceVerifier.cpp
Executable file
@@ -0,0 +1,225 @@
|
||||
// LicenceVerifier.cpp
|
||||
// ---------------------------------------------------------------------------
|
||||
// Voir LicenceVerifier.h pour le contexte general.
|
||||
//
|
||||
// Le parsing JSON est volontairement minimal (recherche de sous-chaines) car
|
||||
// le SDK Acrobat ne fournit pas de bibliotheque JSON et on souhaite eviter
|
||||
// toute dependance externe pour un plugin aussi cible. Le format attendu de
|
||||
// license.php est celui deja documente pour le projet "impose" :
|
||||
// { "active": true/false, "offline_timeout_hours": 24, ... }
|
||||
// Si le serveur utilise plutot un champ "valid" au lieu de "active", les
|
||||
// deux sont acceptes. A AJUSTER si le format reel differe (voir TestConsole
|
||||
// pour verifier la reponse brute sans avoir a passer par Acrobat).
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#include "LicenceVerifier.h"
|
||||
|
||||
#include <windows.h>
|
||||
#include <wininet.h>
|
||||
#include <shlwapi.h>
|
||||
#include <ctime>
|
||||
#include <cstdio>
|
||||
|
||||
#pragma comment(lib, "Wininet.lib")
|
||||
#pragma comment(lib, "Advapi32.lib")
|
||||
#pragma comment(lib, "Shlwapi.lib")
|
||||
|
||||
namespace CDImpLicence {
|
||||
|
||||
static const wchar_t* CLE_REGISTRE = L"Software\\Copydev\\ImposingAcrobat";
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Utilitaires de parsing minimal (pas de dependance JSON externe)
|
||||
// -------------------------------------------------------------------
|
||||
static bool ContientChampBooleenVrai(const std::string& json, const char* champ) {
|
||||
std::string motif = std::string("\"") + champ + "\"";
|
||||
size_t pos = json.find(motif);
|
||||
if (pos == std::string::npos) {
|
||||
return false;
|
||||
}
|
||||
pos = json.find(':', pos);
|
||||
if (pos == std::string::npos) {
|
||||
return false;
|
||||
}
|
||||
// Ignore les espaces apres ':'
|
||||
pos++;
|
||||
while (pos < json.size() && isspace((unsigned char)json[pos])) {
|
||||
pos++;
|
||||
}
|
||||
return json.compare(pos, 4, "true") == 0;
|
||||
}
|
||||
|
||||
static int LireChampEntier(const std::string& json, const char* champ, int defaut) {
|
||||
std::string motif = std::string("\"") + champ + "\"";
|
||||
size_t pos = json.find(motif);
|
||||
if (pos == std::string::npos) {
|
||||
return defaut;
|
||||
}
|
||||
pos = json.find(':', pos);
|
||||
if (pos == std::string::npos) {
|
||||
return defaut;
|
||||
}
|
||||
pos++;
|
||||
while (pos < json.size() && isspace((unsigned char)json[pos])) {
|
||||
pos++;
|
||||
}
|
||||
int valeur = atoi(json.c_str() + pos);
|
||||
return (valeur > 0) ? valeur : defaut;
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Identifiants machine
|
||||
// -------------------------------------------------------------------
|
||||
std::wstring ObtenirHostname() {
|
||||
wchar_t nom[256] = { 0 };
|
||||
DWORD taille = 256;
|
||||
if (GetComputerNameW(nom, &taille)) {
|
||||
return std::wstring(nom);
|
||||
}
|
||||
return L"Inconnu";
|
||||
}
|
||||
|
||||
std::wstring ObtenirMachineId() {
|
||||
wchar_t nomVolume[MAX_PATH] = { 0 };
|
||||
DWORD numeroSerie = 0;
|
||||
// Volume serial number du lecteur systeme : stable pour une
|
||||
// installation Windows donnee, suffisant pour le comptage
|
||||
// d'appareils cote serveur (pas un UUID materiel, mais standard
|
||||
// Win32 fiable, sans dependance WMI/COM).
|
||||
wchar_t racineSysteme[4] = L"C:\\";
|
||||
GetWindowsDirectoryW(nomVolume, MAX_PATH);
|
||||
if (wcslen(nomVolume) >= 2) {
|
||||
racineSysteme[0] = nomVolume[0];
|
||||
}
|
||||
GetVolumeInformationW(racineSysteme, nullptr, 0, &numeroSerie, nullptr, nullptr, nullptr, 0);
|
||||
|
||||
wchar_t buffer[64];
|
||||
swprintf_s(buffer, 64, L"%08X-%s", numeroSerie, ObtenirHostname().c_str());
|
||||
return std::wstring(buffer);
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Requete HTTP (WinINet)
|
||||
// -------------------------------------------------------------------
|
||||
static std::wstring EncoderURL(const std::wstring& valeur) {
|
||||
wchar_t tampon[1024];
|
||||
DWORD taille = 1024;
|
||||
if (UrlEscapeW(valeur.c_str(), tampon, &taille, URL_ESCAPE_PERCENT)) {
|
||||
return std::wstring(tampon);
|
||||
}
|
||||
return valeur;
|
||||
}
|
||||
|
||||
ResultatVerification VerifierLicence(
|
||||
const std::wstring& serveurUrl,
|
||||
const std::wstring& cleLicence,
|
||||
const std::wstring& machineId,
|
||||
const std::wstring& hostname,
|
||||
const std::wstring& produit
|
||||
) {
|
||||
ResultatVerification resultat;
|
||||
|
||||
std::wstring url = serveurUrl
|
||||
+ L"?key=" + EncoderURL(cleLicence)
|
||||
+ L"&machine_id=" + EncoderURL(machineId)
|
||||
+ L"&hostname=" + EncoderURL(hostname)
|
||||
+ L"&product=" + EncoderURL(produit);
|
||||
|
||||
HINTERNET hInternet = InternetOpenW(L"CopydevImposingAcrobat/1.0",
|
||||
INTERNET_OPEN_TYPE_PRECONFIG, nullptr, nullptr, 0);
|
||||
if (!hInternet) {
|
||||
resultat.erreur = "InternetOpenW a echoue";
|
||||
return resultat;
|
||||
}
|
||||
|
||||
// Timeout raisonnable : ne pas bloquer le demarrage d'Acrobat
|
||||
// indefiniment si le serveur ne repond pas.
|
||||
DWORD timeoutMs = 5000;
|
||||
InternetSetOptionW(hInternet, INTERNET_OPTION_CONNECT_TIMEOUT, &timeoutMs, sizeof(timeoutMs));
|
||||
InternetSetOptionW(hInternet, INTERNET_OPTION_RECEIVE_TIMEOUT, &timeoutMs, sizeof(timeoutMs));
|
||||
|
||||
HINTERNET hUrl = InternetOpenUrlW(hInternet, url.c_str(), nullptr, 0,
|
||||
INTERNET_FLAG_RELOAD | INTERNET_FLAG_SECURE, 0);
|
||||
if (!hUrl) {
|
||||
resultat.erreur = "InternetOpenUrlW a echoue (reseau indisponible ou serveur inaccessible)";
|
||||
InternetCloseHandle(hInternet);
|
||||
return resultat;
|
||||
}
|
||||
|
||||
char tampon[2048];
|
||||
DWORD octetsLus = 0;
|
||||
std::string corps;
|
||||
while (InternetReadFile(hUrl, tampon, sizeof(tampon) - 1, &octetsLus) && octetsLus > 0) {
|
||||
tampon[octetsLus] = '\0';
|
||||
corps += tampon;
|
||||
}
|
||||
|
||||
InternetCloseHandle(hUrl);
|
||||
InternetCloseHandle(hInternet);
|
||||
|
||||
if (corps.empty()) {
|
||||
resultat.erreur = "Reponse vide du serveur de licence";
|
||||
return resultat;
|
||||
}
|
||||
|
||||
resultat.succesReseau = true;
|
||||
resultat.reponseBrute = corps;
|
||||
resultat.valide = ContientChampBooleenVrai(corps, "active") || ContientChampBooleenVrai(corps, "valid");
|
||||
resultat.offlineTimeoutHeures = LireChampEntier(corps, "offline_timeout_hours", 24);
|
||||
|
||||
return resultat;
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Registre Windows
|
||||
// -------------------------------------------------------------------
|
||||
void EcrireVerdictRegistre(bool valide, int dureeToleranceHeures) {
|
||||
HKEY hCle;
|
||||
if (RegCreateKeyExW(HKEY_CURRENT_USER, CLE_REGISTRE, 0, nullptr,
|
||||
REG_OPTION_NON_VOLATILE, KEY_WRITE, nullptr, &hCle, nullptr) != ERROR_SUCCESS) {
|
||||
return;
|
||||
}
|
||||
|
||||
long long expiration = (long long)time(nullptr) + (long long)dureeToleranceHeures * 3600LL;
|
||||
|
||||
wchar_t valeurOK[2];
|
||||
swprintf_s(valeurOK, 2, L"%d", valide ? 1 : 0);
|
||||
wchar_t valeurExpiration[32];
|
||||
swprintf_s(valeurExpiration, 32, L"%lld", expiration);
|
||||
|
||||
RegSetValueExW(hCle, L"LicenceOK", 0, REG_SZ,
|
||||
(const BYTE*)valeurOK, (DWORD)((wcslen(valeurOK) + 1) * sizeof(wchar_t)));
|
||||
RegSetValueExW(hCle, L"LicenceValideJusqua", 0, REG_SZ,
|
||||
(const BYTE*)valeurExpiration, (DWORD)((wcslen(valeurExpiration) + 1) * sizeof(wchar_t)));
|
||||
|
||||
RegCloseKey(hCle);
|
||||
}
|
||||
|
||||
bool LireVerdictRegistre(bool& valideOut, long long& expirationUnixOut) {
|
||||
HKEY hCle;
|
||||
if (RegOpenKeyExW(HKEY_CURRENT_USER, CLE_REGISTRE, 0, KEY_READ, &hCle) != ERROR_SUCCESS) {
|
||||
return false;
|
||||
}
|
||||
|
||||
wchar_t valeurOK[16] = { 0 };
|
||||
DWORD tailleOK = sizeof(valeurOK);
|
||||
wchar_t valeurExpiration[32] = { 0 };
|
||||
DWORD tailleExpiration = sizeof(valeurExpiration);
|
||||
|
||||
bool ok1 = RegQueryValueExW(hCle, L"LicenceOK", nullptr, nullptr,
|
||||
(LPBYTE)valeurOK, &tailleOK) == ERROR_SUCCESS;
|
||||
bool ok2 = RegQueryValueExW(hCle, L"LicenceValideJusqua", nullptr, nullptr,
|
||||
(LPBYTE)valeurExpiration, &tailleExpiration) == ERROR_SUCCESS;
|
||||
|
||||
RegCloseKey(hCle);
|
||||
|
||||
if (!ok1 || !ok2) {
|
||||
return false;
|
||||
}
|
||||
|
||||
valideOut = (_wtoi(valeurOK) == 1);
|
||||
expirationUnixOut = _wtoi64(valeurExpiration);
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace CDImpLicence
|
||||
54
acrobat-plugin/native/LicenceVerifier.h
Executable file
54
acrobat-plugin/native/LicenceVerifier.h
Executable file
@@ -0,0 +1,54 @@
|
||||
// LicenceVerifier.h
|
||||
// ---------------------------------------------------------------------------
|
||||
// Verification de licence Vision (meme serveur/API que le projet "impose") -
|
||||
// implementation Win32 pure (WinINet + Registre), independante du SDK
|
||||
// Acrobat. Peut etre compilee et testee comme executable console autonome
|
||||
// via TestConsole.cpp avant d'etre integree au plugin Acrobat (PluginMain.cpp).
|
||||
//
|
||||
// Dependances : Wininet.lib (WinINet), Advapi32.lib (Registre) - standard
|
||||
// Win32, disponibles avec n'importe quelle installation de Visual Studio.
|
||||
// ---------------------------------------------------------------------------
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
|
||||
namespace CDImpLicence {
|
||||
|
||||
struct ResultatVerification {
|
||||
bool succesReseau = false; // la requete HTTP a reussi (reponse recue)
|
||||
bool valide = false; // la licence est active selon le serveur
|
||||
int offlineTimeoutHeures = 24;
|
||||
std::string erreur; // message d'erreur eventuel
|
||||
std::string reponseBrute; // corps de la reponse, pour diagnostic
|
||||
};
|
||||
|
||||
// Construit l'URL de verification et effectue la requete GET.
|
||||
// serveurUrl : ex. "https://vision.copydev.fr/api/license.php"
|
||||
ResultatVerification VerifierLicence(
|
||||
const std::wstring& serveurUrl,
|
||||
const std::wstring& cleLicence,
|
||||
const std::wstring& machineId,
|
||||
const std::wstring& hostname,
|
||||
const std::wstring& produit
|
||||
);
|
||||
|
||||
// Identifiant machine stable : tente d'utiliser le nom de la machine
|
||||
// Windows (GetComputerNameW) combine au volume serial number du disque
|
||||
// systeme (GetVolumeInformationW), deux API Win32 standard et fiables -
|
||||
// contrairement a l'approche JS qui devait generer un identifiant
|
||||
// aleatoire faute d'acces materiel direct.
|
||||
std::wstring ObtenirMachineId();
|
||||
std::wstring ObtenirHostname();
|
||||
|
||||
// Ecrit le verdict de licence dans HKCU\Software\Copydev\ImposingAcrobat
|
||||
// sous forme de chaines REG_SZ simples (lisibles depuis le JS via
|
||||
// WScript.Shell.RegRead, qui gere mal certains types REG_DWORD/QWORD) :
|
||||
// LicenceOK "1" ou "0"
|
||||
// LicenceValideJusqua timestamp Unix (secondes, en texte)
|
||||
void EcrireVerdictRegistre(bool valide, int dureeToleranceHeures);
|
||||
|
||||
// Relit le verdict actuellement stocke (utilise par TestConsole.cpp pour
|
||||
// verifier l'ecriture, et a titre de reference pour l'equivalent JS).
|
||||
bool LireVerdictRegistre(bool& valideOut, long long& expirationUnixOut);
|
||||
|
||||
} // namespace CDImpLicence
|
||||
109
acrobat-plugin/native/PluginMain.cpp
Executable file
109
acrobat-plugin/native/PluginMain.cpp
Executable file
@@ -0,0 +1,109 @@
|
||||
// PluginMain.cpp
|
||||
// ---------------------------------------------------------------------------
|
||||
// Squelette de plugin Acrobat (.api) dont l'unique role est d'appeler
|
||||
// CDImpLicence::VerifierLicence() au demarrage d'Acrobat et d'ecrire le
|
||||
// verdict dans le Registre (voir LicenceVerifier.h/.cpp). Ce fichier ne
|
||||
// touche a aucune fonctionnalite d'imposition : tout le reste de la suite
|
||||
// reste dans les Folder-Level Scripts JS deja en place
|
||||
// (/mnt/homeshare/Documents/Projet/imposing/src/), qui lisent ce verdict.
|
||||
//
|
||||
// ============================================================================
|
||||
// AVERTISSEMENT MAJEUR - A LIRE AVANT DE COMPILER
|
||||
// ============================================================================
|
||||
// Le code ci-dessous suit le squelette de plugin le plus communement
|
||||
// documente dans les exemples du Plug-in SDK Acrobat ("HelloWorld" et
|
||||
// derives), MAIS :
|
||||
// - cet environnement de developpement n'a ni le SDK Acrobat, ni Windows,
|
||||
// ni Visual Studio : ce fichier n'a PU ETRE NI COMPILE NI TESTE ;
|
||||
// - les macros/signatures exactes de handshake (PIHandshake, gExtensionID,
|
||||
// PIPlugInInit, l'enregistrement de l'export HFT) varient legerement
|
||||
// entre versions du SDK (et notamment entre les SDK 32 bits historiques
|
||||
// et les SDK modernes 64 bits) ;
|
||||
// - il FAUT remplacer ce squelette par le vrai boilerplate fourni dans le
|
||||
// dossier "Sample Plug-ins" du SDK que vous installez (generalement
|
||||
// PIMain.cpp dans chaque exemple), et n'y inserer que l'appel a
|
||||
// CDImpLicence::VerifierLicence() + EcrireVerdictRegistre() dans la
|
||||
// fonction d'initialisation du plugin.
|
||||
// La partie fiable et reutilisable telle quelle est LicenceVerifier.cpp/.h
|
||||
// (Win32 pur, deja validable independamment via TestConsole.cpp).
|
||||
// ============================================================================
|
||||
|
||||
#include "PIHeaders.h" // a fournir par le SDK Acrobat (non present ici)
|
||||
#include <windows.h>
|
||||
#include "LicenceVerifier.h"
|
||||
|
||||
// Identifiants a definir selon votre enregistrement developpeur Adobe
|
||||
// (Tools > JavaScript Debugger n'est pas concerne ici : c'est l'ID
|
||||
// d'extension attribue lors de l'inscription au programme Acrobat
|
||||
// Solutions/Integration Partner, requis pour distribuer un plugin signe).
|
||||
extern "C" const char* gExtensionID = "com.copydev.imposingacrobat.licence";
|
||||
|
||||
static const wchar_t* SERVEUR_LICENCE = L"https://vision.copydev.fr/api/license.php";
|
||||
static const wchar_t* PRODUIT = L"imposing-acrobat";
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// Verification effectuee une fois, a l'initialisation du plugin (donc une
|
||||
// fois par session Acrobat). Suffisant pour la semantique de tolerance
|
||||
// hors-ligne deja en place cote serveur (offline_timeout_hours).
|
||||
// -----------------------------------------------------------------------
|
||||
static void EffectuerVerificationLicence() {
|
||||
// La cle de licence est lue depuis le Registre si deja saisie via le
|
||||
// dialogue JS "Gerer la licence..." (Imposition-00b-Licence.js stocke
|
||||
// global.cdImpLicenceCle via global.setPersistent, qui est in fine
|
||||
// persiste par Acrobat dans son propre stockage de preferences - PAS le
|
||||
// meme emplacement que celui utilise ici cote natif). Pour partager la
|
||||
// cle entre JS et natif de facon fiable, le plus simple est de la
|
||||
// stocker aussi dans le Registre depuis le JS (a ajouter dans
|
||||
// Imposition-00b-Licence.js : ecrire la cle saisie sous
|
||||
// HKCU\Software\Copydev\ImposingAcrobat\CleLicence via
|
||||
// WScript.Shell.RegWrite, en plus de global.setPersistent).
|
||||
wchar_t cleLicence[256] = { 0 };
|
||||
HKEY hCle;
|
||||
if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\Copydev\\ImposingAcrobat",
|
||||
0, KEY_READ, &hCle) == ERROR_SUCCESS) {
|
||||
DWORD taille = sizeof(cleLicence);
|
||||
RegQueryValueExW(hCle, L"CleLicence", nullptr, nullptr, (LPBYTE)cleLicence, &taille);
|
||||
RegCloseKey(hCle);
|
||||
}
|
||||
|
||||
if (wcslen(cleLicence) == 0) {
|
||||
// Aucune cle connue cote natif : on n'ecrit aucun verdict, le JS
|
||||
// retombera sur sa propre verification (voir Imposition-00b-Licence.js).
|
||||
return;
|
||||
}
|
||||
|
||||
std::wstring machineId = CDImpLicence::ObtenirMachineId();
|
||||
std::wstring hostname = CDImpLicence::ObtenirHostname();
|
||||
|
||||
CDImpLicence::ResultatVerification resultat = CDImpLicence::VerifierLicence(
|
||||
SERVEUR_LICENCE, cleLicence, machineId, hostname, PRODUIT);
|
||||
|
||||
if (resultat.succesReseau) {
|
||||
CDImpLicence::EcrireVerdictRegistre(resultat.valide, resultat.offlineTimeoutHeures);
|
||||
}
|
||||
// Si la requete reseau echoue, on n'ecrit rien : le verdict precedent
|
||||
// (s'il existe, avec son timestamp d'expiration) reste en place et sera
|
||||
// evalue tel quel par le JS (logique de tolerance hors-ligne).
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// Point d'entree d'initialisation du plugin. Le nom exact et la signature
|
||||
// de cette fonction DOIVENT etre repris du boilerplate PIMain.cpp de votre
|
||||
// SDK (le nom "PluginInit" ci-dessous est indicatif).
|
||||
// -----------------------------------------------------------------------
|
||||
ACCB1 ASBool ACCB2 PluginInit(void) {
|
||||
EffectuerVerificationLicence();
|
||||
return true; // true = le plugin s'est initialise correctement
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// Handshake / export table : A REMPLACER INTEGRALEMENT par le contenu du
|
||||
// boilerplate de votre version du SDK (PIMain.cpp, PIRequir.h, etc.). Conserve
|
||||
// ici uniquement comme rappel de la structure generale attendue.
|
||||
// -----------------------------------------------------------------------
|
||||
/*
|
||||
ACCB1 ASBool ACCB2 PIHandshake(...) {
|
||||
// ... initialisation standard du SDK ...
|
||||
return PluginInit();
|
||||
}
|
||||
*/
|
||||
82
acrobat-plugin/native/TestConsole.cpp
Executable file
82
acrobat-plugin/native/TestConsole.cpp
Executable file
@@ -0,0 +1,82 @@
|
||||
// TestConsole.cpp
|
||||
// ---------------------------------------------------------------------------
|
||||
// Executable console autonome pour valider LicenceVerifier.cpp SANS le SDK
|
||||
// Acrobat (pas besoin d'Acrobat installe ni du Plug-in SDK pour ce test).
|
||||
//
|
||||
// Build rapide (Visual Studio Developer Command Prompt) :
|
||||
// cl /EHsc /std:c++14 TestConsole.cpp LicenceVerifier.cpp ^
|
||||
// wininet.lib advapi32.lib shlwapi.lib
|
||||
//
|
||||
// Ou : creer un projet "Application console" Visual Studio classique avec
|
||||
// ces deux fichiers .cpp + LicenceVerifier.h.
|
||||
//
|
||||
// A FAIRE AVANT D'INTEGRER AU PLUGIN ACROBAT :
|
||||
// 1. Lancer ce programme avec une cle de licence de test valide
|
||||
// (ex: COPYDEV-IMPOS-TEST-2026, comme pour le projet impose) et
|
||||
// verifier que la reponse brute du serveur correspond au parsing
|
||||
// attendu (champ "active" ou "valid", "offline_timeout_hours").
|
||||
// 2. Si le parsing echoue, ajuster ContientChampBooleenVrai/LireChampEntier
|
||||
// dans LicenceVerifier.cpp selon le format reel observe.
|
||||
// 3. Verifier que le Registre est bien ecrit (HKCU\Software\Copydev\
|
||||
// ImposingAcrobat) avec regedit, ou en relancant ce programme avec
|
||||
// l'option "lire" (voir ci-dessous).
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#include "LicenceVerifier.h"
|
||||
#include <cstdio>
|
||||
#include <string>
|
||||
|
||||
// Conversion simple (les reponses JSON attendues sont en ASCII).
|
||||
static std::wstring VersWstring(const std::string& s) {
|
||||
return std::wstring(s.begin(), s.end());
|
||||
}
|
||||
|
||||
int wmain(int argc, wchar_t* argv[]) {
|
||||
if (argc >= 2 && std::wstring(argv[1]) == L"lire") {
|
||||
bool valide = false;
|
||||
long long expiration = 0;
|
||||
if (CDImpLicence::LireVerdictRegistre(valide, expiration)) {
|
||||
wprintf(L"Verdict en registre : valide=%d, expire le (unix)=%lld\n", valide ? 1 : 0, expiration);
|
||||
} else {
|
||||
wprintf(L"Aucun verdict trouve dans le registre.\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (argc < 2) {
|
||||
wprintf(L"Usage: TestConsole.exe <cle_licence> [serveur_url]\n");
|
||||
wprintf(L" TestConsole.exe lire (relit le verdict deja ecrit en registre)\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
std::wstring cle = argv[1];
|
||||
std::wstring serveur = (argc >= 3) ? argv[2] : L"https://vision.copydev.fr/api/license.php";
|
||||
std::wstring produit = L"imposing-acrobat";
|
||||
|
||||
std::wstring machineId = CDImpLicence::ObtenirMachineId();
|
||||
std::wstring hostname = CDImpLicence::ObtenirHostname();
|
||||
|
||||
wprintf(L"Machine ID : %s\n", machineId.c_str());
|
||||
wprintf(L"Hostname : %s\n", hostname.c_str());
|
||||
wprintf(L"Serveur : %s\n", serveur.c_str());
|
||||
wprintf(L"Produit : %s\n\n", produit.c_str());
|
||||
|
||||
CDImpLicence::ResultatVerification resultat = CDImpLicence::VerifierLicence(
|
||||
serveur, cle, machineId, hostname, produit);
|
||||
|
||||
wprintf(L"Succes reseau : %d\n", resultat.succesReseau ? 1 : 0);
|
||||
wprintf(L"Licence valide : %d\n", resultat.valide ? 1 : 0);
|
||||
wprintf(L"Tolerance hors-ligne: %d heures\n", resultat.offlineTimeoutHeures);
|
||||
if (!resultat.erreur.empty()) {
|
||||
wprintf(L"Erreur : %s\n", VersWstring(resultat.erreur).c_str());
|
||||
}
|
||||
wprintf(L"Reponse brute : %s\n\n", VersWstring(resultat.reponseBrute).c_str());
|
||||
|
||||
if (resultat.succesReseau) {
|
||||
CDImpLicence::EcrireVerdictRegistre(resultat.valide, resultat.offlineTimeoutHeures);
|
||||
wprintf(L"Verdict ecrit dans HKCU\\Software\\Copydev\\ImposingAcrobat.\n");
|
||||
wprintf(L"Relancez avec l'argument \"lire\" pour le verifier.\n");
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user