KONTOPRUEF-OFFLINE mit Linux

Inhalt dieser Seite:

• Allgemeines
• Installation von Compilern
  • CentOS / Fedora / Red Hat (32-bit)
  • CentOS / Fedora / Red Hat (64-bit)
  • Debian (32-bit)
  • Debian (64-bit)
  • OpenSuse (32-bit)
  • OpenSuse (64-bit)
  • Ubuntu (32-bit)
  • Ubuntu Desktop (64-bit)
  • Ubuntu Server (64-bit)
• "Hello World": Das erste Miniprogramm
• Weitere Schritte
• Update-Funktion
• Verwendung mit PHP
  • SEPA-Konvertierung
  • Erzeugen einer SEPA-XML-Lastschriftdatei

Allgemeines

KONTOPRUEF-OFFLINE liegt grundsätzlich nur in einer 32-bit-Version vor (und daran wird sich bis auf weiteres auch nichts ändern). Dennoch können Sie KONTOPRUEF-OFFLINE auch auf 64-bit-Systemen einsetzen, mit der einzigen Einschränkung, dass das Hauptprogramm, zu dem Sie die KONTOPRUEF-Bibliotheken linken, ebenfalls mit 32-bit compiliert sein muss. (Dies verhindert den Einsatz der KONTOPRUEF-PHP-Extension auf 64-bit-Systemen, auf denen PHP gewöhnlich in der 64-bit-Version aus dem Package Repository installiert wird, aber auch dafür gibt es Auswege – siehe unten.)

KONTOPRUEF-OFFLINE für Linux liegt als Satz von dynamisch ladbaren Bibliotheken (.so-Dateien, "Shared Libraries") vor, die dazu gedacht sind, aus eigenen C-Programmen heraus aufgerufen zu werden. Falls Sie sich nicht auf die Verwendung der KONTOPRUEF-PHP-Extension beschränken (die zudem nur auf 32-bit-Systemen möglich ist), kommen Sie um ein wenig C-Programmierung also nicht herum. Dies bietet Ihnen aber eine Reihe von Vorteilen:

• Volle Flexibilität: Sie sind nicht auf irgendwelche vordefinierten Funktionen beschränkt, sondern können jegliche benötigte Funktionalität erstellen.
• Sie können alle KONTOPRUEF-OFFLINE-Funktionen ohne Einschränkung benutzen.
• Sie können die von Ihnen erstellten Programme sowohl auf 32-bit- als auch auf 64-bit-Systemen laufen lassen.
• Die Einbindung von KONTOPRUEF-OFFLINE ist sehr einfach; einige Beispiele finden Sie weiter unten.
• Falls Sie einmal nicht weiterkommen sollten, erhalten Sie als KONTOPRUEF-Kunde unbegrenzten Gratis-Support per E-Mail!

Installation von Compilern

Nicht auf allen Linux-Systemen ist überhaupt ein C-Compiler (i.d.R. gcc) installiert. In diesem Fall müssen Sie den Compiler (und ggf. die zugehörigen Bibliotheken) nachinstallieren. Wie das funktioniert, sehen Sie in den nachfolgenden Abschnitten.

Ihre Linux-Version ist nicht aufgeführt? Melden Sie sich einfach per E-Mail mit der Angabe der Linux-Version (und, wenn möglich, einem Download-Link dafür). Die Liste wird dann – soweit möglich – um "Ihr" System ergänzt!

CentOS / Fedora / Red Hat (32-bit, getestet mit CentOS 6.5 und Fedora 19)

Auf einem frisch installierten System ist kein C-Compiler vorinstalliert. Um ihn zu installieren, rufen Sie sudo yum install gcc auf. Außerdem können Sie z.B. sudo yum install wget installieren, um mit wget http://www.kontopruef.de/KtoPruef30.tar.gz die KONTOPRUEF-Software herunterzuladen.

CentOS / Fedora / Red Hat (64-bit, getestet mit CentOS 6.5 und Fedora 19)

Auf einem frisch installierten System ist kein C-Compiler vorinstalliert. Um ihn zu installieren, rufen Sie sudo yum install gcc auf. Außerdem können Sie z.B. sudo yum install wget installieren, um mit wget http://www.kontopruef.de/KtoPruef30.tar.gz die KONTOPRUEF-Software herunterzuladen.

