ERiC API-Referenz 43.3.2.0

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