Zen License Manager Documentation

import com.zenlicensemanager.zlm.*; /* import all classes from zlm1.jar */

public class APIExample
{
  public static void main(String[] args)
  {
    ZlmLicense license = null;
    try {
      license = new ZlmLicense();
      license.get("My Product", "1.0", null, ".", null);
    } catch (ZlmException e) {
      System.out.println("error: " + e.getMessage());
      System.exit(1);
    }
    System.out.println("got license!");
    license.free();
  }
  static {
    /* load shared ZLM library */
    if (System.getProperty("os.name").startsWith("Windows")) {
      System.loadLibrary("zlm_mt1");
    } else {
      System.loadLibrary("zlm1");
    }
  }
}

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

int main(int argc, char *argv[])
{
  ZlmLicense *license;
  char err[ZLM_ERRBUF];

  /* create license object */
  if (!(license = zlm_license_new(err))) {
    fprintf(stderr, "error: %s\n", err);
    return EXIT_FAILURE;
  }

  /* try to get license for product 'My Product' from the same directory as the
     executed binary and if that fails from the current directory */
  if (zlm_license_get(license, "My Product", "1.0", argv[0], ".", NULL, err)) {
    fprintf(stderr, "error: %s\n", err);
    zlm_license_free(license);
    return EXIT_FAILURE;
  }
  else
    puts("got license!");

  /**********************
   * run your code here *
   **********************/

  /* free license object */
  zlm_license_free(license);

  return EXIT_SUCCESS;
}

/*
  Copyright (c) 2013-2020 Wikena GmbH <support@zenlicensemanager.com>
  All rights reserved.
*/

#ifndef ZLM_H
#define ZLM_H