Danach müssen Sie, um 32-bit-Programme compilieren zu können, noch folgende Pakete installieren:

• sudo yum install glibc-devel.i686
• sudo yum install libgcc.i686
• sudo yum install libzip.i686

Debian (32-bit, getestet mit 7.2.0)

Hier sind standardmäßig alle nötigen Pakete installiert, so dass keine weiteren Vorkehrungen zu treffen sind.

Debian (64-bit, getestet mit 7.2.0)

Auf diesem System ist zwar der C-Compiler vorinstalliert, nicht jedoch die nötigen 32-bit-Bibliotheken. Sie installieren Sie mit sudo apt-get install libc6-dev-i386 und sudo apt-get install lib32z1.

OpenSuse (32-bit, getestet mit 13.1)

Auf einem frisch installierten OpenSuse-System ist kein C-Compiler vorinstalliert. Um ihn zu installieren, rufen Sie sudo zypper install gcc auf.

OpenSuse (64-bit, getestet mit 13.1)

Auf einem frisch installierten OpenSuse-System ist kein C-Compiler vorinstalliert. Um ihn zu installieren, dürfen Sie im Gegensatz zu anderen Linux-Versionen jedoch nicht einfach den "normalen" gcc-Compiler mit sudo zypper install gcc dazu hernehmen; Sie müssen die spezielle Version mit 32-bit-Unterstützung verwenden: sudo zypper install gcc-32bit.

Außerdem benötigen Sie auch das Paket glibc-locale-32bit. Das ist auf einem Desktop-GUI-System (also wenn Sie KDE oder Gnome als graphische Benutzeroberfläche installieren) offenbar standardmäßig vorhanden; auf Server-Systemen ohne GUI müssen Sie es mit sudo zypper install glibc-locale-32bit noch manuell nachinstallieren.

Ubuntu (32-bit, getestet mit Desktop 13.10)

Hier sind standardmäßig alle nötigen Pakete installiert, so dass keine weiteren Vorkehrungen zu treffen sind.

Ubuntu (64-bit, getestet mit Desktop 12.04.3 LTS)

Auf diesem System ist zwar der C-Compiler vorinstalliert, nicht jedoch die nötigen 32-bit-Bibliotheken. Sie installieren Sie mit sudo apt-get install libc6-dev-i386 und sudo apt-get install lib32z1.

Ubuntu (64-bit, getestet mit Server 12.04.3 LTS)

Auf diesem System ist standardmäßig kein C-Compiler installiert. Zum Installieren verwenden Sie sudo apt-get install gcc und danach noch (für die nötigen 32-bit-Bibliotheken) sudo apt-get install libc6-dev-i386 sowie (zum Entpacken der Bankdatendateien) sudo apt-get install lib32z1.

"Hello World": Das erste Miniprogramm

Um ein erstes "Lebenszeichen" von KONTOPRUEF-OFFLINE zu erhalten, geben Sie die Version der installierten Bankdatendatei aus. Laden Sie KtoPruef30.tar.gz in ein leeres Verzeichnis herunter und entpacken Sie es mit tar xzvf KtoPruef30.tar.gz. Sie erhalten eine Reihe von Bibliotheken, Include-Dateien und eine Demo-Bankdatendatei.

C-Quellcode

Schreiben Sie ein C-Programm "bankversion.c" wie folgt:

#include <stdio.h>
#include "KtoPruef.h"
int main(int argc, char *argv[]) {
  printf("%s\n", KtoPruefGetVersionExtended());
}

Bibliothekspfad setzen

Geben Sie den Befehl export LD_LIBRARY_PATH=. ein (oder export LD_LIBRARY_PATH=/usr/local/lib etc., je nachdem, wohin Sie die entpackten lib...-Dateien entpackt haben).

Compilieren

Compilieren Sie das obige Programm mit dem Befehl gcc -m32 -o bankversion bankversion.c libKtoPruef.so (wenn die Bibliothek nicht im aktuellen Verzeichnis steht, müssen Sie ggf. den gesamten Pfad dorthin angeben, z.B. /usr/local/lib/libKtoPruef.so).

Zusätzliche Hinweise zur Compilierung:

