ARM SDK

The code examples demonstrate the use of the API calls involved in license management using NSL V10. 

You are also advised to consult the following documents that explain the logical flow using .NET as an example: 

Licensing Logic of Your Application

Retrieving a License From the Activation Server

These provide in-depth descriptions of the license life-cycle and how this should be implemented in a commercial application.

Introduction

In this article, we are going to show you an example ARM app.

NSL and NSA can easily be added to new or existing software as it is a shared library and can be accessed as such.

The Nalpeiron ARM libraries consist of the standard Nalpeiron C library.

The ARMCode example currently supports ARMv5t, ARMv7a, ARMv8a, soft and hard floating point with more support coming.

Having downloaded your Custom Licensing/Analytics library you will now need to code your project with the quick changes listed below.

Please note that this is simply a code example and it is not a complete application, please use this to understand the basics of how you might implement licensing and then create your own code. It is not a finished work and will need modifying in a number of ways depending on your use case.

Download your custom Nalpeiron Libraries and place in your Project

Please see the article about how to generate your custom libraries.

Please ensure you download each architecture (variant) and place the .so files into each folder as below.

Collect some test Nalpeiron License Codes

In order to try out various functions and features of the Nalpeiron Service, you will need to make sure you have a "Product" setup in the Nalpeiron Publisher Center and to have a number of license code numbers ready to input into the UI (or if you are using ADB) generated by the sample code.

Getting Started using ARM

The process is much like all our other OS, simply create a custom library and call that with your code. Then you can test. Here we provide sample projects to allow you to test quickly without the need for your own application code.

1. Setup your device for testing e.g. Raspberry Pi, BeagleBone Black etc

Each device is different in terms of ability, storage,portsandOSsoweare not covering them all here but more general concepts.

Once you have your device setup, in order to test you will need storage access and the ability to run the sample code on the device.

You can make many of the required edits below before sending the test projects to the device via SSH, or via a direct load using removable storage compatible with your device.

2. Download and unpack the Nalpeiron ARM SDK.

• Download SDK to your device (via removable sd card,flashdriveorothermethod)
• Upack:tarxzvf./ ARMCodeKit.tgz
• cd ./ARMCodeKit

• nsaTermandnslTermare C projects that allow you to do your testing (for licensing:nslTermorforanalytics collection:nsaTerm).
• Both need editing and having their parameters changed to match your own.

After unpacking the example, you will have an ARMCodeKit directory.

3. Create and download your Custom Library (from the publisher center)

The custom Nalpeiron libraries must be copied into place for the build to work correctly.

Choosing the correct Nalpeiron Library

You should know the details of your hardware in order to choose the correct library version to use with it. If you are not sure you can use the following method to get an indication (not totally definitive but useful).

Currently, Nalpeiron provides five varieties of the ARM library: armv5te hard and soft floating point, armv7a hard and soft floating point, and armv8a 64 bit hard floating. You will need to determine which library version is appropriate for your device and download the correct one.

If you are unsure which library to use you can find the information from your device in several ways. One method of doing this is to locate the libc.so.6 library and determine its architecture.

You may use the find command to locate the library:

find / -name libc.so.6 2>/dev/null

Then query that library using the readelf command:

readelf -A /lib/arm-linux-gnueabihf/libc.so.6

In this case, we see that the c library is ARMv6 hard floating point by reviewing the 3rd line from the bottom. The Tag_ABI_HardFP_use: SP and DP. There will be no equivalent lineifitisn'thardfp.

Similar information can be obtained from any ARM system.

Below is information gathered from a Beagle Bone Black:

• The above image shows an ARMv7a hard floating point.

• The above image shows an ARMv4t soft floating point.

The "readelf-A" method of telling hard float from soft isn't foolproof. On a 64 bit machine, for instance, readelf-A returns no information at all. On the BBone, you have both sets of libraries one for hardfp and a second set for soft. However, the system boots to hard and there is no easy way to use the soft. If you're just running readelf-A onlibc.so.6 files, you won't necessarily know which is being used.

• A downloaded library of the appropriate architecture for your device should be copied into the directory where you unpacked the code example.

• Ensure you place each file in the correct corresponding folders for their architecture armv5t, armv7a, armv8a (if you plan to try various device architectures)

char *nslVersion = NULL;
char *nsaVersion = NULL;
char *compID = NULL;
char *nslHostName = NULL;
char *nsaHostName = NULL;
char *licenseCode = NULL;
char *licenseInfo = NULL;
char *expDate = NULL;
char *licenseStatus = NULL;
 
//edit below//
char custID[] = "4613";
char prodID[] = "100";
//edit//
char libPath[] = "home/pi/Desktop/ARMCodeKit/ShaferFilechck.so";

void *libHandle = NULL;
char *miscStr1 = NULL;
char *miscStr2 = NULL;

Next change the location of your library file libPath[] to where you have stored the file and the associated code project, in this case: /ARMCodeKit/ShaferFilechck.so.

char *nslVersion = NULL;
char *nsaVersion = NULL;
char *compID = NULL;
char *nslHostName = NULL;
char *nsaHostName = NULL;
char *licenseCode = NULL;
char *licenseInfo = NULL;
char *expDate = NULL;
char *licenseStatus = NULL;
 
