Licenze software in C: SDK e guida CMake

1. Preparare il prodotto e la licenza

Per un'applicazione nativa C11, usa l'SDK C per attivare la licenza del cliente e verificare l'accesso alle funzioni prima di chiamare la callback dell'operazione. Inizia con una licenza legata al dispositivo e un'esportazione senza conteggio dei consumi; aggiungi i contatori quando il flusso di base funziona.

La quota conta le attivazioni correnti e viene restituita al rilascio. Le licenze ordinarie contano anche offline; quelle flottanti restituiscono la quota anche alla scadenza del lease.

1. Copia l’ID prodotto da Console > Prodotti. Apri le chiavi pubbliche di firma dello stesso prodotto e inserisci tutte le coppie ID chiave/chiave pubblica nel codice di inizializzazione, sostituendo YOUR_PRODUCT_ID, YOUR_KEY_ID e YOUR_PUBLIC_KEY. L’integrazione rapida può generare il codice. Non serve un file di configurazione; l’SDK usa https://www.licentivo.com per impostazione predefinita.
2. In Integrazione rapida, crea o seleziona un prodotto. Abilita una funzionalità denominata esportazione nella sua policy e prepara una licenza di prova.

Documentazione SDK

2. Installare SDK

Installa CMake 3.18 o successivo. Su Windows x64 usa Visual Studio 2022 C++ Build Tools e il pacchetto SDK MSVC corrispondente, con -G "Visual Studio 17 2022" -A x64. Su Linux x64 servono compilatori C11/C++17. Sostituisci SDK_PREFIX con il prefisso CMake mostrato dall'installer. Salva l'esempio come app.c e il CMakeLists.txt seguente nella stessa cartella.

Installare un pacchetto di sviluppo libcurl condiviso compatibile con compilatore e architettura. Su Windows MSVC x64, sostituire CURL_DIR con la directory contenente CURLConfig.cmake, aggiungere la directory bin di curl a PATH per le prove locali e distribuire le DLL necessarie con l'applicazione; su Linux, installare il pacchetto di sviluppo libcurl condiviso della distribuzione.

& ([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

Documentazione SDK

3. Tutelare un'esportazione reale

Inizializza l’SDK all’avvio o nel gestore di attivazione della tua applicazione. Leggi la chiave cliente dal modulo e passa ID prodotto e chiavi attendibili. Mantieni il client fino alla chiusura. Inserisci ln_run_feature nell’operazione reale e sostituisci l’esportazione con la tua funzione.

#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. Mantenere il client attivo fino all'arresto

Questo esempio di riga di comando esegue un'operazione e termina. In un'applicazione desktop, apri un client all'avvio, richiama la funzione di callback dall'azione di esportazione e chiudi il client solo alla chiusura dell'applicazione.

Dopo l'attivazione, gli avvii successivi possono lasciare vuoto LICENTIVO_LICENSE_KEY e ripristinare la credenziale privata con lo stesso utente e percorso cache. Conserva le credenziali nella directory application-data dell'utente. La chiusura ferma i heartbeat e restituisce i posti fluttuanti; l'uscita normale non dovrebbe disattivare un dispositivo con nodo bloccato.

L'accesso offline è disponibile solo quando la policy lo consente e la concessione firmata rimane valida. Una funzionalità scaduta o negata deve rimanere bloccata. Le operazioni a consumo richiedono una connessione di rete.

Conservare la maniglia ln_client fino allo spegnimento. ln_start esegue l'autorizzazione all'avvio; solo ln_run_feature o la variante a consumo possono invocare il lavoro protetto. La callback restituisce 1 in caso di successo aziendale e 0 in caso di fallimento. Rilascia le stringhe di stato allocate con ln_free_string, quindi chiama ln_destroy allo spegnimento.

Attivazione offline delle licenze C++

5. Esegui e verifica il risultato

1. Confermare che una licenza valida con accesso all'esportazione crei licensed-report.txt.
2. Cancella LICENTIVO_LICENSE_KEY ed esegui nuovamente utilizzando lo stesso account utente: le credenziali salvate dovrebbero essere ripristinate.
3. Imposta LICENTIVO_FEATURE su una funzionalità assente nella licenza e LICENTIVO_OUTPUT su un nuovo nome file. Il programma deve segnalare un rifiuto senza creare quel file.
4. Testare un riavvio offline solo con una concessione firmata consentita e non scaduta. Non ignorare un controllo delle funzionalità non riuscito dopo un errore di aggiornamento in background.

$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

Limita le esportazioni di file con un contatore di utilizzo mensile

Problemi comuni di integrazione

Controlla ID prodotto, tutte le coppie ID chiave/chiave pubblica e la licenza del cliente. Le chiavi pubbliche appartengono al prodotto; licenze e credenziali dei dispositivi sono separate. Non distribuire chiavi di test o API Key di gestione.

Funzionalità negata, limite dispositivo raggiunto o licenza scaduta: controlla la licenza e la policy nella console, quindi mostra l'errore SDK al cliente. Un'autorizzazione fallita non deve richiamare la funzione di esportazione.

RunFeature controlla l'accesso alle funzionalità; la variante a consumo prenota e liquida l'utilizzo configurato. Utilizza un ID operazione stabile per un lavoro aziendale reale e controllane il risultato duraturo prima di ripristinare un lavoro interrotto.

CMake non riesce a trovare Licentivo: sostituire SDK_PREFIX nel comando configure con il prefisso CMake stampato dal programma di installazione. Compilatore, architettura e libcurl devono corrispondere al pacchetto nativo installato.