licentivo-launch 0.1.1

data/lib/licentivo_launch.rb

@@ -0,0 +1,352 @@
+# frozen_string_literal: true
+require 'json'
+require 'uri'
+require 'net/http'
+require 'openssl'
+require 'base64'
+require 'digest'
+require 'securerandom'
+require 'fileutils'
+require 'time'
+require 'monitor'
+
+module LicentivoLaunch
+  VERSION = '0.1.1'
+  LIMIT = 1 << 20
+  UUID = /\A[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}\z/
+  class Error < StandardError
+    attr_reader :code, :status, :retry_after_seconds
+    def initialize(code, status: 0, retry_after_seconds: 0)
+      @code = code.to_s.match?(/\A[A-Z][A-Z0-9_]{0,79}\z/) ? code.to_s : 'REQUEST_FAILED'
+      @status, @retry_after_seconds = status, [retry_after_seconds, 0].max
+      super("Launch: #{@code}")
+    end
+  end
+  # Cancellation is cooperative. A running native SDK operation finishes before
+  # cancellation is observed; it is never reclassified as an offline success.
+  class CancellationToken
+    def cancel = @cancelled = true
+    def check! = (raise Error.new('CANCELLED') if @cancelled)
+  end
+  class MemoryStore
+    def initialize = @values = {}
+    def persistent? = false
+    def load(scope) = @values.key?(scope) ? JSON.parse(JSON.generate(@values[scope])) : nil
+    def save(scope, record) = @values[scope] = JSON.parse(JSON.generate(record))
+    def delete(scope) = @values.delete(scope)
+  end
+  # The application must obtain this encryption key from its OS credential vault.
+  # Never save the key beside the encrypted records or inside product.json.
+  class EncryptedFileStore
+    def initialize(directory, key)
+      raise Error.new('STORE_KEY_REQUIRED') unless key.is_a?(String) && key.bytesize == 32
+      @root, @key = File.expand_path(directory), key.b.dup
+    end
+    def persistent? = true
+    def secure? = true
+    def path(scope) = File.join(@root, "#{Digest::SHA256.hexdigest(scope)}.aesgcm")
+    def load(scope)
+      return nil unless File.exist?(path(scope))
+      raise Error.new('INVALID_SAVED_SESSION') if File.size(path(scope)) > LIMIT
+      raw = File.binread(path(scope))
+      begin
+        raise ArgumentError unless raw.bytesize >= 30 && raw.getbyte(0) == 1
+        cipher = OpenSSL::Cipher.new('aes-256-gcm').decrypt
+        cipher.key, cipher.iv, cipher.auth_tag = @key, raw.byteslice(1, 12), raw.byteslice(13, 16)
+        cipher.auth_data = scope
+        plain = cipher.update(raw.byteslice(29..)) + cipher.final
+        JSON.parse(plain)
+      rescue OpenSSL::Cipher::CipherError, JSON::ParserError, ArgumentError
+        raise Error.new('INVALID_SAVED_SESSION')
+      ensure
+        plain&.replace("\0" * plain.bytesize)
+      end
+    end
+    def save(scope, record)
+      FileUtils.mkdir_p(@root, mode: 0o700)
+      plain, iv = JSON.generate(record), SecureRandom.random_bytes(12)
+      raise Error.new('INVALID_SAVED_SESSION') if plain.bytesize > LIMIT - 64
+      cipher = OpenSSL::Cipher.new('aes-256-gcm').encrypt
+      cipher.key, cipher.iv, cipher.auth_data = @key, iv, scope
+      encrypted = cipher.update(plain) + cipher.final
+      temporary = File.join(@root, ".session-#{SecureRandom.uuid}")
+      File.open(temporary, File::WRONLY | File::CREAT | File::EXCL, 0o600) { |f| f.binmode; f.write("\1" + iv + cipher.auth_tag + encrypted) }
+      File.rename(temporary, path(scope))
+    ensure
+      FileUtils.rm_f(temporary) if temporary
+      plain&.replace("\0" * plain.bytesize)
+    end
+    def delete(scope) = FileUtils.rm_f(path(scope))
+  end
+
+  def self.origin(value, environment)
+    uri = URI.parse(value)
+    allowed = uri.is_a?(URI::HTTPS) || environment == 'sandbox' && uri.is_a?(URI::HTTP) && %w[localhost 127.0.0.1 [::1]].include?(uri.host)
+    raise Error.new('INVALID_CONFIG') unless allowed && uri.host && !uri.userinfo && !uri.query && !uri.fragment && ['', '/'].include?(uri.path)
+    uri.path = ''; uri.to_s
+  rescue URI::InvalidURIError, TypeError
+    raise Error.new('INVALID_CONFIG')
+  end
+  def self.validate_config(launch, product)
+    fields = %w[schema_version merchant_origin launch_product_id licentivo_product_id environment]
+    unless launch.is_a?(Hash) && (launch.keys - fields).empty? && launch['schema_version'] == 1 && UUID.match?(launch['launch_product_id'].to_s) && UUID.match?(launch['licentivo_product_id'].to_s) && %w[sandbox live].include?(launch['environment'])
+      raise Error.new('INVALID_CONFIG')
+    end
+    public_fields = %w[product_id trusted_keys base_url app_version license_key cache_path device_name allow_http]
+    unless product.is_a?(Hash) && (product.keys - public_fields).empty? && product['product_id'] == launch['licentivo_product_id'] && [nil, ''].include?(product['license_key']) && [nil, ''].include?(product['cache_path']) && [nil, true, false].include?(product['allow_http'])
+      raise Error.new('PUBLIC_CONFIG_INVALID')
+    end
+    %w[app_version device_name].each do |field|
+      value = product[field]
+      raise Error.new('PUBLIC_CONFIG_INVALID') if value && (!value.is_a?(String) || value.length > (field == 'app_version' ? 80 : 128))
+    end
+    keys = product['trusted_keys']
+    unless keys.is_a?(Hash) && (1..32).cover?(keys.length) && keys.all? { |id, key| id.is_a?(String) && (1..128).cover?(id.length) && key.is_a?(String) && key.match?(/\A[A-Za-z0-9_-]{43}\z/) && Base64.urlsafe_encode64(Base64.urlsafe_decode64(key), padding: false) == key }
+      raise Error.new('PUBLIC_CONFIG_INVALID')
+    end
+    runtime_origin = origin(product['base_url'] || 'https://www.licentivo.com', launch['environment'])
+    raise Error.new('PUBLIC_CONFIG_INVALID') if runtime_origin.start_with?('http:') && product['allow_http'] != true
+    safe = { 'product_id' => product['product_id'], 'trusted_keys' => keys, 'base_url' => runtime_origin }
+    safe['app_version'] = product['app_version'] if product['app_version']
+    safe['allow_http'] = true if product['allow_http'] == true
+    [JSON.parse(JSON.generate(launch.merge('merchant_origin' => origin(launch['merchant_origin'], launch['environment'])))), JSON.parse(JSON.generate(safe))]
+  end
+  def self.load_config(launch_path, product_path)
+    read = lambda do |path|
+      raise Error.new('CONFIG_TOO_LARGE') if File.size(path) > 65_536
+      JSON.parse(File.read(path, encoding: 'bom|utf-8'))
+    end
+    validate_config(read.call(launch_path), read.call(product_path))
+  end
+
+  # Net::HTTP never follows redirects. Proxy inheritance is disabled to avoid
+  # accidentally routing merchant credentials through an application proxy.
+  def self.default_transport(request)
+    request[:cancellation]&.check!
+    uri = URI(request.fetch(:url))
+    http = Net::HTTP.new(uri.hostname, uri.port, nil)
+    http.use_ssl = uri.scheme == 'https'
+    http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    http.open_timeout = 10; http.read_timeout = 15; http.write_timeout = 15
+    http.max_retries = 0
+    req = (request[:method] == 'POST' ? Net::HTTP::Post : Net::HTTP::Get).new(uri.request_uri, request[:headers])
+    req.body = request[:body] if request[:body]
+    result = nil
+    # Explicit start keeps the connection alive until the response is consumed.
+    # Net::HTTP's implicit start adds Connection: close, which can cause a TCP
+    # reset on Windows when an endpoint ignores a small request body (logout).
+    http.start do |connection|
+      connection.request(req) do |response|
+        status = response.code.to_i
+        raise Error.new('REDIRECT_REJECTED', status: status) if (300..399).cover?(status)
+        body = +''
+        response.read_body do |chunk|
+          request[:cancellation]&.check!
+          body << chunk
+          raise Error.new('RESPONSE_TOO_LARGE') if body.bytesize > LIMIT
+        end
+        result = { status: status, headers: response.to_hash.transform_values(&:first), body: body }
+      end
+    end
+    request[:cancellation]&.check!
+    result
+  rescue IOError, SystemCallError, SocketError, Timeout::Error, OpenSSL::SSL::SSLError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError
+    request[:cancellation]&.check!
+    raise Error.new('NETWORK_UNAVAILABLE')
+  end
+
+  class Application
+    def initialize(launch, product, store: MemoryStore.new, transport: nil, runtime_factory: nil, cache_dir: nil, sleep: nil, pending_attempts: 5)
+      @launch, @product = LicentivoLaunch.validate_config(launch, product)
+      raise Error.new('SECURE_STORE_REQUIRED') unless store.respond_to?(:persistent?) && (!store.persistent? || store.respond_to?(:secure?) && store.secure?)
+      raise Error.new('INVALID_RETRY_POLICY') unless pending_attempts.is_a?(Integer) && (1..5).cover?(pending_attempts)
+      @store, @transport = store, transport || LicentivoLaunch.method(:default_transport)
+      @factory = runtime_factory || lambda do |config|
+        require_relative 'licentivo_launch/vendor/licentivo'
+        raise Error.new('SDK_VERSION_MISMATCH') unless Licentivo::VERSION == '0.11.0'
+        Licentivo::Client.new(config)
+      end
+      @root = File.expand_path(cache_dir || File.join(Dir.home, '.cache', 'LicentivoLaunch'))
+      @scope = ['launch-session-v1', @launch['merchant_origin'], @launch['launch_product_id'], @launch['licentivo_product_id'], @launch['environment']].join("\n")
+      @lock, @closed, @in_callback, @attempts = Monitor.new, false, false, pending_attempts
+      @wait = sleep || lambda { |seconds, cancellation| (seconds * 10).ceil.times { cancellation&.check!; Kernel.sleep(0.1) }; cancellation&.check! }
+    end
+    def self.connect(merchant_origin, product_id, licentivo_product_id, trusted_keys, environment: 'live', **options)
+      new({ 'schema_version' => 1, 'merchant_origin' => merchant_origin, 'launch_product_id' => product_id, 'licentivo_product_id' => licentivo_product_id, 'environment' => environment },
+          { 'base_url' => 'https://www.licentivo.com', 'product_id' => licentivo_product_id, 'trusted_keys' => trusted_keys }, **options)
+    end
+    def self.from_files(launch_path, product_path, **options) = new(*LicentivoLaunch.load_config(launch_path, product_path), **options)
+    def login(email, password, cancellation: nil)
+      serial do
+        cancellation&.check!; logout_internal(cancellation)
+        grant = call('/auth/login', method: 'POST', body: { email: email, password: password, kind: 'desktop' }, cancellation: cancellation)
+        @record = { 'version' => 1, 'scope' => @scope, 'user' => grant['user'], 'token' => grant['access_token'], 'expires_at' => grant['expires_at'] }
+        begin
+          raise Error.new('INVALID_SESSION') unless valid_identity?(@record) && expiry(@record) > Time.now
+          @record['credential'] = credential(cancellation)
+          state = start_runtime(false, cancellation); @store.save(@scope, @record); state
+        rescue StandardError
+          logout_internal(nil); raise
+        end
+      end
+    end
+    def restore(cancellation: nil)
+      serial do
+        cancellation&.check!; stop; @record = saved
+        next nil unless @record
+        if expiry(@record) <= Time.now
+          clear; raise Error.new('SESSION_EXPIRED')
+        end
+        begin
+          me = call('/me', cancellation: cancellation)
+          raise Error.new('SESSION_MISMATCH', status: 401) unless me.dig('user', 'id') == @record.dig('user', 'id')
+          @record['credential'] = credential(cancellation); @record['user'] = me['user']
+        rescue Error => e
+          cancellation&.check!
+          next start_runtime(true, cancellation) if e.code == 'NETWORK_UNAVAILABLE' || (500..599).cover?(e.status)
+          clear if e.code != 'ENTITLEMENT_PENDING' && ([401, 403, 404].include?(e.status) || %w[SESSION_EXPIRED SESSION_MISMATCH ENTITLEMENT_EXPIRED ENTITLEMENT_SUSPENDED ENTITLEMENT_NOT_PURCHASED].include?(e.code))
+          raise
+        end
+        begin
+          state = start_runtime(false, cancellation); @store.save(@scope, @record); state
+        rescue StandardError
+          clear; raise
+        end
+      end
+    end
+    def run_feature(feature, &action)
+      serial do
+        raise Error.new('LOGIN_REQUIRED') unless @runtime
+        @runtime.run_feature(feature) do
+          begin
+            @in_callback = true; action.call
+          ensure
+            @in_callback = false
+          end
+        end
+      end
+    end
+    def logout(cancellation: nil) = serial { logout_internal(cancellation) }
+    def release_device(cancellation: nil)
+      serial do
+        cancellation&.check!
+        raise Error.new('LOGIN_REQUIRED') unless @runtime
+        begin
+          @runtime.deactivate; cancellation&.check!
+        ensure
+          logout_internal(cancellation)
+        end
+      end
+    end
+    def close
+      @lock.synchronize do
+        raise Error.new('WORKFLOW_BUSY') if @in_callback
+        return if @closed
+        @closed = true
+        begin; stop; ensure; @record = nil; end
+      end
+    end
+
+    private
+    def serial
+      @lock.synchronize do
+        raise Error.new('APPLICATION_CLOSED') if @closed
+        raise Error.new('WORKFLOW_BUSY') if @in_callback
+        yield
+      end
+    end
+    def cache(record) = File.join(@root, Digest::SHA256.hexdigest(@scope), Digest::SHA256.hexdigest(record.dig('user', 'id')), 'lease.json')
+    def expiry(record) = Time.iso8601(record['expires_at'])
+    def valid_identity?(record)
+      record.is_a?(Hash) && record['version'] == 1 && record['scope'] == @scope && record['user'].is_a?(Hash) && UUID.match?(record.dig('user', 'id').to_s) && record['token'].is_a?(String) && record['token'].match?(/\A[A-Za-z0-9_-]{43}\z/) && record['expires_at'].is_a?(String) && record['expires_at'].match?(/(?:Z|[+-]\d\d:\d\d)\z/) && expiry(record)
+    rescue ArgumentError, TypeError
+      false
+    end
+    def saved
+      record = @store.load(@scope)
+      if record && !(valid_identity?(record) && record['credential'].is_a?(Hash) && record.dig('credential', 'product_id') == @launch['launch_product_id'] && record.dig('credential', 'license_key').is_a?(String) && !record.dig('credential', 'license_key').empty?)
+        clear(record); raise Error.new('INVALID_SAVED_SESSION')
+      end
+      record
+    rescue StandardError
+      @store.delete(@scope); raise
+    end
+    def call(path, method: 'GET', body: nil, cancellation: nil, token: @record&.fetch('token', nil))
+      cancellation&.check!
+      headers = { 'Accept' => 'application/json', 'Content-Type' => 'application/json' }
+      headers['Authorization'] = "Bearer #{token}" if token
+      response = @transport.call(url: @launch['merchant_origin'] + '/api/v1' + path, method: method, headers: headers, body: body && JSON.generate(body), cancellation: cancellation)
+      cancellation&.check!
+      status = response[:status]
+      raise Error.new('INVALID_RESPONSE') unless status.is_a?(Integer) && response[:body].is_a?(String) && response[:body].bytesize <= LIMIT
+      raise Error.new('REDIRECT_REJECTED', status: status) if (300..399).cover?(status)
+      begin
+        data = JSON.parse(response[:body])
+      rescue JSON::ParserError
+        raise Error.new((500..599).cover?(status) ? 'SERVICE_UNAVAILABLE' : 'INVALID_RESPONSE', status: status)
+      end
+      raise Error.new('INVALID_RESPONSE', status: status) unless data.is_a?(Hash)
+      if status != 200
+        retry_header = response.fetch(:headers, {})['retry-after'].to_s
+        seconds = retry_header.match?(/\A\d+\z/) ? retry_header.to_i : (Time.httpdate(retry_header) - Time.now).ceil rescue 0
+        raise Error.new(data.dig('error', 'code') || 'REQUEST_FAILED', status: status, retry_after_seconds: seconds)
+      end
+      raise Error.new('INVALID_RESPONSE') unless data['data'].is_a?(Hash)
+      data['data']
+    end
+    def credential(cancellation)
+      @attempts.times do |attempt|
+        begin
+          value = call("/software/products/#{@launch['launch_product_id']}/credential", method: 'POST', body: { environment: @launch['environment'] }, cancellation: cancellation)
+          raise Error.new('CREDENTIAL_MISMATCH') unless value['product_id'] == @launch['launch_product_id'] && value['license_key'].is_a?(String) && !value['license_key'].empty? && value['version'].is_a?(Integer) && value['version'] >= 1
+          return value
+        rescue Error => e
+          raise unless e.status == 403 && e.code == 'ENTITLEMENT_PENDING' && attempt + 1 < @attempts && e.retry_after_seconds <= 30
+          @wait.call([3, e.retry_after_seconds].max, cancellation); cancellation&.check!
+        end
+      end
+    end
+    def start_runtime(offline, cancellation)
+      cancellation&.check!
+      path = cache(@record); FileUtils.mkdir_p(File.dirname(path), mode: 0o700)
+      runtime = @factory.call(@product.merge('license_key' => @record.dig('credential', 'license_key'), 'cache_path' => path))
+      begin
+        cancellation&.check!
+        if offline
+          state = runtime.status
+          raise Error.new('OFFLINE_UNAVAILABLE') unless state['allowed'] == true && state['state'] == 'offline_valid'
+        end
+        runtime.start; cancellation&.check!; @runtime = runtime
+        { user: JSON.parse(JSON.generate(@record['user'])), expires_at: @record['expires_at'], offline_fallback: offline }
+      rescue StandardError
+        runtime.close; raise
+      end
+    end
+    def stop
+      runtime, @runtime = @runtime, nil
+      runtime&.close
+    end
+    def clear(record = @record)
+      begin
+        stop
+      ensure
+        @record = nil
+        begin
+          @store.delete(@scope)
+        ensure
+          FileUtils.rm_rf(File.dirname(cache(record))) if record.is_a?(Hash) && record['user'].is_a?(Hash) && UUID.match?(record.dig('user', 'id').to_s)
+        end
+      end
+    end
+    def logout_internal(cancellation)
+      record = @record || saved
+      clear(record)
+      return true unless record
+      begin
+        call('/auth/logout', method: 'POST', body: {}, cancellation: cancellation, token: record['token']); true
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/vendor/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 spf86 and Licentivo contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/vendor/NOTICE