• Die Angabe von -m32 ist nur auf einem 64-bit-System nötig (auf 32-bit-Systemen ist das ohnehin Voreinstellung).
• In diesem einfachen Beispiel genügt die Angabe von libKtoPruef.so, weil Sie nur eine Funktion aus diesem KONTOPRUEF-Teil verwenden. Wenn Sie später Funktionen aus allen KONTOPRUEF-Teilen verwenden (z.B. KtoSepa...), können Sie hier auch einfach libKto*.so angeben, um alle KONTOPRUEF-Bibliotheken zu laden.
• Geben Sie jedoch nicht bplKtoBase.so (oder gar *.so) beim Compilieren an. Diese Dateien werden automatisch im Hintergrund eingebunden und würden bei expliziter Einbindung eine ordnungsgemäße Compilierung verhindern.
• Sie erhalten beim Compilieren möglicherweise die Meldung ./bplKtoBase.so: warning: the use of `tempnam' is dangerous, better use `mkstemp'. Bitte ignorieren Sie diese Meldung (tempnam ist lediglich in der gelinkten Bibliothek enthalten – wodurch diese Meldung ausgelöst wird –, wird aber nicht aktiv verwendet).

Ausführen

Geben Sie ./bankversion ein. Wenn Sie eine Linux-Version mit der sogenannten Exec-Shield-Funktion haben, erhalten Sie möglicherweise die Meldung Segmentation Fault. In diesem Fall laden Sie das Programm patchelf herunter und wenden es auf die Dateien bplKtoBase.so und die aktuell verwendete Bankdatendatei (bank...lbd oder demo...lbd) an: ./patchelf bplKtoBase.so etc.

Hinweis: Die aktuell herunterladbare Version von KONTOPRUEF-OFFLINE ist bereits vorgepatcht, so dass Sie diesen Schritt normalerweise nicht mehr ausführen müssen. Wenn Sie jedoch die Dateien schon vor einiger Zeit heruntergeladen haben, haben Sie evtl. noch ältere Versionen, bei denen dieser Schritt notwendig ist.

Wenn alles klappt, erhalten Sie die Versionsmeldung ähnlich
Demo-Version vom 01.09.13 (BLZ-Stand: 09.09.13)~2013~3~3~09.09.13~08.12.13~True~False~~

Weitere Schritte

Nachdem Sie mit dem obigen Programm die grundsätzliche Funktionalität festgestellt haben, können Sie nun die "endgültige" Einrichtung von KONTOPRUEF-OFFLINE durchführen:

• Verschieben Sie die Bibliotheksdateien (*.so*) in ein Bibliotheksverzeichnis, z.B. /usr/local/lib/
• Verschieben Sie die Include-Dateien (*.h) in ein Include-Verzeichnis, z.B. /usr/local/include
• Verschieben Sie die Bankdatendatei(en) (bank...lbd bzw. demo...lbd) in ein eigenes Datenverzeichnis, z.B. /var/lib/kontopruef
• Geben Sie diesem Datenverzeichnis Leserechte für alle Benutzer und richten Sie für Schreibzugriffe eine spezielle Gruppe, z.B. kontopruef ein
• Fügen Sie dieser Gruppe alle Benutzer hinzu, die später die Datendatei updaten sollen (das kann root sein, oder ein bestimmter Admin-Benutzer, aber auch apache oder sonstige Prozesse, die später die KONTOPRUEF-Update-Funktionen aufrufen sollen)
• Erstellen Sie die Datei /etc/KtoPruef.conf mit dem Inhalt:
  [Directories]
  data=/var/lib/kontopruef
  bzw. wo Sie die Bankdatendateien speichern wollen (s.o.)
• Ergänzen Sie ggf. alle Init-Skripte der Prozesse, die später irgendwelche KONTOPRUEF-Funktionen verwenden sollen (z.B. /etc/init.d/apache2, oder auch oder auch /usr/sbin/apache2ctl o.ä., je nach Linux-Version), mit dem Verweis auf die KONTOPRUEF-Bibliotheksdateien: export LD_LIBRARY_PATH=/usr/local/lib:${LD_LIBRARY_PATH}

Künftige C-Programme schreiben und compilieren Sie dann standardmäßig so:

