SDK de licenciamento em C: tutorial CMake

1. Prepare o produto e licencie

Em um aplicativo nativo C11, use o SDK C para ativar a licença do cliente e verificar o acesso às funções antes de chamar o callback da operação. Comece com uma licença vinculada ao dispositivo e uma exportação sem contador de uso; adicione contadores quando o fluxo básico estiver funcionando.

A cota conta as ativações atuais e retorna ao liberá-las. Licenças comuns continuam contando offline; licenças flutuantes também devolvem a cota quando a concessão expira.

1. Copie o ID do produto em Console > Produtos. Abra as chaves públicas de assinatura do mesmo produto e insira todos os pares ID da chave/chave pública no código de inicialização, substituindo YOUR_PRODUCT_ID, YOUR_KEY_ID e YOUR_PUBLIC_KEY. A integração rápida pode gerar esse código. Não é necessário um arquivo de configuração; o SDK usa https://www.licentivo.com por padrão.
2. Em Integração rápida, crie ou selecione um produto. Habilite um recurso denominado exportação em sua política e prepare uma licença de teste.

SDK documentação

2. Instale o SDK

Instale o CMake 3.18 ou posterior. No Windows x64, use Visual Studio 2022 C++ Build Tools e o pacote SDK MSVC correspondente, com -G "Visual Studio 17 2022" -A x64. No Linux x64, use compiladores C11/C++17. Substitua SDK_PREFIX pelo prefixo do CMake exibido pelo instalador. Salve o exemplo como app.c e o CMakeLists.txt abaixo no mesmo diretório.

Instale um pacote de desenvolvimento de libcurl compartilhada compatível com o compilador e a arquitetura. No Windows MSVC x64, substitua CURL_DIR pelo diretório que contém CURLConfig.cmake, adicione o diretório bin do curl ao PATH para os testes locais e distribua as DLLs necessárias com o aplicativo; no Linux, instale o pacote de desenvolvimento de libcurl compartilhada da sua distribuição.

& ([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 documentação

3. Proteja uma exportação real

Inicialize o SDK ao iniciar ou ativar seu software. Leia a chave do cliente no formulário e passe o ID do produto e as chaves confiáveis. Mantenha o cliente até o encerramento. Coloque ln_run_feature na operação real e substitua a exportação pela sua função.

#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. Mantenha o cliente ativo até o desligamento

Este exemplo de linha de comando executa uma operação e sai. Em um aplicativo de desktop, abra um cliente na inicialização, invoque o retorno de chamada do recurso da ação de exportação e feche o cliente somente quando o aplicativo for encerrado.

Após a ativação, iniciações posteriores podem deixar LICENTIVO_LICENSE_KEY vazio e restaurar a credencial privada no mesmo usuário e local de cache. Mantenha essa credencial no diretório application-data do usuário. O fechamento interrompe os heartbeats e devolve os assentos flutuantes; a saída normal não deve desativar um dispositivo bloqueado por nó.

O acesso off-line está disponível somente quando a política permitir e a concessão assinada permanecer válida. Um recurso expirado ou negado deve permanecer bloqueado. As operações medidas requerem uma conexão de rede.

Mantenha o identificador ln_client até o desligamento. ln_start realiza autorização de inicialização; apenas ln_run_feature ou a variante medida pode invocar trabalho protegido. O retorno de chamada retorna 1 em caso de sucesso nos negócios e 0 em caso de fracasso. Libere as sequências de status alocadas com ln_free_string e, em seguida, chame ln_destroy no desligamento.

Ativação offline de licenças em C++

5. Execute e verifique o resultado

1. Confirme se uma licença válida com acesso de exportação cria licensed-report.txt.
2. Limpe LICENTIVO_LICENSE_KEY e execute novamente usando a mesma conta de usuário: a credencial salva deve ser restaurada.
3. Defina LICENTIVO_FEATURE como um recurso ausente da licença e LICENTIVO_OUTPUT como um novo nome de arquivo. O programa deve reportar uma negação sem criar esse arquivo.
4. Teste uma reinicialização offline apenas com uma concessão assinada permitida e não expirada. Não ignore uma verificação de recurso com falha após um erro de atualização em segundo plano.

$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

Limite as exportações de arquivos com um contador de uso mensal

Problemas comuns de integração

Confira o ID do produto, todos os pares ID da chave/chave pública e a licença do cliente. As chaves públicas pertencem ao produto; licenças e credenciais de dispositivos são separadas. Não distribua chaves de teste ou API Keys de gerenciamento.

Recurso negado, limite de dispositivo atingido ou licença expirada: inspecione a licença e a política no console e mostre o erro SDK ao cliente. Uma autorização com falha não deve chamar a função de exportação.

RunFeature verifica o acesso ao recurso; a variante medida reserva e liquida o uso configurado. Use um ID de operação estável por trabalho comercial real e inspecione seu resultado durável antes de recuperar um trabalho interrompido.

O CMake não consegue encontrar o Licentivo: substitua SDK_PREFIX no comando configure pelo prefixo CMake impresso pelo instalador. Compilador, arquitetura e libcurl devem corresponder ao pacote nativo instalado.