SDK de licences logicielles C : guide CMake

1. Préparez le produit et la licence

Pour une application native C11, utilisez le SDK C afin d'activer la licence du client et de vérifier les droits avant d'appeler le callback de l'opération. Commencez par une licence liée à l'appareil et un export sans compteur d'utilisation ; ajoutez les compteurs une fois le flux de base opérationnel.

Le quota compte les activations actuelles et est rendu à leur libération. Les licences ordinaires restent comptées hors ligne ; les licences flottantes rendent aussi le quota à l’expiration du bail.

1. Copiez l’ID du produit dans Console > Produits. Ouvrez les clés publiques de signature du même produit et collez toutes les paires ID de clé/clé publique dans le code d’initialisation, en remplaçant YOUR_PRODUCT_ID, YOUR_KEY_ID et YOUR_PUBLIC_KEY. L’intégration rapide peut générer ce code. Aucun fichier de configuration n’est nécessaire ; le SDK utilise https://www.licentivo.com par défaut.
2. Dans Intégration rapide, créez ou sélectionnez un produit. Activez une fonctionnalité nommée export dans sa politique et préparez une licence de test.

SDK documentation

2. Installez le SDK

Installez CMake 3.18 ou une version ultérieure. Sous Windows x64, utilisez Visual Studio 2022 C++ Build Tools et le paquet SDK MSVC correspondant, avec -G "Visual Studio 17 2022" -A x64. Sous Linux x64, utilisez des compilateurs C11/C++17. Remplacez SDK_PREFIX par le préfixe CMake affiché par l'installateur. Enregistrez l'exemple sous app.c et le CMakeLists.txt ci-dessous dans le même répertoire.

Installez un paquet de développement libcurl partagé compatible avec le compilateur et l’architecture. Sous Windows MSVC x64, remplacez CURL_DIR par le dossier contenant CURLConfig.cmake, ajoutez le dossier bin de curl à PATH pour les essais locaux et distribuez les DLL nécessaires avec l’application ; sous Linux, installez le paquet de développement libcurl partagé de votre distribution.

& ([scriptblock]::Create((Invoke-WebRequest 'https://www.licentivo.com/assets/sdk/releases/v0.11.6/install.ps1').Content)) -Language c -Toolchain msvc

curl --fail --silent --show-error --location --proto '=https' --proto-redir '=https' 'https://www.licentivo.com/assets/sdk/releases/v0.11.6/install.sh' | bash -s -- c

cmake_minimum_required(VERSION 3.18)
project(licensed_app LANGUAGES C)
find_package(Licentivo 0.11.6 REQUIRED)
add_executable(licensed_app app.c)
target_link_libraries(licensed_app PRIVATE Licentivo::C)
set_target_properties(licensed_app PROPERTIES C_STANDARD 11 C_STANDARD_REQUIRED ON)

cmake -S . -B build -G "Visual Studio 17 2022" -A x64 -DCMAKE_PREFIX_PATH="SDK_PREFIX" -DCURL_DIR="CURL_DIR"
if ($LASTEXITCODE -ne 0) { throw 'CMake configure failed. Check the SDK prefix and matching libcurl development package.' }
cmake --build build --config Release --target licensed_app
if ($LASTEXITCODE -ne 0) { throw 'Build failed.' }

set -e
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DCMAKE_PREFIX_PATH="SDK_PREFIX"
cmake --build build --target licensed_app

SDK documentation

3. Protéger une véritable exportation

Initialisez le SDK au démarrage ou lors de l’activation de votre logiciel. Lisez la clé client dans votre formulaire et transmettez l’ID produit et les clés approuvées. Gardez le client jusqu’à la fermeture. Placez ln_run_feature au point d’entrée métier réel et remplacez l’export par votre fonction.

#include "licentivo.h"
#include <stdio.h>
#include <stdlib.h>

/* BEGIN LICENTIVO PRODUCT */
/* Copy Product ID and all key ID/public key pairs from Console > Products > Signing public keys. */
static const char *PRODUCT_ID = "YOUR_PRODUCT_ID";
static const char *TRUSTED_KEYS_JSON = "{\"YOUR_KEY_ID\":\"YOUR_PUBLIC_KEY\"}";
/* END LICENTIVO PRODUCT */

static const char *setting(const char *name, const char *fallback) {
    const char *value = getenv(name);
    return value && value[0] ? value : fallback;
}

static int export_report(void *context) {
    const char *path = (const char *)context;
    /* Replace this write with your existing, non-metered export operation. */
    FILE *file = fopen(path, "w");
    if (!file) { perror("Export write failed"); return 0; }
    int wrote = fputs("A report generated by the licensed application.\n", file) >= 0;
    int closed = fclose(file) == 0;
    return wrote && closed;
}

