SDK de licencias de software en C: guía CMake

1. Prepare el producto y la licencia.

En una aplicación nativa C11, usa el SDK de C para activar la licencia del cliente y comprobar el acceso a una función antes de llamar al callback de la operación. Empieza con una licencia vinculada al dispositivo y una exportación sin contador de uso; añade contadores cuando funcione el flujo básico.

La cuota cuenta las activaciones actuales y se recupera al liberarlas. Las licencias normales cuentan sin conexión; las flotantes también liberan cuota al vencer su arrendamiento.

1. Copia el ID del producto en Consola > Productos. Abre las claves públicas de firma del mismo producto y pega todos los pares ID de clave/clave pública en el código de inicialización, sustituyendo YOUR_PRODUCT_ID, YOUR_KEY_ID y YOUR_PUBLIC_KEY. La integración rápida puede generar este código. No hace falta un archivo de configuración; el SDK usa https://www.licentivo.com de forma predeterminada.
2. En Integración rápida, cree o seleccione un producto. Habilite una función denominada exportación en su política y prepare una licencia de prueba.

SDK documentación

2. Instale el SDK

Instala CMake 3.18 o posterior. En Windows x64, usa Visual Studio 2022 C++ Build Tools y el paquete SDK MSVC correspondiente, con -G "Visual Studio 17 2022" -A x64. En Linux x64, utiliza compiladores C11/C++17. Sustituye SDK_PREFIX por el prefijo de CMake que muestre el instalador. Guarda el ejemplo como app.c y el CMakeLists.txt siguiente en el mismo directorio.

Instala un paquete de desarrollo de libcurl compartida compatible con el compilador y la arquitectura. En Windows MSVC x64, sustituye CURL_DIR por el directorio que contiene CURLConfig.cmake, añade el directorio bin de curl a PATH para las pruebas locales y distribuye las DLL necesarias con la aplicación; en Linux, instala el paquete de desarrollo de libcurl compartida de tu distribución.

& ([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 documentación

3. Proteger una exportación real

Inicializa el SDK al iniciar o activar tu programa. Lee la clave del cliente en el formulario y pasa el ID del producto y las claves de confianza. Mantén el cliente hasta cerrar. Coloca ln_run_feature en la operación real y sustituye la exportación por tu propia función.

#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. Mantener vivo al cliente hasta el cierre.

Este ejemplo de línea de comandos realiza una operación y sale. En una aplicación de escritorio, abra un cliente al inicio, invoque la devolución de llamada de la función desde la acción de exportación y cierre el cliente solo cuando se cierre la aplicación.

Después de la activación, los inicios posteriores pueden dejar LICENTIVO_LICENSE_KEY vacío y restaurar la credencial privada con el mismo usuario y ubicación de caché. Mantenga esa credencial en el directorio de datos de la aplicación del usuario. El cierre detiene los heartbeats y devuelve los asientos flotantes; La salida normal no debe desactivar un dispositivo con nodo bloqueado.

El acceso sin conexión está disponible solo cuando la política lo permite y la concesión firmada sigue siendo válida. Una función caducada o denegada debe permanecer bloqueada. Las operaciones medidas requieren una conexión de red.

Mantenga la manija ln_client hasta el apagado. ln_start realiza la autorización de inicio; sólo ln_run_feature o la variante medida pueden invocar trabajo protegido. La devolución de llamada devuelve 1 en caso de éxito empresarial y 0 en caso de fracaso. Libere las cadenas de estado asignadas con ln_free_string, luego llame al ln_destroy al apagar.

Activación de licencias C++ sin conexión

5. Ejecute y verifique el resultado.

1. Confirme que una licencia válida con acceso de exportación crea licensed-report.txt.
2. Borre LICENTIVO_LICENSE_KEY y vuelva a ejecutarlo con la misma cuenta de usuario: la credencial guardada debería restaurarse.
3. Establezca LICENTIVO_FEATURE en una característica ausente de la licencia y LICENTIVO_OUTPUT en un nombre de archivo nuevo. El programa debe informar una denegación sin crear ese archivo.
4. Pruebe un reinicio sin conexión solo con una concesión firmada permitida y vigente. No omita una verificación de función fallida después de un error de actualización en 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 las exportaciones de archivos con un contador de uso mensual

Problemas comunes de integración

Comprueba el ID del producto, todos los pares ID de clave/clave pública y la licencia del cliente. Las claves públicas pertenecen al producto; las licencias y credenciales de dispositivo son independientes. No distribuyas claves de prueba ni API Keys de gestión.

Función denegada, límite de dispositivo alcanzado o licencia vencida: inspeccione la licencia y la política en la consola, luego muestre el error SDK al cliente. Una autorización fallida no debe llamar a la función de exportación.

RunFeature comprueba el acceso a las funciones; la variante medida reserva y liquida el uso configurado. Utilice una identificación de operación estable para cada trabajo comercial real e inspeccione su resultado duradero antes de recuperar un trabajo interrumpido.

CMake no puede encontrar Licentivo: reemplace SDK_PREFIX en el comando de configuración con el prefijo de CMake impreso por el instalador. El compilador, la arquitectura y libcurl deben coincidir con el paquete nativo instalado.