ERiC API-Referenz 43.3.2.0
Lade ...
Suche ...
Keine Treffer
ericapi.h
gehe zur Dokumentation dieser Datei
1/*
2 * Copyright © LfSt Bayern, Muenchen, IuK 111, 2006
3 */
4
5#ifndef ERICAPI_C_H_
6#define ERICAPI_C_H_
7
8#include "platform.h"
9
10#include "ericapiExport.h"
11#include "eric_types.h"
12#include "ericdef.h"
13
14/**
15 * @file
16 * @brief Deklaration der ERiC API-Funktionen für die Singlethreading-API
17 *
18 */
19
20#ifdef __cplusplus
21extern "C"
22{
23#endif
24
25/**
26\mainpage Start
27
28Diese API-Referenz enthält detaillierte Informationen der ERiC API-Funktionen, Typdefinitionen, Aufzählungen, Datenstrukturen und Headerdateien. Die Funktionsdeklarationen für die ERiC Multithreading-API werden in ericmtapi.h, die Deklarationen der Singlethreading-API in ericapi.h bereitgestellt.
29
30In erictoolkit.h werden Prüffunktionen bereitgestellt, deren Funktionalität identisch zu denen in ericapi.h und ericmtapi.h ist. Die erictoolkit.h hat keine Abhängigkeiten zu anderen ERiC-Bibliotheken und kann somit unabhängig von diesen eingesetzt werden.
31
32<H3> Suchfunktion </H3>
33Die ERiC API-Referenz im HTML-Format enthält ein Suchfeld mit integrierter Filterfunktion. Damit können Sie eine gezielte Suche nach Symbolen durchführen.
34@mLB<a>Voraussetzung: In Ihrem Browser ist JavaScript aktiviert.
35
36Für eine Volltextsuche nutzen Sie bitte die PDF-Ausgabe der ERiC API-Referenz. @seeAPI-Referenz{ERiC-API-Referenz.pdf}
37
38<H3> Dokumentation </H3>
39Das Dokumentationspaket beinhaltet: @mAbsatz
40+ Das @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}. Hier finden Sie sowohl allgemeine Zusatzinformationen als auch spezielle Hinweise zum Gebrauch der Bibliotheken, Datensätze, Datensatzformate und Werte.
41+ Das @typeTutorial{ERiC-Tutorial.pdf}. Es illustriert detailliert die Softwareentwicklung mit ERiC an den mitgelieferten Beispielen ericdemo und ottodemo.
42+ Die @typeDokumentation{ERiC-Releasenotes.pdf}. Sie enthalten die Änderungen der aktuell unterstützten ERiC Releases.
43+ Die @lsDokumentation{Datenartversionmatrix.xml}. Sie enthält eine Übersicht der datenartVersionen, die ERiC unterstützt. Einige API-Funktionen verwenden die <I>datenartVersion</I> als Parameter, weitere Informationen siehe @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "datenartVersion – Definition und Verwendung."
44+ Diese API-Referenz sowie die Dokumentation aller Feldkennungen, @lsPlausipruefungen{Plausibilitätsprüfungen}, Schemata und @lsSchnittstellenbeschreibungen{Schnittstellenbeschreibungen}.
45
46<H3> Encoding und Zeichensatz </H3>
47Alle Daten, die an die ELSTER Annahmeserver übermittelt werden, sind in UTF-8 zu kodieren. Hierbei dürfen die zu übermittelnden Daten keine BOM (=Byte Order Mark) enthalten.
48
49Der Datentyp <B>char</B> zeigt an, wo UTF-8 kodierte Zeichenketten zu verwenden sind. Der Datentyp ::byteChar zeigt an, wo ASCII zu verwenden ist bzw. bei Pfadangaben das betriebssystemspezifische Encoding, siehe @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Übergabe von Pfaden an ERiC API-Funktionen."
50
51Die erlaubte Zeichenmenge lässt sich dem Datentyp <I>BaseStringSType</I> aus dem ElsterBasisSchema @lsElsterBasisSchema{headerbasis_datentypen.xsd} der Schnittstellenbeschreibung entnehmen.
52
53Bei der Eingabe von PINs sind nur Zeichen aus dem ASCII Zeichensatz, ohne Sonder- und Steuerzeichen, erlaubt, siehe @linkExt{https://de.wikipedia.org/wiki/ASCII,https://de.wikipedia.org/wiki/ASCII}.
54
55**/
56
57 /**
58 * @brief Diese API-Funktion ist die zentrale Schnittstellenfunktion zur Kommunikation
59 * mit dem ELSTER-Annahmeserver.
60 *
61 * Als Austauschformat wird XML verwendet, siehe Kap. "Datenverarbeitung mit ERiC"
62 * im @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}. Dort sind die Arbeitsabläufe von Einzel- und Sammellieferung
63 * beschrieben.
64 *
65 * Die Funktion kann Steuerdaten plausibilisieren, an den ELSTER-Annahmeserver übertragen und
66 * ausdrucken, sowie Protokolle der Übertragung erzeugen. Die ProcessingFlags im Parameter
67 * @c bearbeitungsFlags definieren, welche der Schritte wie ausgeführt werden.
68 *
69 * Je nach Anwendungsfall können die Daten authentifiziert übertragen werden und es kann
70 * ein PDF-Druck der Daten erfolgen. In diesen Fällen sind die Parameter @c cryptoParameter
71 * und @c druckParameter entsprechend zu befüllen. Die möglichen Parameterkombinationen und
72 * Druckkennzeichnungen können im @typeDokumentation{ERiC-Entwicklerhandbuch.pdf} nachgelesen werden.
73 *
74 * Sind für einen Anwendungsfall mehrere voneinander abhängige Aufrufe von
75 * ::EricBearbeiteVorgang() nötig, so ist der Parameter @c transferHandle zu übergeben. Dies
76 * ist derzeit nur für die Datenabholung der Fall.
77 *
78 * Es werden an bestimmten Punkten der Verarbeitung benutzerdefinierte Callback Funktionen
79 * aufgerufen. Siehe hierzu \ref STSection_Fortschrittcallbacks.
80 *
81 * Zur Erzeugung, Verwendung und Freigabe von Rückgabepuffern siehe Dokumentation
82 * zu ::EricRueckgabepufferHandle.
83 *
84 * @param[in] datenpuffer
85 * Enthält die zu verarbeitenden XML-Daten.
86 * @param[in] datenartVersion
87 * @parblock
88 * Die @c datenartVersion ist der @lsDokumentation{Datenartversionmatrix.xml} zu entnehmen.
89 *
90 * Dieser Parameter darf nicht NULL sein und muss zu den XML-Eingangsdaten passen.
91 *
92 * Siehe auch @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}.
93 * @endparblock
94 * @param[in] bearbeitungsFlags
95 * @parblock
96 * Oder-Verknüpfung von Bearbeitungsvorgaben.
97 * Anhand dieser Vorgaben werden die übergebenen Daten verarbeitet.
98 * Der Parameter darf nicht 0 sein, zu gültigen Werten siehe ::eric_bearbeitung_flag_t.
99 *
100 * Bei welchen Anwendungsfällen welche Flags möglich oder notwendig sind,
101 * ist im @typeDokumentation{ERiC-Entwicklerhandbuch.pdf} nachzulesen.
102 * @endparblock
103 * @param[in] druckParameter
104 * @parblock
105 * Parameter, der für den PDF-Druck benötigt wird, siehe
106 * ::eric_druck_parameter_t.
107 *
108 * Bei welchen Anwendungsfällen der Druckparameter möglich oder notwendig ist,
109 * ist im @typeDokumentation{ERiC-Entwicklerhandbuch.pdf} nachzulesen.
110 *
111 * Soll kein PDF-Druck erfolgen, so ist NULL zu übergeben.
112 * @endparblock
113 * @param[in] cryptoParameter
114 * @parblock
115 * Enthält die für den authentifizierten Versand benötigten
116 * Informationen und darf nur dann übergeben werden,
117 * siehe ::eric_verschluesselungs_parameter_t.
118 *
119 * Erfolgt kein authentifizierter Versand, so ist NULL zu übergeben.
120 * @endparblock
121 * @param[in,out] transferHandle
122 * @parblock
123 * Bei der Datenabholung ist ein Zeiger auf ein vom Aufrufer verwaltetes
124 * und anfangs mit 0 befülltes ::EricTransferHandle zu übergeben, über das die
125 * zusammenhängenden Versandvorgänge einer Datenabholung gebündelt werden
126 * (Bündelung der Versandvorgänge "Anforderung", "Abholung" und optional
127 * "Quittierung").
128 *
129 * Wenn bei der Datenabholung kein Versandflag gesetzt ist (nur Validierung),
130 * darf dem transferHandle auch ein Nullzeiger (NULL) übergeben werden.
131 *
132 * Bei allen anderen Anwendungsfällen ist immer NULL zu übergeben.
133 * @endparblock
134 * @param[out] rueckgabeXmlPuffer
135 * @parblock
136 * Handle auf einen Rückgabepuffer, in den beim Versand
137 * Telenummer und Ordnungsbegriff, Hinweise oder Fehler bei der
138 * Regelprüfung geschrieben werden.
139 *
140 * Siehe
141 * \ref STSection_Rueckgabepuffer und ::EricRueckgabepufferHandle.
142 * @endparblock
143 * @param[out] serverantwortXmlPuffer
144 * @parblock
145 * Handle auf einen Rückgabepuffer, in den beim Versand die
146 * Antwort des Empfangsservers geschrieben wird.
147 *
148 * Siehe
149 * \ref STSection_Rueckgabepuffer und ::EricRueckgabepufferHandle.
150 * @endparblock
151 *
152 * @return
153 * - ::ERIC_OK
154 * - ::ERIC_GLOBAL_UNGUELTIGER_PARAMETER
155 * - ::ERIC_GLOBAL_NULL_PARAMETER
156 * - ::ERIC_GLOBAL_DATENARTVERSION_UNBEKANNT
157 * - ::ERIC_GLOBAL_VERSCHLUESSELUNGS_PARAMETER_NICHT_ANGEGEBEN
158 * - ::ERIC_GLOBAL_PRUEF_FEHLER
159 * Plausibilitätsfehler in den Eingabedaten, die Fehlermeldungen
160 * werden im Rückgabepuffer @c rueckgabeXmlPuffer zurückgegeben.
161 * Siehe Abschnitt \ref STSection_Plausibilitaetsfehler.
162 * - ::ERIC_GLOBAL_HINWEISE
163 * Kann nur zurückgegeben werden, falls das Bearbeitungsflag
164 * ::ERIC_PRUEFE_HINWEISE angegeben wurde.
165 * Es wurden ausschließlich Hinweise zu den Eingabedaten gemeldet,
166 * die Hinweise werden im Rückgabepuffer @c rueckgabeXmlPuffer zurückgegeben.
167 * Siehe Abschnitt \ref STSection_Hinweise.
168 * - ::ERIC_GLOBAL_DATENSATZ_ZU_GROSS
169 * Die maximal zulässige Größe des XML-Eingangsdatensatzes oder des zu übermittelnden,
170 * komprimierten, verschlüsselten und base64-kodierten Datenteils,
171 * siehe @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Größenbegrenzung der
172 * Eingangsdaten", ist überschritten.
173 * - ::ERIC_TRANSFER_ERR_XML_THEADER, ::ERIC_TRANSFER_ERR_XML_NHEADER
174 * Die Serverantwort enthält Fehlermeldungen. Zur Auswertung kann
175 * entweder die Serverantwort selbst ausgewertet werden oder es wird
176 * ::EricGetErrormessagesFromXMLAnswer() aufgerufen.
177 * - ::ERIC_IO_READER_SCHEMA_VALIDIERUNGSFEHLER
178 * - ::ERIC_IO_PARSE_FEHLER
179 * - ::ERIC_GLOBAL_COMMONDATA_NICHT_VERFUEGBAR
180 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
181 * - weitere, siehe eric_fehlercodes.h
182 *
183 * \section STSection_Rueckgabepuffer Inhalt des Rückgabepuffers und des Serverantwortpuffers
184 *
185 * Der Inhalt der Pufferspeicher kann mit ::EricRueckgabepufferInhalt() abgefragt
186 * und ausgewertet werden. @c rueckgabeXmlPuffer gibt im \ref STSection_Erfolgsfall oder bei
187 * \ref STSection_Plausibilitaetsfehler XML-Daten nach Schema
188 * @lsAPI-Rueckgabe-Schemata{Dokumentation\API-Rueckgabe-Schemata\EricBearbeiteVorgang.xsd} zurück.
189 * @c serverantwortXmlPuffer gibt bei Sendevorgängen die Antwort des ELSTER-
190 * Annahmeservers zurück.
191 *
192 * Nach dem Aufruf der Funktion müssen programmatisch folgende Fälle aufgrund des Rückgabewerts
193 * unterschieden werden.
194 *
195 * \subsection STSection_Erfolgsfall Erfolgsfall
196 *
197 * Sind alle Bearbeitungsschritte fehlerfrei durchlaufen worden, dann ist
198 * der Rückgabewert ::ERIC_OK und der Text im Pufferspeicher
199 * @c rueckgabeXmlPuffer enthält beim Versand XML-Daten mit generierter
200 * Telenummer und bei Neuaufnahmen den Ordnungsbegriff.
201 *
202 * \b Beispiel:
203 * \code{.xml}
204 * <?xml version="1.0" encoding="UTF-8"?>
205 * <EricBearbeiteVorgang xmlns="http://www.elster.de/EricXML/1.1/EricBearbeiteVorgang">
206 * <Erfolg>
207 * <Telenummer>N55</Telenummer>
208 * </Erfolg>
209 * </EricBearbeiteVorgang>
210 * \endcode
211 *
212 * Beim Versand befindet sich zusätzlich im Pufferspeicher @c serverantwortXmlPuffer die Antwort
213 * des ELSTER-Annahmeservers. Bei einer Datenabholung kann diese ausgewertet werden. Details
214 * hierzu befinden sich im @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}
215 *
216 * \subsection STSection_Hinweise Hinweise
217 *
218 * Falls das Bearbeitungsflag ::ERIC_PRUEFE_HINWEISE angegeben worden ist, kann der
219 * Rückgabewert ::ERIC_GLOBAL_HINWEISE zurückgegeben werden.
220 * Der Rückgabepuffer enthält dann die gemeldeten Hinweise.
221 *
222 * \b Beispiel:
223 * \code{.xml}
224 * <?xml version="1.0" encoding="UTF-8"?>
225 * <EricBearbeiteVorgang xmlns="http://www.elster.de/EricXML/1.1/EricBearbeiteVorgang">
226 * <Hinweis>
227 * <Nutzdatenticket>1075</Nutzdatenticket>
228 * <Feldidentifikator>100001</Feldidentifikator>
229 * <Mehrfachzeilenindex>1</Mehrfachzeilenindex>
230 * <LfdNrVordruck>1</LfdNrVordruck>
231 * <VordruckZeilennummer>4</VordruckZeilennummer>
232 * <SemantischerIndex>PersonA</SemantischerIndex>
233 * <Untersachbereich>5</Untersachbereich>
234 * <RegelName>testRegelName</RegelName>
235 * <FachlicheHinweisId>9995</FachlicheHinweisId>
236 * <Text>Weitere Angaben können erforderlich sein</Text>
237 * </Hinweis>
238 * </EricBearbeiteVorgang>
239 * \endcode
240 *
241 * Die einzelnen Elemente sind in der Schemadefinition
242 * @lsAPI-Rueckgabe-Schemata{Dokumentation\API-Rueckgabe-Schemata\EricBearbeiteVorgang.xsd} dokumentiert.
243 * Wenn die Bearbeitungsflags ::ERIC_PRUEFE_HINWEISE und ::ERIC_VALIDIERE übergeben
244 * worden sind, wurden bei der Plausibilisierung keine Fehler gefunden. Es sind
245 * keine Fehler im Rückgabepuffer enthalten.
246 *
247 * \subsection STSection_Plausibilitaetsfehler Plausibilitätsfehler
248 *
249 * Bei fehlgeschlagener Plausibilitätsprüfung ist der Rückgabewert
250 * ::ERIC_GLOBAL_PRUEF_FEHLER, und die Fehler werden im Rückgabepuffer
251 * als XML-Daten zurückgeliefert.
252 *
253 * \b Beispiel:
254 * \code{.xml}
255 * <?xml version="1.0" encoding="UTF-8"?>
256 * <EricBearbeiteVorgang xmlns="http://www.elster.de/EricXML/1.1/EricBearbeiteVorgang">
257 * <FehlerRegelpruefung>
258 * <Nutzdatenticket>1075</Nutzdatenticket>
259 * <Feldidentifikator>100001</Feldidentifikator>
260 * <Mehrfachzeilenindex>1</Mehrfachzeilenindex>
261 * <LfdNrVordruck>1</LfdNrVordruck>
262 * <VordruckZeilennummer>4</VordruckZeilennummer>
263 * <SemantischerIndex>PersonA</SemantischerIndex>
264 * <Untersachbereich>5</Untersachbereich>
265 * <RegelName>testRegelName</RegelName>
266 * <FachlicheFehlerId>9995</FachlicheFehlerId>
267 * <Text>Beim Ankreuzfeld muss der Wert 'X' angegeben werden.</Text>
268 * </FehlerRegelpruefung>
269 * </EricBearbeiteVorgang>
270 * \endcode
271 *
272 * Die einzelnen Elemente sind in der Schemadefinition
273 * @lsAPI-Rueckgabe-Schemata{Dokumentation\API-Rueckgabe-Schemata\EricBearbeiteVorgang.xsd} dokumentiert.
274 * Wenn die Bearbeitungsflags ::ERIC_PRUEFE_HINWEISE und ::ERIC_VALIDIERE übergeben
275 * worden sind, kann der Rückgabepuffer auch Hinweise enthalten.
276 *
277 * \subsection STSection_Serverfehlerfall Fehler in der Serverantwort
278 *
279 * Ist der Rückgabewert ::ERIC_TRANSFER_ERR_XML_THEADER oder
280 * ::ERIC_TRANSFER_ERR_XML_NHEADER so enthält der Serverantwortpuffer
281 * Fehlermeldungen. Zur Auswertung kann entweder die Serverantwort selbst
282 * ausgewertet werden oder es wird ::EricGetErrormessagesFromXMLAnswer() aufgerufen.
283 *
284 * \subsection STSection_Fehler Sonstige Fehler
285 *
286 * Bei sonstigen Fehlern ist der Inhalt der Rückgabepuffer undefiniert. Um nähere
287 * Informationen über die Fehlerursache herauszufinden, kann ::EricHoleFehlerText() mit
288 * dem Rückgabewert aufgerufen werden.
289 *
290 * \section STSection_Fortschrittcallbacks Fortschrittcallbacks
291 *
292 * Während der Verarbeitung eines Anwendungsfalls werden die durch die Funktionen
293 * ::EricRegistriereFortschrittCallback() und ::EricRegistriereGlobalenFortschrittCallback()
294 * registrierten Callbacks aufgerufen.
295 *
296 * @see
297 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Anwendungsfälle von EricBearbeiteVorgang()"
298 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. der jeweiligen Datenart
299 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "ElsterDatenabholung"
300 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Größenbegrenzung der Eingangsdaten"
301 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Funktionen für Fortschrittcallbacks"
302 * - EricHoleFehlerText()
303 * - EricGetErrormessagesFromXMLAnswer()
304 * - EricRegistriereFortschrittCallback()
305 * - EricRegistriereGlobalenFortschrittCallback()
306 *
307 */
308 ERICAPI_IMPORT int STDCALL EricBearbeiteVorgang(
309 const char* datenpuffer,
310 const char* datenartVersion,
311 uint32_t bearbeitungsFlags,
312 const eric_druck_parameter_t* druckParameter,
313 const eric_verschluesselungs_parameter_t* cryptoParameter,
314 EricTransferHandle* transferHandle,
315 EricRueckgabepufferHandle rueckgabeXmlPuffer,
316 EricRueckgabepufferHandle serverantwortXmlPuffer);
317
318 /**
319 * @brief Beendet den Singlethreading-ERiC
320 *
321 * Die Verarbeitung mit der ERiC Singlethread-API ist beendet, als letztes muss EricBeende() aufgerufen werden.
322 *
323 * @return
324 * - ::ERIC_OK
325 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
326 * - ::ERIC_GLOBAL_UNKNOWN
327 *
328 * @see
329 * - EricInitialisiere()
330 */
331 ERICAPI_IMPORT int STDCALL EricBeende(void);
332
333 /**
334 * @brief Die PIN für ein clientseitig erzeugtes Zertifikat (CEZ) wird geändert.
335 *
336 * Die Funktion ändert die bei der Funktion EricCreateKey() angegebene PIN
337 * und entsprechend hierfür die Prüfsumme in der Datei \c eric.sfv.
338 * Falls die Datei \c eric.sfv nicht vorhanden ist, wird sie, wie bei EricCreateKey(), erstellt.
339 * Eine PIN-Änderung von einem Portalzertifikat (POZ) ist nicht möglich.
340 *
341 * Pfade müssen auf Windows in der für Datei-Funktionen benutzten ANSI-Codepage,
342 * auf Linux, AIX und Linux Power in der für das Dateisystem benutzten Locale und auf macOS in der
343 * "decomposed form" von UTF-8 übergeben werden.
344 * Bitte weitere Betriebssystemspezifika bzgl. nicht erlaubter Zeichen in
345 * Pfaden und Pfadtrennzeichen beachten.
346 *
347 * Für Details zu Pfaden im ERiC siehe @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kapitel
348 * "Übergabe von Pfaden an ERiC API-Funktionen"
349 *
350 * @param[in] psePath
351 * In dem angegebenen Pfad liegt das Schlüsselpaar
352 * \c eric_private.p12 und \c eric_public.cer
353 * @param[in] oldPin
354 * Bisherige PIN.
355 * @param[in] newPin
356 * Neue PIN. Die Mindestlänge beträgt 4 Stellen. Zulässige
357 * Zeichen sind alle ASCII-Zeichen ohne die Steuerzeichen.
358 *
359 * @return
360 * - ::ERIC_OK
361 * - ::ERIC_GLOBAL_UNGUELTIGER_PARAMETER
362 * - ::ERIC_GLOBAL_UNGUELTIGER_PARAMETER
363 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
364 * - ::ERIC_GLOBAL_UNKNOWN
365 * - ::ERIC_CRYPT_PIN_STAERKE_NICHT_AUSREICHEND
366 * - ::ERIC_CRYPT_PIN_ENTHAELT_UNGUELTIGE_ZEICHEN
367 * - ::ERIC_CRYPT_E_PSE_PATH
368 * - ::ERIC_CRYPT_NICHT_UNTERSTUETZTES_PSE_FORMAT
369 * - ::ERIC_CRYPT_ERROR_CREATE_KEY
370 *
371 *
372 * @see
373 * - EricCreateKey()
374 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Zuordnung der API-Funktionen zur Verwendung von POZ, CEZ und AHZ"
375 */
376 ERICAPI_IMPORT int STDCALL EricChangePassword(
377 const byteChar* psePath,
378 const byteChar* oldPin,
379 const byteChar* newPin);
380
381 /**
382 * @brief Die Bundesfinanzamtsnummer wird überprüft.
383 *
384 * Wird eine 13-stellige Steuernummer im
385 * ELSTER-Steuernummernformat angegeben, so wird nur die
386 * Bundesfinanzamtsnummer (= die ersten 4 Stellen der
387 * 13-stelligen Steuernummer) geprüft.
388 *
389 * Eine Prüfung der Steuernummer selbst findet nicht statt
390 * (hierfür EricPruefeSteuernummer() verwenden).
391 *
392 * @param[in] steuernummer
393 * 13-stellige Steuernummer im ELSTER Steuernummernformat bzw.
394 * 4-stellige Bundesfinanzamtsnummer.
395 * @return
396 * - ::ERIC_OK
397 * - ::ERIC_GLOBAL_BUFANR_UNBEKANNT:
398 * Die Bundesfinanzamtsnummer ist unbekannt oder ungültig.
399 * - ::ERIC_GLOBAL_NULL_PARAMETER:
400 * Es wurde keine Bundesfinanzamtsnummer übergeben (Parameter ist NULL).
401 * - ::ERIC_GLOBAL_COMMONDATA_NICHT_VERFUEGBAR
402 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
403 * - ::ERIC_GLOBAL_UNKNOWN
404 *
405 * @see
406 * - EricPruefeSteuernummer()
407 * - Pruefung_der_Steuer_und_Steueridentifikatsnummer.pdf, siehe \linkExt{https://www.elster.de/elsterweb/entwickler/infoseite/schnittstellenbeschreibungen,Entwicklerbereich} bei \linkExt{https://www.elster.de/eportal/start,ELSTER}.
408 */
409 ERICAPI_IMPORT int STDCALL EricPruefeBuFaNummer(
410 const byteChar* steuernummer);
411
412 /**
413 * @brief Das @c xml wird gegen das Schema der @c datenartVersion validiert.
414 *
415 * Das verwendete Schema kann nachgeschlagen werden unter @lsSchnittstellenbeschreibungen{Dokumentation\\Schnittstellenbeschreibungen\\}
416 *
417 * Nicht unterstützte Datenartversionen: @mAbsatz
418 * - ElsterKMV
419 * - alle Bilanz Datenartversionen
420 *
421 * @param[in] xml
422 * XML-Zeichenfolge
423 * @param[in] datenartVersion
424 * @parblock
425 * Die @c datenartVersion ist der @lsDokumentation{Datenartversionmatrix.xml} zu entnehmen.
426 * Dieser Parameter darf nicht NULL sein und muss zu den XML-Eingangsdaten passen.
427 *
428 * Siehe auch @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}.
429 * @endparblock
430 * @param[out] fehlertextPuffer
431 * @parblock
432 * Handle auf einen Rückgabepuffer, in den
433 * Fehlertexte geschrieben werden.
434 *
435 * Zur Erzeugung, Verwendung und Freigabe von Rückgabepuffern
436 * siehe Dokumentation zu ::EricRueckgabepufferHandle.
437 * @endparblock
438 *
439 * @return
440 * - ::ERIC_OK
441 * - ::ERIC_GLOBAL_NULL_PARAMETER
442 * - ::ERIC_GLOBAL_FUNKTION_NICHT_UNTERSTUETZT: Schemavalidierung wird für die übergebene @c datenartVersion nicht unterstützt.
443 * - ::ERIC_GLOBAL_COMMONDATA_NICHT_VERFUEGBAR
444 * - ::ERIC_GLOBAL_DATENARTVERSION_UNBEKANNT
445 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
446 * - ::ERIC_IO_READER_SCHEMA_VALIDIERUNGSFEHLER: @mLB<a>Die Fehlerbeschreibung steht im <tt>fehlertextPuffer</tt>.
447 * - ::ERIC_IO_PARSE_FEHLER: @mLB<a>Die Fehlerbeschreibung steht im <tt>fehlertextPuffer</tt>.
448 * - weitere, siehe eric_fehlercodes.h
449 */
450 ERICAPI_IMPORT int STDCALL EricCheckXML(
451 const char* xml,
452 const char* datenartVersion,
453 EricRueckgabepufferHandle fehlertextPuffer);
454
455 /**
456 * @brief Das Zertifikat-Handle @c hToken wird freigegeben.
457 *
458 * Diese Funktion gibt das übergebene Zertifikat-Handle frei.
459 * Zertifikat-Handles sollten möglichst frühzeitig, d.h. wenn sie nicht
460 * mehr benötigt werden, mit EricCloseHandleToCertificate() freigegeben
461 * werden, spätestens jedoch zum Programmende bzw. vor dem Entladen der
462 * ericapi Bibliothek.
463 *
464 * Das Ad Hoc-Zertifikat eines neuen Personalausweises sollte immer genau
465 * dann freigegeben werden, wenn es nicht mehr benötigt wird, jedoch spätestens
466 * vor Ablauf der 24 Stunden, die das Ad Hoc-Zertifikat gültig ist.
467 *
468 * Tritt ein Fehler auf, kann die Fehlermeldung mit EricHoleFehlerText()
469 * ausgelesen werden.
470 *
471 * @param[in] hToken
472 * Zertifikat-Handle wie von der Funktion
473 * EricGetHandleToCertificate() zurückgeliefert.
474 * @return
475 * - ::ERIC_OK
476 * - ::ERIC_CRYPT_E_INVALID_HANDLE
477 * - ::ERIC_GLOBAL_UNGUELTIGER_PARAMETER
478 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
479 * - ::ERIC_GLOBAL_UNKNOWN
480 *
481 * @note Die folgenden Rückgabewerte gelten nur bei Verwendung des neuen Personalausweises.
482 * @return
483 * - ::ERIC_TRANSFER_EID_CLIENTFEHLER
484 * - ::ERIC_TRANSFER_EID_FEHLENDEFELDER
485 * - ::ERIC_TRANSFER_EID_IDENTIFIKATIONABGEBROCHEN
486 * - ::ERIC_TRANSFER_EID_NPABLOCKIERT
487 * - ::ERIC_TRANSFER_EID_IDNRNICHTEINDEUTIG
488 * - ::ERIC_TRANSFER_EID_KEINCLIENT
489 * - ::ERIC_TRANSFER_EID_KEINKONTO
490 * - ::ERIC_TRANSFER_EID_SERVERFEHLER
491 * - ::ERIC_TRANSFER_ERR_CONNECTSERVER
492 * - ::ERIC_TRANSFER_ERR_NORESPONSE
493 * - ::ERIC_TRANSFER_ERR_PROXYAUTH
494 * - ::ERIC_TRANSFER_ERR_PROXYCONNECT
495 * - ::ERIC_TRANSFER_ERR_SEND
496 * - ::ERIC_TRANSFER_ERR_SEND_INIT
497 * - ::ERIC_TRANSFER_ERR_TIMEOUT
498 *
499 * @see
500 * - EricGetHandleToCertificate()
501 * - EricZertifikatOeffnenAusBytes()
502 * - EricGetPinStatus()
503 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Authentifizierung mit dem neuen Personalausweis (nPA)"
504 */
505 ERICAPI_IMPORT int STDCALL EricCloseHandleToCertificate(
506 EricZertifikatHandle hToken);
507
508 /**
509 * @brief Es werden die Kryptomittel für ein clientseitig erzeugtes
510 * Zertifikat (CEZ) in einem Verzeichnis des Dateisystems
511 * erstellt.
512 *
513 * Im angegebenen Verzeichnis @c pfad sind nach Ausführung
514 * der Funktion EricCreateKey() drei Dateien erstellt worden: @mAbsatz
515 * - \c eric_public.cer: @mLB<a>Enthält das Zertifikat mit den Daten aus \c zertifikatInfo
516 * und darin den öffentlichen Schlüssel.
517 * - \c eric_private.p12: @mLB<a>Enthält den privaten Schlüssel.
518 * Der Zugriff ist über die @c pin geschützt.
519 * - \c eric.sfv: @mLB<a>Enthält die Prüfsumme der Dateien \c eric_public.cer und \c eric_private.p12.
520 * Die Integrität dieser beiden Dateien kann damit jederzeit überprüft werden.
521 *
522 * Ein CEZ kann unter anderem für die
523 * Bescheiddaten-Rückübermittlung verwendet werden.
524 * Weitere Informationen zur Datenabholung lesen Sie bitte im
525 * @typeDokumentation{ERiC-Entwicklerhandbuch.pdf} nach.
526 *
527 * @param[in] pin
528 * @parblock
529 * PIN (Passwort), mit der auf den privaten Schlüssel
530 * zugegriffen werden kann.
531 *
532 * Die Mindestlänge beträgt 4 Stellen. Zulässige
533 * Zeichen sind alle ASCII-Zeichen ohne die
534 * Steuerzeichen.
535 * @endparblock
536 * @param[in] pfad
537 * @parblock
538 * Pfad (1), in dem die Kryptomittel erzeugt werden sollen.
539 * Das durch den angegebenen
540 * Pfad bezeichnete Verzeichnis muss im Dateisystem
541 * bereits existieren und beschreibbar sein.
542 *
543 * Es gibt folgende Möglichkeiten: @mAbsatz
544 * - Absoluter Pfad: Empfehlung.
545 * - Relativer Pfad: Wird an das Arbeitsverzeichnis
546 * angehängt.
547 * - Leere Zeichenkette: In diesem Fall wird das
548 * Arbeitsverzeichnis verwendet.
549 * @endparblock
550 * @param[in] zertifikatInfo
551 * Daten, die zur Identifikation des Schlüsselinhabers
552 * im Zertifikat abgelegt werden.
553 *
554 * (1) Pfade müssen auf Windows in der für Datei-Funktionen benutzten ANSI-Codepage,
555 * auf Linux, AIX und Linux Power in der für das Dateisystem benutzten Locale und auf macOS in der
556 * "decomposed form" von UTF-8 übergeben werden.
557 * Bitte weitere Betriebssystemspezifika bzgl. nicht erlaubter Zeichen in
558 * Pfaden und Pfadtrennzeichen beachten.
559 *
560 * Für Details zu Pfaden im ERiC siehe @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kapitel
561 * "Übergabe von Pfaden an ERiC API-Funktionen".
562 *
563 * @return
564 * - ::ERIC_OK
565 * - ::ERIC_GLOBAL_NULL_PARAMETER
566 * - ::ERIC_GLOBAL_UNGUELTIGE_PARAMETER_VERSION
567 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
568 * - ::ERIC_GLOBAL_UNKNOWN
569 * - ::ERIC_CRYPT_ZERTIFIKATSPFAD_KEIN_VERZEICHNIS
570 * - ::ERIC_CRYPT_ZERTIFIKATSDATEI_EXISTIERT_BEREITS
571 * - ::ERIC_CRYPT_PIN_STAERKE_NICHT_AUSREICHEND
572 * - ::ERIC_CRYPT_PIN_ENTHAELT_UNGUELTIGE_ZEICHEN
573 * - ::ERIC_CRYPT_ERROR_CREATE_KEY
574 *
575 * @see
576 * - EricChangePassword()
577 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Zertifikate und Authentifizierungsverfahren"
578 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Übergabe von Pfaden an ERiC API-Funktionen"
579 */
580 ERICAPI_IMPORT int STDCALL EricCreateKey(
581 const byteChar* pin,
582 const byteChar* pfad,
583 const eric_zertifikat_parameter_t* zertifikatInfo);
584
585 /**
586 * @brief Diese Funktion erzeugt einen TransferHeader.
587 *
588 * Dieser ist der oberste Header in der Datenstruktur.
589 * Er enthält Felder für die Kommunikation zwischen Server
590 * und Client. Es wird nur die Kombination
591 * NutzdatenHeader-Version "11" und TransferHeader-Version "11" unterstützt.
592 *
593 * Zur Erzeugung, Verwendung und Freigabe von Rückgabepuffern siehe Dokumentation
594 * zu ::EricRueckgabepufferHandle.
595 *
596 * @param[in] xml
597 * @parblock
598 * XML-Datensatz, für den der <TransferHeader>-Block erzeugt werden soll.
599 *
600 * Es kann entweder ein komplettes Elster-XML oder nur der Datenteil übergeben werden.
601 *
602 * ERiC nimmt bei diesem Parameter keine Konvertierung von Sonderzeichen in Entitätenreferenzen vor.
603 *
604 * Attribute, die in den Start-Tags der Elemente <Elster>
605 * bzw. <DatenTeil> im übergebenen XML-Datensatz definiert werden, werden nicht in
606 * das Rückgabe-XML übernommen.
607 *
608 * Namespace-Definitionen, die in den Start-Tags der Elemente <Elster>
609 * bzw. <DatenTeil> im übergebenen XML-Datensatz definiert werden, führen zu einem ::ERIC_IO_PARSE_FEHLER.
610 *
611 * Im Rückgabe-XML werden im Start-Tag des Elements <Elster> die URI "http://www.elster.de/elsterxml/schema/v11" als
612 * Default-Namensraum definiert.
613 *
614 * Die dem Element <DatenTeil>
615 * untergeordneten Elemente aus dem übergebenen XML-Datensatz werden
616 * unverändert übernommen.
617 *
618 * Der allgemeine Aufbau des Elster-XMLs wird im
619 * @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Datenverarbeitung mit ERiC"
620 * beschrieben.
621 * @endparblock
622 * @param[in] verfahren
623 * Name des Verfahrens, z.B:
624 * 'ElsterAnmeldung', siehe @typeDokumentation{ERiC-Entwicklerhandbuch.pdf},
625 * Tabelle "Eigenschaften der Datenart" im
626 * jeweiligen Kapitel zur Datenart.
627 * @param[in] datenart
628 * Name der Datenart, z.B.:'LStB' oder 'UStVA',
629 * siehe @typeDokumentation{ERiC-Entwicklerhandbuch.pdf},
630 * Tabelle "Eigenschaften der Datenart" im
631 * jeweiligen Kapitel zur Datenart.
632 * @param[in] vorgang
633 * Name der Übertragungsart, z.B.
634 * 'send-NoSig', siehe @typeDokumentation{ERiC-Entwicklerhandbuch.pdf},
635 * Tabelle "Eigenschaften der Datenart" im
636 * jeweiligen Kapitel zur Datenart.
637 * @param[in] testmerker
638 * @parblock
639 * Für eine Testübertragung muss der entsprechende Testmerker angegeben werden,
640 * siehe @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Test Unterstützung bei der ERiC-Anbindung".
641 *
642 * Falls ein Echtfall übertragen werden soll, muss der Wert NULL angegeben werden.
643 * @endparblock
644 * @param[in] herstellerId
645 * Hersteller-ID des Softwareproduktes.
646 * @param[in] datenLieferant
647 * @parblock
648 * Der Wert entspricht dem XML-Element <DatenLieferant>, wie es im
649 * Schema des Transferheaders der ElsterBasis-XML-Schnittstelle
650 * definiert ist.
651 *
652 * ERiC konvertiert bei diesem Parameter Sonderzeichen in Entitätenreferenzen.
653 * @endparblock
654 * @param[in] versionClient
655 * @parblock
656 * Angabe von Versionsinformation, die in der Serverantwort
657 * auch zurückgegeben wird und ausgewertet werden kann.
658 * Der Wert NULL entspricht "keine Angabe von Versionsinformation",
659 * d.h. es wird kein XML-Element <VersionClient> im <TransferHeader>-Block erzeugt.
660 *
661 * ERiC konvertiert bei diesem Parameter Sonderzeichen in Entitätenreferenzen.
662 * @endparblock
663 * @param[in] publicKey
664 * @parblock
665 * Öffentlicher Schlüssel für die Transportverschlüsselung beim Verfahren
666 * ElsterLohn. Bei anderen Verfahren sollte NULL übergeben werden.
667 *
668 * Dieser Wert kann mit dem Rückgabewert von ::EricGetPublicKey() befüllt
669 * werden.
670 * Der Inhalt dieses Parameters wird in das <TransportSchluessel>-Element
671 * der Rückgabe-XML geschrieben.
672 * @endparblock
673 * @param[out] xmlRueckgabePuffer
674 * @parblock
675 * Handle auf einen Rückgabepuffer, in den
676 * das Elster-XML mit dem erzeugten TransportHeader geschrieben wird,
677 * siehe ::EricRueckgabepufferHandle.
678 *
679 * Es wird immer ein vollständiger
680 * Elster-XML-Datensatz mit dem <Elster>-Element als Wurzel-Element
681 * zurückgeliefert. Bzgl. der darin enthaltenen XML-Namespace-Definitionen sind
682 * die bei der Beschreibung des Parameters "xml" genannten Einschränkungen
683 * zu berücksichtigen.
684 * @endparblock
685 *
686 * @return
687 * - ::ERIC_OK
688 * - ::ERIC_GLOBAL_NULL_PARAMETER
689 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
690 * - ::ERIC_TRANSFER_ERR_XML_ENCODING: Die übergebenen XML-Daten sind
691 * nicht UTF-8 kodiert.
692 * - ::ERIC_IO_PARSE_FEHLER
693 * - ::ERIC_IO_DATENTEILNOTFOUND
694 * - ::ERIC_IO_DATENTEILENDNOTFOUND
695 * - weitere, siehe eric_fehlercodes.h
696 *
697 *
698 * @see
699 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Datenverarbeitung mit ERiC"
700 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Anwendungsfälle von EricBearbeiteVorgang()"
701 * - ERiC-Returncodes und Fehlertexte sind in eric_fehlercodes.h zu finden.
702 */
703 ERICAPI_IMPORT int STDCALL EricCreateTH(
704 const char* xml, const char* verfahren,
705 const char* datenart, const char* vorgang,
706 const char* testmerker, const char* herstellerId,
707 const char* datenLieferant, const char* versionClient,
708 const byteChar* publicKey,
709 EricRueckgabepufferHandle xmlRueckgabePuffer);
710
711 /**
712 * @brief Erzeugt einen Version 4 Universally Unique Identifier (UUID) gemäß RFC 4122.
713 *
714 * @param[out] uuidRueckgabePuffer Handle auf einen Rückgabepuffer, in den die erzeugte UUID geschrieben wird.
715 * @return
716 * - ::ERIC_OK
717 * - ::ERIC_GLOBAL_NULL_PARAMETER
718 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
719 * - ::ERIC_GLOBAL_UNKNOWN
720 */
721 ERICAPI_IMPORT int STDCALL EricCreateUUID(
722 EricRueckgabepufferHandle uuidRueckgabePuffer);
723
724 /**
725 * @brief Es werden die mit der Datenabholung abgeholten und verschlüsselten Daten entschlüsselt.
726 *
727 * Falls während der Bearbeitung ein Fehler auftritt,
728 * liefert die Funktion EricHoleFehlerText() den
729 * dazugehörigen Fehlertext.
730 *
731 * @param[in] zertifikatHandle Handle auf das zum Entschlüsseln zu verwendende Zertifikat.
732 * @param[in] pin PIN zum Zugriff auf das Zertifikat.
733 * @param[in] base64Eingabe
734 * @parblock
735 * Base64-kodierte verschlüsselte Daten oder Anhänge, welche mit dem Verfahren
736 * ElsterDatenabholung abgeholt wurden.
737 *
738 * Die Abholdaten befinden sich im Element @mLB<tt>/Elster[1]/DatenTeil[1]/Nutzdatenblock/Nutzdaten[1]/Datenabholung[1]/Abholung[1]/Datenpaket</tt>
739 *
740 * Die optionalen Anhänge befinden sich im Element @mLB<tt>/Elster[1]/DatenTeil[1]/Nutzdatenblock/Nutzdaten[1]/Datenabholung[1]/Abholung[1]/Anhaenge[1]/Anhang[1]/Dateiinhalt</tt>
741 * @endparblock
742 * @param[out] rueckgabePuffer
743 * @parblock
744 * Handle auf einen Rückgabepuffer, in den
745 * die entschlüsselten Daten geschrieben werden. Im Fehlerfall ist der Inhalt des Rückgabepuffers undefiniert.
746 *
747 * Zur Erzeugung, Verwendung und Freigabe von Rückgabepuffern
748 * siehe ::EricRueckgabepufferHandle.
749 * @endparblock
750 * @return
751 * - ::ERIC_OK
752 * - ::ERIC_GLOBAL_NULL_PARAMETER
753 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
754 * - ::ERIC_GLOBAL_ERR_DEKODIEREN
755 * - ::ERIC_GLOBAL_UNKNOWN
756 * - Ein Zertifikatsfehler aus dem Statuscodebereich von ::ERIC_CRYPT_E_INVALID_HANDLE = 610201101 bis 610201212
757 *
758 * @see
759 * - EricHoleFehlerText()
760 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "ElsterDatenabholung"
761 */
762 ERICAPI_IMPORT int STDCALL EricDekodiereDaten(
763 EricZertifikatHandle zertifikatHandle,
764 const byteChar* pin,
765 const byteChar* base64Eingabe,
766 EricRueckgabepufferHandle rueckgabePuffer);
767
768 /**
769 * @brief Alle Einstellungen werden auf den jeweiligen Standardwert zurückgesetzt.
770 *
771 * Die Standardwerte sind im Dokument @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Vorbelegung der ERiC-Einstellungen"
772 * zu finden.
773 *
774 *
775 * @return
776 * - ::ERIC_OK
777 * - ::ERIC_GLOBAL_UNKNOWN
778 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
779 *
780 * @see
781 * - EricEinstellungSetzen()
782 * - EricEinstellungLesen()
783 * - EricEinstellungZuruecksetzen()
784 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Bedeutung der ERiC-Einstellungen"
785 */
786 ERICAPI_IMPORT int STDCALL EricEinstellungAlleZuruecksetzen(
787 void);
788
789 /**
790 * @brief Der Wert der API-Einstellung @c name wird im @c rueckgabePuffer zurückgeliefert.
791 *
792 * @param[in] name Name der API-Einstellung, NULL-terminierte Zeichenfolge.
793 * @param[out] rueckgabePuffer
794 * @parblock
795 * Handle auf einen Rückgabepuffer, in den
796 * der Wert der API-Einstellung geschrieben wird.
797 *
798 * Zur Erzeugung, Verwendung und Freigabe von Rückgabepuffern
799 * siehe ::EricRueckgabepufferHandle.
800 * @endparblock
801 *
802 * @return
803 * - ::ERIC_OK
804 * - ::ERIC_GLOBAL_EINSTELLUNG_NAME_UNGUELTIG
805 * - ::ERIC_GLOBAL_NULL_PARAMETER
806 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
807 * - ::ERIC_GLOBAL_UNKNOWN
808 *
809 * @see
810 * - EricEinstellungSetzen()
811 * - EricEinstellungZuruecksetzen()
812 * - EricEinstellungAlleZuruecksetzen()
813 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Bedeutung der ERiC-Einstellungen"
814 */
815 ERICAPI_IMPORT int STDCALL EricEinstellungLesen(
816 const char* name,
817 EricRueckgabepufferHandle rueckgabePuffer);
818
819 /**
820 * @brief Die API-Einstellung @c name wird auf den @c wert gesetzt.
821 *
822 * Nach dem Laden der ERiC-Bibliotheken hat jede API-Einstellung
823 * ihren Standardwert. Mit dieser Funktion kann der Wert
824 * verändert werden. Der Wertebereich der jeweiligen API-Einstellung
825 * ist zu beachten.
826 *
827 * Bei Pfad-Einstellungen muss auf Windows der Wert in der für Datei-Funktionen
828 * benutzten ANSI-Codepage, auf Linux, AIX und Linux Power in der für das Dateisystem benutzten Locale
829 * und auf macOS in der "decomposed form" von UTF-8 übergeben werden.
830 * Bitte weitere Betriebssystemspezifika bzgl. nicht erlaubter Zeichen in
831 * Pfaden und Pfadtrennzeichen beachten.
832 *
833 * Für Details zu Pfaden im ERiC siehe @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kapitel
834 * "Übergabe von Pfaden an ERiC API-Funktionen"
835 *
836 * @param[in] name Name der API-Einstellung, NULL-terminierte Zeichenfolge.
837 * @param[in] wert Wert der API-Einstellung, NULL-terminierte Zeichenfolge.
838 *
839 * @return
840 * - ::ERIC_OK
841 * - ::ERIC_GLOBAL_EINSTELLUNG_NAME_UNGUELTIG
842 * - ::ERIC_GLOBAL_EINSTELLUNG_WERT_UNGUELTIG
843 * - ::ERIC_GLOBAL_NULL_PARAMETER
844 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
845 * - ::ERIC_GLOBAL_UNKNOWN
846 *
847 * @see
848 * - EricEinstellungLesen()
849 * - EricEinstellungZuruecksetzen()
850 * - EricEinstellungAlleZuruecksetzen()
851 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Bedeutung der ERiC-Einstellungen"
852 */
853 ERICAPI_IMPORT int STDCALL EricEinstellungSetzen(
854 const char* name,
855 const char* wert);
856
857 /**
858 * @brief Der Wert der API-Einstellung @c name wird auf den Standardwert zurückgesetzt.
859 *
860 * Die Standardwerte sind im Dokument @typeDokumentation{ERiC-Entwicklerhandbuch.pdf},
861 * Kap. "Vorbelegung der ERiC-Einstellungen" zu finden.
862 *
863 * @param[in] name Name der API-Einstellung, NULL-terminierte Zeichenfolge.
864 *
865 * @return
866 * - ::ERIC_OK
867 * - ::ERIC_GLOBAL_EINSTELLUNG_NAME_UNGUELTIG
868 * - ::ERIC_GLOBAL_NULL_PARAMETER
869 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
870 * - ::ERIC_GLOBAL_UNKNOWN
871 *
872 * @see
873 * - EricEinstellungSetzen()
874 * - EricEinstellungLesen()
875 * - EricEinstellungAlleZuruecksetzen()
876 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Bedeutung der ERiC-Einstellungen"
877 */
878 ERICAPI_IMPORT int STDCALL EricEinstellungZuruecksetzen(
879 const char* name);
880
881 /**
882 * @brief Alle verwendeten Plugin-Bibliotheken werden entladen und deren Speicher wird freigegeben.
883 *
884 * Der ERiC lädt die für die Bearbeitung notwendigen Plugin-Bibliotheken permanent
885 * in den Speicher und gibt diese erst mit dem Aufruf dieser Funktion wieder frei.
886 *
887 * @note EricEntladePlugins() sollte erste dann aufgerufen werden, wenn die
888 * Plugin-Bibliotheken definitiv nicht mehr benötigt werden.
889 * Ein erneutes Laden der Bibliotheken ist verhältnismäßig zeitintensiv.
890 *
891 * Falls eine Plugin-Bibliothek nicht entladen werden kann,
892 * wird dies in eric.log protokolliert. Der Returncode ist immer ::ERIC_OK.
893 *
894 *
895 * @return
896 * - ::ERIC_OK
897 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
898 * - ::ERIC_GLOBAL_UNKNOWN
899 *
900 * @see
901 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Verwendung von EricEntladePlugins()"
902 */
903 ERICAPI_IMPORT int STDCALL EricEntladePlugins(
904 void);
905
906 /**
907 * @brief Konvertiert ein Einheitswert-Aktenzeichen im ELSTER-Format in ein landesspezifisches Bescheidformat
908 *
909 * Konvertiert ein Einheitswert-Aktenzeichen im ELSTER-Format (z.B. 2831400190001250002)
910 * in ein landesspezifisches Einheitswert-Aktenzeichen im Bescheidformat (z.B. 3100190001250002).
911 *
912 * @param[in] ewAzElster Zeiger auf ein Einheitswert-Aktenzeichen im ELSTER-Format (z.B. 2831400190001250002)
913 * @param[out] ewAzBescheidPuffer
914 * @parblock
915 * Handle auf einen Rückgabepuffer, in den
916 * das Einheitswert-Aktenzeichen im Bescheidformat (z.B. 3100190001250002) geschrieben wird.
917 *
918 * Zur Erzeugung, Verwendung und Freigabe von Rückgabepuffern
919 * siehe Dokumentation zu ::EricRueckgabepufferHandle.
920 * @endparblock
921 *
922 * @return
923 * - ::ERIC_OK
924 * - ::ERIC_GLOBAL_EWAZ_UNGUELTIG
925 * - ::ERIC_GLOBAL_NULL_PARAMETER
926 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
927 * - ::ERIC_GLOBAL_UNKNOWN
928 *
929 */
930 ERICAPI_IMPORT int STDCALL EricFormatEWAz(
931 const byteChar *ewAzElster,
932 EricRueckgabepufferHandle ewAzBescheidPuffer);
933
934 /**
935 * @brief Die Steuernummer @c eingabeSteuernummer wird in das Bescheid-Format des jeweiligen Bundeslandes umgewandelt.
936 *
937 * @param[in] eingabeSteuernummer
938 * Gültige, zu formatierende Steuernummer im
939 * ELSTER-Steuernummernformat.
940 * @param[out] rueckgabePuffer
941 * @parblock
942 * Handle auf einen Rückgabepuffer, in den
943 * die formatierte Steuernummer im Bescheid-Format des
944 * jeweiligen Bundeslandes geschrieben wird.
945 *
946 * Zur Erzeugung, Verwendung und Freigabe von Rückgabepuffern
947 * siehe Dokumentation zu ::EricRueckgabepufferHandle.
948 * @endparblock
949 *
950 * @return
951 * - ::ERIC_OK
952 * - ::ERIC_GLOBAL_NULL_PARAMETER
953 * - ::ERIC_GLOBAL_STEUERNUMMER_UNGUELTIG
954 * - ::ERIC_GLOBAL_COMMONDATA_NICHT_VERFUEGBAR
955 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
956 * - ::ERIC_GLOBAL_UNKNOWN
957 *
958 * @see
959 * - Pruefung_der_Steuer_und_Steueridentifikatsnummer.pdf, siehe \linkExt{https://www.elster.de/elsterweb/entwickler/infoseite/schnittstellenbeschreibungen,Entwicklerbereich} bei \linkExt{https://www.elster.de/eportal/start,ELSTER}.
960 */
961 ERICAPI_IMPORT int STDCALL EricFormatStNr(
962 const byteChar* eingabeSteuernummer,
963 EricRueckgabepufferHandle rueckgabePuffer);
964
965 /**
966 * @brief Die Auswahlliste(n) für @c datenartVersion oder @c feldkennung wird zurückgeliefert.
967 *
968 * @details Anwendungsfälle: @mAbsatz
969 * 1. Parameter @c feldkennung ist nicht NULL: @mLB<a>Die Funktion
970 * liefert die zur @c feldkennung und @c datenartVersion gehörige Auswahlliste.
971 * 2. Parameter @c feldkennung ist NULL: @mLB<a>Die Funktion
972 * liefert alle zur @c datenartVersion gehörigen Feldkennungen mit hinterlegten Auswahllisten.
973 *
974 * Für die Ermittlung der Auswahllisten vieler Feldkennungen wird aus Performanzgründen Anwendungsfall 2 empfohlen.
975 * Die Funktion liefert Auswahllisten zu Feldkennungen vom Format "NichtAbgeschlosseneEnumeration" zurück.
976 * Diese Auswahllisten werden auch in der Jahres-/Deltadokumentation dokumentiert.
977 *
978 * @param[in] datenartVersion
979 * Dieser Parameter darf nicht NULL sein.
980 * Die gültigen Datenartversionen sind in der @lsDokumentation{Datenartversionmatrix.xml} enthalten.
981 * @param[in] feldkennung
982 * Feldkennung, für welche die Auswahlliste zu ermitteln ist.
983 * @param[out] rueckgabeXmlPuffer
984 * @parblock
985 * Handle auf einen Rückgabepuffer, in den
986 * die angeforderten Auswahlliste(n) als XML-Daten geschrieben werden.
987 * Die XML-Daten folgen der XML Schema Definition in @lsAPI-Rueckgabe-Schemata{Dokumentation\API-Rueckgabe-Schemata\EricGetAuswahlListen.xsd}. \n
988 *
989 * Zur Erzeugung, Verwendung und Freigabe von Rückgabepuffern
990 * siehe ::EricRueckgabepufferHandle.
991 * @endparblock
992 *
993 * \b Beispiel:
994 * \code{.xml}
995 * <?xml version="1.0" encoding="UTF-8"?>
996 * <EricGetAuswahlListen xmlns="http://www.elster.de/EricXML/1.0/EricGetAuswahlListen">
997 * <AuswahlListe>
998 * <Feldkennung>0104110</Feldkennung>
999 * <ListenElement>Arbeitslosengeld</ListenElement>
1000 * <ListenElement>Elterngeld</ListenElement>
1001 * <ListenElement>Insolvenzgeld</ListenElement>
1002 * <ListenElement>Krankengeld</ListenElement>
1003 * <ListenElement>Mutterschaftsgeld</ListenElement>
1004 * </AuswahlListe>
1005 * </EricGetAuswahlListen>
1006 * \endcode
1007 *
1008 * @return
1009 * - ::ERIC_OK
1010 * - ::ERIC_GLOBAL_NULL_PARAMETER
1011 * - ::ERIC_GLOBAL_KEINE_DATEN_VORHANDEN
1012 * - ::ERIC_GLOBAL_DATENARTVERSION_UNBEKANNT
1013 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
1014 * - ::ERIC_GLOBAL_UNKNOWN
1015 */
1016 ERICAPI_IMPORT int STDCALL EricGetAuswahlListen(
1017 const char* datenartVersion,
1018 const char* feldkennung,
1019 EricRueckgabepufferHandle rueckgabeXmlPuffer);
1020
1021 /**
1022 * @brief Aus dem Antwort-XML des Finanzamtservers wird das Transferticket und Returncodes/Fehlermeldungen zurückgegeben.
1023 *
1024 * Die Funktion liefert bei erfolgreicher Ausführung: @mAbsatz
1025 * - Das Transferticket aus dem Antwort-XML in dem Parameter @c transferticketPuffer.
1026 * - Den Returncode und die Fehlermeldung aus dem Transferheader
1027 * in den Parametern \c returncodeTHPuffer und \c fehlertextTHPuffer.
1028 * - Für jeden Nutzdatenheader dessen Returncode und Fehlermeldung als XML-Daten im
1029 * Parameter @c returncodesUndFehlertexteNDHXmlPuffer nach XML Schema Definition
1030 * @lsAPI-Rueckgabe-Schemata{Dokumentation\API-Rueckgabe-Schemata\EricGetErrormessagesFromXMLAnswer.xsd}.
1031 * Enthält das Antwort-XML keine Nutzdaten, wird kein <Fehler> Element zurückgegeben.
1032 *
1033 * Zur Erzeugung, Verwendung und Freigabe von Rückgabepuffern siehe Dokumentation
1034 * zu ::EricRueckgabepufferHandle.
1035 *
1036 * @param[in] xml
1037 * Antwort-XML des ELSTER-Servers, das ausgewertet
1038 * werden soll. Der originale XML-Server-Datenstrom
1039 * sollte unverändert übergeben werden und darf
1040 * insbesondere keine Zeilenumbruchzeichen enthalten.
1041 * @param[out] transferticketPuffer Handle auf einen Rückgabepuffer, in den
1042 * das Transferticket geschrieben wird, siehe ::EricRueckgabepufferHandle.
1043 * @param[out] returncodeTHPuffer Handle auf einen Rückgabepuffer, in den
1044 * der Returncode aus dem Transferheader geschrieben wird.
1045 * Siehe ::EricRueckgabepufferHandle.
1046 * @param[out] fehlertextTHPuffer Handle auf einen Rückgabepuffer, in den
1047 * die Fehlermeldung aus dem Transferheader geschrieben wird, siehe
1048 * ::EricRueckgabepufferHandle.
1049 * @param[out] returncodesUndFehlertexteNDHXmlPuffer Handle auf einen
1050 * Rückgabepuffer, in den die Liste der Returncodes nach XML-Schema
1051 * @lsAPI-Rueckgabe-Schemata{Dokumentation\API-Rueckgabe-Schemata\EricGetErrormessagesFromXMLAnswer.xsd}
1052 * geschrieben werden, siehe ::EricRueckgabepufferHandle.
1053 *
1054 * \b Beispiel:
1055 * \code{.xml}
1056 * <?xml version="1.0" encoding="UTF-8"?>
1057 * <EricGetErrormessagesFromXMLAnswer xmlns="http://www.elster.de/EricXML/1.0/EricGetErrormessagesFromXMLAnswer">
1058 * <Fehler>
1059 * <Code>1</Code>
1060 * <Meldung>Fehlermeldung 1</Meldung>
1061 * </Fehler>
1062 * <Fehler>
1063 * <Code>2</Code>
1064 * <Meldung>Fehlermeldung 2</Meldung>
1065 * </Fehler>
1066 * (...)
1067 * </EricGetErrormessagesFromXMLAnswer>
1068 * \endcode
1069 *
1070 * @return
1071 * - ::ERIC_OK
1072 * - ::ERIC_IO_PARSE_FEHLER
1073 * - ::ERIC_GLOBAL_NULL_PARAMETER
1074 * - ::ERIC_GLOBAL_PUFFER_ZUGRIFFSKONFLIKT
1075 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
1076 * - ::ERIC_GLOBAL_UNKNOWN
1077 *
1078 * @note
1079 * Diese Funktion kann nicht dafür verwendet werden, die Antwort im Datenteil
1080 * aus einer dekodierten Serverantwort für Lohnsteuerbescheinigungen
1081 * auszuwerten.
1082 *
1083 * @see
1084 * - XML-Schema des Transferheaders: @lsElsterBasisSchema{Dokumentation\Schnittstellenbeschreibungen\ElsterBasisSchema\Schema\th000011_extern.xsd}
1085 * - XML-Schema des Nutzdatenheaders: @lsElsterBasisSchema{Dokumentation\Schnittstellenbeschreibungen\ElsterBasisSchema\Schema\ndh000011.xsd}
1086 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Schnittstellenbeschreibungen",
1087 * Tabelle "Ergänzende Softwarepakete und Dateien – Schnittstellenbeschreibungen"
1088 */
1089 ERICAPI_IMPORT int STDCALL EricGetErrormessagesFromXMLAnswer(
1090 const char* xml,
1091 EricRueckgabepufferHandle transferticketPuffer,
1092 EricRueckgabepufferHandle returncodeTHPuffer,
1093 EricRueckgabepufferHandle fehlertextTHPuffer,
1094 EricRueckgabepufferHandle returncodesUndFehlertexteNDHXmlPuffer);
1095
1096 /**
1097 * @brief Für das übergebene Zertifikat in @c pathToKeystore wird das Handle @c hToken
1098 * und die unterstützten PIN-Werte @c iInfoPinSupport zurückgeliefert.
1099 *
1100 * Die ERiC API benötigt Zertifikat-Handles typischerweise
1101 * bei kryptografischen Operationen.
1102 *
1103 * Zertifikat-Handles sollten möglichst frühzeitig, d.h. wenn sie nicht
1104 * mehr benötigt werden, mit EricCloseHandleToCertificate() freigegeben
1105 * werden, spätestens jedoch zum Programmende bzw. vor dem Entladen der
1106 * ericapi Bibliothek.
1107 *
1108 * @param[out] hToken
1109 * @parblock
1110 * Handle zu einem der folgenden Zertifikate: @mAbsatz
1111 * - Portalzertifikat
1112 * - clientseitig erzeugtes Zertifikat
1113 * - Ad Hoc-Zertifikat für den neuen Personalausweis
1114 * @endparblock
1115 * @param[out] iInfoPinSupport
1116 * @parblock
1117 * Wird in @c iInfoPinSupport ein Zeiger ungleich NULL übergeben und die Funktion mit ::ERIC_OK beendet,
1118 * dann enthält @c iInfoPinSupport einen vorzeichenlosen Integer-Wert.
1119 *
1120 * In diesem Wert ist kodiert abgelegt, ob eine PIN-Eingabe
1121 * erforderlich ist und welche PIN-Statusinformationen
1122 * unterstützt werden.
1123 *
1124 * Die kodierten Werte (nachfolgend in hexadezimaler Form angegeben)
1125 * können durch ein binäres ODER kombiniert werden und bedeuten im
1126 * Einzelnen: @mAbsatz
1127 * - \c 0x00: Keine PIN-Angabe erforderlich, kein PIN-Status unterstützt.
1128 * - \c 0x01: PIN-Angabe für Signatur erforderlich.
1129 * - \c 0x02: PIN-Angabe für Entschlüsselung erforderlich.
1130 * - \c 0x04: PIN-Angabe für Verschlüsselung des Zertifikats erforderlich.
1131 * - \c 0x08: reserviert (wird derzeit nicht verwendet)
1132 * - \c 0x10: PIN-Status "Pin Ok" wird unterstützt.
1133 * - \c 0x20: PIN-Status "Der letzte Versuch der Pin-Eingabe schlug fehl" wird unterstützt.
1134 * - \c 0x40: PIN-Status "Beim nächsten fehlerhaften Versuch wird die Pin gesperrt" wird unterstützt.
1135 * - \c 0x80: PIN-Status "Pin ist gesperrt" wird unterstützt.
1136 *
1137 * Falls vom Aufrufer NULL übergeben wird, gibt die Funktion nichts zurück.
1138 * @endparblock
1139 * @param[in] pathToKeystore
1140 * @parblock
1141 * Folgende Zertifikatstypen werden unterstützt: @mAbsatz
1142 * 1. Clientseitig erzeugtes Zertifikat: @mLB<a>Pfad
1143 * zum Verzeichnis, in dem sich die Zertifikats-Datei (.cer)
1144 * und die Datei mit dem privaten Schlüssel (.p12) befinden.
1145 * Diese Kryptomittel wurden mit EricCreateKey() erzeugt.
1146 * Der Pfad zum Verzeichnis ist bei clientseitig erzeugten
1147 * Zertifikaten relativ zum aktuellen Arbeitsverzeichnis oder absolut
1148 * anzugeben.
1149 * 2. Software-Portalzertifikat: @mLB<a>Pfad
1150 * zur Software-Zertifikatsdatei (i.d.R. mit der Endung .pfx).
1151 * Der Pfad zur Datei ist bei Software-Zertifikaten relativ zum
1152 * aktuellen Arbeitsverzeichnis oder absolut anzugeben.
1153 * 3. Sicherheitsstick: @mLB<a>Pfad
1154 * zur Treiberdatei, siehe (1). Bitte beachten, dass der Treiber
1155 * betriebssystemabhängig sein kann. Weitere Informationen in der
1156 * Anleitung zum Sicherheitsstick oder unter
1157 * \linkExt{https://www.sicherheitsstick.de,https://www.sicherheitsstick.de}.
1158 * 4. Signaturkarte: @mLB<a>Pfad
1159 * zur Treiberdatei, welcher einen Zugriff auf die
1160 * Signaturkarte ermöglicht, siehe (1). Weitere Informationen in
1161 * der Anleitung zur Signaturkarte.
1162 * 5. Neuer Personalausweis (nPA): @mLB<a>URL
1163 * des eID-Clients wie zum Beispiel der AusweisApp 2
1164 * In den meisten Fällen lautet diese URL: http://127.0.0.1:24727/eID-Client
1165 * Optional kann auf die folgende Weise noch ein Testmerker angehängt werden:
1166 * http://127.0.0.1:24727/eID-Client?testmerker=520000000. @mLB<a>Zu
1167 * den verfügbaren Testmerkern siehe @typeDokumentation{ERiC-Entwicklerhandbuch.pdf},
1168 * Kap. "Test Unterstützung bei der ERiC-Anbindung".
1169 *
1170 * <b>Wichtig:</b> Das Ad Hoc-Zertifikat, das in diesem Fall für den neuen
1171 * Personalausweis erzeugt wird, ist nur 24 Stunden gültig.
1172 * @endparblock
1173 *
1174 * (1) Bei Sicherheitssticks und Signaturkarten ist bei der Angabe
1175 * des Treibers der Suchmechanismus nach dynamischen Modulen des
1176 * jeweiligen Betriebssystems zu berücksichtigen. Weitere
1177 * Informationen sind z.B. unter Windows der Dokumentation der
1178 * <tt>LoadLibrary()</tt> oder unter Linux und macOS der Dokumentation der
1179 * <tt>dlopen()</tt> zu entnehmen.
1180 *
1181 * Pfade müssen auf Windows in der für Datei-Funktionen benutzten ANSI-Codepage,
1182 * auf Linux, AIX und Linux Power in der für das Dateisystem benutzten Locale
1183 * und auf macOS in der "decomposed form" von UTF-8 übergeben werden.
1184 * Bitte weitere Betriebssystemspezifika bzgl. nicht erlaubter Zeichen in
1185 * Pfaden und Pfadtrennzeichen beachten.
1186 *
1187 * Für Details zu Pfaden im ERiC siehe @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kapitel
1188 * "Übergabe von Pfaden an ERiC API-Funktionen".
1189 *
1190 * @return
1191 * - ::ERIC_OK
1192 * - ::ERIC_GLOBAL_NULL_PARAMETER
1193 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
1194 * - ::ERIC_GLOBAL_UNKNOWN
1195 * - ::ERIC_CRYPT_NICHT_UNTERSTUETZTES_PSE_FORMAT
1196 * - ::ERIC_CRYPT_E_MAX_SESSION
1197 * - ::ERIC_CRYPT_E_PSE_PATH
1198 * - ::ERIC_CRYPT_E_BUSY
1199 * - ::ERIC_CRYPT_E_P11_SLOT_EMPTY
1200 * - ::ERIC_CRYPT_E_NO_SIG_ENC_KEY
1201 * - ::ERIC_CRYPT_E_LOAD_DLL
1202 * - ::ERIC_CRYPT_E_NO_SERVICE
1203 * - ::ERIC_CRYPT_E_ESICL_EXCEPTION
1204 * @note Die folgenden Rückgabewerte gelten nur bei Verwendung des neuen Personalausweises.
1205 * @return
1206 * - ::ERIC_TRANSFER_EID_CLIENTFEHLER
1207 * - ::ERIC_TRANSFER_EID_FEHLENDEFELDER
1208 * - ::ERIC_TRANSFER_EID_IDENTIFIKATIONABGEBROCHEN
1209 * - ::ERIC_TRANSFER_EID_NPABLOCKIERT
1210 * - ::ERIC_TRANSFER_EID_IDNRNICHTEINDEUTIG
1211 * - ::ERIC_TRANSFER_EID_KEINCLIENT
1212 * - ::ERIC_TRANSFER_EID_KEINKONTO
1213 * - ::ERIC_TRANSFER_EID_SERVERFEHLER
1214 * - ::ERIC_TRANSFER_ERR_CONNECTSERVER
1215 * - ::ERIC_TRANSFER_ERR_NORESPONSE
1216 * - ::ERIC_TRANSFER_ERR_PROXYAUTH
1217 * - ::ERIC_TRANSFER_ERR_PROXYCONNECT
1218 * - ::ERIC_TRANSFER_ERR_SEND
1219 * - ::ERIC_TRANSFER_ERR_SEND_INIT
1220 * - ::ERIC_TRANSFER_ERR_TIMEOUT
1221 *
1222 * @see
1223 * - EricCloseHandleToCertificate()
1224 * - EricGetPinStatus()
1225 */
1226 ERICAPI_IMPORT int STDCALL EricGetHandleToCertificate(
1227 EricZertifikatHandle* hToken,
1228 uint32_t* iInfoPinSupport,
1229 const byteChar* pathToKeystore);
1230
1231 /**
1232 * @brief Für das im Speicher übergebene Zertifikat wird das Handle @c hToken zurückgeliefert.
1233 *
1234 * Die ERiC API benötigt Zertifikat-Handles typischerweise
1235 * bei kryptografischen Operationen.
1236 *
1237 * Zertifikat-Handles sollten möglichst frühzeitig, d.h. wenn sie nicht
1238 * mehr benötigt werden, mit EricCloseHandleToCertificate() freigegeben
1239 * werden, spätestens jedoch zum Programmende bzw. vor dem Entladen der
1240 * Bibliothek ericapi.
1241 *
1242 * @param[out] hToken
1243 * @parblock
1244 * Handle zu einem der folgenden Zertifikate: @mAbsatz
1245 * - Portalzertifikat
1246 * - clientseitig erzeugtes Zertifikat
1247 * @endparblock
1248 * @param[in] pkcs12Container
1249 * Speicheradresse des Zertifikats im PKCS#12-Format.
1250 * Es werden nur passwortgeschützte PKCS#12-Container akzeptiert.
1251 * @param[in] containerGroesse
1252 * Größe des PKCS#12-Containers in Bytes
1253 * @param[in] pkcs12Passwort
1254 * Das Passwort oder die PIN des PKCS#12-Containers.
1255 * Dieser Parameter darf nicht NULL sein.
1256 * @return
1257 * - ::ERIC_OK
1258 * - ::ERIC_GLOBAL_NULL_PARAMETER
1259 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
1260 * - ::ERIC_GLOBAL_UNKNOWN
1261 * - ::ERIC_CRYPT_NICHT_UNTERSTUETZTES_PSE_FORMAT
1262 * - ::ERIC_CRYPT_E_MAX_SESSION
1263 * - ::ERIC_CRYPT_E_PSE_PATH
1264 * - ::ERIC_CRYPT_E_BUSY
1265 * - ::ERIC_CRYPT_E_P11_SLOT_EMPTY
1266 * - ::ERIC_CRYPT_E_NO_SIG_ENC_KEY
1267 * - ::ERIC_CRYPT_E_PIN_WRONG
1268 * - ::ERIC_CRYPT_E_LOAD_DLL
1269 * - ::ERIC_CRYPT_E_NO_SERVICE
1270 * - ::ERIC_CRYPT_E_ESICL_EXCEPTION
1271 *
1272 * @see
1273 * - EricCloseHandleToCertificate()
1274 * - EricGetPinStatus()
1275 */
1276 ERICAPI_IMPORT int STDCALL EricZertifikatOeffnenAusBytes(
1277 EricZertifikatHandle* hToken,
1278 const byteChar *pkcs12Container,
1279 uint32_t containerGroesse,
1280 const byteChar *pkcs12Passwort);
1281
1282 /**
1283 * @brief Der PIN-Status wird für ein passwortgeschütztes Kryptomittel abgefragt und in @c pinStatus zurückgegeben.
1284 *
1285 * Der PIN-Status wird für einen passwortgeschützten Bereich
1286 * ermittelt, der durch das übergebene Zertifikat-Handle im
1287 * Parameter @c hToken referenziert wird. Da bei Sicherheitssticks
1288 * und Signaturkarten durch ein einziges Zertifikat-Handle zwei
1289 * Schlüsselpaare referenziert werden können (eines für die
1290 * Signatur und eines für die Verschlüsselung von Daten),
1291 * muss grundsätzlich der Parameter @c keyType gesetzt werden.
1292 *
1293 * Mit dem Rückgabewert der Funktion kann der Endanwender
1294 * rechtzeitig informiert werden, falls bei einer weiteren
1295 * falschen PIN-Eingabe das Kryptomittel gesperrt wird. Im
1296 * Fehlerfall ist @c pinStatus nicht definiert.
1297 *
1298 * Der Karten- bzw. Stickhersteller ist verantwortlich,
1299 * dass seine Implementierung den korrekten PIN-Status
1300 * zurückgibt, siehe auch
1301 * Tabelle "PIN-Statusabfrage für POZ" im Unterkap.
1302 * "Das Portalzertifikat (POZ)" im Dokument
1303 * @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}.
1304 *
1305 * @param[in] hToken
1306 * @parblock
1307 * Zertifikat-Handle, für dessen passwortgeschützten
1308 * Bereich der PIN-Status ermittelt werden soll.
1309 *
1310 * Wird von der Funktion
1311 * EricGetHandleToCertificate() zurückgeliefert.
1312 * @endparblock
1313 * @param[out] pinStatus
1314 * @parblock
1315 * Mögliche Rückgabewerte: @mAbsatz
1316 * - 0: StatusPinOk: Kein Fehlversuch oder keine
1317 * Informationen verfügbar
1318 * - 1: StatusPinLocked: PIN gesperrt
1319 * - 2: StatusPreviousPinError: Die letzte
1320 * PIN-Eingabe war fehlerhaft
1321 * - 3: StatusLockedIfPinError: Beim nächsten
1322 * fehlerhaften Versuch wird die PIN gesperrt
1323 * @endparblock
1324 * @param[in] keyType
1325 * @parblock
1326 * Mögliche Eingabewerte: @mAbsatz
1327 * - 0: eSignatureKey: Schlüssel für die Signatur
1328 * von Daten
1329 * - 1: eEncryptionKey: Schlüssel für die
1330 * Verschlüsselung von Daten
1331 * @endparblock
1332 * @return
1333 * - ::ERIC_OK
1334 * - ::ERIC_GLOBAL_NULL_PARAMETER
1335 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
1336 * - weitere, siehe eric_fehlercodes.h
1337 *
1338 * @see
1339 * - EricGetHandleToCertificate()
1340 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Zertifikate und Authentifizierungsverfahren"
1341 *
1342 */
1343 ERICAPI_IMPORT int STDCALL EricGetPinStatus(
1344 EricZertifikatHandle hToken,
1345 uint32_t* pinStatus,
1346 uint32_t keyType);
1347
1348 /**
1349 * @brief Es wird der öffentliche Schlüssel als base64-kodierte Zeichenkette
1350 * für das übergebene Zertifikat-Handle in @c cryptoParameter zurückgeliefert.
1351 * Von den beiden öffentlichen Schlüsseln, die in ELSTER-Zertifikaten enthalten sind,
1352 * wird der Verschlüsselungsschlüssel (Encryption Key) zurückgegeben.
1353 *
1354 * @param[in] cryptoParameter
1355 * Die Struktur enthält das Zertifikat-Handle und die PIN.
1356 * Falls der Zugriff auf den öffentlichen Schlüssel keine PIN erfordert,
1357 * ist PIN=NULL anzugeben.
1358 * @param[out] rueckgabePuffer
1359 * @parblock
1360 * Handle auf den Rückgabepuffer. Bei Erfolg enthält
1361 * der Rückgabepuffer den öffentlichen Schlüssel als base64-kodierte Zeichenkette.
1362 *
1363 * Zur Erzeugung, Verwendung und Freigabe von Rückgabepuffern
1364 * siehe Dokumentation zu ::EricRueckgabepufferHandle.
1365 * @endparblock
1366 *
1367 * @return
1368 * - ::ERIC_OK
1369 * - ::ERIC_GLOBAL_NULL_PARAMETER
1370 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
1371 * - ::ERIC_CRYPT_E_INVALID_HANDLE
1372 * - ::ERIC_CRYPT_E_P12_ENC_KEY
1373 * - ::ERIC_CRYPT_E_PIN_WRONG
1374 * - ::ERIC_CRYPT_E_PIN_LOCKED
1375 * - weitere, siehe eric_fehlercodes.h
1376 *
1377 */
1378 ERICAPI_IMPORT int STDCALL EricGetPublicKey(
1379 const eric_verschluesselungs_parameter_t* cryptoParameter,
1380 EricRueckgabepufferHandle rueckgabePuffer);
1381
1382 /**
1383 * @brief Es wird die Klartextfehlermeldung zu dem @c fehlerkode ermittelt.
1384 *
1385 * Die Funktion liefert die Klartextfehlermeldung zu einem
1386 * ERiC Fehlercode - definiert in eric_fehlercodes.h
1387 *
1388 *
1389 * @param[in] fehlerkode
1390 * Eingabe-Fehlercode, definiert in eric_fehlercodes.h.
1391 * @param[out] rueckgabePuffer
1392 * @parblock
1393 * Handle auf einen Rückgabepuffer, in den
1394 * die Klartextfehlermeldung geschrieben wird.
1395 *
1396 * Zur Erzeugung, Verwendung und Freigabe von Rückgabepuffern
1397 * siehe Dokumentation zu ::EricRueckgabepufferHandle.
1398 *
1399 * Die Klartextfehlermeldung ist gemäß UTF-8 kodiert.
1400 * @endparblock
1401 *
1402 * @return
1403 * - ::ERIC_OK
1404 * - ::ERIC_GLOBAL_NULL_PARAMETER
1405 * - ::ERIC_GLOBAL_FEHLERMELDUNG_NICHT_VORHANDEN
1406 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
1407 * - ::ERIC_GLOBAL_UNKNOWN
1408 */
1409 ERICAPI_IMPORT int STDCALL EricHoleFehlerText(
1410 int fehlerkode,
1411 EricRueckgabepufferHandle rueckgabePuffer);
1412
1413 /**
1414 * @brief Es wird die Finanzamtliste für eine bestimmte @c finanzamtLandNummer zurückgegeben.
1415 *
1416 * @param[in] finanzamtLandNummer
1417 * @parblock
1418 * Die Finanzamtlandnummer besteht aus den ersten zwei Stellen der
1419 * Bundesfinanzamtsnummer.
1420 *
1421 * Eine Liste aller Finanzamtlandnummern wird
1422 * von ::EricHoleFinanzamtLandNummern() zurückgegeben.
1423 * @endparblock
1424 * @param[out] rueckgabeXmlPuffer
1425 * @parblock
1426 * Handle auf einen Rückgabepuffer, in den
1427 * die Ergebnis XML-Daten geschrieben werden.
1428 * Die XML-Daten folgen der XML Schema Definition
1429 * @lsAPI-Rueckgabe-Schemata{Dokumentation\API-Rueckgabe-Schemata\EricHoleFinanzaemter.xsd}.
1430
1431 * Zur Erzeugung, Verwendung und Freigabe von Rückgabepuffern
1432 * siehe Dokumentation zu ::EricRueckgabepufferHandle.
1433 * @endparblock
1434 *
1435 * \b Beispiel:
1436 * \code{.xml}
1437 * <?xml version="1.0" encoding="UTF-8"?>
1438 * <EricHoleFinanzaemter xmlns="http://www.elster.de/EricXML/1.0/EricHoleFinanzaemter">
1439 * <Finanzamt>
1440 * <BuFaNummer>2801</BuFaNummer>
1441 * <Name>Finanzamt Offenburg Außenstelle Achern</Name>
1442 * </Finanzamt>
1443 * <Finanzamt>
1444 * <BuFaNummer>2804</BuFaNummer>
1445 * <Name>Finanzamt Villingen-Schwenningen Außenstelle Donaueschingen</Name>
1446 * </Finanzamt>
1447 * (...)
1448 * </EricHoleFinanzaemter>
1449 * \endcode
1450 *
1451 * @return
1452 * - ::ERIC_OK
1453 * - ::ERIC_GLOBAL_NULL_PARAMETER
1454 * - ::ERIC_GLOBAL_UTI_COUNTRY_NOT_SUPPORTED
1455 * - ::ERIC_GLOBAL_COMMONDATA_NICHT_VERFUEGBAR
1456 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
1457 * - ::ERIC_GLOBAL_UNKNOWN
1458 */
1459 ERICAPI_IMPORT int STDCALL EricHoleFinanzaemter(
1460 const byteChar* finanzamtLandNummer,
1461 EricRueckgabepufferHandle rueckgabeXmlPuffer);
1462
1463 /**
1464 * @brief Die Liste aller Finanzamtlandnummern wird zurückgegeben.
1465 *
1466 * @param[out] rueckgabeXmlPuffer
1467 * @parblock
1468 * Handle auf einen Rückgabepuffer, in den
1469 * die Ergebnis XML-Daten geschrieben werden.
1470 * Die XML-Daten folgen der XML Schema Definition
1471 * @lsAPI-Rueckgabe-Schemata{Dokumentation\API-Rueckgabe-Schemata\EricHoleFinanzamtLandNummern.xsd}.
1472 *
1473 * Zur Erzeugung, Verwendung und Freigabe von Rückgabepuffern
1474 * siehe Dokumentation zu ::EricRueckgabepufferHandle.
1475 * @endparblock
1476 *
1477 * \b Beispiel:
1478 * \code{.xml}
1479 * <?xml version="1.0" encoding="UTF-8"?>
1480 * <EricHoleFinanzamtLandNummern xmlns="http://www.elster.de/EricXML/1.0/EricHoleFinanzamtLandNummern">
1481 * <FinanzamtLand>
1482 * <FinanzamtLandNummer>28</FinanzamtLandNummer>
1483 * <Name>Baden-Württemberg</Name>
1484 * </FinanzamtLand>
1485 * <FinanzamtLand>
1486 * <FinanzamtLandNummer>91</FinanzamtLandNummer>
1487 * <Name>Bayern (Zuständigkeit LfSt - München)</Name>
1488 * </FinanzamtLand>
1489 * (...)
1490 * </EricHoleFinanzamtLandNummern>
1491 * \endcode
1492 *
1493 * @return
1494 * - ::ERIC_OK
1495 * - ::ERIC_GLOBAL_NULL_PARAMETER
1496 * - ::ERIC_GLOBAL_COMMONDATA_NICHT_VERFUEGBAR
1497 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
1498 * - ::ERIC_GLOBAL_UNKNOWN
1499 */
1500 ERICAPI_IMPORT int STDCALL EricHoleFinanzamtLandNummern(
1501 EricRueckgabepufferHandle rueckgabeXmlPuffer);
1502
1503 /**
1504 * @brief Die @c finanzamtsdaten werden für eine Bundesfinanzamtsnummer zurückgegeben.
1505 *
1506 * Die Bundesfinanzamtsnummer kann über die Kombination der Funktionen ::EricHoleFinanzamtLandNummern()
1507 * und ::EricHoleFinanzaemter() ermittelt werden.
1508 *
1509 * @param[in] bufaNr
1510 * Übergabe der 4-stelligen Bundesfinanzamtsnummer.
1511 *
1512 * @param[out] rueckgabeXmlPuffer
1513 * @parblock
1514 * Handle auf einen Rückgabepuffer, in den
1515 * die Ergebnis XML-Daten geschrieben werden.
1516 * Die XML-Daten folgen der XML Schema Definition
1517 * @lsAPI-Rueckgabe-Schemata{Dokumentation\API-Rueckgabe-Schemata\EricHoleFinanzamtsdaten.xsd}.
1518 *
1519 * Zur Erzeugung, Verwendung und Freigabe von Rückgabepuffern
1520 * siehe Dokumentation zu ::EricRueckgabepufferHandle.
1521 * @endparblock
1522 *
1523 * @return
1524 * - ::ERIC_OK
1525 * - ::ERIC_GLOBAL_NULL_PARAMETER: Parameter @c bufaNr ist NULL.
1526 * - ::ERIC_GLOBAL_PRUEF_FEHLER: Die übergebene Bundesfinanzamtsnummer ist keine Ganzzahl.
1527 * - ::ERIC_GLOBAL_KEINE_DATEN_VORHANDEN: Immer bei Testfinanzämtern.
1528 * - ::ERIC_GLOBAL_COMMONDATA_NICHT_VERFUEGBAR
1529 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
1530 * - ::ERIC_GLOBAL_UNKNOWN
1531 *
1532 * @see
1533 * - ::EricHoleFinanzamtLandNummern()
1534 * - ::EricHoleFinanzaemter()
1535 */
1536 ERICAPI_IMPORT int STDCALL EricHoleFinanzamtsdaten(
1537 const byteChar bufaNr[5],
1538 EricRueckgabepufferHandle rueckgabeXmlPuffer);
1539
1540 /**
1541 * @brief Die Testfinanzamtliste wird in @c rueckgabeXmlPuffer zurückgegeben.
1542 *
1543 * @param[out] rueckgabeXmlPuffer
1544 * @parblock
1545 * Handle auf einen Rückgabepuffer, in den
1546 * die Ergebnis XML-Daten geschrieben werden.
1547 * Die XML-Daten folgen der XML Schema Definition
1548 * @lsAPI-Rueckgabe-Schemata{Dokumentation\API-Rueckgabe-Schemata\EricHoleTestFinanzaemter.xsd}.
1549 *
1550 * Zur Erzeugung, Verwendung und Freigabe von Rückgabepuffern
1551 * siehe Dokumentation zu ::EricRueckgabepufferHandle.
1552 * @endparblock
1553 *
1554 * \b Beispiel:
1555 * \code{.xml}
1556 * <?xml version="1.0" encoding="UTF-8"?>
1557 * <EricHoleTestFinanzaemter xmlns="http://www.elster.de/EricXML/1.0/EricHoleTestFinanzaemter">
1558 * <Finanzamt>
1559 * <BuFaNummer>1096</BuFaNummer>
1560 * <Name>Testfinanzamt Saarland</Name>
1561 * </Finanzamt>
1562 * <Finanzamt>
1563 * <BuFaNummer>1097</BuFaNummer>
1564 * <Name>Finanzschule (Edenkoben)</Name>
1565 * </Finanzamt>
1566 * (...)
1567 * </EricHoleTestFinanzaemter>
1568 * \endcode
1569 *
1570 * @return
1571 * - ::ERIC_OK
1572 * - ::ERIC_GLOBAL_NULL_PARAMETER
1573 * - ::ERIC_GLOBAL_COMMONDATA_NICHT_VERFUEGBAR
1574 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
1575 * - ::ERIC_GLOBAL_UNKNOWN
1576 */
1577 ERICAPI_IMPORT int STDCALL EricHoleTestfinanzaemter(
1578 EricRueckgabepufferHandle rueckgabeXmlPuffer);
1579
1580 /**
1581 * @brief Die Eigenschaften des übergebenen Zertifikats werden im @c rueckgabeXmlPuffer zurückgegeben.
1582 *
1583 * @param[in] hToken Handle des Zertifikats, dessen Eigenschaften geholt werden sollen.
1584 * Wird von der Funktion EricGetHandleToCertificate() zurückgeliefert.
1585 * @param[in] pin PIN zum Öffnen des Zertifikats. Wird bei Software-Portalzertifikaten
1586 * benötigt.
1587 * @param[out] rueckgabeXmlPuffer
1588 * @parblock
1589 * Handle auf einen Rückgabepuffer, in den die Zertifikateigenschaften
1590 * im XML-Format geschrieben werden. Das Format ist im XML Schema
1591 * @lsAPI-Rueckgabe-Schemata{Dokumentation\API-Rueckgabe-Schemata\EricHoleZertifikatEigenschaften.xsd}
1592 * definiert.
1593 *
1594 * Zur Erzeugung, Verwendung und Freigabe von Rückgabepuffern
1595 * siehe Dokumentation zu ::EricRueckgabepufferHandle.
1596 * @endparblock
1597 * @note Bei einem ELSTER-Softwarezertifikat (.pfx) steht im Common Name (CN) die ID des ELSTER-Kontos,
1598 * für das das Zertifikat ausgestellt wurde.
1599 * Die Konto-ID kann beispielsweise dafür genutzt werden, bei einer Zertifikatsverlängerung
1600 * das verlängerte Zertifikat dem alten Zertifikat zuzuordnen.
1601 *
1602 * \b Beispiel:
1603 * \code{.xml}
1604 * <EricHoleZertifikatEigenschaften xmlns="http://www.elster.de/EricXML/2.0/EricHoleZertifikatEigenschaften">
1605 * <Signaturzertifikateigenschaften>
1606 * <AusgestelltAm>220817152116Z</AusgestelltAm>
1607 * <GueltigBis>230817152116Z</GueltigBis>
1608 * <Signaturalgorithmus>sha1WithRSAEncryption(1.2.840.113549.1.1.5)</Signaturalgorithmus>
1609 * <PublicKeyMD5>6b8b191936677957fe74103198e77f4e</PublicKeyMD5>
1610 * <PublicKeySHA1>884b0dfe2e10221a2aedd28c986cf34db0f1d932</PublicKeySHA1>
1611 * <PublicKeyBitLength>2048</PublicKeyBitLength>
1612 * <Issuer>
1613 * <Info><Name>CN</Name><Wert>ElsterSoftCA</Wert></Info>
1614 * <Info><Name>OU</Name><Wert>CA</Wert></Info>
1615 * (...)
1616 * </Issuer>
1617 * <Subjekt>
1618 * <Info><Name>CN</Name><Wert>1000872896</Wert></Info>
1619 * </Subjekt>
1620 * <Identifikationsmerkmaltyp>Steuernummer</Identifikationsmerkmaltyp>
1621 * <Registrierertyp>Person</Registrierertyp>
1622 * <Verifikationsart>Postweg</Verifikationsart>
1623 * <TokenTyp>Software</TokenTyp>
1624 * <Testzertifikat>true</Testzertifikat>
1625 * </Signaturzertifikateigenschaften>
1626 * <Verschluesselungszertifikateigenschaften>
1627 * (...)
1628 * </Verschluesselungszertifikateigenschaften>
1629 * </EricHoleZertifikatEigenschaften>
1630 * \endcode
1631 *
1632 * @return
1633 * - ::ERIC_OK
1634 * - ::ERIC_GLOBAL_NULL_PARAMETER
1635 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
1636 * - ::ERIC_GLOBAL_UNKNOWN
1637 * - ERIC_CRYPT_E_*: Ein Zertifikatsfehler aus dem Statuscodebereich
1638 * von ::ERIC_CRYPT_E_INVALID_HANDLE = 610201101 bis 610201212
1639 *
1640 * @see
1641 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Verwendung von EricHoleZertifikatEigenschaften()"
1642 * - @lsAPI-Rueckgabe-Schemata{Dokumentation\API-Rueckgabe-Schemata\EricHoleZertifikatEigenschaften.xsd}
1643 *
1644 */
1645 ERICAPI_IMPORT int STDCALL EricHoleZertifikatEigenschaften(
1646 EricZertifikatHandle hToken,
1647 const byteChar * pin,
1648 EricRueckgabepufferHandle rueckgabeXmlPuffer);
1649
1650 /**
1651 * @brief Der Fingerabdruck und dessen Signatur wird für das übergebene
1652 * Zertifikat zurückgegeben.
1653 *
1654 * Zur Erzeugung, Verwendung und Freigabe von Rückgabepuffern siehe Dokumentation
1655 * zu ::EricRueckgabepufferHandle.
1656 *
1657 * @param[in] cryptoParameter Zertifikatsdaten,
1658 * siehe eric_verschluesselungs_parameter_t.
1659 * Das in der übergebenen Struktur referenzierte Zertifikat muss
1660 * ein clientseitig erzeugtes Zertifikat (CEZ) sein.
1661 * @param[out] fingerabdruckPuffer Handle auf einen Rückgabepuffer, in
1662 * den der Fingerabdruck geschrieben wird, siehe
1663 * ::EricRueckgabepufferHandle.
1664 * @param[out] signaturPuffer Handle auf einen Rückgabepuffer, in den
1665 * die Signatur des Fingerabdrucks geschrieben wird, siehe
1666 * ::EricRueckgabepufferHandle.
1667 *
1668 * @note Die Erzeugung eines Fingerabdrucks mit dieser Funktion ist nur
1669 * in Zusammenhang mit clientseitig erzeugten Zertifikaten definiert.
1670 *
1671 * @return
1672 * - ::ERIC_OK
1673 * - ::ERIC_GLOBAL_NULL_PARAMETER
1674 * - ::ERIC_GLOBAL_PUFFER_ZUGRIFFSKONFLIKT
1675 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
1676 * - ::ERIC_GLOBAL_UNKNOWN
1677 * - ::ERIC_CRYPT_E_P12_READ
1678 * - ::ERIC_CRYPT_E_P12_DECODE
1679 * - ::ERIC_CRYPT_E_PIN_WRONG
1680 * - ::ERIC_CRYPT_E_P12_SIG_KEY
1681 * - ::ERIC_CRYPT_E_P12_ENC_KEY
1682 * - ::ERIC_CRYPT_ZERTIFIKAT
1683 * - ::ERIC_CRYPT_EIDKARTE_NICHT_UNTERSTUETZT
1684 * - ::ERIC_CRYPT_SIGNATUR
1685 * - ::ERIC_CRYPT_CORRUPTED
1686 */
1687 ERICAPI_IMPORT int STDCALL EricHoleZertifikatFingerabdruck(
1688 const eric_verschluesselungs_parameter_t* cryptoParameter,
1689 EricRueckgabepufferHandle fingerabdruckPuffer,
1690 EricRueckgabepufferHandle signaturPuffer);
1691
1692 /**
1693 * @brief Initialisiert den Singlethreading-ERiC
1694 *
1695 * Vor der Verwendung der Singlethreading-API muss ::EricInitialisiere()
1696 * aufgerufen werden.
1697 *
1698 * Mehrfache Aufrufe dieser Funktion, ohne das zwischendurch
1699 * ::EricBeende() aufgerufen worden ist, führen dazu, dass der
1700 * Fehlercode ::ERIC_GLOBAL_MEHRFACHE_INITIALISIERUNG zurückgegeben
1701 * wird. Der zuvor initialisierte Singlethreading-ERiC bleibt davon
1702 * aber unberührt und ist weiterhin in einem gültigen Zustand.
1703 *
1704 * @param[in] pluginPfad Pfad, in dem die Plugins rekursiv gesucht werden.
1705 * Ist der Zeiger gleich NULL, wird der Pfad zur
1706 * Bibliothek ericapi verwendet.
1707 * @param[in] logPfad Optionaler Pfad zur Log-Datei eric.log. Ist der
1708 * Wert gleich NULL, wird das betriebssystemspezifische
1709 * Verzeichnis für temporäre Dateien verwendet.
1710 *
1711 * @note
1712 * @parblock
1713 * Kann kein eric.log angelegt werden, wird eine entsprechende
1714 * Fehlermeldung auf die Konsole (stderr) geschrieben und an den
1715 * Windows-Ereignisdienst bzw. den syslogd-Dienst (Linux, AIX, macOS)
1716 * geschickt.
1717 *
1718 * Für Linux, AIX und macOS ist zu beachten, dass der syslogd-Dienst
1719 * gegebenenfalls erst noch zu aktivieren und für die Protokollierung
1720 * von Meldungen der Facility "User" zu konfigurieren ist.
1721 *
1722 * Suchkriterien für ERiC-Meldungen in der Windows-Ereignisansicht
1723 * sind "ERiC (Elster Rich Client)" als Quelle und "Anwendung"
1724 * als Protokoll.
1725 *
1726 * Suchkriterien für ERiC-Meldungen in den Systemlogdateien
1727 * unter Linux, AIX und macOS sind die Facility "User" und
1728 * der Ident "ERiC (Elster Rich Client)".
1729 * @endparblock
1730 *
1731 * @return
1732 * - ::ERIC_OK
1733 * - ::ERIC_GLOBAL_MEHRFACHE_INITIALISIERUNG
1734 * - ::ERIC_GLOBAL_FEHLER_INITIALISIERUNG
1735 * - ::ERIC_GLOBAL_LOG_EXCEPTION
1736 *
1737 * @see
1738 * - ::EricBeende()
1739 */
1740 ERICAPI_IMPORT int STDCALL EricInitialisiere(
1741 const byteChar *pluginPfad,
1742 const byteChar *logPfad);
1743
1744
1745 /**
1746 * @brief Es wird eine Steuernummer im ELSTER-Steuernummerformat erzeugt.
1747 *
1748 * Die Funktion erzeugt aus einer angegebenen Steuernummer
1749 * im Format des Steuerbescheides eine 13-stellige
1750 * Steuernummer im ELSTER-Steuernummerformat.<br>
1751 *
1752 * Die sich ergebende 13-stellige Steuernummer im
1753 * ELSTER-Steuernummerformat wird von der Funktion
1754 * ::EricMakeElsterStnr() auch auf Gültigkeit geprüft.<br>
1755 *
1756 * Einer der beiden Parameter @c landesnr oder @c bundesfinanzamtsnr muss
1757 * korrekt angegeben werden. Der jeweils andere Parameter darf NULL oder leer
1758 * sein. Bei bayerischen und berliner Steuernummern im Format BBB/UUUUP ist die
1759 * Angabe der Bundesfinanzamtsnummer zwingend erforderlich.
1760 *
1761 * @param[in] steuernrBescheid
1762 * Format der Steuernummer wie auch auf amtlichen
1763 * Schreiben angegeben.
1764 * @param[in] landesnr
1765 * 2-stellige Landesnummer (entspricht den ersten
1766 * zwei Stellen der Bundesfinanzamtsnummer).
1767 * @param[in] bundesfinanzamtsnr
1768 * 4-stellige Bundesfinanzamtsnummer.
1769 * @param[out] steuernrPuffer
1770 * @parblock
1771 * Handle auf einen Rückgabepuffer, in den
1772 * die Steuernummer im ELSTER-Steuernummerformat geschrieben wird.
1773 *
1774 * Zur Erzeugung, Verwendung und Freigabe von Rückgabepuffern
1775 * siehe Dokumentation zu ::EricRueckgabepufferHandle.
1776 * @endparblock
1777 *
1778 * @return
1779 * - ::ERIC_OK
1780 * - ::ERIC_GLOBAL_STEUERNUMMER_UNGUELTIG
1781 * - ::ERIC_GLOBAL_LANDESNUMMER_UNBEKANNT
1782 * - ::ERIC_GLOBAL_NULL_PARAMETER
1783 * - ::ERIC_GLOBAL_UNGUELTIGER_PARAMETER
1784 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
1785 * - ::ERIC_GLOBAL_UNKNOWN
1786 */
1787 ERICAPI_IMPORT int STDCALL EricMakeElsterStnr(
1788 const byteChar* steuernrBescheid,
1789 const byteChar landesnr[2+1],
1790 const byteChar bundesfinanzamtsnr[4+1],
1791 EricRueckgabepufferHandle steuernrPuffer);
1792
1793 /**
1794 * @brief Konvertiert ein Einheitswert-Aktenzeichen in das ELSTER-Format
1795 *
1796 * Konvertiert ein gültiges Einheitswert-Aktenzeichen in einem landesspezifischen Bescheidformat (z.B. 208/035-3-03889.3)
1797 * unter Angabe des Landeskürzels in ein Einheitswert-Aktenzeichen im ELSTER-Format (z.B. 520840353038893).
1798 *
1799 * @param[in] ewAzBescheid
1800 * Zeiger auf das Einheitswert-Aktenzeichen in einem landesspezifischen Bescheidformat.
1801 * @param[in] landeskuerzel
1802 * Zeiger auf das Landeskürzel (zum Beispiel BY für Bayern)
1803 * @param[out] ewAzElsterPuffer Handle auf einen Rückgabepuffer, in den
1804 * das erzeugte Einheitswert-Aktenzeichen im ELSTER-Format geschrieben wird.
1805 *
1806 * @return
1807 * - ::ERIC_OK
1808 * - ::ERIC_GLOBAL_EWAZ_UNGUELTIG
1809 * - ::ERIC_GLOBAL_EWAZ_LANDESKUERZEL_UNBEKANNT
1810 * - ::ERIC_GLOBAL_NULL_PARAMETER
1811 * - ::ERIC_GLOBAL_UNGUELTIGER_PARAMETER
1812 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
1813 * - ::ERIC_GLOBAL_UNKNOWN
1814 *
1815 * @see
1816 * - Landeskürzel siehe ISO-3166-2
1817 */
1818 ERICAPI_IMPORT int STDCALL EricMakeElsterEWAz(
1819 const byteChar *ewAzBescheid,
1820 const byteChar *landeskuerzel,
1821 EricRueckgabepufferHandle ewAzElsterPuffer);
1822
1823 /**
1824 * @brief Die @c bic wird auf Gültigkeit überprüft.
1825 *
1826 * Die Prüfung erfolgt in zwei Schritten: @mAbsatz
1827 * -# Formale Prüfung auf gültige Zeichen und richtige Länge.
1828 * -# Prüfung, ob das Länderkennzeichen für BIC gültig ist.
1829 *
1830 * Falls die BIC ungültig ist liefert die Funktion EricHoleFehlerText()
1831 * den zugehörigen Fehlertext.
1832 *
1833 * @param[in] bic Zeiger auf eine NULL-terminierte Zeichenkette.
1834 *
1835 * @return
1836 * - ::ERIC_OK
1837 * - ::ERIC_GLOBAL_BIC_FORMALER_FEHLER: Ungültige Zeichen, falsche Länge.
1838 * - ::ERIC_GLOBAL_BIC_LAENDERCODE_FEHLER
1839 * - ::ERIC_GLOBAL_NULL_PARAMETER: Parameter @c bic ist NULL.
1840 * - ::ERIC_GLOBAL_COMMONDATA_NICHT_VERFUEGBAR
1841 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
1842 * - ::ERIC_GLOBAL_UNKNOWN
1843 *
1844 * @see
1845 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "BIC ISO-Ländercodes"
1846 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "BIC-Prüfung"
1847 */
1848 ERICAPI_IMPORT int STDCALL EricPruefeBIC(
1849 const byteChar* bic);
1850
1851 /**
1852 * @brief Die @c iban wird auf Gültigkeit überprüft.
1853 *
1854 * Die Prüfung erfolgt in vier Schritten: @mAbsatz
1855 * -# Formale Prüfung auf gültige Zeichen und richtige Länge.
1856 * -# Prüfung, ob das Länderkennzeichen für IBAN gültig ist.
1857 * -# Prüfung, ob das länderspezifische Format gültig ist.
1858 * -# Prüfung, ob die Prüfziffer der IBAN gültig ist.
1859 *
1860 * Falls die IBAN ungültig ist, liefert die Funktion EricHoleFehlerText()
1861 * den zugehörigen Fehlertext.
1862 *
1863 * @param[in] iban Zeiger auf eine NULL-terminierte Zeichenkette.
1864 *
1865 * @return
1866 * - ::ERIC_OK
1867 * - ::ERIC_GLOBAL_IBAN_FORMALER_FEHLER: Ungültige Zeichen, falsche Länge.
1868 * - ::ERIC_GLOBAL_IBAN_LAENDERCODE_FEHLER
1869 * - ::ERIC_GLOBAL_IBAN_LANDESFORMAT_FEHLER
1870 * - ::ERIC_GLOBAL_IBAN_PRUEFZIFFER_FEHLER
1871 * - ::ERIC_GLOBAL_NULL_PARAMETER: Parameter @c iban ist NULL.
1872 * - ::ERIC_GLOBAL_COMMONDATA_NICHT_VERFUEGBAR
1873 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
1874 * - ::ERIC_GLOBAL_UNKNOWN
1875 *
1876 * @see
1877 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "IBAN - länderspezifische Formate"
1878 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "IBAN-Prüfung"
1879 *
1880 */
1881 ERICAPI_IMPORT int STDCALL EricPruefeIBAN(
1882 const byteChar* iban);
1883
1884 /**
1885 * @brief Überprüft ein @c Einheitswert-Aktenzeichen im ELSTER-Format auf Gültigkeit.
1886 *
1887 * @param[in] einheitswertAz
1888 * Zeiger auf ein Einheitswert-Aktenzeichen im ELSTER-Format
1889 *
1890 * @return
1891 * - ::ERIC_OK
1892 * - ::ERIC_GLOBAL_NULL_PARAMETER
1893 * - ::ERIC_GLOBAL_EWAZ_UNGUELTIG
1894 * - ::ERIC_GLOBAL_COMMONDATA_NICHT_VERFUEGBAR
1895 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
1896 * - ::ERIC_GLOBAL_UNKNOWN
1897 *
1898 */
1899 ERICAPI_IMPORT int STDCALL EricPruefeEWAz(
1900 const byteChar* einheitswertAz);
1901
1902 /**
1903 * @brief Die @c steuerId wird auf Gültigkeit überprüft.
1904 *
1905 * @param[in] steuerId
1906 * Steuer-Identifikationsnummer (IdNr)
1907 *
1908 * @return
1909 * - ::ERIC_OK
1910 * - ::ERIC_GLOBAL_NULL_PARAMETER
1911 * - ::ERIC_GLOBAL_IDNUMMER_UNGUELTIG
1912 * - ::ERIC_GLOBAL_COMMONDATA_NICHT_VERFUEGBAR
1913 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
1914 * - ::ERIC_GLOBAL_UNKNOWN
1915 *
1916 * @see
1917 * - EricPruefeSteuernummer()
1918 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Prüfung der Steueridentifikationsnummer (IdNr)"
1919 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Test-Steueridentifikationsnummer"
1920 */
1921 ERICAPI_IMPORT int STDCALL EricPruefeIdentifikationsMerkmal(
1922 const byteChar* steuerId);
1923
1924 /**
1925 * @brief Die @c steuernummer wird einschließlich Bundesfinanzamtsnummer
1926 * auf formale Richtigkeit geprüft.
1927 *
1928 * Zur Prüfung der Bundesfinanzamtsnummer wird
1929 * ::EricPruefeBuFaNummer() verwendet.
1930 *
1931 * Zur Erzeugung, Verwendung und Freigabe von Rückgabepuffern siehe Dokumentation
1932 * zu ::EricRueckgabepufferHandle.
1933 *
1934 * @param[in] steuernummer NULL-terminierte 13-stellige Steuernummer im
1935 * ELSTER-Steuernummernformat.
1936 *
1937 * @return
1938 * - ::ERIC_OK
1939 * - ::ERIC_GLOBAL_NULL_PARAMETER
1940 * - ::ERIC_GLOBAL_STEUERNUMMER_UNGUELTIG
1941 * - ::ERIC_GLOBAL_COMMONDATA_NICHT_VERFUEGBAR
1942 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
1943 * - ::ERIC_GLOBAL_UNKNOWN
1944 *
1945 * @see
1946 * - EricPruefeBuFaNummer()
1947 * - Pruefung_der_Steuer_und_Steueridentifikatsnummer.pdf, siehe \linkExt{https://www.elster.de/elsterweb/entwickler/infoseite/schnittstellenbeschreibungen,Entwicklerbereich} bei \linkExt{https://www.elster.de/eportal/start,ELSTER}.
1948 */
1949 ERICAPI_IMPORT int STDCALL EricPruefeSteuernummer(
1950 const byteChar* steuernummer);
1951
1952 /**
1953 * @brief Die @c Wirtschafts-Identifikationsnummer (@c W-IdNr.) wird auf formale Gültigkeit überprüft.
1954 *
1955 * @param[in] wIdNr
1956 * NULL-terminierte Wirtschafts-Identifikationsnummer
1957 * mit oder ohne Unterscheidungsmerkmal.
1958 *
1959 * @return
1960 * - ::ERIC_OK
1961 * - ::ERIC_GLOBAL_NULL_PARAMETER
1962 * - ::ERIC_GLOBAL_IDNUMMER_UNGUELTIG
1963 * - ::ERIC_GLOBAL_COMMONDATA_NICHT_VERFUEGBAR
1964 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
1965 * - ::ERIC_GLOBAL_UNKNOWN
1966 *
1967 * @see
1968 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Prüfung der Wirtschafts-Identifikationsnummer (W-IdNr.)"
1969 */
1970 ERICAPI_IMPORT int STDCALL EricPruefeWIdNr(
1971 const byteChar* wIdNr);
1972
1973 /**
1974 * @brief Prüft, ob die @c pin zum Zertifikat @c pathToKeystore passt.
1975 * Nicht anwendbar auf Ad Hoc-Zertifikate (AHZ), die für einen
1976 * neuen Personalausweis (nPA) ausgestellt sind.
1977 *
1978 * @param[in] pathToKeystore
1979 * @parblock
1980 * Folgende Zertifikatstypen werden unterstützt: @mAbsatz
1981 * 1. Clientseitig erzeugtes Zertifikat: @mLB<a>Pfad
1982 * zum Verzeichnis, in dem sich die Zertifikats-Datei (.cer)
1983 * und die Datei mit dem privaten Schlüssel (.p12) befinden.
1984 * Diese Kryptomittel wurden mit EricCreateKey() erzeugt.
1985 * Der Pfad zum Verzeichnis ist bei clientseitig erzeugten
1986 * Zertifikaten relativ zum aktuellen Arbeitsverzeichnis oder absolut
1987 * anzugeben.
1988 * 2. Software-Portalzertifikat: @mLB<a>Pfad
1989 * zur Software-Zertifikatsdatei (i.d.R. mit der Endung .pfx).
1990 * Der Pfad zur Datei ist bei Software-Zertifikaten relativ zum
1991 * aktuellen Arbeitsverzeichnis oder absolut anzugeben.
1992 * 3. Sicherheitsstick: @mLB<a>Pfad
1993 * zur Treiberdatei, siehe (2). Bitte beachten, dass der Treiber
1994 * betriebssystemabhängig sein kann. Weitere Informationen in der
1995 * Anleitung zum Sicherheitsstick oder unter
1996 * \linkExt{https://www.sicherheitsstick.de,https://www.sicherheitsstick.de}.
1997 * 4. Signaturkarte: @mLB<a>Pfad
1998 * zur Treiberdatei, welcher einen Zugriff auf die
1999 * Signaturkarte ermöglicht, siehe (2). Weitere Informationen in
2000 * der Anleitung zur Signaturkarte.
2001 * @endparblock
2002 * @param[in] pin
2003 * PIN für den Zugriff auf den privaten Schlüssel des Zertifikats.
2004 * @param[in] keyType
2005 * @parblock
2006 * Mögliche Eingabewerte: @mAbsatz
2007 * - 0: eSignatureKey: Schlüssel für die Signatur von Daten, siehe (1).
2008 * - 1: eEncryptionKey: Schlüssel für die Verschlüsselung von Daten, siehe (1).
2009 * @endparblock
2010 *
2011 * (1) Bei einem Zertifikat wie dem mit EricCreateKey() clientseitig
2012 * erzeugten Zertifikat (CEZ), das nur einen einzigen, gemeinsamen Schlüssel
2013 * für Signatur und Verschlüsselung besitzt, sind beide Eingabewerte
2014 * erlaubt. Die Werte beziehen sich dann beide auf denselben Schlüssel.
2015 *
2016 * (2) Bei Sicherheitssticks und Signaturkarten ist bei der Angabe
2017 * des Treibers der Suchmechanismus nach dynamischen Modulen des
2018 * jeweiligen Betriebssystems zu berücksichtigen. Weitere
2019 * Informationen sind z.B. unter Windows der Dokumentation der
2020 * <tt>LoadLibrary()</tt> oder unter Linux und macOS der Dokumentation der
2021 * <tt>dlopen()</tt> zu entnehmen.
2022 *
2023 * Pfade müssen auf Windows in der für Datei-Funktionen benutzten ANSI-Codepage,
2024 * auf Linux, AIX und Linux Power in der für das Dateisystem benutzten Locale
2025 * und auf macOS in der "decomposed form" von UTF-8 übergeben werden.
2026 * Bitte weitere Betriebssystemspezifika bzgl. nicht erlaubter Zeichen in
2027 * Pfaden und Pfadtrennzeichen beachten.
2028 *
2029 * Für Details zu Pfaden im ERiC siehe @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kapitel
2030 * "Übergabe von Pfaden an ERiC API-Funktionen".
2031 *
2032 * Es wird empfohlen, geöffnete Zertifikatshandle zu schließen, bevor mit
2033 * der API-Funktion EricPruefeZertifikatPin() das gewünschte Zertifikat geprüft wird.
2034 *
2035 * @note Eine falsche PIN-Eingabe erhöht bei Sicherheitsstick und Signaturkarte den
2036 * Zähler für Fehlversuche. Welche Zertifikatstypen aufgrund von 3 Fehlversuchen
2037 * gesperrt werden, ist im @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap.
2038 * "Das Portalzertifikat (POZ)" beschrieben.
2039 *
2040 * @return
2041 * - ::ERIC_OK
2042 * - ::ERIC_CRYPT_E_PIN_WRONG
2043 * - ::ERIC_CRYPT_NICHT_UNTERSTUETZTES_PSE_FORMAT
2044 * - ::ERIC_CRYPT_EIDKARTE_NICHT_UNTERSTUETZT
2045 * - ::ERIC_CRYPT_E_PSE_PATH
2046 * - ::ERIC_GLOBAL_NULL_PARAMETER
2047 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
2048 * - ::ERIC_GLOBAL_UNKNOWN
2049 */
2050 ERICAPI_IMPORT int STDCALL EricPruefeZertifikatPin(
2051 const byteChar *pathToKeystore,
2052 const byteChar *pin,
2053 uint32_t keyType);
2054
2055 /**
2056 * @brief Die @c funktion wird als Callback-Funktion für
2057 * ::EricBearbeiteVorgang() registriert.
2058 *
2059 * Die registrierte Callback-Funktion wird von der Funktion
2060 * ::EricBearbeiteVorgang() aufgerufen, um bei der Verarbeitung
2061 * den Fortschritt der einzelnen Arbeitsbereiche anzuzeigen.
2062 *
2063 * @param[in] funktion Zeiger auf die zu registrierende Funktion oder \c NULL
2064 * @param[in] benutzerdaten Zeiger, der der registrierten Funktion immer
2065 * mitgegeben wird. Die Anwendung kann diesen Parameter
2066 * dazu verwenden, einen Zeiger auf eigene Daten oder
2067 * Funktionen an die zu registrierende Funktion
2068 * übergeben zu lassen.
2069 *
2070 * @return
2071 * - ::ERIC_OK
2072 * - ::ERIC_GLOBAL_UNGUELTIGER_PARAMETER
2073 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
2074 * - ::ERIC_GLOBAL_UNKNOWN
2075 *
2076 * @remark
2077 * - Wenn eine zuvor registrierte Funktion nicht mehr aufgerufen
2078 * werden soll, ist ::EricRegistriereFortschrittCallback() mit dem
2079 * Wert \c NULL im Parameter \c funktion aufzurufen.
2080 * - Es ist nicht erlaubt eine ERiC API-Funktion aus einer Callback-Funktion aufzurufen.
2081 * - Die Verarbeitung im Callback findet synchron statt.
2082 * Deshalb sollte der Callback sehr schnell ausgeführt werden.
2083 *
2084 * @see
2085 * - EricFortschrittCallback
2086 * - EricBearbeiteVorgang()
2087 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Funktionen für Fortschrittcallbacks"
2088 *
2089 */
2090 ERICAPI_IMPORT int STDCALL EricRegistriereFortschrittCallback(
2091 EricFortschrittCallback funktion,
2092 void* benutzerdaten);
2093
2094 /**
2095 * @brief Die registrierte @c funktion wird als Callback-Funktion
2096 * von ::EricBearbeiteVorgang() aufgerufen und zeigt den
2097 * Gesamtfortschritt der Verarbeitung an.
2098 *
2099 * @param[in] funktion Zeiger auf die zu registrierende Funktion oder \c NULL
2100 * @param[in] benutzerdaten Zeiger, der der registrierten Funktion immer
2101 * mitgegeben wird. Die Anwendung kann diesen Parameter
2102 * dazu verwenden, einen Zeiger auf eigene Daten oder
2103 * Funktionen an die zu registrierende Funktion
2104 * übergeben zu lassen.
2105 *
2106 * @return
2107 * - ::ERIC_OK
2108 * - ::ERIC_GLOBAL_UNGUELTIGER_PARAMETER
2109 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
2110 * - ::ERIC_GLOBAL_UNKNOWN
2111 *
2112 * @remark
2113 * - Wenn eine zuvor registrierte Funktion nicht mehr aufgerufen
2114 * werden soll, ist ::EricRegistriereGlobalenFortschrittCallback()
2115 * mit dem Wert \c NULL im Parameter \c funktion aufzurufen.
2116 * - Es ist nicht erlaubt eine ERiC API-Funktion aus einer
2117 * Callback-Funktion aufzurufen.
2118 * - Die Verarbeitung im Callback findet synchron statt.
2119 * Deshalb sollte der Callback sehr schnell ausgeführt werden.
2120 *
2121 * @see
2122 * - EricBearbeiteVorgang()
2123 * - @typeDokumentation{ERiC-Entwicklerhandbuch.pdf}, Kap. "Funktionen für Fortschrittcallbacks"
2124 */
2125 ERICAPI_IMPORT int STDCALL EricRegistriereGlobalenFortschrittCallback(
2126 EricFortschrittCallback funktion,
2127 void* benutzerdaten);
2128
2129 /**
2130 * @brief Die registrierte @c funktion wird als Callback-Funktion für
2131 * jede Lognachricht aufgerufen.
2132 * Die Ausgabe entspricht einer Zeile im eric.log.
2133 *
2134 * @param[in] funktion Zeiger auf die zu registrierende Funktion oder NULL.
2135 * @param[in] schreibeEricLogDatei
2136 * @parblock
2137 * Log-Nachrichten im eric.log: @mAbsatz
2138 * - \c 1 Jede Log-Nachricht wird nach eric.log geschrieben.
2139 * Der Parameter \c funktion kann auf eine
2140 * Funktion zeigen oder \c NULL sein.
2141 * - \c 0 Falls \c funktion \c != \c NULL werden keine Log-Nachrichten
2142 * nach eric.log geschrieben, andernfalls werden die
2143 * Log-Nachrichten nach eric.log geschrieben.
2144 * @endparblock
2145 * @param[in] benutzerdaten
2146 * @parblock
2147 * Zeiger, welcher der registrierten Funktion immer
2148 * mitgegeben wird.
2149 *
2150 * Die Anwendung kann diesen Parameter
2151 * dazu verwenden, einen Zeiger auf eigene Daten oder
2152 * Funktionen an die zu registrierende Funktion
2153 * übergeben zu lassen.
2154 * @endparblock
2155 *
2156 * @return
2157 * - ::ERIC_OK
2158 * - ::ERIC_GLOBAL_UNGUELTIGER_PARAMETER
2159 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
2160 * - ::ERIC_GLOBAL_UNKNOWN
2161 *
2162 * @remark
2163 * - Wenn eine zuvor registrierte Funktion nicht mehr aufgerufen
2164 * werden soll, ist ::EricRegistriereLogCallback() mit dem Wert
2165 * \c NULL im Parameter \c funktion aufzurufen (=Deregistrierung).
2166 * - Vor dem Beenden der Steueranwendung ist eine registrierte
2167 * Funktion zu deregistrieren, da es sonst zu einem Absturz
2168 * kommen kann.
2169 * - Es ist nicht erlaubt eine ERiC API-Funktion aus einer
2170 * Callback-Funktion aufzurufen.
2171 * - Die Verarbeitung im Callback findet synchron statt.
2172 * Deshalb sollte der Callback sehr schnell ausgeführt werden.
2173 *
2174 */
2175 ERICAPI_IMPORT int STDCALL EricRegistriereLogCallback(
2176 EricLogCallback funktion,
2177 uint32_t schreibeEricLogDatei,
2178 void* benutzerdaten);
2179
2180 /**
2181 * @brief Diese API-Funktion erzeugt einen Rückgabepuffer und gibt
2182 * ein Handle darauf zurück.
2183 *
2184 * Die von dieser Funktion erzeugten Rückgabepuffer werden verwendet, um
2185 * die Ausgaben von ERiC-Funktionen (z.B. EricBearbeiteVorgang())
2186 * aufzunehmen. Dazu wird das Rückgabepuffer-Handle für den Schreibvorgang
2187 * an die ausgebende Funktion übergeben.
2188 *
2189 * Zum Auslesen des von den API-Funktionen beschriebenen Puffers wird das
2190 * Rückgabepuffer-Handle an EricRueckgabepufferInhalt() übergeben.
2191 * Ein einmal erzeugtes Rückgabepuffer-Handle kann für weitere nachfolgende
2192 * Aufrufe von ERiC API-Funktionen wiederverwendet werden. Bei einer
2193 * Wiederverwendung eines Handles werden frühere Inhalte überschrieben.
2194 * Nach Verwendung muss jeder Rückgabepuffer mit
2195 * EricRueckgabepufferFreigeben() freigegeben werden.
2196 *
2197 * Rückgabepuffer sind der Singlethreading-API bzw. einer ERiC-Instanz der
2198 * Multithreading-API fest zugeordnet. Die Funktionen der ERiC API, die
2199 * einen Rückgabepuffer entgegennehmen, geben den Fehlercode
2200 * ::ERIC_GLOBAL_PUFFER_UNGLEICHER_INSTANZ zurück, wenn der übergebene
2201 * Rückgabepuffer: @mAbsatz
2202 * - mit der Singlethreading-API erzeugt worden ist und dann mit der
2203 * Multithreading-API verwendet wird.
2204 * - mit der Multithreading-API erzeugt worden ist und dann mit der
2205 * Singlethreading-API verwendet wird.
2206 * - mit einer ERiC-Instanz erzeugt worden ist und dann mit einer
2207 * anderen Instanz verwendet wird.
2208 *
2209 *
2210 * @return
2211 * - ::EricRueckgabepufferHandle im Erfolgsfall.
2212 * - NULL im Fehlerfall.
2213 *
2214 * @see
2215 * - EricRueckgabepufferLaenge()
2216 * - EricRueckgabepufferInhalt()
2217 * - EricRueckgabepufferFreigeben()
2218 */
2219 ERICAPI_IMPORT EricRueckgabepufferHandle STDCALL EricRueckgabepufferErzeugen(
2220 void);
2221
2222 /**
2223 * @brief Der durch das @c handle bezeichnete Rückgabepuffer wird
2224 * freigegeben.
2225 *
2226 * Das Handle darf danach nicht weiter verwendet werden. Es wird daher
2227 * empfohlen, Handle-Variablen nach der Freigabe explizit auf
2228 * NULL zu setzen.
2229 *
2230 * @param[in] handle Handle auf einen mit EricRueckgabepufferErzeugen().
2231 * angelegten Rückgabepuffer. Dieser Rückgabepuffer darf nicht
2232 * bereits freigegeben worden sein.
2233 *
2234 * @return
2235 * - ::ERIC_OK
2236 * - ::ERIC_GLOBAL_UNGUELTIGER_PARAMETER
2237 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
2238 * - ::ERIC_GLOBAL_UNKNOWN
2239 *
2240 * @see
2241 * - EricRueckgabepufferErzeugen()
2242 * - EricRueckgabepufferLaenge()
2243 * - EricRueckgabepufferInhalt()
2244 */
2245 ERICAPI_IMPORT int STDCALL EricRueckgabepufferFreigeben(
2246 EricRueckgabepufferHandle handle);
2247
2248 /**
2249 * @brief Der durch das @c handle bezeichnete Inhalt des Rückgabepuffers wird zurückgegeben.
2250 *
2251 * Der zurückgegebene Zeiger verweist auf ein Byte-Array, das alle in
2252 * den Rückgabepuffer geschriebenen Bytes sowie eine abschließende
2253 * NULL-Terminierung enthält. Dieses Array existiert so lange im Speicher,
2254 * bis der Rückgabepuffer entweder (bei einer Wiederverwendung des Handles)
2255 * erneut beschrieben oder der Puffer explizit freigegeben wird.
2256 *
2257 * @param[in] handle Handle auf einen mit EricRueckgabepufferErzeugen().
2258 * angelegten Rückgabepuffer. Dieser Rückgabepuffer darf nicht
2259 * bereits freigegeben worden sein.
2260 *
2261 * @return
2262 * - Zeiger auf den NULL-terminierten Rückgabepufferinhalt, wenn ein gültiges Handle übergeben wird.
2263 * - NULL: Bei Übergabe des ungültigen Handles NULL.
2264 *
2265 * @see
2266 * - EricRueckgabepufferErzeugen()
2267 * - EricRueckgabepufferLaenge()
2268 * - EricRueckgabepufferFreigeben()
2269 */
2270 ERICAPI_IMPORT const char* STDCALL EricRueckgabepufferInhalt(
2271 EricRueckgabepufferHandle handle);
2272
2273 /**
2274 * @brief Die Länge des Rückgabepufferinhalts wird zurückgegeben.
2275 *
2276 * Die zurückgegebene Zahl entspricht der Anzahl von Bytes, die von einer
2277 * zuvor aufgerufenen ERiC API-Funktion in den Rückgabepuffer geschrieben
2278 * wurden.
2279 * Die NULL-Terminierung, die bei Aufruf von EricRueckgabepufferInhalt() an
2280 * das zurückgegebene Byte-Array angefügt wird, wird bei dieser
2281 * Längenangabe nicht berücksichtigt.
2282 *
2283 * @param[in] handle Handle auf einen mit EricRueckgabepufferErzeugen()
2284 * angelegten Rückgabepuffer. Dieser Rückgabepuffer darf nicht
2285 * bereits freigegeben worden sein.
2286 *
2287 * @return
2288 * - Anzahl der in den Rückgabepuffer geschriebenen Bytes, wenn ein gültiges Handle übergeben wird.
2289 * - 0: Bei Übergabe des ungültigen Handles NULL.
2290 *
2291 * @see
2292 * - EricRueckgabepufferErzeugen()
2293 * - EricRueckgabepufferInhalt()
2294 * - EricRueckgabepufferFreigeben()
2295 */
2296 ERICAPI_IMPORT uint32_t STDCALL EricRueckgabepufferLaenge(
2297 EricRueckgabepufferHandle handle);
2298
2299 /**
2300 * @brief Es werden Plattform-, Betriebssystem- und
2301 * ERiC-Informationen ausgegeben.
2302 *
2303 * Diese Funktion liefert Informationen über die
2304 * verwendeten ERiC-Bibliotheken, ERiC-Druckvorlagen,
2305 * die eingesetzte Plattform, den Arbeitsspeicher und
2306 * das verwendete Betriebssystem.
2307 *
2308 *
2309 * @return
2310 * - ::ERIC_OK
2311 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
2312 * - weitere, siehe eric_fehlercodes.h
2313 *
2314 * @see
2315 * - EricVersion()
2316 */
2317 ERICAPI_IMPORT int STDCALL EricSystemCheck(
2318 void);
2319
2320 /**
2321 * @brief Es wird eine Liste sämtlicher Produkt- und Dateiversionen
2322 * der verwendeten ERiC-Bibliotheken als XML-Daten zurückgegeben.
2323 *
2324 * Diese Funktion kann bei auftretenden Fehlern die
2325 * Fehlersuche beschleunigen und Supportfälle unterstützen.
2326 *
2327 * @param[out] rueckgabeXmlPuffer
2328 * @parblock
2329 * Handle auf einen Rückgabepuffer, in den
2330 * zu allen ERiC-Bibliotheken die Produkt- und Dateiversionen
2331 * als XML-Daten nach XML Schema Definition @lsAPI-Rueckgabe-Schemata{Dokumentation\API-Rueckgabe-Schemata\EricVersion.xsd}
2332 * geschrieben werden.
2333 *
2334 * Zur Erzeugung, Verwendung und Freigabe von Rückgabepuffern
2335 * siehe Dokumentation zu ::EricRueckgabepufferHandle.
2336 * @endparblock
2337 *
2338 * \b Beispiel:
2339 * \code{.xml}
2340 * <?xml version="1.0" encoding="UTF-8"?>
2341 * <EricVersion xmlns="http://www.elster.de/EricXML/1.0/EricVersion">
2342 * <Bibliothek>
2343 * <Name>ericapi.dll</Name>
2344 * <Produktversion>99, 1, 2, 32767</Produktversion>
2345 * <Dateiversion>2008, 3, 5, 0</Dateiversion>
2346 * </Bibliothek>
2347 * <Bibliothek>
2348 * <Name>ericctrl.dll</Name>
2349 * <Produktversion>99, 1, 2, 32767</Produktversion>
2350 * <Dateiversion>2008, 3, 5, 0</Dateiversion>
2351 * </Bibliothek>
2352 * (...)
2353 * </EricVersion>
2354 * \endcode
2355 *
2356 * @return
2357 * - ::ERIC_OK
2358 * - ::ERIC_GLOBAL_NULL_PARAMETER
2359 * - ::ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER
2360 * - weitere, siehe eric_fehlercodes.h
2361 *
2362 * @see
2363 * - EricSystemCheck()
2364 */
2365 ERICAPI_IMPORT int STDCALL EricVersion(
2366 EricRueckgabepufferHandle rueckgabeXmlPuffer);
2367
2368#ifdef __cplusplus
2369}
2370#endif
2371
2372#endif /*ERICAPI_C_H_*/
eric_types.h
Definition von Datenstrukturen und Datentypen.
byteChar
char byteChar
Der Datentyp byteChar wird immer dann verwendet, wenn an diesem Parameter keine UTF-8 codierte Daten ...
Definition eric_types.h:53
EricRueckgabepufferHandle
struct EricReturnBufferApi * EricRueckgabepufferHandle
Handle zur Verwaltung und Verwendung von Rückgabepuffern.
Definition eric_types.h:175
EricTransferHandle
uint32_t EricTransferHandle
Das EricTransferHandle wird beim Anwendungsfall "Datenabholung" der API-Funktion EricBearbeiteVorgang...
Definition eric_types.h:84
EricZertifikatHandle
uint32_t EricZertifikatHandle
Integer-Typ für Zertifikat-Handles.
Definition eric_types.h:59
EricFortschrittCallback
void(* EricFortschrittCallback)(uint32_t id, uint32_t pos, uint32_t max, void *benutzerdaten)
Typ der Callback-Funktionen, die am ERiC für Fortschrittanzeigen registriert werden können.
Definition eric_types.h:534
EricLogCallback
void(* EricLogCallback)(const char *kategorie, eric_log_level_t loglevel, const char *nachricht, void *benutzerdaten)
Typ der Callback-Funktion zum Logging.
Definition eric_types.h:472
EricPruefeBuFaNummer
ERICAPI_IMPORT int EricPruefeBuFaNummer(const byteChar *steuernummer)
Die Bundesfinanzamtsnummer wird überprüft.
EricHoleFinanzamtLandNummern
ERICAPI_IMPORT int EricHoleFinanzamtLandNummern(EricRueckgabepufferHandle rueckgabeXmlPuffer)
Die Liste aller Finanzamtlandnummern wird zurückgegeben.
EricCreateTH
ERICAPI_IMPORT int EricCreateTH(const char *xml, const char *verfahren, const char *datenart, const char *vorgang, const char *testmerker, const char *herstellerId, const char *datenLieferant, const char *versionClient, const byteChar *publicKey, EricRueckgabepufferHandle xmlRueckgabePuffer)
Diese Funktion erzeugt einen TransferHeader.
EricRueckgabepufferInhalt
ERICAPI_IMPORT const char * EricRueckgabepufferInhalt(EricRueckgabepufferHandle handle)
Der durch das handle bezeichnete Inhalt des Rückgabepuffers wird zurückgegeben.
EricCheckXML
ERICAPI_IMPORT int EricCheckXML(const char *xml, const char *datenartVersion, EricRueckgabepufferHandle fehlertextPuffer)
Das xml wird gegen das Schema der datenartVersion validiert.
EricVersion
ERICAPI_IMPORT int EricVersion(EricRueckgabepufferHandle rueckgabeXmlPuffer)
Es wird eine Liste sämtlicher Produkt- und Dateiversionen der verwendeten ERiC-Bibliotheken als XML-D...
EricGetPublicKey
ERICAPI_IMPORT int EricGetPublicKey(const eric_verschluesselungs_parameter_t *cryptoParameter, EricRueckgabepufferHandle rueckgabePuffer)
Es wird der öffentliche Schlüssel als base64-kodierte Zeichenkette für das übergebene Zertifikat-Hand...
EricGetPinStatus
ERICAPI_IMPORT int EricGetPinStatus(EricZertifikatHandle hToken, uint32_t *pinStatus, uint32_t keyType)
Der PIN-Status wird für ein passwortgeschütztes Kryptomittel abgefragt und in pinStatus zurückgegeben...
EricMakeElsterEWAz
ERICAPI_IMPORT int EricMakeElsterEWAz(const byteChar *ewAzBescheid, const byteChar *landeskuerzel, EricRueckgabepufferHandle ewAzElsterPuffer)
Konvertiert ein Einheitswert-Aktenzeichen in das ELSTER-Format.
EricMakeElsterStnr
ERICAPI_IMPORT int EricMakeElsterStnr(const byteChar *steuernrBescheid, const byteChar landesnr[2+1], const byteChar bundesfinanzamtsnr[4+1], EricRueckgabepufferHandle steuernrPuffer)
Es wird eine Steuernummer im ELSTER-Steuernummerformat erzeugt.
EricRueckgabepufferFreigeben
ERICAPI_IMPORT int EricRueckgabepufferFreigeben(EricRueckgabepufferHandle handle)
Der durch das handle bezeichnete Rückgabepuffer wird freigegeben.
EricBearbeiteVorgang
ERICAPI_IMPORT int EricBearbeiteVorgang(const char *datenpuffer, const char *datenartVersion, uint32_t bearbeitungsFlags, const eric_druck_parameter_t *druckParameter, const eric_verschluesselungs_parameter_t *cryptoParameter, EricTransferHandle *transferHandle, EricRueckgabepufferHandle rueckgabeXmlPuffer, EricRueckgabepufferHandle serverantwortXmlPuffer)
Diese API-Funktion ist die zentrale Schnittstellenfunktion zur Kommunikation mit dem ELSTER-Annahmese...
EricHoleFehlerText
ERICAPI_IMPORT int EricHoleFehlerText(int fehlerkode, EricRueckgabepufferHandle rueckgabePuffer)
Es wird die Klartextfehlermeldung zu dem fehlerkode ermittelt.
EricCloseHandleToCertificate
ERICAPI_IMPORT int EricCloseHandleToCertificate(EricZertifikatHandle hToken)
Das Zertifikat-Handle hToken wird freigegeben.
EricSystemCheck
ERICAPI_IMPORT int EricSystemCheck(void)
Es werden Plattform-, Betriebssystem- und ERiC-Informationen ausgegeben.
EricFormatEWAz
ERICAPI_IMPORT int EricFormatEWAz(const byteChar *ewAzElster, EricRueckgabepufferHandle ewAzBescheidPuffer)
Konvertiert ein Einheitswert-Aktenzeichen im ELSTER-Format in ein landesspezifisches Bescheidformat.
EricPruefeZertifikatPin
ERICAPI_IMPORT int EricPruefeZertifikatPin(const byteChar *pathToKeystore, const byteChar *pin, uint32_t keyType)
Prüft, ob die pin zum Zertifikat pathToKeystore passt. Nicht anwendbar auf Ad Hoc-Zertifikate (AHZ),...
EricDekodiereDaten
ERICAPI_IMPORT int EricDekodiereDaten(EricZertifikatHandle zertifikatHandle, const byteChar *pin, const byteChar *base64Eingabe, EricRueckgabepufferHandle rueckgabePuffer)
Es werden die mit der Datenabholung abgeholten und verschlüsselten Daten entschlüsselt.
EricRueckgabepufferLaenge
ERICAPI_IMPORT uint32_t EricRueckgabepufferLaenge(EricRueckgabepufferHandle handle)
Die Länge des Rückgabepufferinhalts wird zurückgegeben.
EricEinstellungZuruecksetzen
ERICAPI_IMPORT int EricEinstellungZuruecksetzen(const char *name)
Der Wert der API-Einstellung name wird auf den Standardwert zurückgesetzt.
EricPruefeBIC
ERICAPI_IMPORT int EricPruefeBIC(const byteChar *bic)
Die bic wird auf Gültigkeit überprüft.
EricEinstellungSetzen
ERICAPI_IMPORT int EricEinstellungSetzen(const char *name, const char *wert)
Die API-Einstellung name wird auf den wert gesetzt.
EricHoleFinanzamtsdaten
ERICAPI_IMPORT int EricHoleFinanzamtsdaten(const byteChar bufaNr[5], EricRueckgabepufferHandle rueckgabeXmlPuffer)
Die finanzamtsdaten werden für eine Bundesfinanzamtsnummer zurückgegeben.
EricPruefeIdentifikationsMerkmal
ERICAPI_IMPORT int EricPruefeIdentifikationsMerkmal(const byteChar *steuerId)
Die steuerId wird auf Gültigkeit überprüft.
EricRegistriereFortschrittCallback
ERICAPI_IMPORT int EricRegistriereFortschrittCallback(EricFortschrittCallback funktion, void *benutzerdaten)
Die funktion wird als Callback-Funktion für EricBearbeiteVorgang() registriert.
EricInitialisiere
ERICAPI_IMPORT int EricInitialisiere(const byteChar *pluginPfad, const byteChar *logPfad)
Initialisiert den Singlethreading-ERiC.
EricChangePassword
ERICAPI_IMPORT int EricChangePassword(const byteChar *psePath, const byteChar *oldPin, const byteChar *newPin)
Die PIN für ein clientseitig erzeugtes Zertifikat (CEZ) wird geändert.
EricPruefeIBAN
ERICAPI_IMPORT int EricPruefeIBAN(const byteChar *iban)
Die iban wird auf Gültigkeit überprüft.
EricRegistriereGlobalenFortschrittCallback
ERICAPI_IMPORT int EricRegistriereGlobalenFortschrittCallback(EricFortschrittCallback funktion, void *benutzerdaten)
Die registrierte funktion wird als Callback-Funktion von EricBearbeiteVorgang() aufgerufen und zeigt ...
EricHoleFinanzaemter
ERICAPI_IMPORT int EricHoleFinanzaemter(const byteChar *finanzamtLandNummer, EricRueckgabepufferHandle rueckgabeXmlPuffer)
Es wird die Finanzamtliste für eine bestimmte finanzamtLandNummer zurückgegeben.
EricPruefeWIdNr
ERICAPI_IMPORT int EricPruefeWIdNr(const byteChar *wIdNr)
Die Wirtschafts-Identifikationsnummer (W-IdNr.) wird auf formale Gültigkeit überprüft.
EricRueckgabepufferErzeugen
ERICAPI_IMPORT EricRueckgabepufferHandle EricRueckgabepufferErzeugen(void)
Diese API-Funktion erzeugt einen Rückgabepuffer und gibt ein Handle darauf zurück.
EricEinstellungLesen
ERICAPI_IMPORT int EricEinstellungLesen(const char *name, EricRueckgabepufferHandle rueckgabePuffer)
Der Wert der API-Einstellung name wird im rueckgabePuffer zurückgeliefert.
EricEntladePlugins
ERICAPI_IMPORT int EricEntladePlugins(void)
Alle verwendeten Plugin-Bibliotheken werden entladen und deren Speicher wird freigegeben.
EricBeende
ERICAPI_IMPORT int EricBeende(void)
Beendet den Singlethreading-ERiC.
EricHoleZertifikatFingerabdruck
ERICAPI_IMPORT int EricHoleZertifikatFingerabdruck(const eric_verschluesselungs_parameter_t *cryptoParameter, EricRueckgabepufferHandle fingerabdruckPuffer, EricRueckgabepufferHandle signaturPuffer)
Der Fingerabdruck und dessen Signatur wird für das übergebene Zertifikat zurückgegeben.
EricPruefeSteuernummer
ERICAPI_IMPORT int EricPruefeSteuernummer(const byteChar *steuernummer)
Die steuernummer wird einschließlich Bundesfinanzamtsnummer auf formale Richtigkeit geprüft.
EricGetAuswahlListen
ERICAPI_IMPORT int EricGetAuswahlListen(const char *datenartVersion, const char *feldkennung, EricRueckgabepufferHandle rueckgabeXmlPuffer)
Die Auswahlliste(n) für datenartVersion oder feldkennung wird zurückgeliefert.
EricHoleTestfinanzaemter
ERICAPI_IMPORT int EricHoleTestfinanzaemter(EricRueckgabepufferHandle rueckgabeXmlPuffer)
Die Testfinanzamtliste wird in rueckgabeXmlPuffer zurückgegeben.
EricPruefeEWAz
ERICAPI_IMPORT int EricPruefeEWAz(const byteChar *einheitswertAz)
Überprüft ein Einheitswert-Aktenzeichen im ELSTER-Format auf Gültigkeit.
EricZertifikatOeffnenAusBytes
ERICAPI_IMPORT int EricZertifikatOeffnenAusBytes(EricZertifikatHandle *hToken, const byteChar *pkcs12Container, uint32_t containerGroesse, const byteChar *pkcs12Passwort)
Für das im Speicher übergebene Zertifikat wird das Handle hToken zurückgeliefert.
EricGetErrormessagesFromXMLAnswer
ERICAPI_IMPORT int EricGetErrormessagesFromXMLAnswer(const char *xml, EricRueckgabepufferHandle transferticketPuffer, EricRueckgabepufferHandle returncodeTHPuffer, EricRueckgabepufferHandle fehlertextTHPuffer, EricRueckgabepufferHandle returncodesUndFehlertexteNDHXmlPuffer)
Aus dem Antwort-XML des Finanzamtservers wird das Transferticket und Returncodes/Fehlermeldungen zurü...
EricCreateKey
ERICAPI_IMPORT int EricCreateKey(const byteChar *pin, const byteChar *pfad, const eric_zertifikat_parameter_t *zertifikatInfo)
Es werden die Kryptomittel für ein clientseitig erzeugtes Zertifikat (CEZ) in einem Verzeichnis des D...
EricHoleZertifikatEigenschaften
ERICAPI_IMPORT int EricHoleZertifikatEigenschaften(EricZertifikatHandle hToken, const byteChar *pin, EricRueckgabepufferHandle rueckgabeXmlPuffer)
Die Eigenschaften des übergebenen Zertifikats werden im rueckgabeXmlPuffer zurückgegeben.
EricRegistriereLogCallback
ERICAPI_IMPORT int EricRegistriereLogCallback(EricLogCallback funktion, uint32_t schreibeEricLogDatei, void *benutzerdaten)
Die registrierte funktion wird als Callback-Funktion für jede Lognachricht aufgerufen....
EricGetHandleToCertificate
ERICAPI_IMPORT int EricGetHandleToCertificate(EricZertifikatHandle *hToken, uint32_t *iInfoPinSupport, const byteChar *pathToKeystore)
Für das übergebene Zertifikat in pathToKeystore wird das Handle hToken und die unterstützten PIN-Wert...
EricFormatStNr
ERICAPI_IMPORT int EricFormatStNr(const byteChar *eingabeSteuernummer, EricRueckgabepufferHandle rueckgabePuffer)
Die Steuernummer eingabeSteuernummer wird in das Bescheid-Format des jeweiligen Bundeslandes umgewand...
EricEinstellungAlleZuruecksetzen
ERICAPI_IMPORT int EricEinstellungAlleZuruecksetzen(void)
Alle Einstellungen werden auf den jeweiligen Standardwert zurückgesetzt.
EricCreateUUID
ERICAPI_IMPORT int EricCreateUUID(EricRueckgabepufferHandle uuidRueckgabePuffer)
Erzeugt einen Version 4 Universally Unique Identifier (UUID) gemäß RFC 4122.
ERICAPI_IMPORT
#define ERICAPI_IMPORT
Definition ericapiExport.h:30
uint32_t
__plattformabhaengige_Implementierung__ uint32_t
Definition platform.h:211
eric_druck_parameter_t
Diese Struktur enthält alle für den Druck notwendigen Informationen.
Definition eric_types.h:228
eric_verschluesselungs_parameter_t
Für die Signatur oder Authentifizierung benötigte Informationen.
Definition eric_types.h:324
eric_zertifikat_parameter_t
Struktur mit Informationen zur Erzeugung von Zertifikaten mit EricCreateKey().
Definition eric_types.h:357