#ifdef __cplusplus
extern "C" {
#endif

#ifdef __ANDROID__
#include <jni.h>
#endif

#ifdef __APPLE__
#include <TargetConditionals.h>
#endif

/* The minimum size of an error buffer. */
#define ZLM_ERRBUF 1024

/* The minimum size of a salt string. */
#define ZLM_SALTLEN  65

/* ZLM error codes. */
#define ZLM_OK           0 /* everything went fine */
#define ZLM_NOMEM       -2 /* memory allocation error */
#define ZLM_IOERR       -3 /* I/O error */
#define ZLM_APIERR      -4 /* API was used incorrectly */
#define ZLM_NOLIBLIC    -5 /* library license malformed/invalid */
#define ZLM_NOLICFILE   -6 /* no license file found */
#define ZLM_BADLICFILE  -7 /* malformed licfile */
#define ZLM_BADVENDOR   -8 /* vendor mismatch between library lic. and file */
#define ZLM_NOVERIFY    -9 /* signature verification failed */
#define ZLM_OLDVERSION -10 /* version in license is too old */
#define ZLM_EXPIRED    -11 /* the license expired */
#define ZLM_WRONGHOST  -12 /* wrong host ID / appcert */
#define ZLM_NOPRODUCT  -13 /* no license found for product */
#define ZLM_HOSTIDERR  -14 /* error while determining host ID */
#define ZLM_KEYGENERR  -15 /* error while generating public/private key pair */
#define ZLM_SIGNERR    -16 /* error while signing */
#define ZLM_MINVERSION -17 /* product version is too old for minversion */
#define ZLM_WRONGOS    -18 /* wrong operating system */
#define ZLM_JNIERR     -19 /* JNI related error (Android only) */
#define ZLM_WRONGCPU   -20 /* wrong CPU architecture */

/* The type of a ZLM license object. */
typedef struct ZlmLicense ZlmLicense;

/* Return a new license object (or NULL if not enough memory is available). */
ZlmLicense* zlm_license_new(char *err);

/* Try to get a new <license> for the given <product>.
   The version given in the corresponding license file or string must be smaller
   or equal than the one given in the mandatory <produt_version> parameter such
   that the license is valid. <product_version> must be of the form
   "major.minor" (e.g., "1.0") or "major.minor.patch" (e.g., "1.0.1"). If no
   valid license can be obtained an error code is returned and an error message
   describing the problem is stored in <err> (if <err> is not NULL). If <err> is
   not NULL, it must have at least ZLM_ERRBUF many bytes. If a valid license was
   obtained, ZLM_OK is returned and <license> points to the active license.
   zlm_license_get() tries to aquire the license in the following order:

   1.) If the environment variable <ZLM_LICENSE> is defined it is used as path:
       If it points directly to a file, the file is probed for a valid license.
       If it points to a directory, then all files ending with '.lic' are probed
       for a valid license.
   2.) If <argv0> is not NULL it should point to the first member of your
       main's argv. In this case, the directory in which the main binary resides
       is used as license directory.
   3.) If <path> is not NULL it is used as license path (as in case 1.)).
       Use "." to search the current directory for valid license files.
   4.) If <license_string> is not NULL the given string is used as the content
       of a license file.

   zlm_license_get() can only be called once on a fresh <license> object. */
int         zlm_license_get(ZlmLicense *license, const char *product,
                            const char *product_version, const char *argv0,
                            const char *path, const char *license_string,
                            char *err);

/* Release <license> and free corresponding memory. */
void        zlm_license_free(ZlmLicense *license);

/* Return the product of the given <license>. <license> must be a license which
   has been validated with zlm_license_get(), otherwise NULL is returned. */
const char* zlm_license_product(const ZlmLicense *license);

/* Return the version of the given <license>. <license> must be a license which
   has been validated with zlm_license_get(), otherwise NULL is returned. */
const char* zlm_license_version(const ZlmLicense *license);

/* Return the expiry of the given <license>. <license> must be a license which
   has been validated with zlm_license_get(), otherwise NULL is returned. */
const char* zlm_license_expiry(const ZlmLicense *license);

/* Return the number of days the given <license> will expire in. Returns 0 if
   the license never expires. <license> must be a license which has been
   validated with zlm_license_get(), otherwise ZLM_APIERR is returned. */
int         zlm_license_expiry_days(const ZlmLicense *license);

/* Return the customer of the given <license>. <license> must be a license which
   has been validated with zlm_license_get(), otherwise NULL is returned. */
const char* zlm_license_customer(const ZlmLicense *license);

/* Return the userdata associated with the given valid <license>. Possible JSON
   escape sequences are included in unmodified form. If the <license> has not
   been validated with zlm_license_get() or it does not have userdata
   associated with it NULL is returned. */
const char* zlm_license_userdata(const ZlmLicense *license);

/* Return the userdata associated with the given valid <license> in unescaped
   form. That is, possible JSON escape sequences have been removed: The escaped
   characters '\"', '\\', '\/', '\b', '\f', '\n', '\r', and '\t' have been
   unescaped and '\uXXXX' sequences have been converted to 1-3 bytes UTF-8.
   If the <license> has not been validated with zlm_license_get(), it does not
   have userdata associated with it, or no memory could be allocated NULL is
   returned. The caller is responsible to free the returned string with
   zlm_free()! */
char*       zlm_license_userdata_unescaped(const ZlmLicense *license);

/* Sets <license> to the next available valid license.
   <license> must be a license which has been validated with
   zlm_license_get(), otherwise ZLM_APIERR is returned.
   If no further valid license can be obtained an error code is returned and an
   error message describing the problem is stored in <err> (if <err> is not
   NULL). If <err> is not NULL, it must have at least ZLM_ERRBUF many bytes.
   This method can be used to extend the ZLM checks with your own userdata. For
   example, if you want to implement different host IDs.*/
int         zlm_license_next(ZlmLicense *license, char *err);

/* Check if <license> has expired. <license> must be a license which has been
   validated with zlm_license_get(), otherwise ZLM_APIERR is returned. If the
   license expired since it was validated with zlm_license_get(), ZLM_EXPIRED
   is returned and an error message describing the expiry is stored in <err> (if
   <err> is not NULL). If <err> is not NULL, it must have at least ZLM_ERRBUF
   many bytes. */
int         zlm_license_not_expired(const ZlmLicense *license, char *err);

/* Return the version of the ZLM library in use as a string. */
const char* zlm_version(void);

/* Return the unhashed host ID string of this computer in JSON format (in a
   single line). The caller is responsible to free the returned string with
   zlm_free()! In case of error, NULL is returned and the error buffer <err> is
   set accordingly. */
char*       zlm_hostid_json(char *err);

/* Return the hashed host ID string of this computer in JSON format (in a
   single line). The caller is responsible to free the returned string with
   zlm_free()! In case of error, NULL is returned and the error buffer <err> is
   set accordingly. The salt used for the hashing is stored in <salt> which must
   not be NULL and have at least ZLM_SALTLEN many bytes.
   Deprecated: Use zlm_hostid_json() instead! */
char*       zlm_hostid_json_hashed(char *salt, char *err);

/* Free the memory memory space pointed to by <ptr>, which must have been
   returned by a previous call to another ZLM library function. */
void        zlm_free(void *ptr);

/* License check methods which make it harder to remove ZLM from your binary.
   You should call these methods in different places of your program with a
   valid <license>. Thereby, <license> must be a license which has been
   validated with zlm_license_get(), otherwise the methods will crash!
   zlm_license_check_a() to zlm_license_check_f() just check, if the license was
   valid before.
   zlm_license_check_g() to zlm_license_check_l() also recheck the expiry.
   That is, if the license expired in the meantime, these checks would crash.
   If you want to shut down gracefully in such cases, use
   zlm_license_not_expired() instead to recheck the expiry.
   zlm_license_check_m() to zlm_license_check_r() also recheck the hostid
   (but not the expiry). That is, if the hostid became invalid in the meantime,
   these checks would crash. */
void        zlm_license_check_a(const ZlmLicense *license);
void        zlm_license_check_b(const ZlmLicense *license);
void        zlm_license_check_c(const ZlmLicense *license);
void        zlm_license_check_d(const ZlmLicense *license);
void        zlm_license_check_e(const ZlmLicense *license);
void        zlm_license_check_f(const ZlmLicense *license);
void        zlm_license_check_g(const ZlmLicense *license);
void        zlm_license_check_h(const ZlmLicense *license);
void        zlm_license_check_i(const ZlmLicense *license);
void        zlm_license_check_j(const ZlmLicense *license);
void        zlm_license_check_k(const ZlmLicense *license);
void        zlm_license_check_l(const ZlmLicense *license);
void        zlm_license_check_m(const ZlmLicense *license);
void        zlm_license_check_n(const ZlmLicense *license);
void        zlm_license_check_o(const ZlmLicense *license);
void        zlm_license_check_p(const ZlmLicense *license);
void        zlm_license_check_q(const ZlmLicense *license);
void        zlm_license_check_r(const ZlmLicense *license);

/* The type of a key function (public or private). */
typedef const unsigned char* (ZlmKeyfunc)(int *keylen);

/* Generate public/private key pair and write it to the files zlm_pubkey.c and
   zlm_privkey.c in the current directory. */
int zlm_genkeys(char *err);

/* Print host ID string of this computer on stdout. */
int zlm_hostid(char *err);

/* Print host ID string of this computer on stdout and to write it to a file
   named zlmhostid.txt in the current working directory.
   If the file already exists it is overwritten! */
int zlm_hostid_file(char *err);

/* Print hash of <public_key> on stdout. */
int zlm_keyhash(ZlmKeyfunc *public_key, char *err);

/* Sign the license file given in <path> with the given <private_key>.
   If <path> is NULL the license file is read from stdin and the result written
   to stdout. Reading from stdin limits the max. license file size to 64 KB. */
int zlm_sign_file(const char *path, ZlmKeyfunc *private_key, char *err);

/* Verify signatures of license file given in <path> with given <public_key>.
   If <path> is NULL the license file is read from stdin.
   Reading from stdin limits the maximum license file size to 64 KB. */
int zlm_verify_file(const char *path, ZlmKeyfunc *public_key, char *err);

/* Sign the license file given in buffer <license> with the given <private_key>
   and return the result. The caller is responsible to free the returned string
   with zlm_free()! In case of error, NULL is returned and the error buffer
   <err> is set accordingly. */
char* zlm_sign_license(const char *license, ZlmKeyfunc *private_key, char *err);

#ifdef __ANDROID__
/* Android only: In order to use ANDROID_ID entries in the "hostid" field of
   license files you have to call this this function once before using any other
   library function! <env> must be the JNI environment, otherwise ZLM_APIERR is
   returned. <activity> must be an Android activity (that is, an object with the
   getContentResolver() method), otherwise ZLM_APIERR or ZLM_JNIERR is returned.
   If the ANDROID_ID cannot be determined ZLM_JNIERR is returned and err
   contains an error message. */
int zlm_read_android_id(JNIEnv *env, jobject activity, char *err);

/* Android only: Return the ANDROID_ID. Before this method can be used
   the ANDROID_ID has to be read once by calling zlm_read_android_id(). */
const char* zlm_android_id(void);

/* Android only: In order to use application ID entries in the "hostid" field of
   license files you have to call this this function once before using any other
   library function! <env> must be the JNI environment, otherwise ZLM_APIERR is
   returned. <activity> must be an Android activity (that is, an object with the
   getPackageName() method), otherwise ZLM_APIERR or ZLM_JNIERR is returned.
   If the application ID cannot be determined ZLM_JNIERR is returned and err
   contains an error message. */
int zlm_read_application_id(JNIEnv *env, jobject activity, char *err);

/* Android only: Return the application ID. Before this method can be used the
   application ID has to be read once by calling zlm_read_application_id(). */
const char* zlm_application_id(void);

/* Android only: In order to use application certificate entries in the
   "appcert" field of license files you have to call this this function once
   before using any other library function! <env> must be the JNI environment,
   otherwise ZLM_APIERR is returned. If the application certificate cannot be
   determined ZLM_JNIERR is returned and err contains an error message. */
int zlm_read_application_cert(JNIEnv *env, jobject activity, char *err);

/* Android only: Return the (oldest) application certificate as SHA-256.
   Before this method can be used the application ID has to be read once by
   calling zlm_read_application_cert(). */
const char* zlm_application_cert(void);
#endif

#if defined (__APPLE__) && (TARGET_OS_IOS > 0)
/* iOS only: Return the vendor specific unique key (a UUID conforming to RFC
   4122 version 4) as a C-string. See http://apple.co/2ohHcQY for details.

   If the result is NULL wait and get the value again later. This happens, for
   example, after the device has been restarted but before the user has unlocked
   the device.

   The value in this property remains the same while the app (or another app
   from the same vendor) is installed on the iOS device. The value changes when
   the user deletes all of that vendor’s apps from the device and subsequently
   reinstalls one or more of them. The value can also change when installing
   test builds using Xcode or when installing an app on a device using ad-hoc
   distribution. */
const char* zlm_ios_hostid(char *err);

/* iOS only: Return the unique bundle identifier (CFBundleIdentifier).
   See https://apple.co/2SU5j50 for details. */
const char* zlm_ios_bundle_identifier(char *err);
#endif

#ifdef __cplusplus
}
#endif

