//
// Copyright (c) 2014 ANSCENTER. All rights reserved.
//

#include "precomp.h"

#include "base32.h"
#include "base64.h"
#include "sha1.h"
#include "except.h"
#include "bitstream.h"
#include "template.h"
#include "generator.h"
#include "validator.h"
#include "license.h"
#include "licensevalidationargs.h"
#include "licensevalidationresult.h"
#include "licensingclient.h"
#include "certificate.h"
#include "uniconv.h"

void * KeyGenerator_Create()
{
	return new(std::nothrow) KeyGeneratorImpl();
}

void KeyGenerator_Destroy(void * generator)
{
	delete static_cast<KeyGeneratorImpl *>(generator);
}

int KeyGenerator_SetKeyTemplate(void * generator, const void * tmpl)
{
	try {
		static_cast<KeyGeneratorImpl *>(generator)->SetKeyTemplate(static_cast<LicenseTemplateImpl *>(const_cast<void *>(tmpl)));
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyGenerator_SetKeyDataA(void * generator, const char * fieldName, const void * data, int len)
{
	

	try {
		static_cast<KeyGeneratorImpl *>(generator)->SetKeyData(fieldName, data, len);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyGenerator_SetKeyDataW(void * generator, const wchar_t * fieldName, const void * data, int len)
{
	try {
		static_cast<KeyGeneratorImpl *>(generator)->SetKeyData(w2s(fieldName).c_str(), data, len);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyGenerator_SetIntKeyDataA(void * generator, const char * fieldName, int data)
{
	try {
		static_cast<KeyGeneratorImpl *>(generator)->SetKeyData(fieldName, data);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyGenerator_SetIntKeyDataW(void * generator, const wchar_t * fieldName, int data)
{
	

	try {
		static_cast<KeyGeneratorImpl *>(generator)->SetKeyData(w2s(fieldName).c_str(), data);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyGenerator_SetDateKeyDataA(void * generator, const char * fieldName, int year, int month, int day)
{
	

	try {
		static_cast<KeyGeneratorImpl *>(generator)->SetKeyData(fieldName, year, month, day);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyGenerator_SetDateKeyDataW(void * generator, const wchar_t * fieldName, int year, int month, int day)
{
	

	try {
		static_cast<KeyGeneratorImpl *>(generator)->SetKeyData(w2s(fieldName).c_str(), year, month, day);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyGenerator_SetStringKeyDataA(void * generator, const char * fieldName, const char * data)
{
	

	try {
		static_cast<KeyGeneratorImpl *>(generator)->SetKeyData(fieldName, data);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyGenerator_SetStringKeyDataW(void * generator, const wchar_t * fieldName, const wchar_t * data)
{
	

	try {
		static_cast<KeyGeneratorImpl *>(generator)->SetKeyData(w2s(fieldName).c_str(), w2s(data).c_str());
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyGenerator_SetValidationDataA(void * generator, const char * fieldName, const void * buf, int len)
{
	

	try {
		static_cast<KeyGeneratorImpl *>(generator)->SetValidationData(fieldName, buf, len);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyGenerator_SetValidationDataW(void * generator, const wchar_t * fieldName, const void * buf, int len)
{
	

	try {
		static_cast<KeyGeneratorImpl *>(generator)->SetValidationData(w2s(fieldName).c_str(), buf, len);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyGenerator_SetIntValidationDataA(void * generator, const char * fieldName, int data)
{
	

	try {
		static_cast<KeyGeneratorImpl *>(generator)->SetValidationData(fieldName, data);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyGenerator_SetIntValidationDataW(void * generator, const wchar_t * fieldName, int data)
{
	

	try {
		static_cast<KeyGeneratorImpl *>(generator)->SetValidationData(w2s(fieldName).c_str(), data);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyGenerator_SetStringValidationDataA(void * generator, const char * fieldName, const char * data)
{
	try {
		static_cast<KeyGeneratorImpl *>(generator)->SetValidationData(fieldName, data);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyGenerator_SetStringValidationDataW(void * generator, const wchar_t * fieldName, const wchar_t * data)
{
	try {
		static_cast<KeyGeneratorImpl *>(generator)->SetValidationData(w2s(fieldName).c_str(), w2s(data).c_str());
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyGenerator_GenerateKeyA(void * generator, const char **key)
{
	try {
		*key = static_cast<KeyGeneratorImpl *>(generator)->GenerateKey();
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyGenerator_GenerateKeyW(void * generator, const wchar_t **key)
{
	try {	
		static wstring wstr1;
		wstr1 = s2w(static_cast<KeyGeneratorImpl *>(generator)->GenerateKey());
		*key = wstr1.c_str();
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

void * KeyValidator_Create()
{
	return new(std::nothrow) KeyValidatorImpl();
}

void KeyValidator_Destroy(void * validator)
{
	delete static_cast<KeyValidatorImpl *>(validator);
}

int KeyValidator_SetKeyTemplate(void * validator, const void * tmpl)
{
	try {
		static_cast<KeyValidatorImpl *>(validator)->SetKeyTemplate(static_cast<LicenseTemplateImpl *>(const_cast<void *>(tmpl)));
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyValidator_SetKeyA(void * validator, const char * key)
{
	
	try {
		static_cast<KeyValidatorImpl *>(validator)->SetKey(key);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyValidator_SetKeyW(void * validator, const wchar_t * key)
{
	

	try {
		static_cast<KeyValidatorImpl *>(validator)->SetKey(w2s(key).c_str());
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyValidator_SetValidationDataA(void * validator, const char * fieldName, const void * buf, int len)
{
	
	try {
		static_cast<KeyValidatorImpl *>(validator)->SetValidationData(fieldName, buf, len);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyValidator_SetValidationDataW(void * validator, const wchar_t * fieldName, const void * buf, int len)
{
	

	try {
		static_cast<KeyValidatorImpl *>(validator)->SetValidationData(w2s(fieldName).c_str(), buf, len);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyValidator_SetIntValidationDataA(void * validator, const char * fieldName, int data)
{
	

	try {
		static_cast<KeyValidatorImpl *>(validator)->SetValidationData(fieldName, data); 
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyValidator_SetIntValidationDataW(void * validator, const wchar_t * fieldName, int data)
{
	

	try {
		static_cast<KeyValidatorImpl *>(validator)->SetValidationData(w2s(fieldName).c_str(), data); 
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyValidator_SetStringValidationDataA(void * validator, const char * fieldName, const char * data)
{
	

	try {
		static_cast<KeyValidatorImpl *>(validator)->SetValidationData(fieldName, data);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyValidator_SetStringValidationDataW(void * validator, const wchar_t * fieldName, const wchar_t * data)
{
	

	try {
		static_cast<KeyValidatorImpl *>(validator)->SetValidationData(w2s(fieldName).c_str(), w2s(data).c_str());
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyValidator_IsKeyValid(void * validator)
{
	int status = STATUS_SUCCESS;

	try {
		if (!static_cast<KeyValidatorImpl *>(validator)->IsKeyValid())
			status = STATUS_INVALID_LICENSE_KEY;
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return status;
}

int KeyValidator_QueryKeyDataA(void * validator, const char * dataField, void * buf, int * len)
{
	

	try {
		static_cast<KeyValidatorImpl *>(validator)->QueryKeyData(dataField, buf, len);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyValidator_QueryKeyDataW(void * validator, const wchar_t * dataField, void * buf, int * len)
{
	

	try {
		static_cast<KeyValidatorImpl *>(validator)->QueryKeyData(w2s(dataField).c_str(), buf, len);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyValidator_QueryIntKeyDataA(void * validator, const char * dataField, int * data)
{
	

	try {
		*data = static_cast<KeyValidatorImpl *>(validator)->QueryIntKeyData(dataField);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyValidator_QueryIntKeyDataW(void * validator, const wchar_t * dataField, int * data)
{
	

	try {
		*data = static_cast<KeyValidatorImpl *>(validator)->QueryIntKeyData(w2s(dataField).c_str());
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyValidator_QueryDateKeyDataA(void * validator, const char * dataField, int * year, int * month, int * day)
{
	

	try {
		static_cast<KeyValidatorImpl *>(validator)->QueryDateKeyData(dataField, year, month, day);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyValidator_QueryDateKeyDataW(void * validator, const wchar_t * dataField, int * year, int * month, int * day)
{
	

	try {
		static_cast<KeyValidatorImpl *>(validator)->QueryDateKeyData(w2s(dataField).c_str(), year, month, day);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyValidator_QueryValidationDataA(void * validator, const char * dataField, void * buf, int * len)
{
	

	try {
		static_cast<KeyValidatorImpl *>(validator)->QueryValidationData(dataField, buf, len);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyValidator_QueryValidationDataW(void * validator, const wchar_t * dataField, void * buf, int * len)
{
	

	try {
		static_cast<KeyValidatorImpl *>(validator)->QueryValidationData(w2s(dataField).c_str(), buf, len);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

void * LicenseTemplate_Create()
{
	return new(std::nothrow) LicenseTemplateImpl();
}

void LicenseTemplate_Destroy(void * tmpl)
{
	delete static_cast<LicenseTemplateImpl *>(tmpl);
}

int LicenseTemplate_SetVersion(void * tmpl, int version)
{
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetVersion(version);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetVersion(void * tmpl, int * version)
{
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->GetVersion();
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_SetNumberOfGroups(void * tmpl, int numGroups)
{
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetNumberOfGroups(numGroups);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetNumberOfGroups(void * tmpl, int * numGroups)
{
	try {
		*numGroups = static_cast<LicenseTemplateImpl *>(tmpl)->GetNumberOfGroups();
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_SetCharactersPerGroup(void * tmpl, int charsPerGroup)
{
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetCharactersPerGroup(charsPerGroup);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetCharactersPerGroup(void * tmpl, int * charsPerGroup)
{
	try {
		*charsPerGroup = static_cast<LicenseTemplateImpl *>(tmpl)->GetCharactersPerGroup();
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_SetGroupSeparatorA(void * tmpl, const char * groupSep)
{
	

	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetGroupSeparator(groupSep);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_SetGroupSeparatorW(void * tmpl, const wchar_t * groupSep)
{
	

	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetGroupSeparator(w2s(groupSep).c_str());
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetGroupSeparatorA(void * tmpl, const char **groupSep)
{
	try {
		*groupSep = static_cast<LicenseTemplateImpl *>(tmpl)->GetGroupSeparator();
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetGroupSeparatorW(void * tmpl, const wchar_t **groupSep)
{
	try {
		 static wstring wstr1;
		 
		 wstr1 = s2w(static_cast<LicenseTemplateImpl *>(tmpl)->GetGroupSeparator());
		 *groupSep = wstr1.c_str();
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_SetEncoding(void * tmpl, int encoding)
{
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetEncoding(encoding);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetEncoding(void * tmpl, int * encoding)
{
	try {
		*encoding = static_cast<LicenseTemplateImpl *>(tmpl)->GetEncoding();
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_SetHeaderA(void * tmpl, const char * header)
{
	

	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetHeader(header);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_SetHeaderW(void * tmpl, const wchar_t * header)
{
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetHeader(w2s(header).c_str());
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetHeaderA(void * tmpl, const char ** header)
{
	try {
		*header = static_cast<LicenseTemplateImpl *>(tmpl)->GetHeader();
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetHeaderW(void * tmpl, const wchar_t ** header)
{
	try {
		static wstring wstr1;
		
		wstr1 = s2w(static_cast<LicenseTemplateImpl *>(tmpl)->GetHeader());
		*header = wstr1.c_str();
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_SetFooterA(void * tmpl, const char * footer)
{
	

	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetFooter(footer);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_SetFooterW(void * tmpl, const wchar_t * footer)
{
	

	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetFooter(w2s(footer).c_str());
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetFooterA(void * tmpl, const char **footer)
{
	try {
		*footer = static_cast<LicenseTemplateImpl *>(tmpl)->GetFooter();
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetFooterW(void * tmpl, const wchar_t **footer)
{
	try {
		static wstring wstr1;
		
		wstr1 = s2w(static_cast<LicenseTemplateImpl *>(tmpl)->GetFooter());
		*footer = wstr1.c_str();
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_SetDataSize(void * tmpl, int sizeInBits)
{
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetDataSize(sizeInBits);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetDataSize(void * tmpl, int * sizeInBits)
{
	try {
		*sizeInBits = static_cast<LicenseTemplateImpl *>(tmpl)->GetDataSize();
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_AddDataFieldA(void * tmpl, const char * fieldName, int fieldType, int fieldBitSize, int offset)
{
	
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->AddDataField(fieldName, fieldType, fieldBitSize, offset);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_AddDataFieldW(void * tmpl, const wchar_t * fieldName, int fieldType, int fieldBitSize, int fieldOffset)
{
	
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->AddDataField(w2s(fieldName).c_str(), fieldType, fieldBitSize, fieldOffset);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}


int LicenseTemplate_GetDataFieldA(void *tmpl, const char *fieldName, int * fieldType, int *fieldSize, int *fieldOffset)
{
	

	if (static_cast<LicenseTemplateImpl *>(tmpl)->GetDataField(fieldName, fieldType, fieldSize, fieldOffset))
		return STATUS_SUCCESS;

	return STATUS_GENERIC_ERROR;
}

int LicenseTemplate_GetDataFieldW(void *tmpl, const wchar_t *fieldName, int * fieldType, int *fieldSize, int *fieldOffset)
{
	

	if (static_cast<LicenseTemplateImpl *>(tmpl)->GetDataField(w2s(fieldName).c_str(), fieldType, fieldSize, fieldOffset))
		return STATUS_SUCCESS;

	return STATUS_GENERIC_ERROR;
}

int LicenseTemplate_EnumDataFieldsA(void * tmpl, void **enumHandle, const char **fieldName, int * fieldType, int * fieldSize, int * fieldOffset)
{
	int status = STATUS_SUCCESS;

	try {
		if (!static_cast<LicenseTemplateImpl *>(tmpl)->EnumDataFields(enumHandle, fieldName, fieldType, fieldSize, fieldOffset))
			status = STATUS_GENERIC_ERROR;
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return status;
}

int LicenseTemplate_EnumDataFieldsW(void * tmpl, void **enumHandle, const wchar_t **fieldName, int * fieldType, int * fieldSize, int * fieldOffset)
{
	int status = STATUS_SUCCESS;

	try {
		const char* str1;
		
		if (static_cast<LicenseTemplateImpl*>(tmpl)->EnumDataFields(enumHandle, &str1, fieldType, fieldSize, fieldOffset))
		{
			static wstring wstr1;

			wstr1 = s2w(str1);
			*fieldName = wstr1.c_str();
		} else
			status = STATUS_GENERIC_ERROR;
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return status;
}

int LicenseTemplate_SetValidationDataSize(void * tmpl, int sizeInBits)
{
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetValidationDataSize(sizeInBits);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetValidationDataSize(void * tmpl, int * sizeInBits)
{
	try {
		*sizeInBits = static_cast<LicenseTemplateImpl *>(tmpl)->GetValidationDataSize();
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_AddValidationFieldA(void * tmpl, const char * fieldName, int fieldType, int fieldBitSize, int offset)
{
	
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->AddValidationField(fieldName, fieldType, fieldBitSize, offset);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_AddValidationFieldW(void * tmpl, const wchar_t * fieldName, int fieldType, int fieldBitSize, int offset)
{
	
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->AddValidationField(w2s(fieldName).c_str(), fieldType, fieldBitSize, offset);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetValidationFieldA(void *tmpl, const char *fieldName, int * fieldType, int *fieldSize, int *fieldOffset)
{
	

	if (static_cast<LicenseTemplateImpl *>(tmpl)->GetValidationField(fieldName, fieldType, fieldSize, fieldOffset))
		return STATUS_SUCCESS;

	return STATUS_GENERIC_ERROR;
}

int LicenseTemplate_GetValidationFieldW(void *tmpl, const wchar_t *fieldName, int * fieldType, int *fieldSize, int *fieldOffset)
{
	

	if (static_cast<LicenseTemplateImpl *>(tmpl)->GetValidationField(w2s(fieldName).c_str(), fieldType, fieldSize, fieldOffset))
		return STATUS_SUCCESS;

	return STATUS_GENERIC_ERROR;
}

int LicenseTemplate_EnumValidationFieldsA(void * tmpl, void **enumHandle, const char **fieldName, int * fieldType, int * fieldSize, int * fieldOffset)
{
	int status = STATUS_SUCCESS;

	try {
		if (!static_cast<LicenseTemplateImpl *>(tmpl)->EnumValidationFields(enumHandle, fieldName, fieldType, fieldSize, fieldOffset))
			status = STATUS_GENERIC_ERROR;
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return status;
}

int LicenseTemplate_EnumValidationFieldsW(void * tmpl, void **enumHandle, const wchar_t **fieldName, int * fieldType, int * fieldSize, int * fieldOffset)
{
	int status = STATUS_SUCCESS;

	try {
		const char* str1;

		if (static_cast<LicenseTemplateImpl *>(tmpl)->EnumValidationFields(enumHandle, &str1, fieldType, fieldSize, fieldOffset))
		{
			static wstring wstr1;
			
			wstr1 = s2w(str1);
			*fieldName = wstr1.c_str();
		} else
			status = STATUS_GENERIC_ERROR;
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return status;
}

int LicenseTemplate_SetSignatureSize(void * tmpl, int signatureSize)
{
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetSignatureSize(signatureSize);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetSignatureSize(void * tmpl, int * signatureSize)
{
	try {
		*signatureSize = static_cast<LicenseTemplateImpl *>(tmpl)->GetSignatureSize();
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_LoadXml(void * tmpl, const char * xmlTemplate)
{
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->LoadXml(xmlTemplate);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_SaveXml(void * tmpl, int savePrivateKey, const char **xmlTemplate)
{
	try {
		*xmlTemplate = static_cast<LicenseTemplateImpl *>(tmpl)->SaveXml((savePrivateKey) ? true : false);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_LoadJson(void * tmpl, const char * jsonTemplate)
{
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->LoadJson(jsonTemplate);
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_SaveJson(void * tmpl, int savePrivateKey, const char **jsonTemplate)
{
	try {
		*jsonTemplate = static_cast<LicenseTemplateImpl *>(tmpl)->SaveJson((savePrivateKey) ? true : false);
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_SetLicensingServiceUrlA(void * tmpl, const char * url)
{
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetLicensingServiceUrl(url);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_SetLicensingServiceUrlW(void * tmpl, const wchar_t * url)
{
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetLicensingServiceUrl(w2s(url).c_str());
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetLicensingServiceUrlA(void * tmpl, const char **url)
{
	try {
		*url = static_cast<LicenseTemplateImpl *>(tmpl)->GetLicensingServiceUrl();
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetLicensingServiceUrlW(void * tmpl, const wchar_t **url)
{
	try {
		static wstring wstr1;
		
		wstr1 = s2w(static_cast<LicenseTemplateImpl*>(tmpl)->GetLicensingServiceUrl());
		*url = wstr1.c_str();
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_SetTemplateIdA(void * tmpl, const char * templateId)
{
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetTemplateId(templateId);
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_SetTemplateIdW(void * tmpl, const wchar_t * templateId)
{
	

	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetTemplateId(w2s(templateId).c_str());
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetTemplateIdA(void * tmpl, const char **templateId)
{
	try {
		*templateId = static_cast<LicenseTemplateImpl *>(tmpl)->GetTemplateId();
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetTemplateIdW(void * tmpl, const wchar_t **templateId)
{
	try {
		static wstring wstr1;
		
		wstr1 = s2w(static_cast<LicenseTemplateImpl*>(tmpl)->GetTemplateId());
		*templateId = wstr1.c_str();
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

/*
int LicenseTemplate_SetProductId(void * tmpl, int productId)
{
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetProductId(productId);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetProductId(void * tmpl, int * productId)
{
	try {
		*productId = static_cast<LicenseTemplateImpl *>(tmpl)->GetProductId();
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

*/

int KeyHelper_GetCurrentHardwareIdW(const wchar_t **hwid)
{
	try {
		*hwid = KeyHelperT<wchar_t>::GetCurrentHardwareId();
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyHelper_GetCurrentHardwareIdA(const char **hwid)
{
	try {
		*hwid = KeyHelperT<char>::GetCurrentHardwareId();
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyHelper_MatchCurrentHardwareIdW(const wchar_t *hwid)
{
	try {
		if (!KeyHelperT<wchar_t>::MatchCurrentHardwareId(hwid))
			return STATUS_INVALID_LICENSE_KEY;
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int KeyHelper_MatchCurrentHardwareIdA(const char *hwid)
{
	try {
		if (!KeyHelperT<char>::MatchCurrentHardwareId(hwid))
			return STATUS_INVALID_LICENSE_KEY;
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int SDKRegistration_SetLicenseKeyA(const char * key)
{
	try {
		SDKRegistrationT<char>::SetLicenseKey(key);
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int SDKRegistration_SetLicenseKeyW(const wchar_t * key)
{
	try {
		SDKRegistrationT<wchar_t>::SetLicenseKey(key);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetPublicKeyCertificateA(void * tmpl, const char **base64Certificate)
{
	try {
		*base64Certificate = static_cast<LicenseTemplateImpl *>(tmpl)->GetPublicKeyCertificate();
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetPublicKeyCertificateW(void * tmpl, const wchar_t **base64Certificate)
{
	try {
		static wstring wstr1;
		
		wstr1 = s2w(static_cast<LicenseTemplateImpl *>(tmpl)->GetPublicKeyCertificate());
		*base64Certificate = wstr1.c_str();
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_SetPublicKeyCertificateA(void * tmpl, const char * base64Certificate)
{
	

	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetPublicKeyCertificate(base64Certificate);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_SetPublicKeyCertificateW(void * tmpl, const wchar_t * base64Certificate)
{
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetPublicKeyCertificate(w2s(base64Certificate).c_str());
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetPrivateKeyA(void * tmpl, const char **base64Key)
{
	try {
		*base64Key = static_cast<LicenseTemplateImpl *>(tmpl)->GetPrivateKey();
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetPrivateKeyW(void * tmpl, const wchar_t **base64Key)
{
	try 
	{
		static wstring wstr1;
		wstr1 = s2w(static_cast<LicenseTemplateImpl *>(tmpl)->GetPrivateKey());
		*base64Key = wstr1.c_str();
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_SetPrivateKeyA(void * tmpl, const char * base64Key)
{
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetPrivateKey(base64Key);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_SetPrivateKeyW(void * tmpl, const wchar_t * base64Key)
{
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetPrivateKey(w2s(base64Key).c_str());
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GenerateSigningKeyPair(void * tmpl)
{
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->GenerateSigningKeyPair();
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_SetPropertyA(void * tmpl, const char * path, const char * name, const char * value)
{	
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetProperty(path, name, value);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_SetPropertyW(void * tmpl, const wchar_t * path, const wchar_t * name, const wchar_t * value)
{
	try {
		static_cast<LicenseTemplateImpl *>(tmpl)->SetProperty(w2s(path).c_str(), w2s(name).c_str(), w2s(value).c_str());
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetPropertyA(void * tmpl, const char * path, const char * name, const char **value)
{
	try {
		*value = static_cast<LicenseTemplateImpl *>(tmpl)->GetProperty(path, name);
	} 
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseTemplate_GetPropertyW(void *tmpl, const wchar_t * path, const wchar_t * name, const wchar_t **value)
{
	try 
	{
		static wstring wstr1;
		wstr1 = s2w(static_cast<LicenseTemplateImpl *>(tmpl)->GetProperty(w2s(path).c_str(), w2s(name).c_str()));
		*value = wstr1.c_str();
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int Certificate_SignA(const char * csr, const char * privateKey, const char * signingPrivateKey, const char * signingCertificate, const char * certificateAuthorityUrl, int expYear, int expMonth, int expDay, const char **signedCert)
{
	try {
		static std::string staticSignedCert;
		
		staticSignedCert = Certificate::Sign(
			csr,
			privateKey,
			signingPrivateKey,
			signingCertificate,
			certificateAuthorityUrl,
			expYear, expMonth, expDay);

		*signedCert = staticSignedCert.c_str();
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();

		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

void * License_Create()
{
	return new(std::nothrow) LicenseImpl();
}

void License_Destroy(void * license)
{
	delete (LicenseImpl *)license;
}

int License_LoadXml(void * license, const char * xml)
{
	try {
		static_cast<LicenseImpl *>(license)->LoadXml(xml);
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int License_SaveXml(void * license, const char ** xmlLicense)
{
	try {
		*xmlLicense = static_cast<LicenseImpl *>(license)->SaveXml();
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int License_LoadJson(void * license, const char * json)
{
	try {
		static_cast<LicenseImpl *>(license)->LoadJson(json);
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int License_SaveJson(void * license, const char ** jsonLicense)
{
	try {
		*jsonLicense = static_cast<LicenseImpl *>(license)->SaveJson();
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

void * LicenseValidationArgs_CreateA(void * license, char * licenseKey)
{
	
	LicenseValidationArgsImpl * args = new(std::nothrow) LicenseValidationArgsImpl();

	if (license) args->SetLicense((LicenseImpl *)license);

	if (licenseKey)
	{
		args->SetLicenseKey(licenseKey);
	}

	return args;
}

void * LicenseValidationArgs_CreateW(void * license, wchar_t * licenseKey)
{
	
	LicenseValidationArgsImpl * args = new(std::nothrow) LicenseValidationArgsImpl();

	if (license) args->SetLicense((LicenseImpl *)license);

	if (licenseKey)
	{
		args->SetLicenseKey(w2s(licenseKey).c_str());
	}

	return args;
}

void LicenseValidationArgs_Destroy(void* obj)
{
	delete (LicenseValidationArgsImpl*)obj;
}

int LicenseValidationArgs_SetIntLicenseKeyValidationDataA(void * args, const char * fieldName, int fieldValue)
{
	

	try {
		static_cast<LicenseValidationArgsImpl *>(args)->SetLicenseKeyValidationData(fieldName, fieldValue);
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseValidationArgs_SetIntLicenseKeyValidationDataW(void * args, const wchar_t * fieldName, int fieldValue)
{
	

	try {
		static_cast<LicenseValidationArgsImpl *>(args)->SetLicenseKeyValidationData(w2s(fieldName).c_str(), fieldValue);
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseValidationArgs_SetStringLicenseKeyValidationDataA(void * args, const char * fieldName, const char * fieldValue)
{
	try {
		static_cast<LicenseValidationArgsImpl *>(args)->SetLicenseKeyValidationData(fieldName, fieldValue);
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseValidationArgs_SetStringLicenseKeyValidationDataW(void * args, const wchar_t * fieldName, const wchar_t * fieldValue)
{
	try {
		static_cast<LicenseValidationArgsImpl *>(args)->SetLicenseKeyValidationData(w2s(fieldName).c_str(), w2s(fieldValue).c_str());
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseValidationArgs_SetDateLicenseKeyValidationDataA(void * args, const char * fieldName, int year, int month, int day)
{
	

	try {
		static_cast<LicenseValidationArgsImpl *>(args)->SetLicenseKeyValidationData(fieldName, year, month, day);
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseValidationArgs_SetDateLicenseKeyValidationDataW(void * args, const wchar_t * fieldName, int year, int month, int day)
{
	

	try {
		static_cast<LicenseValidationArgsImpl *>(args)->SetLicenseKeyValidationData(w2s(fieldName).c_str(), year, month, day);
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseValidationArgs_SetLicenseKeyValidationDataA(void * args, const char * fieldName, void * data, int len)
{
	

	try {
		static_cast<LicenseValidationArgsImpl *>(args)->SetLicenseKeyValidationData(fieldName, data, len);
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

int LicenseValidationArgs_SetLicenseKeyValidationDataW(void * args, const wchar_t * fieldName, void * data, int len)
{
	

	try {
		static_cast<LicenseValidationArgsImpl *>(args)->SetLicenseKeyValidationData(w2s(fieldName).c_str(), data, len);
	}
	catch (Exception * ex)
	{
		int status = ex->GetCode();
		ex->Destroy();
		return status;
	}
	catch (...)
	{
		return STATUS_GENERIC_ERROR;
	}

	return STATUS_SUCCESS;
}

void * LicensingClient_Create(void * licenseTemplate)
{
	LicensingClientImpl * licensingClient = new(std::nothrow) LicensingClientImpl(NULL, false);

	if (licensingClient)
	{
		licensingClient->SetLicenseTemplate((LicenseTemplateImpl *)licenseTemplate);
	}

	return licensingClient;
}

void LicensingClient_Destroy(void * client)
{
	delete (LicensingClientImpl *)client;
}

int LicensingClient_SetLicenseTemplate(void * client, void * tmpl)
{
	int result = STATUS_SUCCESS;

	try {
		((LicensingClientImpl *)client)->SetLicenseTemplate((LicenseTemplateImpl *)tmpl);
	}
	catch (LicensingException * ex)
	{
		result = ex->GetCode();
		ex->Destroy();
	}
	catch (...)
	{
		result = STATUS_GENERIC_ERROR;
	}

	return result;
}

int LicensingClient_ValidateLicense(void* client, void* licenseValidationArgs, void** licenseValidationResult)
{
	int result = STATUS_SUCCESS;

	try {
		*((LicenseValidationResultImpl **)licenseValidationResult) = &((LicensingClientImpl *)client)->ValidateLicense((LicenseValidationArgsImpl *)licenseValidationArgs);
	}
	catch (LicensingException * ex)
	{
		result = ex->GetCode();
		ex->Destroy();
	}
	catch (...)
	{
		result = STATUS_GENERIC_ERROR;
	}

	return result;
}

int LicenseValidationResult_GetLicense(void * resultObj, void **license)
{
	int result = STATUS_SUCCESS;

	try {
		*((LicenseImpl **)license) = ((LicenseValidationResultImpl *)resultObj)->GetLicense();
	}
	catch (LicensingException * ex)
	{
		result = ex->GetCode();
		ex->Destroy();
	}
	catch (...)
	{
		result = STATUS_GENERIC_ERROR;
	}

	return result;
}

int LicenseValidationResult_IsLicenseExpired(void * result)
{
	return 0;
}

int LicenseValidationResult_IsPaymentRequired(void * result)
{
	int status = STATUS_SUCCESS;

	try {
		((LicenseValidationResultImpl *)result)->IsPaymentRequired();
	}
	catch (LicensingException * ex)
	{
		status = ex->GetCode();
		ex->Destroy();
	}
	catch (...)
	{
		status = STATUS_GENERIC_ERROR;
	}

	return status;
}

int LicenseValidationResult_GetLicenseValidityDays(void * result, int * days)
{
	int status = STATUS_SUCCESS;

	try {
		*days = ((LicenseValidationResultImpl *)result)->GetLicenseValidityDays();
	}
	catch (LicensingException * ex)
	{
		status = ex->GetCode();
		ex->Destroy();
	}
	catch (...)
	{
		status = STATUS_GENERIC_ERROR;
	}

	return status;
}

int LicenseValidationResult_GetLicenseExpirationDate(void * result, int * year, int * month, int * day)
{
	int status = STATUS_SUCCESS;

	try {
		((LicenseValidationResultImpl *)result)->GetLicenseExpirationDate(year, month,day);
	}
	catch (LicensingException * ex)
	{
		status = ex->GetCode();
		ex->Destroy();
	}
	catch (...)
	{
		status = STATUS_GENERIC_ERROR;
	}

	return status;
}