// !! this file should not be modified

// DAPF file is in the following format:
// DINKEYINFO
// LICENCEINFO (however many are needed)
// FILEINFO (however many are needed)
// ALGORITHM (however many are needed)
// DATAFILEENC (however many are needed)

using System;
using System.Runtime.InteropServices;   // so we can marshal the structures as a block of memory
using System.Text;						// for StringBuilder class for GetLastMessage API

// ***********  define structures that make up the DAPF file   *******************

[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Ansi, Pack=1)]
public struct DINKEYINFO
{
	public byte Header1;                // should be set to "DAPF"
	public byte Header2;
	public byte Header3;
	public byte Header4;
	public int Version;                 // version of this structure. Currently 9.
	public int SelectedModels;          // BIT0 = Dinkey Pro Lite, BIT1 = Dinkey Pro Plus, BIT2 = Dinkey Pro Net etc...
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst=12)]
	public string ProdCode;
	public int PerLicence;              // 1 = per licence, 0 = per product (default)
	public int MaxNetUsers;             // product net users, unlimited = -1, no entry = -2
	public int RangeSettings;           // 0 = any number, 1 = dongle in computer, 2 = range
	public uint	RangeMin;
	public uint	RangeMax;
	public int NumLicences;				// number of LICENCEINFO structures in this DAPF file
	public int NumProgs;				// number of FILEINFO structures in this DAPF file
	public int NumAlgs;
	public int DataSizeType;            // 1 = set the zero data size, 0 = use file to initialise data area
	public int ZeroDataSize;            // size of the data area area in bytes
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)]		
	public string DataFile;             // path to data file (0 = no data file)
	public int DataAreaSize;            // file size in bytes, -1 = file not found
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)]		
	public string ShellSuccessMsg;		// Shell Method messages...
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)]		
	public string ShellNoDongleMsg;
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)]		
	public string ShellExpiryDateMsg;
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)]		
	public string ShellExpiryExecsMsg;
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)]		
	public string ShellWarnDateMsg;
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)]		
	public string ShellWarnExecsMsg;
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)]		
	public string ShellNetUserLimitMsg;
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)]		
	public string ShellOtherErrorMsg;
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)]		
	public string ShellBackgroundMsg;
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)]		
	public string NetNoServerMsg;
	[MarshalAs(UnmanagedType.ByValArray, SizeConst=12)]
	public byte[] rwalg;				// coded form of rw algorithm (0 = no algorithm)
	public int SecOptions;              // BIT0: DRIS encryption, BIT1: Data encryption, BIT2: Data enc with alg, BIT3: only secure update codes
	public byte SecDRISEncKey1;			// DRIS encryption parameters
	public byte SecDRISEncKey2;			
	public byte SecDRISEncKey3;			
	public byte Ignored1;			    // this byte is ignored
	public byte SecDataEncKey1;			// API Data encryption parameters
	public byte SecDataEncKey2;			
	public byte SecDataEncKey3;			
	public byte Ignored2;			    // this byte is ignored
	public int ProtectionType;          // 0 = software + dongle, 1 = dongle only, 2 = program only
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst=12)]
	public string DataEncKeyProdCode;   // Alternative Product Code used to generate internal encryption keys. Normally set to 0.
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)]		
	public string Notes;                // user-defined notes
	public int LockDongle;				// 0 = don't lock (default), 1 = lock dongle to user's computer
	public int Reserved1;				// must be 0
	public int Reserved2;				// must be 0
	public int AdvancedOptions;			// BIT0 = do not allow usb-over-network for non-Net dongles, BIT1 = do not check for Software Key at Runtime. 
	public int NumDataFileEnc;			// Number of data files in our encryption list
}

[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Ansi, Pack=1)]
public struct LICENCEINFO
{
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)]
	public string LicenceName;
	public int MaxDays;                                     // -1 = no limit
	public int ExpiryDay;                                   // -1 = no limit, 0 = no change
	public int ExpiryMonth;
	public int ExpiryYear;
	public int Execs;					                    // -1 = no limit
	public int ExecsWarn;                                   // 0 = no warning (just for Shell method)
	public int DaysWarn;                                    // 0 = no warning (just for Shell method)
	public uint	Features;
	public int LicenceNetUsers;                             // unlimited = -1  (-2 = not needed (this is for display only))
}