#endif

char err[ZLM_ERRBUF];

ZlmLicense* zlm_license_new(char *err);

ZlmLicense *license;
char err[ZLM_ERRBUF];

if (!(license = zlm_license_new(err))) {
  fprintf(stderr, "error: %s\n", err);
  return EXIT_FAILURE;
}

int zlm_license_get(ZlmLicense *license,
                    const char *product,
                    const char *version,
                    const char *argv0,
                    const char *path,
                    const char *license_string,
                    char *err);

if (zlm_license_get(license, "My Product", "1.0", argv[0], ".", NULL, err)) {
  fprintf(stderr, "error: %s\n", err);
  zlm_license_free(license);
  return EXIT_FAILURE;
}
else
  puts("got license!");

zlm_license_free(license);

const char* zlm_license_product(const ZlmLicense *license);

const char* zlm_license_version(const ZlmLicense *license);

const char* zlm_license_expiry(const ZlmLicense *license);

int zlm_license_expiry_days(const ZlmLicense *license);

const char* zlm_license_customer(const ZlmLicense *license);

const char *zlm_license_userdata(const ZlmLicense *license);

char* zlm_license_userdata_unescaped(const ZlmLicense *license);

int zlm_license_next(ZlmLicense *license, char *err);

const char* zlm_version(void);