#include <KtoUpdate.h>
#include <KtoPruef.h>
#include <KtoSepa.h>
int main...
...
result=KtoPruefGetIban(strcat(blz, "*"), kto, 0);
...
result=KtoSepaOpenCredit(...);
...

export LD_LIBRARY_PATH=/usr/local/lib
gcc -m32 -o programmname programmname.c libKto*.so

Hinweis: Die Angabe von -m32 ist nur auf 64-bit-Systemen nötig.

Update-Funktion

Ein wesentlicher Bestandteil von KONTOPRUEF ist die automatische Update-Möglichkeit im laufenden Betrieb! Damit Sie nicht "das Rad neu erfinden" müssen, finden Sie hier eine geeignete Update-Funktion, die Sie in Ihre Programme einbauen können:

#include <string.h>
#include "KtoUpdate.h"

int kontopruef_update(const char *username, const char *password) {
  char current[20], server[20], download[20];
  char current_version[20], server_version[20];
  int unpack_result, activate_result;

  strcpy(current, KtoUpdateGetCurrentFileName());
  strcpy(server, KtoUpdateServerCheck(username, password));
  if (*server!='+') // Check fehlgeschlagen
    return 1;
  strcpy(current_version, current+4);
  current_version[4]='\0'; // jetzt z.B. "1131"
  strcpy(server_version, server+5);
  server_version[4]='\0'; // jetzt z.B. "1341"
  if (strcmp(current_version, server_version)>=0) // keine neue Datei
    return 2;
  strcpy(download, KtoUpdateServerDownload(username, password));
  if (*server!='+') // Download fehlgeschlagen
    return 3;
  unpack_result=KtoUpdateUnpack(download+1);
  if (unpack_result) // Entpacken fehlgeschlagen
    return 4;
  download[12]='d'; // Paketname in Datenname wandeln
  activate_result=KtoUpdateActivate(download+1);
  if (activate_result) // Aktivieren fehlgeschlagen
    return 5;
  return 0; // Alles OK
}

Sie bauen diese Funktion in Ihr Programm ein und compilieren es wie üblich mit gcc -m32 -o update update.c libKtoUpdate.so. Sie sollten die Update- Funktion nicht öfter als einmal täglich aufrufen! Sie können die obige Funktion z.B. auch in ein sonst leeres Hauptprogramm integrieren und es in Ihre "daily" crontab schreiben, dann brauchen Sie sich überhaupt nicht mehr um irgendwelche Updates kümmern, mit einer Ausnahme:

Beachten Sie, dass Sie alles außer KtoUpdateActivate auch in einem separaten/externen Programm erledigen können. KtoUpdateActivate muss jedoch immer in dem Programm selbst aufgerufen werden, das KONTOPRUEF verwendet, sonst wird weiterhin auf die alte Datendatei zugegriffen! (Oder Sie starten Ihr Programm neu, dann wird automatisch die neueste Datendatei verwendet.)

Verwendung mit PHP

Auf einem 32-bit-System installieren Sie am besten die KONTOPRUEF-PHP-Extension – dann können Sie alle KONTOPRUEF-OFFLINE-Funktionen direkt aufrufen, als wären es eingebaute PHP-Funktionen.

Auf einem 64-bit-System können Sie die KONTOPRUEF-PHP-Extension leider nicht verwenden (es sei denn, Sie hätten – zusätzlich oder anstatt – manuell eine 32-bit-Version von PHP und/oder Apache installiert, was kaum der Fall sein dürfte).

Die Lösung dafür ist ein kleiner "C-Wrapper", der als 32-bit-Programm aus PHP heraus mit dem exec()-Befehl aufgerufen wird. Achtung: Hierfür muss der aufrufende Prozess (i.d.R. Apache) Zugriff auf die KONTOPRUEF-Bibliotheken haben, d.h. Sie müssen im Init-Skript von Apache (z.B. /etc/init.d/apache2 oder auch /usr/sbin/apache2ctl o.ä., je nach Linux-Version) vor dem Start des Servers die Zeile export LD_LIBRARY_PATH=/usr/local/lib:${LD_LIBRARY_PATH} einfügen und den Server neu starten! (Statt /usr/local/lib müssen Sie natürlich das Verzeichnis nehmen, in dem die KONTOPRUEF-Bibliotheken gespeichert sind.)