@@ -0,0 +1,17 @@
+Licentivo client SDKs
+Copyright (c) 2026 spf86 and Licentivo contributors
+Project: https://github.com/spf86/licentivo-sdk
+
+The MIT license applies to the Licentivo client SDK code, examples and
+installation tools. The licensing server and administration application are
+separate software and are not included in this SDK distribution.
+
+Bundled third-party source retains its original license:
+- cJSON: see sdk/c/vendor/cJSON-LICENSE (or c/vendor/cJSON-LICENSE).
+- Monocypher and its Ed25519 extension: see
+  sdk/c/vendor/Monocypher-LICENCE.md (or c/vendor/Monocypher-LICENCE.md).
+Native packages include these files in the licenses directory.
+
+External dependencies such as libcurl, OpenSSL, cryptography, undici and
+BouncyCastle retain their own licenses. Their installation is handled by
+the corresponding package manager or the target system.

data/vendor/VERSION

@@ -0,0 +1 @@
+0.11.0

data/vendor/c/app.c

@@ -0,0 +1,33 @@
+/* A customer application's activation screen and protected report operation. */
+#include "licentivo.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.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 void line(char *value,size_t capacity){if(!fgets(value,(int)capacity,stdin))value[0]=0;value[strcspn(value,"\r\n")]=0;}
+static int write_report(void *context){const char *path=(const char*)context;FILE *file=fopen(path,"w");if(!file)return 0;int ok=fputs("Item,Quantity,Price\nNotebook,2,12.50\nPen,5,3.00\n",file)>=0;return fclose(file)==0&&ok;}
+int main(void){
+ char key[80],choice[16];printf("License key (empty to restore this device): ");line(key,sizeof(key));
+ ln_client *client=ln_init_product(PRODUCT_ID,TRUSTED_KEYS_JSON,key);
+ if(!client){fputs("Check product ID, public keys and activation input.\n",stderr);return 2;}
+ if(!ln_start(client)){fprintf(stderr,"%s\n",ln_last_error(client));ln_destroy(client);return 2;}
+ for(;;){
+  puts("1 Status  2 Export CSV  3 Pro report  4 Refresh license  5 Release device  0 Exit");line(choice,sizeof(choice));
+  if(!choice[0]||!strcmp(choice,"0"))break;
+  int ok=1;
+  if(!strcmp(choice,"1")){char *status=ln_status(client);puts(status?status:"unavailable");ln_free_string(status);}
+  if(!strcmp(choice,"2"))ok=ln_run_feature(client,"export",write_report,"licensed-report.csv");
+  if(!strcmp(choice,"3"))ok=ln_run_feature(client,"pro",write_report,"pro-report.csv");
+  if(!strcmp(choice,"4"))ok=ln_refresh_online(client);
+  if(!strcmp(choice,"5"))ok=ln_deactivate(client);
+  if(!ok)fprintf(stderr,"Operation blocked or failed: %s\n",ln_last_error(client));
+ }
+ ln_destroy(client);return 0;
+}