char* zlm_hostid_json(char *err);

char* zlm_hostid_json_hashed(char *salt, char *err);

void zlm_free(void *ptr);

void zlm_license_check_a(const ZlmLicense *license);
void zlm_license_check_b(const ZlmLicense *license);
void zlm_license_check_c(const ZlmLicense *license);
void zlm_license_check_d(const ZlmLicense *license);
void zlm_license_check_e(const ZlmLicense *license);
void zlm_license_check_f(const ZlmLicense *license);
void zlm_license_check_g(const ZlmLicense *license);
void zlm_license_check_h(const ZlmLicense *license);
void zlm_license_check_i(const ZlmLicense *license);
void zlm_license_check_j(const ZlmLicense *license);
void zlm_license_check_k(const ZlmLicense *license);
void zlm_license_check_l(const ZlmLicense *license);
void zlm_license_check_m(const ZlmLicense *license);
void zlm_license_check_n(const ZlmLicense *license);
void zlm_license_check_o(const ZlmLicense *license);
void zlm_license_check_p(const ZlmLicense *license);
void zlm_license_check_q(const ZlmLicense *license);
void zlm_license_check_r(const ZlmLicense *license);

int zlm_genkeys(char *err);

int zlm_hostid(char *err);

int zlm_hostid_file(char *err);