[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Ansi, Pack=1)]
public struct FILEINFO
{
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)]		
	public string InputName;                                // input file (full path)
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)]
	public string OutputName;                               // output file/folder
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)]
	public string CallingProg;                              // calling program name
	public int LicenceIndex;                                // index (of licence) in the LicenceInfo structure (1-based index. 0 = no selection)
	public int Method;                                      // 0-api, 1-shell, 2-shell & api
	public int ShellFlags;                                  // same bit flag values as in dris. i.e. 1 = DEC_ONE_EXEC, 4 = START_NET_USER
	public int BackGround;                                  // 0=no background, 1=1min, 2=5min, 3=10min, 4=30min, 5=60min
	public int OtherShellOptions;                           // BIT0 = Shell Data Encryption is enabled, BIT1: Extra Anti-Debug is disabled, BIT2: Extra Anti-Piracy is disabled
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)]
	public string EncFileList;                              // files (or file types) that the Shell-protected program will treat as encrypted (separated by ':')
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)]
	public string ExceptList;                               // files (or file types) that are exceptions to the above list (separated by ':')
	public int ExtraAntiPiracy;                             // 0 = off, 1=min, 10=max
}

[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Ansi, Pack=1)]
public struct ALGORITHM
{
	[MarshalAs(UnmanagedType.ByValArray, SizeConst=12)]
	public byte[] alg;
}

[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Ansi, Pack=1)]
public struct DATAFILEENC
{
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)]
	public string InputName;                                // file name, wild cards are allowed
	[MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)]
	public string OutputName;                               // file name (or folder name if input is a wildcard)
}

// this structure is used for creating temporary software keys
[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Ansi, Pack=1)]
public struct TEMP_SWKEY_INFO
{
	public int size;                                        // size of this structure (must be initialised)
	public uint machineID;                                  // machine ID in (hex) integer form
	public int expiry_day;                                  // expiry date of the Software Key
	public int expiry_month;
	public int expiry_year;
	public int dongle_model;                                // model of the Software Key. See constant values below
	public uint dongle_number;                              // dongle number of the Software Key. 0 = default (random)
}

// this structure is used for creating demo software key templates
[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Ansi, Pack=1)]
public struct DEMO_SWKEY_INFO
{
	public int size;                                        // size of this structure (must be initialised)
	public int max_days;                                    // max days demo swkey installation is valid (0-60)
	public int models;                                      // bitmap of valid dongle models. See constant values below. 0 = default (only use if only one model is selected in DINKEYINFO)
}


// **********************  API functions  ************************
// we declare classes for all the API functions for each bitness

// Loads DAPF from disk and returns handle
class LoadDAPFFromFile32
{
	[DllImport("DinkeyAdd32.dll", CharSet = CharSet.Ansi)]
	public static extern IntPtr LoadDAPFFromFile(string dapf_file, out int err_code);
}

class LoadDAPFFromFile64
{
	[DllImport("DinkeyAdd64.dll", CharSet = CharSet.Ansi)]
	public static extern IntPtr LoadDAPFFromFile(string dapf_file, out int err_code);
}

// Loads DAPF from disk into structures supplied (so we can modify DAPF in memory)
class ReadDAPFEx32
{
	[DllImport("DinkeyAdd32.dll", CharSet = CharSet.Ansi)]
	public static extern int ReadDAPFEx(string dapf_file, out DINKEYINFO DinkeyInfo, byte[] licence_bytes, byte[] fileinfo_bytes, byte[] alg_bytes, byte[] datafile_bytes, out int dapf_version, out int dapf_format);
}

class ReadDAPFEx64
{
	[DllImport("DinkeyAdd64.dll", CharSet = CharSet.Ansi)]
	public static extern int ReadDAPFEx(string dapf_file, out DINKEYINFO DinkeyInfo, byte[] licence_bytes, byte[] fileinfo_bytes, byte[] alg_bytes, byte[] datafile_bytes, out int dapf_version, out int dapf_format);
}