data/vendor/c/demo.c

@@ -0,0 +1,77 @@
+#define _POSIX_C_SOURCE 200809L
+#ifdef _WIN32
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x0600
+#endif
+#endif
+#include "licentivo.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <time.h>
+#ifdef _WIN32
+#include <windows.h>
+static double clock_seconds(void){return GetTickCount64()/1000.0;}
+#else
+static double clock_seconds(void){struct timespec t;clock_gettime(CLOCK_MONOTONIC,&t);return t.tv_sec+t.tv_nsec/1e9;}
+#endif
+#include "vendor/cJSON.h"
+static char *read_text(const char *path) { FILE*f=fopen(path,"rb");if(!f)return NULL;char*b=calloc(32769,1);size_t n=fread(b,1,32768,f);int bad=ferror(f)||!feof(f);fclose(f);if(bad||!n){free(b);return NULL;}return b;}
+static int used_is(const char*s,double used,double over){cJSON*j=s?cJSON_Parse(s):NULL;const cJSON*u=cJSON_GetObjectItemCaseSensitive(j,"used"),*o=cJSON_GetObjectItemCaseSensitive(j,"overage");int ok=cJSON_IsNumber(u)&&u->valuedouble==used&&cJSON_IsNumber(o)&&o->valuedouble==over;cJSON_Delete(j);return ok;}
+
+static cJSON*receipt(char*value){if(!value)return NULL;cJSON*j=ln_json(value);ln_free_string(value);return j;}
+static int reservation_is(const cJSON*j,const char*status,double used){const cJSON*s=cJSON_GetObjectItemCaseSensitive(j,"status"),*cons=cJSON_GetObjectItemCaseSensitive(j,"consumption"),*u=cJSON_GetObjectItemCaseSensitive(cons,"used");return cJSON_IsString(s)&&!strcmp(s->valuestring,status)&&cJSON_IsNumber(u)&&u->valuedouble==used;}
+static int improvements(ln_client*c,const char*path){int ok=ln_start(c);cJSON*one=ok?receipt(ln_reserve(c,"export",1,"cancel-job")):NULL;ok=ok&&reservation_is(one,"pending",0);const cJSON*id=cJSON_GetObjectItemCaseSensitive(one,"reservation_id");cJSON*cancel=ok?receipt(ln_cancel(c,id->valuestring,"cancel-job")):NULL;ok=ok&&reservation_is(cancel,"canceled",0);cJSON_Delete(cancel);cJSON_Delete(one);cJSON*two=ok?receipt(ln_reserve(c,"export",1,"commit-job")):NULL;id=cJSON_GetObjectItemCaseSensitive(two,"reservation_id");for(int i=0;i<2&&ok;i++){cJSON*done=receipt(ln_commit(c,id->valuestring,"commit-job"));ok=reservation_is(done,"committed",1);cJSON_Delete(done);}cJSON_Delete(two);cJSON*replay=ok?receipt(ln_reserve(c,"export",1,"commit-job")):NULL;ok=ok&&reservation_is(replay,"committed",1);cJSON_Delete(replay);char*over=ok?ln_consume(c,"export",1000,"quota-job"):NULL;ln_error_info e={0};ln_get_error_info(c,&e);ok=ok&&!over&&!strcmp(e.code,"FEATURE_QUOTA_EXCEEDED")&&e.request_id[0]&&!e.retryable&&ln_check_feature(c,"export");ln_free_string(over);ln_client*restored=ok?ln_init_file_with_license(path,""):NULL;ok=ok&&restored&&ln_start(restored)&&ln_validate(restored)&&ln_check_feature(restored,"export")&&ln_deactivate(restored)&&!ln_check_feature(restored,"export");ln_destroy(restored);return ok;}
+int main(int argc, char **argv) {
+    const char *path = argc > 2 && !strcmp(argv[1], "--config") ? argv[2] : ".local/protocol-fixture.json";
+    int cache_test = 0;
+    for (int i = 1; i < argc; i++) if (!strcmp(argv[i], "--cache-test")) cache_test = 1;
+    ln_client *client = ln_init_file(path);
+    if (!client) { fprintf(stderr, "C: invalid configuration\n"); return 1; }
+    for(int i=1;i<argc;i++)if(!strcmp(argv[i],"--improvements-test")){int ok=improvements(client,path);if(!ok)fprintf(stderr,"C: %s\n",ln_last_error(client));ln_destroy(client);if(ok)puts("C: credential / reservation / typed status OK");return ok?0:1;}
+    for(int i=1;i<argc;i++)if(!strcmp(argv[i],"--startup-test")){double start=clock_seconds();int ok=ln_start(client)&&clock_seconds()-start<.3;start=clock_seconds();ok=ok&&ln_check_feature(client,"export")&&clock_seconds()-start<.3;ln_destroy(client);if(ok)puts("C: cached startup and local feature checks stay responsive");return ok?0:1;}
+    int advanced=0,offline_export=0,offline_import=0,floating=0;
+    for(int i=1;i<argc;i++){if(!strcmp(argv[i],"--advanced-test"))advanced=1;if(!strcmp(argv[i],"--offline-export"))offline_export=1;if(!strcmp(argv[i],"--offline-import"))offline_import=1;if(!strcmp(argv[i],"--floating-test"))floating=1;}
+    if(offline_export){char*request=ln_offline_request(client,"activate");char file[4096];snprintf(file,sizeof(file),"%s.request.json",path);FILE*f=request?fopen(file,"wb"):NULL;int ok=f&&fwrite(request,1,strlen(request),f)==strlen(request);if(f)fclose(f);ln_free_string(request);ln_destroy(client);if(ok)puts("C: offline request exported");return ok?0:1;}
+    for(int i=1;i<argc;i++)if(!strcmp(argv[i],"--transfer-test")||!strcmp(argv[i],"--transfer-import")){
+        int ok=1;if(!strcmp(argv[i],"--transfer-import")){char file[4096];snprintf(file,sizeof(file),"%s.request.json",path);char*req=read_text(file);snprintf(file,sizeof(file),"%s.response.json",path);char*res=read_text(file);ok=req&&res&&ln_import_offline(client,req,res);free(req);free(res);}else ok=ln_start(client);
+        ok=ok&&ln_validate(client)&&ln_heartbeat(client)&&ln_check_feature(client,"export");if(!ok)fprintf(stderr,"C: %s\n",ln_last_error(client));ln_destroy(client);if(ok)puts("C: transferred device credential OK");return ok?0:1;
+    }
+    if(floating){int ok=ln_start(client);ln_client*other=ln_init_file(path);ok=ok&&other&&!ln_check_feature(other,"export")&&!ln_start(other);ln_destroy(client);ok=ok&&ln_start(other)&&ln_check_feature(other,"export");ln_destroy(other);if(ok)puts("C: floating seat release OK");return ok?0:1;}
+    if(advanced||offline_import){int ok=1;
+        if(offline_import){char file[4096];snprintf(file,sizeof(file),"%s.request.json",path);char*req=read_text(file);snprintf(file,sizeof(file),"%s.response.json",path);char*res=read_text(file);ok=req&&res&&ln_import_offline(client,req,res);free(req);free(res);}else ok=ln_start(client);
+        ok=ok&&ln_check_feature(client,"export");char*r=ok?ln_consume(client,"export",1,"business-job-1"):NULL;ok=ok&&used_is(r,1,0);ln_free_string(r);
+        r=ok?ln_consume(client,"export",1,"business-job-1"):NULL;ok=ok&&used_is(r,1,0);ln_free_string(r);
+        r=ok?ln_consume(client,"export",3,"business-job-2"):NULL;ok=ok&&used_is(r,4,1);ln_free_string(r);
+        r=ok?ln_consume(client,"export",1,"business-job-3"):NULL;ok=ok&&!r&&strstr(ln_last_error(client),"FEATURE_QUOTA_EXCEEDED")&&ln_check_feature(client,"export");ln_free_string(r);
+        ok=ok&&ln_deactivate(client);if(!ok)fprintf(stderr,"C: %s\n",ln_last_error(client));ln_destroy(client);if(ok)puts("C: offline/metered feature checks OK");return ok?0:1;
+    }
+    for(int i=1;i<argc;i++)if(!strcmp(argv[i],"--refresh-test")){
+        int ok=!ln_refresh_online(client)&&ln_check_feature(client,"export");
+        ok=ok&&ln_refresh_online(client)&&ln_check_feature(client,"updated")&&!ln_check_feature(client,"export");
+        ok=ok&&!ln_refresh_online(client)&&!ln_check_feature(client,"updated");
+        ln_destroy(client);if(ok)puts("C: online refresh OK");return ok?0:1;
+    }
+    int policy_test=0,deny=0;
+    for(int i=1;i<argc;i++){if(!strcmp(argv[i],"--policy-test"))policy_test=1;if(!strcmp(argv[i],"--expect-denied"))deny=1;}
+    if(policy_test){int ok=ln_check_feature(client,"export")!=deny;if(ok&&!deny)ok=ln_activate(client)&&ln_validate(client)&&ln_heartbeat(client);ln_destroy(client);if(ok)puts("C: policy cache OK");return ok?0:1;}
+    int ok = ln_activate(client);
+    if (ok && cache_test) {
+        ln_destroy(client); client = ln_init_file(path);
+        ok = client && ln_validate(client) && ln_check_feature(client, "export");
+        if (ok) ok = !ln_validate(client) && !ln_check_feature(client, "export");
+        ln_destroy(client); client = ln_init_file(path);
+        ok = ok && client && !ln_check_feature(client, "export");
+        if (ok) puts("C: cache restored on 503; 403 invalidated access and persisted cache");
+    } else if (ok) {
+        ok = ln_validate(client) && ln_heartbeat(client);
+        if (ok) {
+            printf("C: activated, validated, heartbeat OK; export enabled %d\n", ln_check_feature(client, "export"));
+            ok = ln_deactivate(client);
+        }
+        if (ok) puts("C: deactivated");
+    }
+    if (!ok) fprintf(stderr, "C: %s\n", ln_last_error(client));
+    ln_destroy(client);
+    return ok ? 0 : 1;
+}