int zlm_keyhash(ZlmKeyfunc *public_key, char *err);

int zlm_sign_file(const char *path, ZlmKeyfunc *private_key, char *err);

int zlm_verify_file(const char *path, ZlmKeyfunc *public_key, char *err);

char* zlm_sign_license(const char *license, ZlmKeyfunc *private_key, char *err);

extern const unsigned char* zlm_get_private_key(int *keylen);

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

int main(int argc, char *argv[])
{
  ZlmLicense *license;
  char err[ZLM_ERRBUF];

  if (argc != 2) {
    fprintf(stderr, "Usage %s license_file\n", argv[0]);
    return EXIT_FAILURE;
  }

  /* create license object */
  if (!(license = zlm_license_new(err))) {
    fprintf(stderr, "error: %s\n", err);
    return EXIT_FAILURE;
  }

  /* try to get license for product 'My Product' from supplied license file path
     (first argument in argument vector) */
  if (zlm_license_get(license, "My Product", "1.0", NULL, argv[1], NULL, err)) {
    fprintf(stderr, "error: %s\n", err);
    zlm_license_free(license);
    return EXIT_FAILURE;
  }
  else
    puts("got license!");

  /**********************
   * run your code here *
   **********************/

  /* free license object */
  zlm_license_free(license);

  return EXIT_SUCCESS;
}

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

#define LICENSE \
        "{\"vendor\":\"Wikena GmbH\",\"license\":{\"product\":\"My Product\"," \
        "\"version\":\"1.0\",\"expiry\":\"never\",\"hostid\":\"any\","         \
        "\"customer\":\"John Doe\",\"signature\":\"3041021e74901fc7088ae32bb1" \
        "276dee2699d6d4e82cd5b39df396a57f608ffa31be021f008d59f1d76a0ac31ad85f" \
        "9428f145df50292748f15834f92c2d557087b1af\"}}"

int main(int argc, char *argv[])
{
  ZlmLicense *license;
  char err[ZLM_ERRBUF];

  /* create license object */
  if (!(license = zlm_license_new(err))) {
    fprintf(stderr, "error: %s\n", err);
    return EXIT_FAILURE;
  }

  /* try to get license for product 'My Product' directly from supplied license
     string */
  if (zlm_license_get(license, "My Product", "1.0", NULL, NULL, LICENSE, err)) {
    fprintf(stderr, "error: %s\n", err);
    zlm_license_free(license);
    return EXIT_FAILURE;
  }
  else
    puts("got license!");

  /**********************
   * run your code here *
   **********************/

  /* free license object */
  zlm_license_free(license);

  return EXIT_SUCCESS;
}

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

static void foo(ZlmLicense *license)
{
  zlm_license_check_a(license);

  /**********************
  * run your code here *
  **********************/
}

static void bar(ZlmLicense *license)
{
  zlm_license_check_b(license);

  /**********************
  * run your code here *
  **********************/
}

static void baz(ZlmLicense *license)
{
  zlm_license_check_c(license);

  /**********************
  * run your code here *
  **********************/
}