// Loads DAPF from structures and returns a handle
class LoadDAPF32
{
	[DllImport("DinkeyAdd32.dll", CharSet = CharSet.Ansi)]
	public static extern IntPtr LoadDAPF(ref DINKEYINFO DinkeyInfo, byte[] licence_bytes, byte[] fileinfo_bytes, byte[] alg_bytes, byte[] datafile_bytes, out int ret_code);
}

class LoadDAPF64
{
	[DllImport("DinkeyAdd64.dll", CharSet = CharSet.Ansi)]
	public static extern IntPtr LoadDAPF(ref DINKEYINFO DinkeyInfo, byte[] licence_bytes, byte[] fileinfo_bytes, byte[] alg_bytes, byte[] datafile_bytes, out int ret_code);
}

// saves the DAPF file to disk
class WriteDAPFEx32
{
	[DllImport("DinkeyAdd32.dll", CharSet = CharSet.Ansi)]
	public static extern int WriteDAPFEx(IntPtr dapf_handle, string dapf_file, int dapf_format, int dapf_version, int flags);
}

class WriteDAPFEx64
{
	[DllImport("DinkeyAdd64.dll", CharSet = CharSet.Ansi)]
	public static extern int WriteDAPFEx(IntPtr dapf_handle, string dapf_file, int dapf_format, int dapf_version, int flags);
}

// unloads the DAPF file
class UnloadDAPF32
{
	[DllImport("DinkeyAdd32.dll", CharSet = CharSet.Ansi)]
	public static extern void UnloadDAPF(ref IntPtr dapf_handle);
}

class UnloadDAPF64
{
	[DllImport("DinkeyAdd64.dll", CharSet = CharSet.Ansi)]
	public static extern void UnloadDAPF(ref IntPtr dapf_handle);
}

class AddProtection32
{
	[DllImport("DinkeyAdd32.dll", CharSet = CharSet.Ansi)]
	public static extern int AddProtection(IntPtr dapf_handle, int action, int file_num, int flags, out uint dongle_number);
}

class AddProtection64
{
	[DllImport("DinkeyAdd64.dll", CharSet = CharSet.Ansi)]
	public static extern int AddProtection(IntPtr dapf_handle, int action, int file_num, int flags, out uint dongle_number);
}

class CreateTempSoftwareKey32
{
	[DllImport("DinkeyAdd32.dll", CharSet = CharSet.Ansi)]
	public static extern int CreateTempSoftwareKey(IntPtr dapf_handle, ref TEMP_SWKEY_INFO swkey_info, int flags);
}

class CreateTempSoftwareKey64
{
	[DllImport("DinkeyAdd64.dll", CharSet = CharSet.Ansi)]
	public static extern int CreateTempSoftwareKey(IntPtr dapf_handle, ref TEMP_SWKEY_INFO swkey_info, int flags);
}

class CreateDemoSoftwareKeyTemplate32
{
	[DllImport("DinkeyAdd32.dll", CharSet = CharSet.Ansi)]
	public static extern int CreateDemoSoftwareKeyTemplate(IntPtr dapf_handle, ref DEMO_SWKEY_INFO swkey_info, int flags);
}

class CreateDemoSoftwareKeyTemplate64
{
	[DllImport("DinkeyAdd64.dll", CharSet = CharSet.Ansi)]
	public static extern int CreateDemoSoftwareKeyTemplate(IntPtr dapf_handle, ref DEMO_SWKEY_INFO swkey_info, int flags);
}

class EncryptShellDataFiles32
{
	[DllImport("DinkeyAdd32.dll", CharSet = CharSet.Ansi)]
	public static extern int EncryptShellDataFiles(IntPtr dapf_handle, int file_num, int flags);
}

class EncryptShellDataFiles64
{
	[DllImport("DinkeyAdd64.dll", CharSet = CharSet.Ansi)]
	public static extern int EncryptShellDataFiles(IntPtr dapf_handle, int file_num, int flags);
}

class GetLastMessage32
{
	[DllImport("DinkeyAdd32.dll", CharSet = CharSet.Ansi)]
	public static extern void GetLastMessage(StringBuilder message, int buffer_size, out int message_length);
}