data/vendor/c/feature_tasks.h

@@ -0,0 +1,72 @@
+/* Included by licentivo.c only. Private task IDs/outcome, never business data. */
+static int task_error(ln_client*c,const char*code){lock(c);snprintf(c->error,sizeof(c->error),"%s",code);c->http_status=0;c->retryable=0;c->request_id[0]=0;view_lock(c);int online=c->view_online;view_unlock(c);publish(c,online);unlock(c);return 0;}
+static int task_enter(ln_client*c){view_lock(c);int busy=c->task_busy;if(!busy)c->task_busy=1;view_unlock(c);return !busy;}
+static void task_leave(ln_client*c){view_lock(c);c->task_busy=0;view_unlock(c);}
+static char*task_path(ln_client*c,const char*id){
+ if(!id||!id[0]||strlen(id)>80)return NULL;
+ for(const unsigned char*p=(const unsigned char*)id;*p;p++)if(*p<33||*p>126)return NULL;
+ char source[65],digest[65],input[256];lock(c);
+ const char*key=text(c->cfg,"license_key");int ok=key&&key[0]?hash(key,source):text(c->auth,"source_hash")!=NULL;
+ if(ok&&(!key||!key[0]))snprintf(source,sizeof(source),"%s",text(c->auth,"source_hash"));unlock(c);
+ if(!ok)return NULL;snprintf(input,sizeof(input),"%s\n%s",source,id);if(!hash(input,digest))return NULL;
+ const char*cache=text(c->cfg,"cache_path");if(!cache)return NULL;
+ char*path=malloc(strlen(cache)+78);if(path)sprintf(path,"%s.task-%s.json",cache,digest);return path;
+}
+static cJSON*task_read(const char*path,const char*id){
+ struct stat info;if(stat(path,&info)==0){if(info.st_size>4096)return NULL;char*raw=readfile(path,4096);cJSON*task=raw?ln_json(raw):NULL;free(raw);int64_t version;
+  int64_t quantity;
+  if(!task||!num(task,"version",&version)||version!=1||!text(task,"operation_id")||strcmp(text(task,"operation_id"),id)||!text(task,"reservation_id")||!text(task,"reservation_id")[0]||!text(task,"state")||!text(task,"feature")||!text(task,"feature")[0]||!num(task,"quantity",&quantity)||quantity<=0){cJSON_Delete(task);return NULL;}return task;
+ }
+ if(errno!=ENOENT)return NULL;
+ cJSON*task=cJSON_CreateObject();cJSON_AddNumberToObject(task,"version",1);cJSON_AddStringToObject(task,"operation_id",id);cJSON_AddStringToObject(task,"reservation_id","");cJSON_AddStringToObject(task,"state","");return task;
+}
+static void task_state(cJSON*task,const char*state){cJSON_ReplaceItemInObjectCaseSensitive(task,"state",cJSON_CreateString(state));}
+static int task_finish(ln_client*c,const char*path,cJSON*task,int succeeded){
+ char*raw=succeeded?ln_commit(c,text(task,"reservation_id"),text(task,"operation_id")):ln_cancel(c,text(task,"reservation_id"),text(task,"operation_id"));
+ cJSON*receipt=raw?ln_json(raw):NULL;ln_free_string(raw);if(!receipt)return 0;
+ const char*state=text(receipt,"status"),*expected=succeeded?"committed":"canceled";
+ int ok=state&&!strcmp(state,expected);cJSON_Delete(receipt);
+ if(!ok)return task_error(c,"RESERVATION_CLOSED");task_state(task,expected);
+ return write_state(path,task)?1:task_error(c,"TASK_JOURNAL_ERROR");
+}
+int ln_run_metered_feature(ln_client*c,const char*feature,int64_t quantity,const char*id,ln_feature_action action,void*context){
+ if(!c||!feature||!action||quantity<=0)return c?task_error(c,"TASK_INPUT_INVALID"):0;
+ if(!task_enter(c))return task_error(c,"TASK_BUSY");
+ int ok=0;char*path=task_path(c,id);cJSON*task=path?task_read(path,id):NULL;
+ if(!task){task_error(c,"TASK_JOURNAL_ERROR");goto done;}
+ const char*state=text(task,"state");
+ if(state[0]){int64_t old_quantity;if(!text(task,"feature")||strcmp(text(task,"feature"),feature)||!num(task,"quantity",&old_quantity)||old_quantity!=quantity){task_error(c,"OPERATION_ID_CONFLICT");goto done;}}
+ if(!state[0]){cJSON_AddStringToObject(task,"feature",feature);cJSON_AddNumberToObject(task,"quantity",(double)quantity);}
+ if(!strcmp(state,"committed")){ok=1;goto done;}
+ if(!strcmp(state,"commit_pending")){ok=task_finish(c,path,task,1);goto done;}
+ if(!strcmp(state,"cancel_pending")){if(!task_finish(c,path,task,0))goto done;task_error(c,"OPERATION_CANCELED");goto done;}
+ if(!strcmp(state,"canceled")){task_error(c,"OPERATION_CANCELED");goto done;}
+ if(!strcmp(state,"business_running")){task_error(c,"BUSINESS_OUTCOME_UNKNOWN");goto done;}
+ if(state[0]){task_error(c,"TASK_JOURNAL_ERROR");goto done;}
+ if(!ln_check_feature(c,feature)){task_error(c,"FEATURE_NOT_ENTITLED");goto done;}
+ char*raw=ln_reserve(c,feature,quantity,id);cJSON*hold=raw?ln_json(raw):NULL;ln_free_string(raw);
+ if(!hold)goto done;
+ const char*held=text(hold,"status");
+ if(held&&!strcmp(held,"committed")){cJSON_ReplaceItemInObjectCaseSensitive(task,"reservation_id",cJSON_CreateString(text(hold,"reservation_id")));task_state(task,"committed");cJSON_Delete(hold);ok=write_state(path,task)?1:task_error(c,"TASK_JOURNAL_ERROR");goto done;}
+ if(!held||strcmp(held,"pending")||!text(hold,"reservation_id")){cJSON_Delete(hold);task_error(c,"RESERVATION_CLOSED");goto done;}
+ cJSON_ReplaceItemInObjectCaseSensitive(task,"reservation_id",cJSON_CreateString(text(hold,"reservation_id")));cJSON_Delete(hold);task_state(task,"business_running");
+ if(!write_state(path,task)){raw=ln_cancel(c,text(task,"reservation_id"),id);ln_free_string(raw);task_error(c,"TASK_JOURNAL_ERROR");goto done;}
+ if(!action(context)){
+  task_state(task,"cancel_pending");if(write_state(path,task))task_finish(c,path,task,0);task_error(c,"BUSINESS_ACTION_FAILED");goto done;
+ }
+ task_state(task,"commit_pending");if(!write_state(path,task)){task_error(c,"BUSINESS_COMPLETED_JOURNAL_ERROR");goto done;}
+ ok=task_finish(c,path,task,1);
+done:
+ cJSON_Delete(task);free(path);task_leave(c);return ok;
+}
+int ln_resolve_metered_feature(ln_client*c,const char*id,int succeeded){
+ if(!c)return 0;if(!task_enter(c))return task_error(c,"TASK_BUSY");
+ int ok=0;char*path=task_path(c,id);cJSON*task=path?task_read(path,id):NULL;
+ if(!task){task_error(c,"TASK_JOURNAL_ERROR");goto done;}
+ const char*state=text(task,"state");if(!strcmp(state,succeeded?"committed":"canceled")){ok=1;goto done;}
+ if(!text(task,"reservation_id")[0]||(strcmp(state,"business_running")&&strcmp(state,"commit_pending")&&strcmp(state,"cancel_pending"))||(!succeeded&&!strcmp(state,"commit_pending"))||(succeeded&&!strcmp(state,"cancel_pending"))){task_error(c,"TASK_OUTCOME_CONFLICT");goto done;}
+ task_state(task,succeeded?"commit_pending":"cancel_pending");if(!write_state(path,task)){task_error(c,"TASK_JOURNAL_ERROR");goto done;}
+ ok=task_finish(c,path,task,succeeded);
+done:
+ cJSON_Delete(task);free(path);task_leave(c);return ok;
+}