int main(int argc, char *argv[])
{
  ZlmLicense *license;
  char err[ZLM_ERRBUF];

  /* create license object */
  if (!(license = zlm_license_new(err))) {
    fprintf(stderr, "error: %s\n", err);
    return EXIT_FAILURE;
  }

  /* try to get license for product 'My Product' from the same directory as the
     executed binary and if that fails from the current directory */
  if (zlm_license_get(license, "My Product", "1.0", argv[0], ".", NULL, err)) {
    fprintf(stderr, "error: %s\n", err);
    zlm_license_free(license);
    return EXIT_FAILURE;
  }
  else
    puts("got license!");

  /************************************************
   * example code foo(), bar(), baz() called here *
   ************************************************/
  foo(license);
  bar(license);
  baz(license);

  /* free license object */
  zlm_license_free(license);

  return EXIT_SUCCESS;
}

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

ZlmLicense *license; /* global license variable */

static void foo(void)
{
  zlm_license_check_a(license);

  /**********************
  * run your code here *
  **********************/
}

static void bar(void)
{
  zlm_license_check_b(license);

  /**********************
  * run your code here *
  **********************/
}

static void baz(void)
{
  zlm_license_check_c(license);

  /**********************
  * run your code here *
  **********************/
}

int main(int argc, char *argv[])
{
  char err[ZLM_ERRBUF];

  /* create global license object */
  if (!(license = zlm_license_new(err))) {
    fprintf(stderr, "error: %s\n", err);
    return EXIT_FAILURE;
  }

  /* try to get license for product 'My Product' from the same directory as the
     executed binary and if that fails from the current directory */
  if (zlm_license_get(license, "My Product", "1.0", argv[0], ".", NULL, err)) {
    fprintf(stderr, "error: %s\n", err);
    zlm_license_free(license);
    return EXIT_FAILURE;
  }
  else
    puts("got license!");

  /************************************************
   * example code foo(), bar(), baz() called here *
   ************************************************/
  foo();
  bar();
  baz();

  /* free license object */
  zlm_license_free(license);

  return EXIT_SUCCESS;
}

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifndef _WIN32
#include <unistd.h>
#else
#include <winsock2.h>
#endif
#include "zlm.h"

int main(int argc, char *argv[])
{
  ZlmLicense *license;
  char hostname[256], err[ZLM_ERRBUF];
  int had_err = ZLM_OK;

  /* determine hostname */
  if (gethostname(hostname, sizeof hostname)) {
    fprintf(stderr, "error: cannot determine hostname: %s\n", strerror(errno));
    return EXIT_FAILURE;
  }

  /* create license object */
  if (!(license = zlm_license_new(err))) {
    fprintf(stderr, "error: %s\n", err);
    return EXIT_FAILURE;
  }

  /* try to get license for product 'My Product' from the same directory as the
     executed binary and if that fails from the current directory */
  if (zlm_license_get(license, "My Product", "1.0", argv[0], ".", NULL, err)) {
    fprintf(stderr, "error: %s\n", err);
    zlm_license_free(license);
    return EXIT_FAILURE;
  }

  /* we got the first valid license */
  do {
    /* get userdata */
    const char *userdata = zlm_license_userdata(license);
    if (userdata) {
      /* check if the userdata contains the hostname of this machine */
      if (strcmp(userdata, hostname) == 0) {
        /* valid license found, break while-loop */
        break;
      }
    }
    /* try to get next valid license */
    had_err = zlm_license_next(license, err);
  } while (had_err == ZLM_OK);

  if (had_err) {
    fprintf(stderr, "error: %s\n", err);
    zlm_license_free(license);
    return EXIT_FAILURE;
  }
  else
    puts("got license!");

  /**********************
   * run your code here *
   **********************/

  /* free license object */
  zlm_license_free(license);

  return EXIT_SUCCESS;
}

int zlm_read_android_id(JNIEnv *env, jobject activity, char *err);

const char* zlm_android_id(void);

int zlm_read_application_id(JNIEnv *env, jobject activity, char *err);

const char* zlm_application_id(void);

int zlm_read_application_cert(JNIEnv *env, jobject activity, char *err);

const char* zlm_application_cert(void);

const char* zlm_ios_hostid(char *err);

const char* zlm_ios_bundle_identifier(char *err);

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "zlm.h"