class GetLastMessage64
{
	[DllImport("DinkeyAdd64.dll", CharSet = CharSet.Ansi)]
	public static extern void GetLastMessage(StringBuilder message, int buffer_size, out int message_length);
}

class GetLastExtendedError32
{
	[DllImport("DinkeyAdd32.dll", CharSet = CharSet.Ansi)]
	public static extern int GetLastExtendedError();
}

class GetLastExtendedError64
{
	[DllImport("DinkeyAdd64.dll", CharSet = CharSet.Ansi)]
	public static extern int GetLastExtendedError();
}

// ********************* DinkeyAdd class **********************
class DinkeyAdd
{
	// constants
	public const int DAPF_VERSION = 9;					// current DAPF version

	// WriteDAPFEx API flags
	public const int FLAGS_LOSE_FEATURES = 1;			// means that you can save the DAPF file to an earlier version even if it means losing some new features that have been currently set

	// AddProtection API action values
	public const int ACTION_USE_DAPF_SETTINGS   = 0;	// means you just ignore the action value and use the default dapf settings
	public const int ACTION_PROGRAM_DONGLE      = 1;	// program the dongle only
	public const int ACTION_PROTECT_SOFTWARE    = 2;	// protect a software file (index indicated by separate parameter)
	public const int ACTION_PROGRAM_AND_PROTECT = 3;	// program the dongle and protect software

	// AddProtection API flags values
	public const int FLAGS_OVERWRITE_OUTPUT = 1;		// overwrite the output file if it already exists (default is to give an error)

	// SoftwareKey API flags
	public const int FLAGS_OVERWRITE_SWKEY = 1;			// overwrite an existing swkey with the new one
	public const int FLAGS_EXPIRY_DONTCARE = 2;			// create the Software Key even though the expiry date (or max days) is less than the expiry date of the key itself.

	// constants for dapf_format in ReadDAPFEx and WriteDAPFEx functions
	public const int DAPF_FORMAT_BINARY = 1;
	public const int DAPF_FORMAT_JSON = 2;
	public const int DAPF_FORMAT_JSON_MIN = 3;			// this value is only used with WriteDAPEx. ReadDAPFEx cannot return this value.

	// constants for values for model in the TEMP_SWKEY_INFO structure
	public const int SWKEY_MODEL_PRO_LITE = 0;			
	public const int SWKEY_MODEL_PRO_PLUS = 1;
	public const int SWKEY_MODEL_PRO_NET  = 2;
	public const int SWKEY_MODEL_FD_LITE  = 3;
	public const int SWKEY_MODEL_FD_PLUS  = 4;
	public const int SWKEY_MODEL_FD_NET   = 5;

	// constants for models bitmap in the DEMO_SWKEY_INFO structure
	public const int SWKEY_BITMAP_DEFAULT  = 0;         // use default value set in DINKEYINFO.SelectedModels
	public const int SWKEY_BITMAP_PRO_LITE = 1;         // BIT0
	public const int SWKEY_BITMAP_PRO_PLUS = 2;         // BIT1
	public const int SWKEY_BITMAP_PRO_NET  = 4;         // BIT2
	public const int SWKEY_BITMAP_FD_LITE  = 8;         // BIT3
	public const int SWKEY_BITMAP_FD_PLUS  = 16;        // BIT4
    public const int SWKEY_BITMAP_FD_NET   = 32;        // BIT5  

	// private constants
	private const int MAX_LICENCES = 255;				// max number of licences in a DAPF file
	private const int MAX_FILE_INFO = 1000;				// theoretically unlimited but in practice it is easier if we limit it
	private const int MAX_USER_ALGS = 20;				// max number of user algs in DAPF file
	private const int MAX_DATA_ENCS = 255;				// max number of Shell data encryption files in DAPF file

	// **** main API
	// We only want to load the correct DLL for the bit-ness of the computer. The other DLL may not exist.
	// if the appropriate DLL does not exist in the same directory as this test program you will receive a DllNotFoundException