Hier ein einfaches Beispiel zur SEPA-Konvertierung (Ermittlung von IBAN und BIC aus KTO und BLZ):

SEPA-Konvertierung

1. Sie schreiben ein kleines C-Programm GetIban.c, das die Parameter BLZ und KTO als Parameter erwartet und das Ergebnis von KtoPruef.GetIban ("IBAN~BIC") zurückliefert:

   #include <stdio.h>
   #include <string.h>
   #include <KtoPruef.h>
   int main(int argc, char* argv[]) {
     char blz[10]={'\0'};
     strncpy(blz, argv[1], 8);
     printf("%s\n", KtoPruefGetIban(strcat(blz, "*"), argv[2], 0));
     return 0;
   }

2. Sie compilieren dieses Programm mit gcc -m32 -o GetIban GetIban.c libKtoPruef.so
   (Hinweis: Der Parameter -m32 ist nur auf 64-bit-Systemen nötig.)
   Wenn Sie vorher LD_LIBRARY_PATH gesetzt hatten (was zum Compilieren ohnehin nötig war), können Sie das Programm bereits jetzt mit ./GetIban 76010085 1856 testen (Sie sollten die Ausgabe DE08760100850000001856~PBNKDEFF760 erhalten).

3. Sie erstellen ein Shellskript namens ShellGetIban ungefähr wie folgt:

   #!/bin/bash
   export LD_LIBRARY_PATH=/usr/local/lib
   /usr/local/bin/GetIban $1 $2

   (Sie müssen natürlich die Verzeichnise angeben, in denen die aufgeführten Dateien und Programm tatsächlich stehen.) Jetzt können Sie das Shellskript testen mit ./ShellGetIban 76010085 1856 (auch hier sollten Sie die Ausgabe DE08760100850000001856~PBNKDEFF760 erhalten).

4. und in PHP gehen Sie schließlich ungefähr wie folgt vor:

   $blz='76010085';
   $kto='1856';
   $myCommand='/usr/local/bin/ShellGetIban '.escapeshellarg($blz).' '.escapeshellarg($kto);
   exec($myCommand, $myResArray);
   echo 'IBAN~BIC ist '.$myResArray[0];

Sie sollten die Ausgabe IBAN~BIC ist DE08760100850000001856~PBNKDEFF760 erhalten.

Die Datenübergabe via Parameter an ein eigenständiges Programm eignet sich natürlich nur für geringe Datenmengen wie z.B. einzelne Kontonummern oder Bankleitzahlen wie im letzten Beispiel, und dieser Weg funktioniert auch nur für "stateless" Transaktionen (d.h. bei denen ein Funktionsaufruf nicht von einem vorherigen Aufruf abhängt).

Wenn Sie also z.B. eine SEPA-XML-Lastschriftdatei auf diesem Weg erzeugen wollen, ist es besser (und im Prinzip auch nötig), wenn Sie die Daten aus PHP erst in ein einigermaßen "maschinenlesbares" Format schreiben (ähnlich einer CSV-Datei) und diese Datei dann "in einem Schwung" via C-Programm an KONTOPRUEF übergeben.

Im folgenden finden Sie ein Beispiel für diesen Weg:

Erzeugen einer SEPA-XML-Lastschriftdatei

Hier sehen Sie, wie Sie z.B. eine SEPA-XML-Lastschriftdatei erzeugen können. Es ist ein sehr einfaches Beispiel (ohne Fehlerbehandlung), das Sie nach Ihren Wünschen und Erfordernissen verändern und erweitern können.

Da Ihre Auftraggeberdaten (IBAN, BIC, Name etc.) ja konstant sind, werden diese Daten unmittelbar in den C-Wrapper codiert und in der Dateiübergabe nur die variablen Daten der Schuldner abgelegt. Das Buchungsdatum wird dem C-Wrapper als Parameter übergeben. Es wird die Automatik zur Ermittlung des SequenceTypes verwendet; die Mini-Datenbank dazu wird im Standardverzeichnis (/var/db/hanft/kontopruef/sepa) angenommen. Als Feldtrenner in der Übergabedatei wird die Tilde ~ verwendet, da diese im SEPA-Zeichensatz nicht vorkommen darf. Zur Vermeidung von Inkompatibilitäten bei der Interpretation der Übergabedatei werden leere Felder mit dem speziellen Wert !!!EMPTY!!! übergeben.