int main(int argc, char *argv[])
{
  ZlmLicense *license;
  char err[ZLM_ERRBUF];
  unsigned int seconds = 1;

  /* create license object */
  if (!(license = zlm_license_new(err))) {
    fprintf(stderr, "error: %s\n", err);
    return EXIT_FAILURE;
  }

  /* make sure the vendor specific unique key is available */
  while (zlm_ios_hostid(err) == NULL) {
    /* temporary failure, sleep before retry */
    sleep(seconds);
    /* double number of seconds for next sleep round */
    seconds <<= 1;
  }

  /* try to get license for product 'My Product' from the same directory as the
     executed binary and if that fails from the current directory */
  if (zlm_license_get(license, "My Product", "1.0", argv[0], ".", NULL, err)) {
    fprintf(stderr, "error: %s\n", err);
    zlm_license_free(license);
    return EXIT_FAILURE;
  }
  else
    puts("got license!");

  /**********************
   * run your code here *
   **********************/

  /* free license object */
  zlm_license_free(license);

  return EXIT_SUCCESS;
}

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

int main(int argc, char *argv[])
{
  char err[ZLM_ERRBUF];
  int had_err;

  if (argc != 1) {
    fprintf(stderr, "Usage: %s\n", argv[0]);
    fprintf(stderr, "Generate private and public keys for signatures.\n");
    return EXIT_FAILURE;
  }

  /* generate keys */
  had_err = zlm_genkeys(err);

  if (had_err) {
    fprintf(stderr, "%s: error: %s\n", argv[0], err);
    return -had_err;
  }

  return EXIT_SUCCESS;
}

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

int main(int argc, char *argv[])
{
  char err[ZLM_ERRBUF];
  int had_err;

  if (argc != 1) {
    fprintf(stderr, "Usage: %s\n", argv[0]);
    fprintf(stderr, "Print host ID on stdout.\n");
    return EXIT_FAILURE;
  }

  /* print host ID on stdout and write it to file zlmhostid.txt in CWD. */
  had_err = zlm_hostid_file(err);

  if (had_err) {
    fprintf(stderr, "%s: error: %s\n", argv[0], err);
    return -had_err;
  }

  return EXIT_SUCCESS;
}

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

extern const unsigned char* zlm_get_public_key(int *keylen);

int main(int argc, char *argv[])
{
  char err[ZLM_ERRBUF];
  int had_err;

  if (argc != 1) {
    fprintf(stderr, "Usage: %s\n", argv[0]);
    fprintf(stderr, "Print hash of public key on stdout.\n");
    return EXIT_FAILURE;
  }

  /* print public key hash */
  had_err = zlm_keyhash(zlm_get_public_key, err);

  if (had_err) {
    fprintf(stderr, "%s: error: %s\n", argv[0], err);
    return -had_err;
  }

  return EXIT_SUCCESS;
}

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

extern const unsigned char* zlm_get_private_key(int *keylen);

int main(int argc, char *argv[])
{
  char err[ZLM_ERRBUF];
  int had_err;

  if (argc > 2) {
    fprintf(stderr, "Usage: %s [license_file_to_sign]\n", argv[0]);
    fprintf(stderr, "Sign the given license file (or read from stdin).\n");
    return EXIT_FAILURE;
  }
  else if (argc == 1)
    fprintf(stderr, "reading license file from stdin...\n");

  /* sign license file */
  had_err = zlm_sign_file(argv[1], zlm_get_private_key, err);

  if (had_err) {
    fprintf(stderr, "%s: error: %s\n", argv[0], err);
    return -had_err;
  }

  return EXIT_SUCCESS;
}

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

extern const unsigned char* zlm_get_public_key(int *keylen);

int main(int argc, char *argv[])
{
  char err[ZLM_ERRBUF];
  int had_err;

  if (argc > 2) {
    fprintf(stderr, "Usage: %s [license_file_to_verify]\n", argv[0]);
    fprintf(stderr, "Verify the given license file (or read from stdin).\n");
    return EXIT_FAILURE;
  }
  else if (argc == 1)
    fprintf(stderr, "reading license file from stdin...\n");

  /* verify license file */
  had_err = zlm_verify_file(argv[1], zlm_get_public_key, err);

  if (had_err) {
    fprintf(stderr, "%s: error: %s\n", argv[0], err);
    return -had_err;
  }

  return EXIT_SUCCESS;
}