int main(void) {
    /* Keep the handle to report startup errors. A GUI supplies the activation input. */
    ln_client *client = ln_init_product(PRODUCT_ID, TRUSTED_KEYS_JSON, setting("LICENTIVO_LICENSE_KEY", ""));
    if (!client) {
        fputs("Startup failed: check the product ID and public keys and supply a license key for first activation.\n", stderr);
        return 2;
    }
    if (!ln_start(client)) {
        fprintf(stderr, "Startup failed: %s\n", ln_last_error(client));
        ln_destroy(client);
        return 2;
    }
    const char *feature = setting("LICENTIVO_FEATURE", "export");
    const char *path = setting("LICENTIVO_OUTPUT", "licensed-report.txt");
    int ok = setting("LICENTIVO_METERED", "")[0] == '1'
        ? ln_run_metered_feature(client, feature, 1, setting("LICENTIVO_OPERATION_ID", ""), export_report, (void *)path)
        : ln_run_feature(client, feature, export_report, (void *)path);
    if (!ok) {
        char *status = ln_feature_status(client, feature);
        fprintf(stderr, "Export denied or failed: %s; %s\n", status ? status : "status unavailable", ln_last_error(client));
        ln_free_string(status);
    }
    if (ok) printf("License OK: %s is available\nExport completed: %s\n", feature, path);
    ln_destroy(client); /* Real app: destroy on shutdown; no Deactivate on normal exit. */
    return ok ? 0 : 2;
}

4. Gardez le client en vie jusqu'à l'arrêt

Cet exemple de ligne de commande effectue une opération et se ferme. Dans une application de bureau, ouvrez un client au démarrage, appelez le rappel de fonctionnalité à partir de l'action d'exportation et fermez le client uniquement lorsque l'application se ferme.

Après l'activation, les démarrages ultérieurs peuvent laisser LICENTIVO_LICENSE_KEY vide et restaurer les informations d'identification privées sous le même utilisateur et le même emplacement de cache. Conservez ces informations d'identification dans le répertoire de données d'application utilisateur. La fermeture arrête les heartbeats et rend les sièges flottants ; la sortie normale ne doit pas désactiver un périphérique verrouillé par nœud.

L'accès hors ligne n'est disponible que lorsque la politique le permet et que la subvention signée reste valide. Une fonctionnalité expirée ou refusée doit rester bloquée. Les opérations mesurées nécessitent une connexion réseau.

Conservez la poignée ln_client jusqu'à l'arrêt. ln_start effectue l'autorisation de démarrage ; seul ln_run_feature ou la variante mesurée peut invoquer une œuvre protégée. Le rappel renvoie 1 en cas de réussite commerciale et 0 en cas d'échec. Libérez les chaînes d'état allouées avec ln_free_string, puis appelez le ln_destroy à l'arrêt.

Activation de licences C++ hors ligne

5. Exécutez et vérifiez le résultat

1. Confirmez qu'une licence valide avec accès à l'exportation crée licensed-report.txt.
2. Effacez LICENTIVO_LICENSE_KEY et réexécutez en utilisant le même compte utilisateur : les informations d'identification enregistrées doivent être restaurées.
3. Définissez LICENTIVO_FEATURE sur une fonctionnalité absente de la licence et LICENTIVO_OUTPUT sur un nouveau nom de fichier. Le programme doit signaler un refus sans créer ce fichier.
4. Testez un redémarrage hors ligne uniquement avec une autorisation signée autorisée et non expirée. Ne contournez pas une vérification de fonctionnalité ayant échoué après une erreur d’actualisation en arrière-plan.

$env:LICENTIVO_LICENSE_KEY = 'YOUR_TEST_LICENSE_KEY'
./build/Release/licensed_app.exe
Remove-Item Env:LICENTIVO_LICENSE_KEY
./build/Release/licensed_app.exe

LICENTIVO_LICENSE_KEY=YOUR_TEST_LICENSE_KEY ./build/licensed_app
unset LICENTIVO_LICENSE_KEY
./build/licensed_app

Limitez les exports de fichiers avec un compteur d'utilisation mensuel

Problèmes d'intégration courants

Vérifiez l’ID produit, toutes les paires ID de clé/clé publique et la licence du client. Les clés publiques appartiennent au produit ; licences et identifiants des appareils sont distincts. Ne distribuez pas de clés de test ou de clés API de gestion.

Fonctionnalité refusée, limite d'appareils atteinte ou licence expirée : inspectez la licence et la stratégie dans la console, puis affichez l'erreur SDK au client. Une autorisation échouée ne doit pas appeler la fonction d'exportation.

RunFeature vérifie l'accès aux fonctionnalités ; la variante mesurée réserve et règle l'utilisation configurée. Utilisez un ID d'opération stable par tâche métier réelle et inspectez son résultat durable avant de récupérer une tâche interrompue.

CMake ne trouve pas Licentivo : remplacez SDK_PREFIX dans la commande de configuration par le préfixe CMake indiqué par le programme d’installation. Le compilateur, l’architecture et libcurl doivent correspondre au paquet natif installé.