    public static IntPtr LoadDAPFFromFile(string dapf_file, out int err_code)
    {
        if (IntPtr.Size == 4)
			return LoadDAPFFromFile32.LoadDAPFFromFile(dapf_file, out err_code);
        return LoadDAPFFromFile64.LoadDAPFFromFile(dapf_file, out err_code);
    }

	// we have to do some marshalling of arrays of bytes into arrays of structures
	public static int ReadDAPFEx(string dapf_file, out DINKEYINFO DinkeyInfo, out LICENCEINFO[] LicenceInfo, out FILEINFO[] FileInfo, out ALGORITHM[] Algorithms, out DATAFILEENC[] DataFileEnc, out int dapf_version, out int dapf_format)
	{
		int ret_code, i;
		byte[] licence_bytes = new byte[MAX_LICENCES * Marshal.SizeOf(typeof(LICENCEINFO))];
		byte[] licence_bytes_one_struct = new byte[Marshal.SizeOf(typeof(LICENCEINFO))];
		byte[] fileinfo_bytes = new byte[MAX_FILE_INFO * Marshal.SizeOf(typeof(FILEINFO))];
		byte[] fileinfo_bytes_one_struct = new byte[Marshal.SizeOf(typeof(FILEINFO))];
		byte[] alg_bytes = new byte[MAX_USER_ALGS * Marshal.SizeOf(typeof(ALGORITHM))];
		byte[] alg_bytes_one_struct = new byte[Marshal.SizeOf(typeof(ALGORITHM))];
		byte[] datafile_bytes = new byte[MAX_DATA_ENCS * Marshal.SizeOf(typeof(DATAFILEENC))];
		byte[] datafile_bytes_one_struct = new byte[Marshal.SizeOf(typeof(DATAFILEENC))];
		GCHandle MyGC;
		DinkeyInfo = new DINKEYINFO();
		LicenceInfo = null;
		FileInfo = null;
		Algorithms = null;
		DataFileEnc = null;

        if (IntPtr.Size == 4)
			ret_code = ReadDAPFEx32.ReadDAPFEx(dapf_file, out DinkeyInfo, licence_bytes, fileinfo_bytes, alg_bytes, datafile_bytes, out dapf_version, out dapf_format);
		else 
			ret_code = ReadDAPFEx64.ReadDAPFEx(dapf_file, out DinkeyInfo, licence_bytes, fileinfo_bytes, alg_bytes, datafile_bytes, out dapf_version, out dapf_format);
		
		if (ret_code != 0)
			return ret_code;
		
		// convert byte array to an array of structs
		LicenceInfo = new LICENCEINFO[DinkeyInfo.NumLicences];
		for (i=0; i<DinkeyInfo.NumLicences; i++)
		{
			Array.Copy(licence_bytes, i*Marshal.SizeOf(typeof(LICENCEINFO)), licence_bytes_one_struct, 0, Marshal.SizeOf(typeof(LICENCEINFO)));
			MyGC = GCHandle.Alloc(licence_bytes_one_struct, GCHandleType.Pinned);
			LicenceInfo[i] = (LICENCEINFO)Marshal.PtrToStructure(MyGC.AddrOfPinnedObject(), typeof(LICENCEINFO));
			MyGC.Free();
		}

		FileInfo = new FILEINFO[DinkeyInfo.NumProgs];
		for (i=0; i<DinkeyInfo.NumProgs; i++)
		{
			Array.Copy(fileinfo_bytes, i*Marshal.SizeOf(typeof(FILEINFO)), fileinfo_bytes_one_struct, 0, Marshal.SizeOf(typeof(FILEINFO)));
			MyGC = GCHandle.Alloc(fileinfo_bytes_one_struct, GCHandleType.Pinned);
			FileInfo[i] = (FILEINFO)Marshal.PtrToStructure(MyGC.AddrOfPinnedObject(), typeof(FILEINFO));
			MyGC.Free();
		}

		Algorithms = new ALGORITHM[DinkeyInfo.NumAlgs];
		for (i=0; i<DinkeyInfo.NumAlgs; i++)
		{
			Array.Copy(alg_bytes, i*Marshal.SizeOf(typeof(ALGORITHM)), alg_bytes_one_struct, 0, Marshal.SizeOf(typeof(ALGORITHM)));
			MyGC = GCHandle.Alloc(alg_bytes_one_struct, GCHandleType.Pinned);
			Algorithms[i] = (ALGORITHM)Marshal.PtrToStructure(MyGC.AddrOfPinnedObject(), typeof(ALGORITHM));
			MyGC.Free();
		}

		DataFileEnc = new DATAFILEENC[DinkeyInfo.NumDataFileEnc];
		for (i=0; i<DinkeyInfo.NumDataFileEnc; i++)
		{
			Array.Copy(datafile_bytes, i*Marshal.SizeOf(typeof(DATAFILEENC)), datafile_bytes_one_struct, 0, Marshal.SizeOf(typeof(DATAFILEENC)));
			MyGC = GCHandle.Alloc(datafile_bytes_one_struct, GCHandleType.Pinned);
			DataFileEnc[i] = (DATAFILEENC)Marshal.PtrToStructure(MyGC.AddrOfPinnedObject(), typeof(DATAFILEENC));
			MyGC.Free();
		}

		return ret_code;
	}

