ERiC API-Referenz 43.3.2.0

Lade ...
Suche ...
Keine Treffer
otto.h
gehe zur Dokumentation dieser Datei
1#ifndef OTTO_H_
2#define OTTO_H_
3
4#include "otto_statuscode.h"
5#include "otto_types.h"
6
7#include <stdint.h>
8
9
10// Definiere Windows-x86 cdecl-Aufrufkonvention
11#ifndef C_DECL
12# if defined(_WIN32) && !defined(_WIN64)
13# define C_DECL __cdecl
14# else
15# define C_DECL
16# endif
17#endif
18
19
20/**
21 * @file
22* @brief Deklaration der Otto-Funktionen
23 *
24 */
25
26#ifdef __cplusplus
27 extern "C" {
28#endif
29
30/**
31 * @brief Erstellt und initialisiert eine neue Otto-Instanz.
32 *
33 * Otto-Instanzen sind nicht an ihre Ersteller-Threads gebunden.
34 * Sie dürfen zwar _nicht gleichzeitig_ in mehreren
35 * Threads verwendet werden, aber sie dürfen wechselnd von verschiedenen
36 * Threads verwendet werden. Das heißt insbesondere, dass sie von neuen
37 * Threads wiederverwendet werden können.
38 *
39 * Otto-Instanzen sind in dem Sinne threadsicher, dass verschiedene
40 * Otto-Instanzen zeitgleich in verschiedenen Threads verwendet werden können.
41 * Jedoch darf ein- und dieselbe Otto-Instanz nicht zeitgleich in mehreren
42 * Threads verwendet werden.
43 *
44 * @param[in] logPfad
45 * Optionaler Pfad zur Log-Datei otto.log. Ist der
46 * Wert gleich @c NULL, wird das betriebssystemspezifische
47 * Verzeichnis für temporäre Dateien verwendet.
48 *
49 * @param[in] logCallback
50 * Callback-Funktion, die gegebenenfalls von Otto bei der
51 * Protokollierung von Meldungen aufgerufen wird.
52 * Siehe ::OttoLogCallback
53 * Der Parameter darf @c NULL sein.
54 *
55 * @param[in] logCallbackBenutzerdaten
56 * @parblock
57 * Beliebiger Zeiger auf Daten, den Otto beim Aufruf eines
58 * @p logCallback an den Callback weiterreicht.
59 *
60 * Über diesen Weg kann sich eine Anwendung eigene Daten an
61 * ihre Log-Callback-Funktion übergeben lassen.
62 * Der Parameter darf @c NULL sein.
63 * @endparblock
64 * @param[out] instanz
65 * Handle der erzeugten Otto-Instanz
66 *
67 * @note
68 * @parblock
69 * Kann kein otto.log angelegt werden, wird eine entsprechende
70 * Fehlermeldung auf die Konsole (stderr) geschrieben und an den
71 * Windows-Ereignisdienst bzw. den syslogd-Dienst (Linux, AIX, macOS)
72 * geschickt.
73 *
74 * Für Linux, AIX und macOS ist zu beachten, dass der syslogd-Dienst
75 * gegebenenfalls erst noch zu aktivieren und für die Protokollierung
76 * von Meldungen der Facility "User" zu konfigurieren ist.
77 * Suchkriterien für Otto-Meldungen in der Windows-Ereignisansicht
78 * sind "ERiC (Elster Rich Client)" als Quelle und "Anwendung"
79 * als Protokoll.
80 *
81 * Suchkriterien für ERiC-Meldungen in den Systemlogdateien
82 * unter Linux, AIX und macOS sind die Facility "User" und
83 * der Ident "ERiC (Elster Rich Client)".
84 * @endparblock
85 *
86 * @return
87 * - siehe otto_statuscode.h
88 *
89 * @see
90 * - OttoInstanzFreigeben()
91 * - OttoLogCallback
92 */
93 OttoStatusCode C_DECL OttoInstanzErzeugen(const byteChar *logPfad,
94 OttoLogCallback logCallback,
95 void *logCallbackBenutzerdaten,
96 OttoInstanzHandle *instanz);
97
98/**
99 * @brief Gibt eine Otto-Instanz frei.
100 *
101 * Die freigegebene Otto-Instanz sowie alle eventuell noch daran
102 * gebundenen Objekte dürfen nach der Freigabe nicht mehr verwendet
103 * werden.
104 *
105 * @param[in] instanz
106 * Handle der Otto-Instanz, die freigegeben werden soll.
107 *
108 * @return
109 * - siehe otto_statuscode.h
110 *
111 * @see
112 * - OttoInstanzErzeugen()
113 */
114 OttoStatusCode C_DECL OttoInstanzFreigeben(OttoInstanzHandle instanz);
115
116/**
117 * @brief Erstellt ein Otto-Zertifikatsobjekt für ein Sicherheitstoken.
118 *
119 * Das Zertifikatsobjekt ist an die Otto-Instanz gebunden, für die es erzeugt
120 * wurde, und darf nicht zusammen mit einer anderen Otto-Instanz oder mit
121 * Objekten anderer Otto-Instanzen verwendet werden.
122 * Soll ein Sicherheitstoken von mehreren Otto-Instanzen verwendet werden, so
123 * sind hierfür mehrere Zertifikatsobjekte zu erstellen: für jede Instanz eines.
124 *
125 * @param[in] instanz
126 * Handle der Otto-Instanz, die das Zertifikatsobjekt verwenden soll.
127 *
128 * @param[in] zertifikatsPfad
129 * @parblock
130 * Pfad zum Sicherheitstoken, folgende Angaben sind möglich: @mAbsatz
131 * 1. Clientseitig erzeugtes Zertifikat: @mLB<a>Pfad
132 * Verzeichnis, in dem sich die Zertifikats-Datei (.cer)
133 * und die Datei mit dem privaten Schlüssel (.p12) befinden.
134 * Diese Sicherheitstokens wurden mit EricMtCreateKey() bzw. EricCreateKey() erzeugt.
135 * Der Pfad zum Verzeichnis ist bei clientseitig erzeugten
136 * Zertifikaten relativ zum aktuellen Arbeitsverzeichnis oder absolut
137 * anzugeben.
138 * 2. Software-Portalzertifikat: @mLB<a>Pfad
139 * zur Software-Zertifikatsdatei (i.d.R. mit der Endung .pfx).
140 * Der Pfad zur Datei ist bei Software-Zertifikaten relativ zum
141 * aktuellen Arbeitsverzeichnis oder absolut anzugeben.
142 * 3. Sicherheitsstick: @mLB<a>Pfad
143 * zur Treiberdatei, siehe (*). Bitte beachten, dass der Treiber
144 * betriebssystemabhängig sein kann. Weitere Informationen in der
145 * Anleitung zum Sicherheitsstick oder unter
146 * \linkExt{https://www.sicherheitsstick.de,https://www.sicherheitsstick.de}.
147 * 4. Signaturkarte: (**) @mLB<a>Pfad
148 * zur Treiberdatei, welcher einen Zugriff auf die
149 * Signaturkarte ermöglicht, siehe (*). Weitere Informationen in
150 * der Anleitung zur Signaturkarte.
151 * 5. Elektronischer Personalausweis (nPA) oder Aufenthaltstitel (eAT): @mLB<a>Die
152 * URL des eID-Clients wie zum Beispiel der AusweisApp 2.
153 * In den meisten Fällen lautet diese URL: http://127.0.0.1:24727/eID-Client
154 * Optional kann auf die folgende Weise noch ein Testmerker angehängt werden:
155 * http://127.0.0.1:24727/eID-Client?testmerker=520000000. @mLB<a>Zu
156 * den verfügbaren Testmerkern siehe @typeDokumentation{ERiC-Entwicklerhandbuch.pdf},
157 * Kap. "Testunterstützung bei der ERiC-Anbindung".
158 *
159 * <B>Wichtig:</B>
160 * Das Ad-hoc-Zertifikat, das in diesem Fall für den elektronischen
161 * Personalausweis erzeugt wird, ist nur 24 Stunden gültig.
162 * @endparblock
163 * (*) Wird der Dateipfad eines Treibers angegeben, ist der Suchmechanismus zu
164 * beachten, mit dem das jeweilige Betriebssystem dynamische Bibliotheken lädt.
165 * Weitere Informationen sind der Systemdokumentation zu den Betriebssystemfunktionen
166 * <tt>LoadLibrary()</tt> (Windows) bzw. <tt>dlopen()</tt> (Linux, AIX und macOS) zu entnehmen.
167 *
168 * (**) Bei Signaturkarten erfolgt eine PIN-Abfrage nicht beim Aufruf von
169 * OttoZertifikatOeffnen(), sondern beim Aufruf von OttoPruefsummeSignieren(),
170 * OttoEmpfangBeginnen() und OttoEmpfangBeginnenAbholzertifikat().
171 *
172 * Pfade müssen auf Windows in der für Datei-Funktionen benutzten ANSI-Codepage,
173 * auf Linux, AIX und Linux Power in der für das Dateisystem benutzten Locale
174 * und auf macOS in der "decomposed form" von UTF-8 übergeben werden.
175 * Bitte weitere Betriebssystemspezifika bzgl. nicht erlaubter Zeichen in
176 * Pfaden und Pfadtrennzeichen beachten.
177 *
178 * Für Details zu Pfaden im ERiC siehe @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kapitel
179 * "Übergabe von Pfaden an ERiC API-Funktionen".
180 *
181 * @param[in] zertifikatsPasswort
182 * Das Passwort oder die PIN des Sicherheitstokens.
183 * Bei Tokens, bei denen das Passwort oder die PIN nicht von der Anwendung
184 * übergeben, sondern separat über einen Treiber (z. B. von einem Kartenlesegerät)
185 * abgefragt wird, ist hier NULL zu übergeben.
186 *
187 * @param[out] zertifikat
188 * Handle auf das erstellte Zertifikatsobjekt
189 *
190 * @return
191 * - siehe otto_statuscode.h
192 *
193 * @see
194 * - OttoZertifikatSchliessen()
195 * - OttoZertifikatOeffnenAusBytes()
196 */
197 OttoStatusCode C_DECL OttoZertifikatOeffnen(OttoInstanzHandle instanz,
198 const byteChar *zertifikatsPfad,
199 const byteChar *zertifikatsPasswort,
200 OttoZertifikatHandle *zertifikat);
201
202/**
203 * @brief Erstellt ein Otto-Zertifikatsobjekt für ein PKCS#12-Sicherheitstoken,
204 * das im Hauptspeicher übergeben wird.
205 *
206 * Das Zertifikatsobjekt ist an die Otto-Instanz gebunden, für die es erzeugt
207 * wurde, und darf nicht zusammen mit einer anderen Otto-Instanz oder mit
208 * Objekten anderer Otto-Instanzen verwendet werden.
209 * Soll ein PKCS#12-Container von mehreren Otto-Instanzen verwendet werden, so
210 * sind hierfür mehrere Zertifikatsobjekte zu erstellen: für jede Instanz eines.
211 *
212 * @param[in] instanz
213 * Handle der Otto-Instanz, die das Zertifikatsobjekt verwenden soll.
214 *
215 * @param[in] pkcs12Container
216 * Adresse des PKCS#12-Containers im Hauptspeicher.
217 * Es werden nur passwortgeschützte PKCS#12-Container akzeptiert.
218 *
219 * @param[in] containerGroesse
220 * Größe des PKCS#12-Containers in Bytes
221 *
222 * @param[in] zertifikatsPasswort
223 * Das Passwort oder die PIN des PKCS#12-Containers.
224 * Dieser Parameter darf nicht NULL sein.
225 *
226 * @param[out] zertifikat
227 * Handle auf das erstellte Zertifikatsobjekt
228 *
229 * @return
230 * - siehe otto_statuscode.h
231 *
232 * @see
233 * - OttoZertifikatSchliessen()
234 * - OttoZertifikatOeffnen()
235 */
236 OttoStatusCode C_DECL OttoZertifikatOeffnenAusBytes(OttoInstanzHandle instanz,
237 const byteChar *pkcs12Container,
238 uint32_t containerGroesse,
239 const byteChar *zertifikatsPasswort,
240 OttoZertifikatHandle *zertifikat);
241
242/**
243 * @brief Schließt das Otto-Zertifikatsobjekt zu einem Sicherheitstoken.
244 * Anschließend darf das Zertifikatsobjekt nicht mehr verwendet werden.
245 *
246 * @param[in] zertifikat
247 * Handle auf das Zertifikatsobjekt, das geschlossen werden soll.
248 *
249 * @return
250 * - siehe otto_statuscode.h
251 *
252 * @see
253 * - OttoZertifikatOeffnen()
254 */
255 OttoStatusCode C_DECL OttoZertifikatSchliessen(OttoZertifikatHandle zertifikat);
256
257/**
258 * @brief Erzeugt einen Rückgabepuffer und gibt ein Handle darauf zurück.
259 *
260 * Die von dieser Funktion erzeugten Rückgabepuffer werden verwendet, um
261 * die Rückgabedaten von Otto-Funktionen (z. B. OttoEmpfangFortsetzen()
262 * oder OttoVersandBeenden()) aufzunehmen.
263 * Dazu wird das Rückgabepuffer-Handle für den Schreibvorgang
264 * an die ausgebende Funktion übergeben.
265 *
266 * Zum Auslesen des von den API-Funktionen beschriebenen Puffers wird das
267 * Rückgabepuffer-Handle an OttoRueckgabepufferInhalt() übergeben.
268 * Ein einmal erzeugtes Rückgabepuffer-Handle kann für weitere nachfolgende
269 * Aufrufe von Otto API-Funktionen wiederverwendet werden. Bei einer
270 * Wiederverwendung eines Handles werden frühere Inhalte überschrieben.
271 * Nach letztmaliger Verwendung muss jeder Rückgabepuffer mit
272 * OttoRueckgabepufferFreigeben() freigegeben werden.
273 *
274 * Der Rückgabepuffer ist an die Otto-Instanz gebunden, für die er erzeugt
275 * wurde und kann nicht zusammen mit einer anderen Otto-Instanz oder mit
276 * Objekten anderen Otto-Instanzen verwendet werden.
277 *
278 * @param[in] instanz
279 * Handle der Otto-Instanz, auf der diese Funktion ausgeführt werden soll.
280 *
281 * @param[out] rueckgabepuffer
282 * Zeiger auf das Handle des erzeugten Rückgabepuffers
283 *
284 * @return
285 * - siehe otto_statuscode.h
286 *
287 * @see
288 * - OttoRueckgabepufferGroesse()
289 * - OttoRueckgabepufferInhalt()
290 * - OttoRueckgabepufferFreigeben()
291 */
292 OttoStatusCode C_DECL OttoRueckgabepufferErzeugen(OttoInstanzHandle instanz,
293 OttoRueckgabepufferHandle *rueckgabepuffer);
294
295/**
296 * @brief Gibt die Anzahl der im Rückgabepuffer
297 * enthaltenen Bytes zurück. Das abschließende Null-Byte wird
298 * nicht mitgezählt.
299 *
300 * @param[in] rueckgabepuffer
301 * Das Handle des Rückgabepuffers
302 *
303 * @return
304 * - Anzahl der im Rückgabepuffer enthaltenen Bytes,
305 * wenn ein gültiges Handle übergeben wird.
306 * - 0 sonst
307 *
308 * @see
309 * - OttoRueckgabepufferInhalt()
310 * - OttoRueckgabepufferErzeugen()
311 * - OttoRueckgabepufferFreigeben()
312 */
313uint64_t C_DECL OttoRueckgabepufferGroesse(OttoRueckgabepufferHandle rueckgabepuffer);
314
315/**
316 * @brief Gibt den Inhalt eines Rückgabepuffers zurück.
317 *
318 * Der zurückgegebene Zeiger verweist auf ein Byte-Array, das alle in
319 * den Rückgabepuffer geschriebenen Bytes enthält.
320 * Dieses Array existiert so lange im Speicher, bis der Rückgabepuffer
321 * entweder (bei einer Wiederverwendung des Handles) erneut beschrieben
322 * oder der Puffer explizit freigegeben wird.
323 * Der Array wird immer von einem Null-Byte abgeschlossen. Wenn der
324 * Rückgabepuffer keine weiteren Null-Bytes enthält, kann folglich der
325 * Rückgabepufferinhalt bequem als null-terminierte Zeichenkette
326 * interpretiert werden.
327 *
328 * @param[in] rueckgabepuffer
329 * Das Handle des Rückgabepuffers, dessen Inhalt zurückgegeben werden soll.
330 *
331 * @return
332 * - Zeiger auf den Rückgabepufferinhalt, wenn ein gültiges Handle übergeben wird.
333 * - NULL sonst
334 *
335 * @see
336 * - OttoRueckgabepufferGroesse()
337 * - OttoRueckgabepufferErzeugen()
338 * - OttoRueckgabepufferFreigeben()
339 */
340 const byteChar* C_DECL OttoRueckgabepufferInhalt(OttoRueckgabepufferHandle rueckgabepuffer);
341
342/**
343 * @brief Gibt einen Rückgabepuffer frei.
344 *
345 * Das Handle des Rückgabepuffers darf danach nicht weiter verwendet werden.
346 * Es wird daher empfohlen, Handle-Variablen nach der Freigabe explizit auf
347 * @c NULL zu setzen.
348 *
349 * @param[in] rueckgabepuffer
350 * Handle auf den Rückgabepuffer, der freigegeben werden soll.
351 * Dieser Rückgabepuffer darf nicht bereits freigegeben worden sein.
352 *
353 * @return
354 * - siehe otto_statuscode.h
355 *
356 * @see
357 * - OttoRueckgabepufferGroesse()
358 * - OttoRueckgabepufferInhalt()
359 * - OttoRueckgabepufferErzeugen()
360 */
361 OttoStatusCode C_DECL OttoRueckgabepufferFreigeben(OttoRueckgabepufferHandle rueckgabepuffer);
362
363/**
364 * @brief Erzeugt ein Objekt zur Berechnung einer Datenprüfsumme, die Otto
365 * zu Beginn einer Übermittlung an den OTTER-Server senden muss.
366 *
367 * Das Prüfsummenobjekt ist an die Otto-Instanz gebunden, für die es erzeugt
368 * wurde und darf nicht zusammen mit einer anderen Otto-Instanz oder mit
369 * Objekten anderen Otto-Instanzen verwendet werden.
370 *
371 * @param[in] instanz
372 * Handle der Otto-Instanz, für die das Prüfsummenobjekt erzeugt werden soll.
373 *
374 * @param[out] pruefsumme
375 * Handle des erzeugten Prüfsummenobjekts
376 *
377 * @return
378 * - siehe otto_statuscode.h
379 *
380 * @see
381 * - OttoPruefsummeAktualisieren()
382 * - OttoPruefsummeSignieren()
383 * - OttoPruefsummeFreigeben()
384 */
385 OttoStatusCode C_DECL OttoPruefsummeErzeugen(OttoInstanzHandle instanz, OttoPruefsummeHandle *pruefsumme);
386
387/**
388 * @brief Aktualisiert die Prüfsumme über Daten.
389 * Eine Prüfsumme, die bereits signiert wurde, kann nicht mehr
390 * aktualisiert werden.
391 *
392 * @param[in,out] pruefsumme
393 * Handle der Prüfsumme, die aktualisiert werden soll.
394 *
395 * @param[in] datenBlock
396 * Zeiger auf die Daten, über die die Prüfsumme aktualisiert werden soll.
397 *
398 * @param[in] datenBlockGroesse
399 * Größe der Daten, über die die Prüfsumme aktualisiert werden soll, in Bytes.
400 *
401 * @return
402 * - ::OTTO_OK wenn die Prüfsumme erfolgreich aktualisiert werden konnte
403 * - ::OTTO_PRUEFSUMME_FINALISIERT wenn die Prüfsumme bereits signiert wurde
404 * - weitere, siehe otto_statuscode.h
405 *
406 * @see
407 * - OttoPruefsummeErzeugen()
408 * - OttoPruefsummeSignieren()
409 * - OttoPruefsummeFreigeben()
410 *
411 */
412 OttoStatusCode C_DECL OttoPruefsummeAktualisieren(OttoPruefsummeHandle pruefsumme,
413 const byteChar *datenBlock,
414 uint64_t datenBlockGroesse);
415
416/**
417 * @brief Erstellt eine Signatur über eine Prüfsumme.
418 *
419 * Die Signierung der Prüfsumme ist nur dann möglich,
420 * wenn diese über die Mindestdatenmenge für eine Übermittlung
421 * an den OTTER-Server berechnet wurde. (20 MiB)
422 * Eine Prüfsumme kann nur einmalig signiert werden.
423 * Danach muß das Prüfsummenobjekt freigegeben werden.
424 *
425 * @param[in] pruefsumme
426 * Handle der Prüfsumme, die signiert werden soll.
427 *
428 * @param[in] zertifikat
429 * Handle des Sicherheitstoken, mit dem die Prüfsumme signiert werden soll.
430 *
431 * @param[out] rueckgabepuffer
432 * Handle des Rückgabepuffers, in den die signierte Prüfsumme
433 * geschrieben werden soll.
434 * Die signierte Prüfsumme wird als base64-codierte Zeichenfolge übergeben.
435 *
436 * @return
437 * - ::OTTO_OK wenn die Prüfsumme signiert werden konnte
438 * - ::OTTO_PRUEFSUMME_FINALISIERT wenn die Prüfsumme bereits signiert wurde
439 * - ::OTTO_VERSAND_GERINGE_DATENMENGE wenn die Prüfsumme über weniger Daten gebildet wurde als für den Versand an den OTTER-Server erforderlich sind
440 * - ::OTTO_ESIGNER_NICHT_GELADEN wenn die Signaturkomponente eSigner nicht geladen werden konnte
441 * - ::OTTO_ESIGNER_VERALTET wenn die vorliegende Version der Signaturkomponente eSigner zu alt ist
442 * - ::OTTO_ESIGNER_INKOMPATIBEL wenn die vorliegende Signaturkomponente eSigner zur Otto-Bibliothek nicht kompatibel ist
443 * - Fehler der Signaturkomponente eSigner aus dem Statuscodebereich ab ::OTTO_ESIGNER_BUSY = 610405801
444 * - weitere, siehe otto_statuscode.h
445 *
446 * @see
447 * - OttoPruefsummeErzeugen()
448 * - OttoPruefsummeAktualisieren()
449 * - OttoPruefsummeFreigeben()
450 *
451 */
452 OttoStatusCode C_DECL OttoPruefsummeSignieren(OttoPruefsummeHandle pruefsumme,
453 OttoZertifikatHandle zertifikat,
454 OttoRueckgabepufferHandle rueckgabepuffer);
455
456/**
457 * @brief Gibt ein Prüfsummenobjekt frei.
458 *
459 * Das Prüfsummenobjekt darf danach nicht wieder verwendet werden.
460 *
461 * @param[in] pruefsumme
462 * Handle des Prüfsummenobjekts, das freigegeben werden soll.
463 *
464 * @return
465 * - siehe otto_statuscode.h
466 *
467 * @see
468 * - OttoPruefsummeErzeugen()
469 * - OttoPruefsummeAktualisieren()
470 * - OttoPruefsummeSignieren()
471 */
472 OttoStatusCode C_DECL OttoPruefsummeFreigeben(OttoPruefsummeHandle pruefsumme);
473
474/**
475 * @brief Initialisiert einen Datenversand an den OTTER-Server.
476 *
477 * Das zurückgegebene Handle des Versandobjekts wird der Funktion
478 * OttoVersandFortsetzen() übergeben, um Daten blockweise hochzuladen.
479 * Sind alle Daten versendet, ist OttoVersandAbschliessen() aufzurufen, womit
480 * der Versand abgeschlossen wird.
481 * Zum Freigeben des Versandobjekts ist OttoVersandBeenden() aufzurufen.
482 *
483 * Bevor der Versand begonnen werden kann, muss eine Prüfsumme über alle zu
484 * versendenen Daten gebildet (siehe OttoPruefsummeErzeugen()) und mit
485 * OttoPruefsummeSignieren() signiert werden.
486 *
487 * @note Wurde Otto vor dem Aufruf dieser Funktion für einen Proxy mit OttoProxyKonfigurationSetzen()
488 * konfiguriert, wird der Versand über den Proxy durchgeführt. Die Proxy-Konfiguration wird
489 * intern an dem Versandobjekt gespeichert und spätere Aufrufe von OttoProxyKonfigurationSetzen()
490 * haben keinen Einfluss auf den bereits begonnenen Versand.
491 *
492 * @param[in] instanz
493 * Handle der Otto-Instanz, auf der diese Funktion ausgeführt werden soll.
494 *
495 * @param[in] signiertePruefsumme
496 * @parblock
497 * Signierte Prüfsumme über die Gesamtheit der Daten, die in diesem Versand
498 * versendet werden sollen.
499 *
500 * Die signierte Prüfsumme wird als base64-codierte, nullterminierte Zeichenfolge erwartet,
501 * wie sie von OttoPruefsummeSignieren() zurückgeliefert wird.
502 * @endparblock
503 * @param[in] herstellerId
504 * Hersteller-ID des Softwareproduktes
505 *
506 * @param[out] versand
507 * Handle auf das Versandobjekt. Im Fehlerfall wird kein Versandobjekt erzeugt.
508 *
509 * @return
510 * - siehe otto_statuscode.h
511 *
512 * @see
513 * - OttoVersandFortsetzen()
514 * - OttoVersandAbschliessen()
515 * - OttoVersandBeenden()
516 * - OttoPruefsummeSignieren()
517 * - OttoProxyKonfigurationSetzen()
518 */
519 OttoStatusCode C_DECL OttoVersandBeginnen(OttoInstanzHandle instanz,
520 const byteChar *signiertePruefsumme,
521 const byteChar *herstellerId,
522 OttoVersandHandle *versand);
523
524/**
525 * @brief Versendet einen Datenblock an den OTTER-Server.
526 *
527 * Otto liest den übergebenen Datenblock ein und versendet ihn an den OTTER-Server.
528 * Wenn @c OTTO_OK zurückgegeben wird, kann diese Funktion erneut mit einem weiteren
529 * Datenblock aufgerufen werden. Dies ist zu wiederholen, bis Otto alle zu diesem Versand
530 * gehörigen Daten erhalten hat. Falls nicht @c OTTO_OK zurückgegeben wird, ist der
531 * Versand fehlgeschlagen.
532 *
533 * Ist das Ende der Daten erreicht, muss OttoVersandAbschliessen() aufgerufen werden.
534 *
535 * @param[in] versand
536 * Ein mit OttoVersandBeginnen() erzeugtes Handle
537 *
538 * @param[in] datenBlock
539 * Zeiger auf die zu versendenen Daten. Falls @c NULL wird der Aufruf ignoriert.
540 *
541 * @param[in] datenBlockGroesse
542 * Größe des Arrays @p datenBlock in Bytes. Falls 0 wird der Aufruf ignoriert.
543 *
544 * @return
545 * - ::OTTO_OK im Erfolgsfall
546 * - ::OTTO_TRANSFER_UNAUTHORIZED
547 * - ::OTTO_TRANSFER_CONNECTSERVER
548 * - ::OTTO_VERSAND_ABGESCHLOSSEN falls OttoVersandAbschliessen() bereits aufgerufen wurde
549 * - weitere, siehe otto_statuscode.h
550 *
551 * @see
552 * - OttoVersandAbschliessen()
553 */
554 OttoStatusCode C_DECL OttoVersandFortsetzen(OttoVersandHandle versand,
555 const byteChar *datenBlock,
556 uint64_t datenBlockGroesse);
557
558/**
559 * @brief Schließt einen Versand ab und gibt die Objekt-ID zurück
560 *
561 * Mit dieser Funktion wird das Ende der Daten gekennzeichnet und der Datenversand abgeschlossen.
562 *
563 * Im Erfolgsfall wird die vom OTTER-Server vergebene Objekt-ID zurückgegeben, über die die
564 * versendeten Daten bei OTTER referenziert werden.
565 *
566 * @param[in] versand
567 * Ein mit OttoVersandBeginnen() erzeugtes Handle
568 *
569 * @param[out] objektId
570 * Handle des Rückgabepuffers, in den die Objekt-ID geschrieben werden soll.
571 *
572 * @return
573 * - ::OTTO_OK im Erfolgsfall
574 * - ::OTTO_TRANSFER_UNAUTHORIZED
575 * - ::OTTO_TRANSFER_CONNECTSERVER
576 * - ::OTTO_VERSAND_GERINGE_DATENMENGE
577 * - ::OTTO_VERSAND_ABGESCHLOSSEN falls OttoVersandAbschliessen() bereits aufgerufen wurde
578 * - weitere, siehe otto_statuscode.h
579 *
580 */
581 OttoStatusCode C_DECL OttoVersandAbschliessen(OttoVersandHandle versand,
582 OttoRueckgabepufferHandle objektId);
583
584/**
585 * @brief Gibt ein Versandobjekt frei.
586 *
587 * Das Versandobjekt darf danach nicht wieder verwendet werden.
588 *
589 * @param[in] versand
590 * Handle des Versandobjekts, das freigegeben werden soll.
591 * @return
592 * - siehe otto_statuscode.h
593 *
594 * @see
595 * - OttoVersandBeginnen()
596 * - OttoVersandFortsetzen()
597 * - OttoVersandAbschliessen()
598 */
599 OttoStatusCode C_DECL OttoVersandBeenden(OttoVersandHandle versand);
600
601/**
602 * @brief Initialisiert eine Datenabholung vom OTTER-Server.
603 *
604 * Das zurückgegebene Handle des Empfangsobjekts wird der Funktion
605 * OttoEmpfangFortsetzen() übergeben, um Daten blockweise abzuholen.
606 * Sind alle Daten abgeholt, wird OttoEmpfangBeenden() aufgerufen, womit
607 * das Empfangsobjekt wieder freigegeben wird.
608 *
609 * @note Wurde eine Otto-Instanz vor dem Aufruf dieser Funktion mit OttoProxyKonfigurationSetzen()
610 * für einen Proxy konfiguriert, wird der Empfang über den Proxy durchgeführt.
611 * Die Proxy-Konfiguration wird intern an dem Empfangsobjekt gespeichert und spätere Aufrufe
612 * von OttoProxyKonfigurationSetzen() haben keinen Einfluss auf den bereits begonnenen Empfang.
613 *
614 * @param[in] instanz
615 * Handle der Otto-Instanz, auf der diese Funktion ausgeführt werden soll.
616 *
617 * @param[in] objektId
618 * ID des Objekts, das vom OTTER-Server abgeholt werden soll.
619 *
620 * @param[in] zertifikat
621 * Handle auf ein Zertifikatsobjekt
622 *
623 * @param[in] herstellerId
624 * Hersteller-ID des Softwareproduktes
625 *
626 * @param[out] empfang
627 * Handle auf das Empfangsobjekt. Im Fehlerfall wird kein Empfangobjekt erzeugt.
628 *
629 * @return
630 * - siehe otto_statuscode.h
631 *
632 * @see
633 * - OttoEmpfangFortsetzen()
634 * - OttoEmpfangBeenden()
635 * - OttoProxyKonfigurationSetzen()
636 *
637 */
638 OttoStatusCode C_DECL OttoEmpfangBeginnen(OttoInstanzHandle instanz,
639 const byteChar *objektId,
640 OttoZertifikatHandle zertifikat,
641 const byteChar *herstellerId,
642 OttoEmpfangHandle *empfang);
643
644/**
645 * @brief Initialisiert eine Datenabholung vom OTTER-Server mit Angabe eines Abholzertifikats
646 *
647 * Die Angabe eines Abholzertifikats ist erforderlich, wenn eine
648 * nicht bei ELSTER registrierte Signaturkarte zur Authentifizierung verwendet wird.
649 *
650 * Die Funktion darf nicht verwendet werden, wenn zur Authentifizierung ein clientseitig
651 * erzeugtes Zertifikat (CEZ) verwendet wird. (Parameter @c zertifikat)
652 *
653 * Das zurückgegebene Handle des Empfangsobjekts wird der Funktion
654 * OttoEmpfangFortsetzen() übergeben, um Daten blockweise abzuholen.
655 * Sind alle Daten abgeholt, wird OttoEmpfangBeenden() aufgerufen, womit
656 * das Empfangsobjekt wieder freigegeben wird.
657 *
658 * Ein wichtiger Unterschied zu OttoEmpfangBeginnen() besteht darin, dass der OTTER-Server die Daten auf
659 * den in @p abholzertifikat enthaltenen öffentlichen Schlüssel umschlüsselt. Die Daten werden vom Otto
660 * nicht entschlüsselt und OttoEmpfangFortsetzen() gibt lediglich die verschlüsselten Daten zurück.
661 *
662 * @note Wurde eine Otto-Instanz vor dem Aufruf dieser Funktion mit OttoProxyKonfigurationSetzen()
663 * für einen Proxy konfiguriert, wird der Empfang über den Proxy durchgeführt.
664 * Die Proxy-Konfiguration wird intern an dem Empfangsobjekt gespeichert und spätere Aufrufe
665 * von OttoProxyKonfigurationSetzen() haben keinen Einfluss auf den bereits begonnenen Empfang.
666 *
667 * @param[in] instanz
668 * Handle der Otto-Instanz, auf der diese Funktion ausgeführt werden soll.
669 *
670 * @param[in] objektId
671 * ID des Objekts, das vom OTTER-Server abgeholt werden soll.
672 *
673 * @param[in] zertifikat
674 * Handle auf ein Zertifikatsobjekt
675 * Es darf hier kein clientseitig erzeugtes Zertifikat (CEZ) angegeben werden.
676 *
677 * @param[in] herstellerId
678 * Hersteller-ID des Softwareproduktes
679 *
680 * @param[in] abholzertifikat
681 * Base64-kodierter Teil eines X.509-v3-Zertifikats im PEM-Format
682 *
683 * @param[out] empfang
684 * Handle auf das Empfangsobjekt. Im Fehlerfall wird kein Empfangobjekt erzeugt.
685 *
686 * @return
687 * - siehe otto_statuscode.h
688 *
689 * @see
690 * - OttoEmpfangFortsetzen()
691 * - OttoEmpfangBeenden()
692 * - OttoProxyKonfigurationSetzen()
693 *
694 */
695 OttoStatusCode C_DECL OttoEmpfangBeginnenAbholzertifikat(OttoInstanzHandle instanz,
696 const byteChar *objektId,
697 OttoZertifikatHandle zertifikat,
698 const byteChar *herstellerId,
699 const byteChar *abholzertifikat,
700 OttoEmpfangHandle *empfang);
701
702/**
703 * @brief Empfängt einen Datenblock vom OTTER-Server
704 *
705 * Otto empfängt Daten vom OTTER-Server und gibt sie blockweise an den Aufrufer zurück.
706 * Wird \c OTTO_OK zurückgegeben, kann diese Funktion erneut aufgerufen werden und weitere
707 * Datenblöcke empfangen werden. Werden leere Daten zurückgegeben, ist der Empfang beendet
708 * und alle Daten wurden empfangen. Dann muss OttoEmpfangBeenden() aufgerufen werden.
709 *
710 * @param[in] empfang
711 * Ein mit OttoEmpfangBeginnen() erzeugtes Handle.
712 *
713 * @param[out] datenBlock
714 * @parblock
715 * Rückgabepuffer mit allen oder einem Teil der empfangenen Daten. Falls leer, ist der Empfang beendet.
716 *
717 * Der Inhalt des Rückgabepuffers darf nicht als null-terminierte Zeichenkette interpretiert werden, da die
718 * empfangenen Daten weitere Null-Bytes enthalten können.
719 * @endparblock
720 *
721 * @return
722 * - ::OTTO_OK
723 * - ::OTTO_TRANSFER_UNAUTHORIZED
724 * - ::OTTO_TRANSFER_NOT_FOUND
725 * - weitere, siehe otto_statuscode.h
726 *
727 * @see
728 * - OttoEmpfangBeenden()
729 */
730 OttoStatusCode C_DECL OttoEmpfangFortsetzen(OttoEmpfangHandle empfang,
731 OttoRueckgabepufferHandle datenBlock);
732
733/**
734 * @brief Gibt das Empfangsobjekt wieder frei.
735 *
736 * Das Empfangsobjekt darf nach diesem Aufruf nicht mehr verwendet werden.
737 * Wird diese Funktion aufgerufen, bevor OttoEmpfangFortsetzen() einen leeren Rückgabepuffer
738 * zurückgegeben hat, können die bis dahin empfangenen Daten unvollständig sein.
739 *
740 * @param[in] empfang
741 * Ein mit OttoEmpfangBeginnen() erzeugtes Handle
742 *
743 * @return
744 * - ::OTTO_OK
745 * - ::OTTO_EMPFANG_VORZEITIG_BEENDET falls noch nicht alle Daten mit OttoEmpfangFortsetzen() empfangen wurden
746 * - weitere, siehe otto_statuscode.h
747 */
748 OttoStatusCode C_DECL OttoEmpfangBeenden(OttoEmpfangHandle empfang);
749
750/**
751 * @brief Holt das Datenobjekt zu einer Objekt-ID von OTTER mit einem einzigen Funktionsaufruf vollständig ab
752 *
753 * Diese Funktion ist eine bequemere Alternative zu der blockweisen Datenabholung über die
754 * OttoEmpfang-Funktionen. Intern bündelt sie die Aufrufe der OttoEmpfangs-Funktionen,
755 * wie sie sonst von der Anwendung selbst durchgeführt werden müßten.
756 *
757 * Der Nachteil dieser Funktion gegenüber den OttoEmpfang-Funktionen besteht darin, dass
758 * die abgeholten Daten alle im Hauptspeicher von Otto gehalten werden. Sie eignet sich daher nicht
759 * für die Abholung sehr großer Datenobjekte oder wenn nur sehr wenig Hauptspeicher zur Verfügung steht.
760 *
761 * @note Wurde eine Otto-Instanz vor dem Aufruf dieser Funktion mit OttoProxyKonfigurationSetzen()
762 * für einen Proxy konfiguriert, wird die Abholung über den Proxy durchgeführt.
763 *
764 * @param[in] instanz
765 * Handle der Otto-Instanz, auf der diese Funktion ausgeführt werden soll.
766 *
767 * @param[in] objektId
768 * ID des Datenobjekts, das vom OTTER-Server abgeholt werden soll.
769 *
770 * @param[in] objektGroesse
771 * @parblock
772 * Die erwartete Größe des Datenobjekts, das vom OTTER-Server abgeholt werden soll, in Bytes.
773 * Diesen Wert findet die Anwendung zusammen mit der Objekt-ID im Rückgabe-XML zu einer
774 * PostfachAnfrage.
775 *
776 * Wenn die Größe zu gering angegeben wird, geht dies zwar zu Lasten der Geschwindigkeit und
777 * des Hauptspeicherbedarfs, weil dann der Rückgabepuffer von Otto intern sukzessive vergrößert
778 * werden muß, aber es führt nicht zu einem Fehler.
779 * @endparblock
780 * @param[in] zertifikatsPfad
781 * @parblock
782 * Pfad zum Sicherheitstoken, folgende Angaben sind möglich: @mAbsatz
783 * 1. Clientseitig erzeugtes Zertifikat: @mLB<a>Pfad
784 * zum Verzeichnis, in dem sich die Zertifikats-Datei (.cer)
785 * und die Datei mit dem privaten Schlüssel (.p12) befinden.
786 * Diese Sicherheitstokens wurden mit EricMtCreateKey() bzw. EricCreateKey() erzeugt.
787 * Der Pfad zum Verzeichnis ist bei clientseitig erzeugten
788 * Zertifikaten relativ zum aktuellen Arbeitsverzeichnis oder absolut
789 * anzugeben.
790 * 2. Software-Portalzertifikat: @mLB<a>Pfad
791 * zur Software-Zertifikatsdatei (i.d.R. mit der Endung .pfx).
792 * Der Pfad zur Datei ist bei Software-Zertifikaten relativ zum
793 * aktuellen Arbeitsverzeichnis oder absolut anzugeben.
794 * 3. Sicherheitsstick: @mLB<a>Pfad
795 * zur Treiberdatei, siehe (*). Bitte beachten, dass der Treiber
796 * betriebssystemabhängig sein kann. Weitere Informationen in der
797 * Anleitung zum Sicherheitsstick oder unter
798 * \linkExt{https://www.sicherheitsstick.de,https://www.sicherheitsstick.de}.
799 * 4. Signaturkarte: (*) @mLB<a>Pfad
800 * zur Treiberdatei, welcher einen Zugriff auf die
801 * Signaturkarte ermöglicht. Weitere Informationen in
802 * der Anleitung zur Signaturkarte.
803 * 5. Elektronischer Personalausweis (nPA) oder Aufenthaltstitel (eAT): @mLB<a>Die
804 * URL des eID-Clients wie zum Beispiel der AusweisApp 2.
805 * In den meisten Fällen lautet diese URL: http://127.0.0.1:24727/eID-Client.
806 * Optional kann auf die folgende Weise noch ein Testmerker angehängt werden:
807 * http://127.0.0.1:24727/eID-Client?testmerker=520000000. @mLB<a>Zu
808 * den verfügbaren Testmerkern siehe @typeDokumentation{ERiC-Entwicklerhandbuch.pdf},
809 * Kap. "Testunterstützung bei der ERiC-Anbindung".
810 *
811 * <B>Wichtig:</B>
812 * Das Ad-hoc-Zertifikat, das in diesem Fall für den elektronischen
813 * Personalausweis erzeugt wird, ist nur 24 Stunden gültig.
814 * @endparblock
815 * (*) Wird der Dateipfad eines Treibers angegeben, ist der Suchmechanismus zu
816 * beachten, mit dem das jeweilige Betriebssystem dynamische Bibliotheken lädt.
817 * Weitere Informationen sind der Systemdokumentation zu den Betriebssystemfunktionen
818 * <tt>LoadLibrary()</tt> (Windows) bzw. <tt>dlopen()</tt> (Linux, AIX und macOS) zu entnehmen.
819 *
820 * Pfade müssen auf Windows in der für Datei-Funktionen benutzten ANSI-Codepage,
821 * auf Linux, AIX und Linux Power in der für das Dateisystem benutzten Locale
822 * und auf macOS in der "decomposed form" von UTF-8 übergeben werden.
823 * Bitte weitere Betriebssystemspezifika bzgl. nicht erlaubter Zeichen in
824 * Pfaden und Pfadtrennzeichen beachten.
825 *
826 * Für Details zu Pfaden im ERiC siehe @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kapitel
827 * "Übergabe von Pfaden an ERiC API-Funktionen".
828 *
829 * @param[in] zertifikatsPasswort
830 * Das Passwort oder die PIN des Sicherheitstokens.
831 * Bei Tokens, bei denen das Passwort oder die PIN nicht von der Anwendung
832 * übergeben, sondern separat über einen Treiber (z. B. von einem Kartenlesegerät)
833 * abgefragt wird, ist hier NULL zu übergeben.
834 *
835 * @param[in] herstellerId
836 * Hersteller-ID des Softwareproduktes
837 * @param[in] abholzertifikat
838 * @parblock
839 * Base64-kodierter Teil eines X.509-v3-Zertifikats im PEM-Format.
840 * Die Angabe eines Abholzertifikats ist optional und nur erlaubt,
841 * wenn im Parameter zertifikatsPfad kein clientseitig erzeugtes Zertifikat (CEZ)
842 * angegeben wurde.
843 *
844 * Wird ein Abholzertifikat übergeben, so werden die Abholdaten
845 * vom Server auf den öffentlichen Schlüssel des Zertifikats umgeschlüsselt.
846 * Diese Daten werden vom Otto nicht entschlüsselt und OttoDatenAbholen() gibt
847 * lediglich die verschlüsselten Daten zurück.
848 *
849 * Wenn eine nicht bei ELSTER registrierte Signaturkarte zur Authentifizierung
850 * verwendet wird, muss dieser Parameter gesetzt werden,
851 * ansonsten kann hier NULL übergeben werden.
852 * @endparblock
853 * @param[out] abholDaten
854 * Rückgabepuffer mit den abgeholten Daten.
855 * Der Inhalt des Rückgabepuffers darf nicht als null-terminierte Zeichenkette interpretiert werden,
856 * da die abgeholten Daten weitere Null-Bytes enthalten können.
857 *
858 * @return
859 * - ::OTTO_OK
860 * - ::OTTO_TRANSFER_UNAUTHORIZED
861 * - ::OTTO_TRANSFER_NOT_FOUND
862 * - weitere, siehe otto_statuscode.h
863 */
864 OttoStatusCode C_DECL OttoDatenAbholen(OttoInstanzHandle instanz,
865 const byteChar *objektId,
866 uint32_t objektGroesse,
867 const byteChar *zertifikatsPfad,
868 const byteChar *zertifikatsPasswort,
869 const byteChar *herstellerId,
870 const byteChar *abholzertifikat,
871 OttoRueckgabepufferHandle abholDaten);
872
873/**
874 * @brief Die Funktion liefert die Klartextfehlermeldung zu einem Otto-Statuscode - definiert in otto_statuscode.h
875 *
876 * @param[in] statuscode Statuscode
877 *
878 * @return
879 * - Zeiger auf einen statischen Puffer mit der Klartextmeldung zu einem Statuscode
880 * als null-terminierte, UTF-8-kodierte Zeichenkette.
881 * - @c NULL, falls kein Text ermittelt werden konnte.
882 */
883 const char* C_DECL OttoHoleFehlertext(OttoStatusCode statuscode);
884
885/**
886 * @brief Konfiguriert eine Otto-Instanz für einen Proxy.
887 *
888 * Damit eine Otto-Instanz ihre Internetverbindungen über einen
889 * Proxy aufbaut, muss ihr die Proxy-Konfiguration über diese Methode
890 * mitgeteilt werden.
891 * Die Konfiguration gilt dann für alle Verbindungen der Instanz nach
892 * außen, d.h. für die Verbindungen zu den OTTER-Servern ebenso wie
893 * für Verbindungen zum ELSTER-eID-Server bei der Verwendung eines
894 * elektronischen Personalausweises oder Aufenthaltstitels.
895 *
896 * @param[in] instanz
897 * Die Otto-Instanz, für die die Konfiguration gelten soll.
898 *
899 * @param[in] proxyKonfiguration
900 * Die Proxy-Konfiguration, die von der Otto-Instanz verwendet werden soll.
901 * Wenn hier @c NULL übergeben wird, verwendet die Otto-Instanz keinen Proxy.
902 *
903 * @return
904 * - siehe otto_statuscode.h
905 *
906 * @see
907 * - OttoProxyKonfiguration
908 */
909 OttoStatusCode C_DECL OttoProxyKonfigurationSetzen(OttoInstanzHandle instanz,
910 const OttoProxyKonfiguration* proxyKonfiguration);
911
912/**
913 * @brief Setzt den Wert einer Otto-Einstellung für die angegebene Instanz.
914 *
915 *
916 * Die Einstellungen gelten immer nur für die übergebene Otto-Instanz.
917 *
918 * Die Änderungen von Werten ist nicht immer unmittelbar wirksam.
919 *
920 *
921 * @param[in] instanz
922 * Die Otto-Instanz, für die eine Einstellung gesetzt werden soll.
923 *
924 * @param[in] einstellungName
925 * Name der Einstellung, deren Wert gesetzt werden soll.
926 *
927 * @param[in] einstellungWert
928 * Wert, auf den die Einstellung gesetzt werden soll.
929 *
930 * @return
931 * - ::OTTO_OK
932 * - ::OTTO_EINSTELLUNG_UNBEKANNT
933 * - ::OTTO_EINSTELLUNG_WERT_UNGUELTIG
934 * - weitere, siehe otto_statuscode.h
935 *
936 * @see
937 * - OttoEinstellungLesen()
938 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Bedeutung der Otto-Einstellungen"
939 *
940 */
941 OttoStatusCode C_DECL OttoEinstellungSetzen(OttoInstanzHandle instanz,
942 const char *einstellungName, const char *einstellungWert);
943
944/**
945 * @brief Liest den aktuellen Wert einer Otto-Einstellung in der angegebenen Instanz aus.
946 *
947 *
948 * @param[in] instanz
949 * Die Otto-Instanz, deren Einstellung ausgelesen werden soll.
950 *
951 * @param[in] einstellungName
952 * Name der Einstellung, deren Wert ausgelesen werden soll.
953 *
954 * @param[out] einstellungWert
955 * Der ausgelesene Wert der Einstellung
956 *
957 * @return
958 * - ::OTTO_OK
959 * - ::OTTO_EINSTELLUNG_UNBEKANNT
960 * - weitere, siehe otto_statuscode.h
961 *
962 * @see
963 * - OttoEinstellungSetzen()
964 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Bedeutung der Otto-Einstellungen"
965 */
966 OttoStatusCode C_DECL OttoEinstellungLesen(OttoInstanzHandle instanz,
967 const char *einstellungName,
968 OttoRueckgabepufferHandle einstellungWert);
969
970/**
971 * @brief Gibt die Version der Otto-Bibliothek zurück.
972 *
973 * @note Die Version der Otto-Bibliothek ist nicht zwingend gleich der Version
974 * des ERiC-Auslieferungspaketes, sondern kann davon abweichen.
975 *
976 * @return
977 * - siehe otto_statuscode.h
978 */
979 OttoStatusCode C_DECL OttoVersion(OttoRueckgabepufferHandle rueckgabepuffer);
980
981#ifdef __cplusplus
982} // extern "C"
983#endif
984
985
986#endif /* OTTO_H_ */
byteChar
char byteChar
Der Datentyp byteChar wird immer dann verwendet, wenn an diesem Parameter keine UTF-8 codierte Daten ...
Definition eric_types.h:53
OttoEmpfangBeenden
OttoStatusCode OttoEmpfangBeenden(OttoEmpfangHandle empfang)
Gibt das Empfangsobjekt wieder frei.
OttoEinstellungLesen
OttoStatusCode OttoEinstellungLesen(OttoInstanzHandle instanz, const char *einstellungName, OttoRueckgabepufferHandle einstellungWert)
Liest den aktuellen Wert einer Otto-Einstellung in der angegebenen Instanz aus.
OttoProxyKonfigurationSetzen
OttoStatusCode OttoProxyKonfigurationSetzen(OttoInstanzHandle instanz, const OttoProxyKonfiguration *proxyKonfiguration)
Konfiguriert eine Otto-Instanz für einen Proxy.
OttoPruefsummeErzeugen
OttoStatusCode OttoPruefsummeErzeugen(OttoInstanzHandle instanz, OttoPruefsummeHandle *pruefsumme)
Erzeugt ein Objekt zur Berechnung einer Datenprüfsumme, die Otto zu Beginn einer Übermittlung an den ...
OttoVersandBeenden
OttoStatusCode OttoVersandBeenden(OttoVersandHandle versand)
Gibt ein Versandobjekt frei.
OttoZertifikatOeffnen
OttoStatusCode OttoZertifikatOeffnen(OttoInstanzHandle instanz, const byteChar *zertifikatsPfad, const byteChar *zertifikatsPasswort, OttoZertifikatHandle *zertifikat)
Erstellt ein Otto-Zertifikatsobjekt für ein Sicherheitstoken.
OttoRueckgabepufferFreigeben
OttoStatusCode OttoRueckgabepufferFreigeben(OttoRueckgabepufferHandle rueckgabepuffer)
Gibt einen Rückgabepuffer frei.
OttoInstanzErzeugen
OttoStatusCode OttoInstanzErzeugen(const byteChar *logPfad, OttoLogCallback logCallback, void *logCallbackBenutzerdaten, OttoInstanzHandle *instanz)
Erstellt und initialisiert eine neue Otto-Instanz.
OttoRueckgabepufferInhalt
const byteChar * OttoRueckgabepufferInhalt(OttoRueckgabepufferHandle rueckgabepuffer)
Gibt den Inhalt eines Rückgabepuffers zurück.
OttoZertifikatSchliessen
OttoStatusCode OttoZertifikatSchliessen(OttoZertifikatHandle zertifikat)
Schließt das Otto-Zertifikatsobjekt zu einem Sicherheitstoken. Anschließend darf das Zertifikatsobjek...
OttoDatenAbholen
OttoStatusCode OttoDatenAbholen(OttoInstanzHandle instanz, const byteChar *objektId, uint32_t objektGroesse, const byteChar *zertifikatsPfad, const byteChar *zertifikatsPasswort, const byteChar *herstellerId, const byteChar *abholzertifikat, OttoRueckgabepufferHandle abholDaten)
Holt das Datenobjekt zu einer Objekt-ID von OTTER mit einem einzigen Funktionsaufruf vollständig ab.
OttoVersandBeginnen
OttoStatusCode OttoVersandBeginnen(OttoInstanzHandle instanz, const byteChar *signiertePruefsumme, const byteChar *herstellerId, OttoVersandHandle *versand)
Initialisiert einen Datenversand an den OTTER-Server.
OttoRueckgabepufferErzeugen
OttoStatusCode OttoRueckgabepufferErzeugen(OttoInstanzHandle instanz, OttoRueckgabepufferHandle *rueckgabepuffer)
Erzeugt einen Rückgabepuffer und gibt ein Handle darauf zurück.
OttoEmpfangBeginnenAbholzertifikat
OttoStatusCode OttoEmpfangBeginnenAbholzertifikat(OttoInstanzHandle instanz, const byteChar *objektId, OttoZertifikatHandle zertifikat, const byteChar *herstellerId, const byteChar *abholzertifikat, OttoEmpfangHandle *empfang)
Initialisiert eine Datenabholung vom OTTER-Server mit Angabe eines Abholzertifikats.
OttoEinstellungSetzen
OttoStatusCode OttoEinstellungSetzen(OttoInstanzHandle instanz, const char *einstellungName, const char *einstellungWert)
Setzt den Wert einer Otto-Einstellung für die angegebene Instanz.
OttoInstanzFreigeben
OttoStatusCode OttoInstanzFreigeben(OttoInstanzHandle instanz)
Gibt eine Otto-Instanz frei.
OttoEmpfangFortsetzen
OttoStatusCode OttoEmpfangFortsetzen(OttoEmpfangHandle empfang, OttoRueckgabepufferHandle datenBlock)
Empfängt einen Datenblock vom OTTER-Server.
OttoPruefsummeSignieren
OttoStatusCode OttoPruefsummeSignieren(OttoPruefsummeHandle pruefsumme, OttoZertifikatHandle zertifikat, OttoRueckgabepufferHandle rueckgabepuffer)
Erstellt eine Signatur über eine Prüfsumme.
OttoEmpfangBeginnen
OttoStatusCode OttoEmpfangBeginnen(OttoInstanzHandle instanz, const byteChar *objektId, OttoZertifikatHandle zertifikat, const byteChar *herstellerId, OttoEmpfangHandle *empfang)
Initialisiert eine Datenabholung vom OTTER-Server.
OttoPruefsummeFreigeben
OttoStatusCode OttoPruefsummeFreigeben(OttoPruefsummeHandle pruefsumme)
Gibt ein Prüfsummenobjekt frei.
OttoZertifikatOeffnenAusBytes
OttoStatusCode OttoZertifikatOeffnenAusBytes(OttoInstanzHandle instanz, const byteChar *pkcs12Container, uint32_t containerGroesse, const byteChar *zertifikatsPasswort, OttoZertifikatHandle *zertifikat)
Erstellt ein Otto-Zertifikatsobjekt für ein PKCS#12-Sicherheitstoken, das im Hauptspeicher übergeben ...
OttoVersandAbschliessen
OttoStatusCode OttoVersandAbschliessen(OttoVersandHandle versand, OttoRueckgabepufferHandle objektId)
Schließt einen Versand ab und gibt die Objekt-ID zurück.
OttoRueckgabepufferGroesse
uint64_t OttoRueckgabepufferGroesse(OttoRueckgabepufferHandle rueckgabepuffer)
Gibt die Anzahl der im Rückgabepuffer enthaltenen Bytes zurück. Das abschließende Null-Byte wird nich...
OttoVersandFortsetzen
OttoStatusCode OttoVersandFortsetzen(OttoVersandHandle versand, const byteChar *datenBlock, uint64_t datenBlockGroesse)
Versendet einen Datenblock an den OTTER-Server.
OttoPruefsummeAktualisieren
OttoStatusCode OttoPruefsummeAktualisieren(OttoPruefsummeHandle pruefsumme, const byteChar *datenBlock, uint64_t datenBlockGroesse)
Aktualisiert die Prüfsumme über Daten. Eine Prüfsumme, die bereits signiert wurde,...
OttoHoleFehlertext
const char * OttoHoleFehlertext(OttoStatusCode statuscode)
Die Funktion liefert die Klartextfehlermeldung zu einem Otto-Statuscode - definiert in otto_statuscod...
OttoVersion
OttoStatusCode OttoVersion(OttoRueckgabepufferHandle rueckgabepuffer)
Gibt die Version der Otto-Bibliothek zurück.
otto_statuscode.h
Auflistung der Otto-Statuscodes.
OttoStatusCode
OttoStatusCode
Definition otto_statuscode.h:8
otto_types.h
Definition von Datenstrukturen und Datentypen.
OttoPruefsummeHandle
struct OttoPruefsumme * OttoPruefsummeHandle
Handle auf eine Otto-Prüfsumme.
Definition otto_types.h:66
OttoLogCallback
int(* OttoLogCallback)(const char *instanzId, const char *logZeitpunkt, OttoLogEbene logEbene, const char *logNachricht, void *benutzerdaten)
Funktionstyp für einen Log-Callback, den eine Anwendung beim Erzeugen einer Otto-Instanz angeben kann...
Definition otto_types.h:126
OttoInstanzHandle
struct OttoInstanz * OttoInstanzHandle
Handle auf eine Otto-Instanz.
Definition otto_types.h:28
OttoRueckgabepufferHandle
struct OttoRueckgabepuffer * OttoRueckgabepufferHandle
Handle auf einen Otto-Rückgabepuffer.
Definition otto_types.h:54
OttoEmpfangHandle
struct OttoEmpfang * OttoEmpfangHandle
Handle auf ein Otto-Empfangsobjekt.
Definition otto_types.h:82
OttoZertifikatHandle
struct OttoZertifikat * OttoZertifikatHandle
Handle auf ein Sicherheitstoken zur Authentifizierung des Daten-Übermittlers oder -Abholers.
Definition otto_types.h:34
OttoVersandHandle
struct OttoVersand * OttoVersandHandle
Handle auf ein Otto-Versandobjekt.
Definition otto_types.h:74
uint32_t
__plattformabhaengige_Implementierung__ uint32_t
Definition platform.h:211
OttoProxyKonfiguration
Diese Struktur enthält alle Informationen, die Otto benötigt, um die Verbindung zum OTTER-Server oder...
Definition otto_types.h:143