copydev-imposing-tool/acrobat-plugin/native/PluginMain.cpp

// 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();
}
*/