	// we have to do some marshalling of an array of structures into an array of bytes
	public static IntPtr LoadDAPF(DINKEYINFO DinkeyInfo, LICENCEINFO[] LicenceInfo, FILEINFO[] FileInfo, ALGORITHM[] Algorithms, DATAFILEENC[] DataFileEnc, out int ret_code)
	{
		int i;
		byte[] licence_bytes = new byte[MAX_LICENCES * Marshal.SizeOf(typeof(LICENCEINFO))];
		byte[] licence_bytes_one_struct = new byte[Marshal.SizeOf(typeof(LICENCEINFO))];
		byte[] fileinfo_bytes = new byte[MAX_FILE_INFO * Marshal.SizeOf(typeof(FILEINFO))];
		byte[] fileinfo_bytes_one_struct = new byte[Marshal.SizeOf(typeof(FILEINFO))];
		byte[] alg_bytes = new byte[MAX_USER_ALGS * Marshal.SizeOf(typeof(ALGORITHM))];
		byte[] alg_bytes_one_struct = new byte[Marshal.SizeOf(typeof(ALGORITHM))];
		byte[] datafile_bytes = new byte[MAX_DATA_ENCS * Marshal.SizeOf(typeof(DATAFILEENC))];
		byte[] datafile_bytes_one_struct = new byte[Marshal.SizeOf(typeof(DATAFILEENC))];
		GCHandle MyGC;
		
		// convert array of structs to a byte array
		for (i=0; i<DinkeyInfo.NumLicences; i++)
		{
			MyGC = GCHandle.Alloc(licence_bytes_one_struct, GCHandleType.Pinned);
			Marshal.StructureToPtr(LicenceInfo[i], MyGC.AddrOfPinnedObject(), false);
			MyGC.Free();
			Array.Copy(licence_bytes_one_struct, 0, licence_bytes, i*Marshal.SizeOf(typeof(LICENCEINFO)), Marshal.SizeOf(typeof(LICENCEINFO)));
		}

		for (i=0; i<DinkeyInfo.NumProgs; i++)
		{
			MyGC = GCHandle.Alloc(fileinfo_bytes_one_struct, GCHandleType.Pinned);
			Marshal.StructureToPtr(FileInfo[i], MyGC.AddrOfPinnedObject(), false);
			MyGC.Free();
			Array.Copy(fileinfo_bytes_one_struct, 0, fileinfo_bytes, i*Marshal.SizeOf(typeof(FILEINFO)), Marshal.SizeOf(typeof(FILEINFO)));
		}

		for (i=0; i<DinkeyInfo.NumAlgs; i++)
		{
			MyGC = GCHandle.Alloc(alg_bytes_one_struct, GCHandleType.Pinned);
			Marshal.StructureToPtr(Algorithms[i], MyGC.AddrOfPinnedObject(), false);
			MyGC.Free();
			Array.Copy(alg_bytes_one_struct, 0, alg_bytes, i*Marshal.SizeOf(typeof(ALGORITHM)), Marshal.SizeOf(typeof(ALGORITHM)));
		}

		for (i=0; i<DinkeyInfo.NumDataFileEnc; i++)
		{
			MyGC = GCHandle.Alloc(datafile_bytes_one_struct, GCHandleType.Pinned);
			Marshal.StructureToPtr(DataFileEnc[i], MyGC.AddrOfPinnedObject(), false);
			MyGC.Free();
			Array.Copy(datafile_bytes_one_struct, 0, datafile_bytes, i*Marshal.SizeOf(typeof(DATAFILEENC)), Marshal.SizeOf(typeof(DATAFILEENC)));
		}

		if (IntPtr.Size == 4)
			return LoadDAPF32.LoadDAPF(ref DinkeyInfo, licence_bytes, fileinfo_bytes, alg_bytes, datafile_bytes, out ret_code);
		return LoadDAPF64.LoadDAPF(ref DinkeyInfo, licence_bytes, fileinfo_bytes, alg_bytes, datafile_bytes, out ret_code);
	}