In die Übergabedatei schreiben Sie im Prinzip die Daten, die für die Funktion WriteDebit nötig sind. In PHP sieht das ungefähr wie folgt aus:

PHP-Teil

(Dies ist nur ein einfaches Beispiel. Sie können es besser, schöner oder auch ganz anders machen.)

<?php

function WriteData($aKunde, $aSeqTp, $aBetrag, $aName, $aIban, $aBic,
                   $aPurp, $aRef, $aVerwend, $aMandatRef, $aMandatDate) {
  global $datafile;
  $mydata=array($aKunde, $aSeqTp, $aBetrag, $aName, $aIban, $aBic,
                $aPurp, $aRef, $aVerwend, $aMandatRef, $aMandatDate);
  foreach ($mydata as &$value) {
    if (empty($value))
      $value='!!!EMPTY!!!';
  }
  fputcsv($datafile, $mydata, '~');
}

$datafile=fopen("/tmp/sepa.dat", "wt");

WriteData(0, 0, 123.45, 'Testkunde 1', 'DE75873517920003143847', 'PBNKDEFF',
          'ELEC', 'Ref', 'Verwend', 'MandRef', '2013-12-01');
WriteData(1, -1, 678.90, 'Testkunde 2', 'DE10435205880000213487', 'PBNKDEFF', 
          NULL, 'Ref', 'Verwend', 'MandRef', '2013-12-01');

fclose($datafile);

$datum='2013-12-01'; // gewünschtes Ausführungsdatum

exec("/usr/local/bin/readsepa $datum", $myResArray);

print_r($myResArray);

?>

(Beachten Sie, dass dies alles fiktive Daten sind!) Sie erhalten damit eine Datei /tmp/sepa.dat wie folgt:

!!!EMPTY!!!~!!!EMPTY!!!~123.45~"Testkunde 1"~DE75873517920003143847~PBNKDEFF~ELEC~Ref~Verwend~MandRef~2013-12-01
1~-1~678.9~"Testkunde 2"~DE10435205880000213487~PBNKDEFF~!!!EMPTY!!!~Ref~Verwend~MandRef~2013-12-01

Die Beschreibung der einzelnen Parameter finden Sie in der Dokumentation zur Funktion WriteDebit.

C-Wrapper

Im C-Wrapper müssen Sie diese Datei /tmp/sepa.dat nun wieder auslesen und mit KONTOPRUEF die Zieldatei /tmp/sepa.xml schreiben, die Sie zu Ihrer Bank übertragen. Dies geschieht im wesentlichen mit der C-Funktion strtok, die auf jedem System vorhanden ist und die in einem Programm namens readsepa verwendet wird; darin werden ggf. auch !!!EMPTY!!!-Felder wieder auf 0 oder einen Leerstring gesetzt und einschließende Anführungszeichen entfernt.

Die eingelesenen Daten werden dann mit WriteDebit per KONTOPRUEF in die SEPA-XML-Datei geschrieben. Vorher wird diese mit OpenDebit geöffnet und danach mit CloseDebit geschlossen.

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <KtoSepa.h>

int convert_to_int(char *value) {
  if (strcmp(value, "!!!EMPTY!!!"))
    return atoi(value);
  else
    return 0;
}

void convert_to_string(char *value) {
  int myLen;
  if (strcmp(value, "!!!EMPTY!!!")) {
    myLen=strlen(value);
    while (*value) {
      if (*value=='"' || *value=='\r' || *value=='\n')
        memmove(value, value+1, myLen); // inkl. \0
      else
        value++;
      myLen--;
    }
  } else {
    *value='\0';
  }
}

