Für die meisten Funktionen finden sie Code-Samples in den Sourcen der Gui, welche dem SDK beiliegt. 


Eine der kompliziertesten Funktionalitäten ist der Tar-Export. Hier wird nämlich mit einer Callback-Funktion gearbeitet. Folgend ein paar Beispiele in unterschiedlichen Programmiersprachen:

C:

In dem folgenden Beispiel wird der komplette TAR-Export in ein File geschrieben. Relevant ist hierbei vor allem der FunctionPointer "export". Dieser zeigt auf eine Funktion, welche weiter unten definiert ist. Diese Funktion muss mit genau diesem Rückgabewert sowie diesen drei Argumenten definiert sein.

  WormExportTarCallback export = &fun;
  FILE* callbackData;
  if (fopen_s(&callbackData, cpath, "wb") != 0) {
    // return error;
  }
  if (callbackData == 0) {
    // return error;
  }
  int err = worm_export_tar(w_context, export, callbackData);
  if (fclose(callbackData) != 0) {
    // return error;
  }

Die Funktion, welche an worm_export_tar übergeben wird. Sobald ein Wert != 0 zurückgegeben wird, gilt der TAR-Export als gescheitert. Diese Funktion wird, je nach Größe des zu exportierenden TAR-Files, mehrmals aufgerufen.

int fun(const unsigned char *chunk, unsigned int chunkLength, void *callbackData) {
  if (fwrite(chunk, 1, chunkLength, callbackData) != chunkLength) {
    //return error;
  }
  return 0;
}

Java:

In Java wird im Endeffekt das Gleiche gemacht. Es wird der komplette Tar-Export in ein File geschrieben.

WormExportTarCallback callback = new WormExportTarCallback() {
      public int onNewData(byte[] data) {
        try (FileOutputStream output = new FileOutputStream(file, true)) {
          output.write(data);
        } catch (IOException e) {
          e.printStackTrace();
          return -1;
        }
        return 0;
      }
    };

C#

In der Methode MyWormExportTarCallback muss einfach festgelegt werden, was man mit den Daten machen will.

[DllImport("WormAPI.dll", CallingConvention = CallingConvention.Cdecl)]
private static extern int worm_export_tar(IntPtr context, WormExportTarCallback callback, IntPtr callbackData);

[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate int WormExportTarCallback(IntPtr chunk, uint chunkLength, IntPtr callbackData);


private static int MyWormExportTarCallback(IntPtr chunk, uint chunkLength, IntPtr callbackData) {
     return 0;
}

Auslesen des PublicKeys mit C#:


private static extern void worm_info_tsePublicKey(IntPtr info, out IntPtr array, out int size);
[DllImport("WormAPI.dll", CallingConvention = CallingConvention.Cdecl)]

worm_info_tsePublicKey(info, out var intptr, out var count);

byte[] publicKey = new byte[count];
Marshal.Copy(intptr, publicKey, 0, count);


Auslesen des regestrierten Clients mit C#:

Man weiß, dass mit dem struct maximal 16 Cients mit 31 Zeichen ausgelesen werden (30 Zeichen + 1 Null). In folgendem Beispiel wird es so gelöst, dass ein eindimensionaler Array mit der Größe 16*31 deklariert wird. In diesem haben die kompletten Daten Platz. 

 
[DllImport("WormAPI.dll", CallingConvention = CallingConvention.Cdecl)]
private static extern int worm_tse_listRegisteredClients(IntPtr info, int toSkip, out Clients clients);
        
[StructLayout(LayoutKind.Sequential)]
 public struct Clients {
          public int amount;
          [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16 * 31)]
          public char[] clientIds;
 }

Jeden Client auslesen könnte man danach mit folgendem Code-Snippet realisieren:

 
var err = worm_tse_listRegisteredClients(context, 0, out var clients);
           
for (int i = 1; i < clients.amount; i++) {
      Console.WriteLine(new string(clients.clientIds.Skip(i * 31).Take(31).ToArray()));
}
Console.WriteLine("Clients: " + clients.amount);

Inkrementeller Export mit C#:

Ab Version 5.4 gibt es den inkrementellen Export. Dieser kann so implementiert werden:

[UnmanagedFunctionPointer(Calling)]
public delegate int WormExportTarIncrementalCallback(IntPtr chunk, int chunkLength, int processedBlocks, int totalBlocks, IntPtr callbackData);

[DllImport("WormAPI.dll", CallingConvention = Calling)]
public static extern int worm_export_tar_incremental(IntPtr wormContext, byte[] lastState, int lastStateSize, byte[] newState, int newStateSize, out UInt64 firstSignatureCounter, out UInt64 lastSignatureCounter, WormExportTarIncrementalCallback callback, IntPtr callbackData);

private static int MyWormExportTarIncrementalCallback(IntPtr chunk, int chunkLength, int processedBlocks, int totalBlocks, IntPtr callbackData) {
  return 0;
}

var newState = new byte[StatusLength];
var err = ExportingStoredData.worm_export_tar_incremental(tse.GetPointer(), lastState, lastState?.Length ?? 0, newState, newState.Length, out var fistSignatureCounter, out var lastSignatureCounter, MyWormExportTarIncrementalCallback, callbackData);

private static int MyWormExportTarIncrementalCallback(IntPtr chunk, int chunkLength, UInt32 processedBlocks, UInt32 totalBlocks, IntPtr callbackData) {
return 0;
}