	public static int WriteDAPFEx(IntPtr dapf_handle, string dapf_file, int dapf_format, int dapf_version, int flags)
	{
		if (IntPtr.Size == 4)
			return WriteDAPFEx32.WriteDAPFEx(dapf_handle, dapf_file, dapf_format, dapf_version, flags);
		return WriteDAPFEx64.WriteDAPFEx(dapf_handle, dapf_file, dapf_format, dapf_version, flags);
	}
	
	public static void UnloadDAPF(ref IntPtr dapf_handle)
	{
		if (IntPtr.Size == 4)
			UnloadDAPF32.UnloadDAPF(ref dapf_handle);
		else
			UnloadDAPF64.UnloadDAPF(ref dapf_handle);
		return;
	}

	public static int AddProtection(IntPtr dapf_handle, int action, int file_num, int flags, out uint dongle_number)
	{
		if (IntPtr.Size == 4)
			return AddProtection32.AddProtection(dapf_handle, action, file_num, flags, out dongle_number);
		return AddProtection64.AddProtection(dapf_handle, action, file_num, flags, out dongle_number);
	}

	public static int CreateTempSoftwareKey(IntPtr dapf_handle, TEMP_SWKEY_INFO swkey_info, int flags) 
	{
		if (IntPtr.Size == 4)
			return CreateTempSoftwareKey32.CreateTempSoftwareKey(dapf_handle, ref swkey_info, flags);
		return CreateTempSoftwareKey64.CreateTempSoftwareKey(dapf_handle, ref swkey_info, flags);
	}

	public static int CreateDemoSoftwareKeyTemplate(IntPtr dapf_handle, DEMO_SWKEY_INFO swkey_info, int flags) 
	{
		if (IntPtr.Size == 4)
			return CreateDemoSoftwareKeyTemplate32.CreateDemoSoftwareKeyTemplate(dapf_handle, ref swkey_info, flags);
		return CreateDemoSoftwareKeyTemplate64.CreateDemoSoftwareKeyTemplate(dapf_handle, ref swkey_info, flags);
	}

    public static int EncryptShellDataFiles(IntPtr dapf_handle, int file_num, int flags)
    {
        if (IntPtr.Size == 4)
            return EncryptShellDataFiles32.EncryptShellDataFiles(dapf_handle, file_num, flags);
        return EncryptShellDataFiles64.EncryptShellDataFiles(dapf_handle, file_num, flags);
    }

	// do a bit of work here to make the function easier to use for C#
	public static string GetLastMessage()
	{
		int length, dummy;
		StringBuilder message;

		if (IntPtr.Size == 4)
		{
			GetLastMessage32.GetLastMessage(null, 0, out length);
			message = new StringBuilder(length);
			GetLastMessage32.GetLastMessage(message, length, out dummy);
		}
		else
		{
			GetLastMessage64.GetLastMessage(null, 0, out length);
			message = new StringBuilder(length);
			GetLastMessage64.GetLastMessage(message, length, out dummy);
		}

		return message.ToString();
	}

	public static int GetLastExtendedError()
	{
		if (IntPtr.Size == 4)
			return GetLastExtendedError32.GetLastExtendedError();
		return GetLastExtendedError64.GetLastExtendedError();
	}

}