int main(int argc, char *argv[]) {
  FILE *sepadat;
  char line[500];
  int myKunde, mySeqTp, myResult;
  unsigned long myBetrag;
  char myName[73], myIban[37], myBic[14], myPurp[14], myRef[38],
       myVerwend[143], myMandatRef[38], myMandatDate[14];

  KtoSepaSetSepaVersion(27);
  KtoSepaSepaCommand("CALCDUEDATE", 0, 2, 0, argv[1], NULL, NULL);
  KtoSepaOpenDebit(1, "Message-ID", "Ersteller", NULL, "Auftraggeber",
                   "DE06793517830000023984", "PBNKDEFF", "DE98ZZZ09999999999");
  sepadat=fopen("/tmp/sepa.dat", "rt");
  while (fgets(line, 500, sepadat)) {
    myKunde=convert_to_int(strtok(line, "~"));
    mySeqTp=convert_to_int(strtok(NULL, "~"));
    myBetrag=lround(strtod(strtok(NULL, "~"), NULL)*100.0);
    strcpy(myName, strtok(NULL, "~"));
    convert_to_string(myName);
    strcpy(myIban, strtok(NULL, "~"));
    convert_to_string(myIban);
    strcpy(myBic, strtok(NULL, "~"));
    convert_to_string(myBic);
    strcpy(myPurp, strtok(NULL, "~"));
    convert_to_string(myPurp);
    strcpy(myRef, strtok(NULL, "~"));
    convert_to_string(myRef);
    strcpy(myVerwend, strtok(NULL, "~"));
    convert_to_string(myVerwend);
    strcpy(myMandatRef, strtok(NULL, "~"));
    convert_to_string(myMandatRef);
    strcpy(myMandatDate, strtok(NULL, "~"));
    convert_to_string(myMandatDate);
    myResult=KtoSepaWriteDebit(myKunde, mySeqTp, myBetrag, myName, myIban, myBic,
                               myPurp, myRef, myVerwend, myMandatRef, myMandatDate);
    printf("%d,\"%s\"\n", myResult, KtoSepaGetLastError());
  } // while
  fclose(sepadat);
  KtoSepaCloseDebit("/tmp/sepa.xml");
  return 0;

Dieses Programm müssen Sie mit gcc -m32 -lm -o readsepa readsepa.c libKtoSepa.so übersetzen. Beachten Sie -lm zur Einbindung der "Math"-Bibliothek. -m32 können Sie dagegen auf 32-bit-Systemen weglassen (aber dort würden Sie wohl ohnehin eher die KONTOPRUEF-PHP-Extension verwenden als solche Programme zu schreiben).

An dieser Stelle auch nochmals die Erinnerung, dass readsepa ja aus PHP heraus aufgerufen wird – und PHP aus Apache heraus... also braucht Apache Zugriff auf die KONTOPRUEF-Bibliotheken! Suchen Sie also das Init-Skript von Apache (z.B. /etc/init.d/apache2 oder auch /usr/sbin/apache2ctl) und darin nach dem "start"-Teil und fügen Sie dort unmittelbar vor dem Startbefehl noch export LD_LIBRARY_PATH=/usr/local/lib:${LD_LIBRARY_PATH} ein (bzw. wo die KONTOPRUEF-Bibliotheken stehen) und starten Sie den Server neu (je nach Ihrem Linux z.B. mit service apache2 restart oder auch /etc/init.d/apache2 restart o.ä).

In der Datei /tmp/sepa.xml stehen nach dem Aufruf des PHP-Skripts (das wiederum readsepa aufruft) die fertigen Lastschriften (auf eine Wiedergabe der doch etwas länglichen Datei wird hier verzichtet). In der PHP-Variable $myResArray (siehe oben) finden Sie in jedem Array-Element den Fehlercode (und ggf. die Klartext-Fehlermeldung) zur korrespondierenden Lastschrift (d.h. wenn im ersten Array-Element der Fehlercode 0 steht, wurde die erste Lastschrift erfolgreich geschrieben usw.).

Vergessen Sie nicht (bei Benutzung der Mini-Datenbank), nach der Einlieferung bei Ihrer Bank MergeTemp aufzurufen, um die temporären Lastschriften in die Mandatendatenbank einzutragen. Dies können Sie wieder mit einem Mini-C-Programm wie oben bei der SEPA-Konvertierung machen (übergeben Sie einfach die Mandantennummer als Parameter und rufen Sie im C-Programm die Funktion KtoSepaMergeTemp auf). Dies sei Ihnen – ebenso wie der Einbau der Update-Funktion in PHP – zur Übung überlassen...