char custID[] = "4613";
char prodID[] = "100";
 
//edit below//
char libPath[] = "home/pi/Desktop/ARMCodeKit/ShaferFilechck.so";
//edit//
void *libHandle = NULL;
char *miscStr1 = NULL;
char *miscStr2 = NULL;

Be sure that this is correct to the folder on the device.

Finally change the Security Constants (X, Y and Z values) to match those stamped into your library (for the NSL example). Do not copy this example as many others may read this document and your values should be unique and secret!

int offset;

int main(
void
)
{
 
//edit below//
unsigned int xauth = 9;
unsigned int yauth = 599;
unsigned int zauth = 399;
//edit//
unsigned int security;
char *xmlParams;

Remember the Security Constants are set to "0" (or off) by default and you need to change them when generating your DLL. We highly recommend adding these constants to help improve security.

Differences in the NSA code

char				custID[] = "3183";
char				prodID[] = "100";

char				libPath[] = "/tmp/test30.so";

Build the Example Project

Now you can save and test build the project.

• Run the "make" command to build the Projects.

There should be no errors and you should have two binaries when complete: nslTerm and nsaTerm. Now you have everything successfully building you can start to use the example code and start any testing.

Start Testing

Now you may run the edited example code on your ARM device using nslTerm and nsaTerm (for licensing: nslTerm or for analytics collection: nsaTerm).

• Start nslTerm with:

  ./nslTerm

Once running you will have a test UI:

The GUI shows various useful details such as:

1. The current library path and the Customer and product IDs parameters that should match your own. The "computerID" is a unique Nalpeiron ID for your device that we will use to track it on the Server side, Library versions and the server location shown above as NSL/NSA host (my.nalpeiron.com).
2. The license status area shows the license state and any error numbers.
3. The column of number options allows you to test various license processes.

Go to test docs

callNalpLibOpen Parameters

The prototype of NSA.callNalpLibOpen is:

int callNalpLibOpen(String Filename, boolean NSAEnable, boolean NSLEnable, int LogLevel, String WorkDir, int LogQLen, int CacheQLen, int NetThMin, int NetThMax, int OfflineMode, String ProxyIP, String ProxyPort, String ProxyUsername, String ProxyPass, int security)

where: Filename use this parameter to change the location and/or name of the libNSA libraries.

NSAEnable - If true the NSA portion of the library is enabled. NSLEnable - If true the NSL portion of the library is enabled. WorkDir is the location where NSA/NSL will store its log file, licensing files, cache file, etc.

If this value is not specified the files will be stored in the current working directory as defined by your running software on Linux and Mac.

On Windows, the library will use a publically accessible directory (selected by the OS). loglevel is an integer 0 to 6.

If loglevel is not specified it will default to level 0 (off). You should not use log level higher than 4.

The higher levels do not provide any useful end-user debugging.

LogQLen is the maximum length of the log queue. Once the log queue reaches this length, additional log entries will be discarded.

As messages in the queue are written to the log file, the queue will shrink and logging will automatically resume. The default is 300.

CacheQLen is the maximum length of the cache queue. Once the cache queue reaches this length, additional cache entries will be discarded. As messages in the queue are written to the cache file, the queue will shrink and caching will automatically begin again. The default is 25.

SoapThreadsMin/SoapThreadsMax - Network connections between the NSA library and the Nalpeiron server are handled by a lthread pool. The values specify the minimum number of threads available to the pool and the maximum number of threads available to the pool. The number of threads in the pool will grow and shrink between these two extremes as needed. The default for each is 10.

ProxyIP/ProxyPort - If the NSA library is connecting to the internet via a proxy use these values to specify the IP address and port number of the proxy server. If no proxy is used, they can be left empty or completely unspecified. The default is no proxy. ProxyUsername/ProxyPassword - If you are using a network proxy to which requires a username and password, specify them here.

OfflineMode - If OfflineMode is on (1), the no data is sent to the Nalpeiron server. All transactions are written immediately to cache. The library makes no attempts to collection location information or send the cache to Nalpeiron. The default is 0 (ie on-line).

Security - Security is a random value created by you at the start of your program (see NalpExample.java for an example of this process). This value in combination with the x, y and z authentication values you stamped into your library when you created it are used for security in the NSL licensing functions. If the security value is specified, all returns from the NSL library will include an offset. Your calling program will need to calculate this offset and subtract it from the return values. In this example, the offset is calculated in NalpExample.java.

The return values are adjusted inside the C wrapper library (nsljava.c).

Library Prototypes

All functions return positive numbers (or 0) on success and a negative number on error. Strings passed into NSA are expected to be either ANSI C strings or UTF8 encoded Unicode. The following functions are provided by the NSA library. Of course, as you will be accessing them from the shared libraries rather than directly you need to use the typedeffed functions pointers (see NSAFunctions.h in the c/c++ SDK) rather than these prototypes.

For example, usage see: nsaExample.c in the SDK.

Download the Example Application

Release Notes (Please always check the release notes for the latest updates)

You can download the required sample files at the Customer Center below: