konto_check 6.13.0 → 6.15.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (7) hide show
  1. checksums.yaml +4 -4
  2. data/README.textile +1 -1
  3. data/ext/konto_check_raw/konto_check.c +302 -188
  4. data/ext/konto_check_raw/konto_check.h +6 -6
  5. data/ext/konto_check_raw/konto_check_raw_ruby.c +1 -1
  6. data/ext/konto_check_raw/retvals.h +7 -7
  7. metadata +7 -7
data/ext/konto_check_raw/konto_check.c CHANGED
@@ -13,7 +13,7 @@
13
13
  * # wurden aus der aktuellen BLZ-Datei der Deutschen Bundesbank #
14
14
  * # �bernommen. #
15
15
  * # #
16
- * # Copyright (C) 2002-2020 Michael Plugge <m.plugge@hs-mannheim.de> #
16
+ * # Copyright (C) 2002-2023 Michael Plugge <konto_check@yahoo.com> #
17
17
  * # #
18
18
  * # Dieses Programm ist freie Software; Sie d�rfen es unter den #
19
19
  * # Bedingungen der GNU Lesser General Public License, wie von der Free #
@@ -48,11 +48,11 @@
48
48
 
49
49
  /* Definitionen und Includes */
50
50
  #ifndef VERSION
51
- #define VERSION "6.13 (final)"
51
+ #define VERSION "6.15 (final)"
52
52
  #define VERSION_MAJOR 6
53
- #define VERSION_MINOR 13
53
+ #define VERSION_MINOR 15
54
54
  #endif
55
- #define VERSION_DATE "2020-12-16"
55
+ #define VERSION_DATE "2023-04-13"
56
56
 
57
57
  #ifndef INCLUDE_KONTO_CHECK_DE
58
58
  #define INCLUDE_KONTO_CHECK_DE 1
@@ -92,6 +92,7 @@ static lzo_align_t __LZO_MMODEL wrkmem[LZO1X_1_MEM_COMPRESS];
92
92
  #include <fcntl.h>
93
93
  #include <sys/types.h>
94
94
  #include <sys/stat.h>
95
+ #include <unistd.h>
95
96
  #if COMPRESS>0
96
97
  #include <zlib.h>
97
98
  #endif
@@ -206,8 +207,8 @@ static char **sortc_buf;
206
207
  static int *sorti_buf;
207
208
 
208
209
  /* Variablen f�r das SCL-Verzeichnis */
209
- static char *scl_info_block,*scl_bic_block,*scl_name_block,*scl_flags_block,
210
- **scl_bic_array,**scl_name_array,**scl_flags_array,
210
+ static char *scl_info_block,*scl_bic_block,*scl_name_block,*scl_flags_block,*scl_flags_block_orig,
211
+ **scl_bic_array,**scl_name_array,**scl_flags_array,**scl_flags_array_o,
211
212
  scl_gueltigkeit[16],scl_gueltigkeit_iso[16];
212
213
  static int scl_cnt;
213
214
  long scl_ts;
@@ -216,6 +217,7 @@ long scl_ts;
216
217
  DLL_EXPORT const char *(*retval_enc)(int)=NULL;
217
218
 
218
219
  static int convert_encoding(char **data,UINT4 *len);
220
+ static int scl_idx(const char *bic,int *retval,int *raw);
219
221
 
220
222
 
221
223
  /* das Makro RETURN(r) gibt Debug-Meldungen zu Fehler-R�ckgabewerten (zur Fehlersuche) */
@@ -808,7 +810,7 @@ static UINT4 adler32a(UINT4 adler,const char *buf,unsigned int len)
808
810
  * # was einen Sortierlauf vor der Generierung der Tabelle bedingt. #
809
811
  * # Die Funktion wird von qsort() (aus der libc) aufgerufen. #
810
812
  * # #
811
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
813
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
812
814
  * ###########################################################################
813
815
  */
814
816
 
@@ -835,7 +837,7 @@ static int sort_cmp(const void *ap,const void *bp)
835
837
  * # Diese Funktion dient als Vergleichsfunktion f�r zwei Integerwerte f�r #
836
838
  * # die Quicksort-Bibliotheksfunktion. #
837
839
  * # #
838
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de> #
840
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com> #
839
841
  * ###########################################################################
840
842
  */
841
843
 
@@ -888,7 +890,7 @@ DLL_EXPORT int set_default_compression(int mode)
888
890
  * # Funktion create_lutfile_int() (ohne den FILE-Pointer). Die generierte #
889
891
  * # Datei wird nach dem Aufruf geschlossen. #
890
892
  * # #
891
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
893
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
892
894
  * ###########################################################################
893
895
  */
894
896
 
@@ -909,7 +911,7 @@ DLL_EXPORT int create_lutfile(char *filename, char *prolog, int slots)
909
911
  * # des Inhaltsverzeichnisses mit 0-Bytes. Diese Datei kann dann mit der #
910
912
  * # Funktion write_lut_block() (bzw. write_lut_block_int()) gef�llt werden. #
911
913
  * # #
912
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
914
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
913
915
  * ###########################################################################
914
916
  */
915
917
 
@@ -946,7 +948,7 @@ static int create_lutfile_int(char *name, char *prolog, int slots,FILE **lut)
946
948
  * # einige grundlegende Tests gemacht, um sicherzustellen, da� es sich auch #
947
949
  * # um eine LUT2-Datei handelt (hier und sp�ter in write_block_int()). #
948
950
  * # #
949
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
951
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
950
952
  * ###########################################################################
951
953
  */
952
954
 
@@ -983,7 +985,7 @@ DLL_EXPORT int write_lut_block(char *lutname,UINT4 typ,UINT4 len,char *data)
983
985
  * # meldung LUT2_NO_SLOT_FREE zur�ckgegeben, aber nichts geschrieben. #
984
986
  * # Vor dem Schreiben wird der Block mittels der ZLIB komprimiert. #
985
987
  * # #
986
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
988
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
987
989
  * #############################################################################
988
990
  */
989
991
 
@@ -1118,7 +1120,7 @@ static int write_lut_block_int(FILE *lut,UINT4 typ,UINT4 len,char *data)
1118
1120
  * # mehrere Blocks des angegebenen Typs enthalten sind, wird der letze #
1119
1121
  * # zur�ckgeliefert. #
1120
1122
  * # #
1121
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
1123
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
1122
1124
  * ###########################################################################
1123
1125
  */
1124
1126
 
@@ -1140,7 +1142,7 @@ DLL_EXPORT int read_lut_block(char *lutname, UINT4 typ,UINT4 *blocklen,char **da
1140
1142
  * # Blocks eines bestimmeten Typs enthalten sind, auch alte Blocks gelesen #
1141
1143
  * # werden. #
1142
1144
  * # #
1143
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
1145
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
1144
1146
  * ###########################################################################
1145
1147
  */
1146
1148
 
@@ -1161,7 +1163,7 @@ DLL_EXPORT int read_lut_slot(char *lutname,int slot,UINT4 *blocklen,char **data)
1161
1163
  * # lesen; sie wird von vielen internen Funktionen benutzt. Die LUT-Datei #
1162
1164
  * # wird als FILE-Pointer �bergeben und nicht geschlossen. #
1163
1165
  * # #
1164
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
1166
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
1165
1167
  * ###########################################################################
1166
1168
  */
1167
1169
 
@@ -1418,7 +1420,7 @@ static int read_lut_block_int(FILE *lut,int slot,int typ,UINT4 *blocklen,char **
1418
1420
  * # gegeben. Falls eine Variable nicht ben�tigt wird, kann f�r sie auch #
1419
1421
  * # NULL �bergeben werden; die entsprechende Variable wird dann ignoriert. #
1420
1422
  * # #
1421
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
1423
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
1422
1424
  * #############################################################################
1423
1425
  */
1424
1426
 
@@ -1587,7 +1589,7 @@ static int lut_dir(FILE *lut,int id,UINT4 *slot_cnt,UINT4 *typ,UINT4 *len,
1587
1589
  * # dieser Buffer wird dann mittels der Funktion write_lut_block_int() #
1588
1590
  * # komprimiert und in die LUT-Datei geschrieben. #
1589
1591
  * # #
1590
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
1592
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
1591
1593
  * ###########################################################################
1592
1594
  */
1593
1595
 
@@ -2159,7 +2161,7 @@ static int write_lutfile_entry_de(UINT4 typ,int auch_filialen,int bank_cnt,char
2159
2161
  * # generate_lut2(), aber die Funktionalit�t reicht in der Praxis normaler- #
2160
2162
  * # weise gut aus. #
2161
2163
  * # #
2162
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de> #
2164
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com> #
2163
2165
  * ###########################################################################
2164
2166
  */
2165
2167
 
@@ -2211,7 +2213,7 @@ DLL_EXPORT int generate_lut2_p(char *inputname,char *outputname,char *user_info,
2211
2213
  * # f�r einige Pr�fziffermethoden (52, 53, B6) ben�tigt werden (sie sind in #
2212
2214
  * # den Beispielen enthalten, haben aber keine reale Entsprechung). #
2213
2215
  * # #
2214
- * # Copyright (C) 2007, 2013 Michael Plugge <m.plugge@hs-mannheim.de> #
2216
+ * # Copyright (C) 2007, 2013 Michael Plugge <konto_check@yahoo.com> #
2215
2217
  * ###########################################################################
2216
2218
  */
2217
2219
 
@@ -2591,7 +2593,7 @@ fini:
2591
2593
  * # Die Funktion lut_dir_dump_str() allokiert f�r die Ausgabe Speicher; #
2592
2594
  * # dieser mu� von dre aufrufenden Funktion wieder freigegeben werden. #
2593
2595
  * # #
2594
- * # Copyright (C) 2007-2010 Michael Plugge <m.plugge@hs-mannheim.de> #
2596
+ * # Copyright (C) 2007-2010 Michael Plugge <konto_check@yahoo.com> #
2595
2597
  * ###########################################################################
2596
2598
  */
2597
2599
 
@@ -2701,7 +2703,7 @@ DLL_EXPORT int lut_dir_dump_str(char *lutname,char **dptr)
2701
2703
  * # LUT2_NO_VALID_DATE: Der Datenblock enth�lt kein G�ltigkeitsdatum #
2702
2704
  * # LUT2_NOT_INITIALIZED: die library wurde noch nicht initialisiert #
2703
2705
  * # #
2704
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de> #
2706
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com> #
2705
2707
  * ###########################################################################
2706
2708
  */
2707
2709
  DLL_EXPORT int lut_valid(void)
@@ -2773,7 +2775,7 @@ DLL_EXPORT int lut_valid_date(char *lut_name,int *v11,int *v12,int *v21,int *v22
2773
2775
  * # und info2; danach wird der Speicher der von lut_info() allokiert wurde, #
2774
2776
  * # wieder freigegeben. #
2775
2777
  * # #
2776
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
2778
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
2777
2779
  * ###########################################################################
2778
2780
  */
2779
2781
 
@@ -2806,7 +2808,7 @@ DLL_EXPORT int lut_info_b(char *lut_name,char **info1,char **info2,int *valid1,i
2806
2808
  * # mittels der Funktion kc_id2ptr() in einen String umgewandelt, sowie mit #
2807
2809
  * # der Funktion kc_id_free() wieder freigegeben werden kann. #
2808
2810
  * # #
2809
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
2811
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
2810
2812
  * ###########################################################################
2811
2813
  */
2812
2814
 
@@ -2874,7 +2876,7 @@ DLL_EXPORT int lut_info_id(char *lut_name,int *info1,int *info2,int *valid1,int
2874
2876
  * # LUT2_NO_VALID_DATE: Der Datenblock enth�lt kein G�ltigkeitsdatum #
2875
2877
  * # LUT2_BLOCK_NOT_IN_FILE: Die LUT-Datei enth�lt den Infoblock nicht #
2876
2878
  * # #
2877
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
2879
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
2878
2880
  * ###########################################################################
2879
2881
  */
2880
2882
 
@@ -3089,7 +3091,7 @@ DLL_EXPORT int lut_info(char *lut_name,char **info1,char **info2,int *valid1,int
3089
3091
  * # info_p: Variablenpointer f�r R�ckgabe des Info-Strings #
3090
3092
  * # user_info_p: Variablenpointer f�r R�ckgabe des User-Info-Strings #
3091
3093
  * # #
3092
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
3094
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
3093
3095
  * ###########################################################################
3094
3096
  */
3095
3097
 
@@ -3200,7 +3202,7 @@ DLL_EXPORT int get_lut_info2(char *lut_name,int *version_p,char **prolog_p,char
3200
3202
  * # Au�erdem kann die Anzahl Slots ver�ndert (vergr��ert oder verkleinert) #
3201
3203
  * # werden. #
3202
3204
  * # #
3203
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
3205
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
3204
3206
  * ###########################################################################
3205
3207
  */
3206
3208
 
@@ -3247,7 +3249,7 @@ DLL_EXPORT int copy_lutfile(char *old_name,char *new_name,int new_slots)
3247
3249
  * # Sets geladen. Der R�ckgabewert ist daher oft -38 (nicht alle Blocks #
3248
3250
  * # geladen), da die LUT-Datei nicht unbedingt alle Blocks enth�lt :-). #
3249
3251
  * # #
3250
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de> #
3252
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com> #
3251
3253
  * ###########################################################################
3252
3254
  */
3253
3255
 
@@ -3265,7 +3267,7 @@ DLL_EXPORT int kto_check_init2(char *lut_name)
3265
3267
  * # unterschiedlichen Blocks definiert (lut_set_0 ... lut_set_9), die �ber #
3266
3268
  * # einen skalaren Parameter ausgew�hlt werden k�nnen. #
3267
3269
  * # #
3268
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de> #
3270
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com> #
3269
3271
  * ###########################################################################
3270
3272
  */
3271
3273
 
@@ -3305,7 +3307,7 @@ DLL_EXPORT int kto_check_init_p(char *lut_name,int required,int set,int incremen
3305
3307
  * # testen, ob ein bestimmter Block initialisiert wurde, und welcher #
3306
3308
  * # R�ckgabewert dabei auftrat. #
3307
3309
  * # #
3308
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de> #
3310
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com> #
3309
3311
  * ###########################################################################
3310
3312
  */
3311
3313
 
@@ -3327,7 +3329,7 @@ DLL_EXPORT int *lut2_status(void)
3327
3329
  * # Der Parameter id sollte auf einen Speicherbereich von mindestens 33 Byte#
3328
3330
  * # zeigen. Die Datei-ID wird in diesen Speicher geschrieben. #
3329
3331
  * # #
3330
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de> #
3332
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com> #
3331
3333
  * ###########################################################################
3332
3334
  */
3333
3335
 
@@ -3425,7 +3427,7 @@ DLL_EXPORT int get_lut_id(char *lut_name,int set,char *id)
3425
3427
  * # inkrementelle Initialisierung, um noch ben�tigte Blocks nachzuladen. #
3426
3428
  * # Falls schon alle gew�nschten Blocks geladen sind, wird nichts gemacht. #
3427
3429
  * # #
3428
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de> #
3430
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com> #
3429
3431
  * ###########################################################################
3430
3432
  */
3431
3433
 
@@ -3456,7 +3458,7 @@ DLL_EXPORT int lut_init(char *lut_name,int required,int set)
3456
3458
  * # Probleme; daher gibt es noch einige andere Initialisierungsfunktionen #
3457
3459
  * # mit einfacherem Aufrufinterface, wie lut_init() oder kto_check_init_p().#
3458
3460
  * # #
3459
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de> #
3461
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com> #
3460
3462
  * ###########################################################################
3461
3463
  */
3462
3464
  DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,int incremental)
@@ -4269,7 +4271,7 @@ DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,
4269
4271
  * # LUT2_BLOCKS_MISSING bei einigen Blocks traten Fehler auf #
4270
4272
  * # OK alle Blocks erfolgreich geladen #
4271
4273
  * # #
4272
- * # Copyright (C) 2013 Michael Plugge <m.plugge@hs-mannheim.de> #
4274
+ * # Copyright (C) 2013 Michael Plugge <konto_check@yahoo.com> #
4273
4275
  * ############################################################################
4274
4276
  */
4275
4277
  DLL_EXPORT int lut_blocks(int mode,char **lut_filename,char **lut_blocks_ok,char **lut_blocks_fehler)
@@ -4343,7 +4345,7 @@ DLL_EXPORT int lut_blocks(int mode,char **lut_filename,char **lut_blocks_ok,char
4343
4345
  * # Variablen lut_filename, lut_blocks_ok und lut_blocks_fehler m�ssen immer #
4344
4346
  * # angegeben werden; eine �bergabe von NULL f�hrt zu einer access violation.#
4345
4347
  * # #
4346
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
4348
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
4347
4349
  * ############################################################################
4348
4350
  */
4349
4351
  DLL_EXPORT int lut_blocks_id(int mode,int *lut_filename,int *lut_blocks_ok,int *lut_blocks_fehler)
@@ -4374,7 +4376,7 @@ DLL_EXPORT int lut_blocks_id(int mode,int *lut_filename,int *lut_blocks_ok,int *
4374
4376
  * # benutzt, ist aber auch als Info interessant, falls f�r die LUT-Datei #
4375
4377
  * # die Default-Werte benutzt wurden (Pfad und Dateiname). #
4376
4378
  * # #
4377
- * # Copyright (C) 2011 Michael Plugge <m.plugge@hs-mannheim.de> #
4379
+ * # Copyright (C) 2011 Michael Plugge <konto_check@yahoo.com> #
4378
4380
  * ###########################################################################
4379
4381
  */
4380
4382
 
@@ -4396,7 +4398,7 @@ DLL_EXPORT const char *current_lutfile_name(int *set,int *level,int *retval)
4396
4398
  /* ###########################################################################
4397
4399
  * # lut_index(): Index einer BLZ in den internen Arrays bestimmen #
4398
4400
  * # #
4399
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
4401
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
4400
4402
  * ###########################################################################
4401
4403
  */
4402
4404
 
@@ -4445,7 +4447,7 @@ static int lut_index(char *b)
4445
4447
  * # Diese Funktion ist nicht so optimiert wie lut_index(), #
4446
4448
  * # da sie nicht in zeitkritischen Routinen benutzt wird. #
4447
4449
  * # #
4448
- * # Copyright (C) 2009 Michael Plugge <m.plugge@hs-mannheim.de> #
4450
+ * # Copyright (C) 2009 Michael Plugge <konto_check@yahoo.com> #
4449
4451
  * ###########################################################################
4450
4452
  */
4451
4453
 
@@ -4514,7 +4516,7 @@ static int lut_index_i(int b)
4514
4516
  * # wird. Falls f�r retval NULL �bergeben wird, wird der #
4515
4517
  * # R�ckgabewert verworfen. #
4516
4518
  * # #
4517
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
4519
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
4518
4520
  * ###########################################################################
4519
4521
  */
4520
4522
 
@@ -4525,7 +4527,7 @@ static int lut_index_i(int b)
4525
4527
  * # Diese Funktion testet, ob eine BLZ (und Zweigstelle, falls gew�nscht) #
4526
4528
  * # existiert und g�ltig ist. #
4527
4529
  * # #
4528
- * # Copyright (C) 2010 Michael Plugge <m.plugge@hs-mannheim.de> #
4530
+ * # Copyright (C) 2010 Michael Plugge <konto_check@yahoo.com> #
4529
4531
  * ###########################################################################
4530
4532
  */
4531
4533
 
@@ -4556,7 +4558,7 @@ DLL_EXPORT int lut_blz_i(int b,int zweigstelle)
4556
4558
  * # lut_filialen(): Anzahl der Filialen zu einer gegebenen Bankleitzahl #
4557
4559
  * # bestimmen. #
4558
4560
  * # #
4559
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
4561
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
4560
4562
  * ###########################################################################
4561
4563
  */
4562
4564
 
@@ -4584,7 +4586,7 @@ DLL_EXPORT int lut_filialen_i(int b,int *retval)
4584
4586
  /* ###########################################################################
4585
4587
  * # lut_name(): Banknamen (lange Form) bestimmen #
4586
4588
  * # #
4587
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
4589
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
4588
4590
  * ###########################################################################
4589
4591
  */
4590
4592
 
@@ -4619,7 +4621,7 @@ DLL_EXPORT const char *lut_name_i(int b,int zweigstelle,int *retval)
4619
4621
  * # der deutschen Kreditwirtschaft ist die L�nge der Angaben f�r die #
4620
4622
  * # Bezeichnung des Kreditinstituts begrenzt. #
4621
4623
  * # #
4622
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
4624
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
4623
4625
  * ###########################################################################
4624
4626
  */
4625
4627
 
@@ -4647,7 +4649,7 @@ DLL_EXPORT const char *lut_name_kurz_i(int b,int zweigstelle,int *retval)
4647
4649
  /* ###########################################################################
4648
4650
  * # lut_plz(): Postleitzahl bestimmen #
4649
4651
  * # #
4650
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
4652
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
4651
4653
  * ###########################################################################
4652
4654
  */
4653
4655
 
@@ -4675,7 +4677,7 @@ DLL_EXPORT int lut_plz_i(int b,int zweigstelle,int *retval)
4675
4677
  /* ###########################################################################
4676
4678
  * # lut_ort(): Sitz einer Bank bestimmen #
4677
4679
  * # #
4678
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
4680
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
4679
4681
  * ###########################################################################
4680
4682
  */
4681
4683
 
@@ -4715,7 +4717,7 @@ DLL_EXPORT const char *lut_ort_i(int b,int zweigstelle,int *retval)
4715
4717
  * # den Stellen der Deutschen Bundesbank stets die Institutsgruppennummer #
4716
4718
  * # 2 zugewiesen worden. #
4717
4719
  * # #
4718
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
4720
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
4719
4721
  * ###########################################################################
4720
4722
  */
4721
4723
 
@@ -4771,7 +4773,7 @@ DLL_EXPORT int lut_pan_i(int b,int zweigstelle,int *retval)
4771
4773
  * # korrekte Wert l��t sich in diesem Fall durch die Funktion iban_bic_gen()#
4772
4774
  * # ermitteln. #
4773
4775
  * # #
4774
- * # Copyright (C) 2007,2013 Michael Plugge <m.plugge@hs-mannheim.de> #
4776
+ * # Copyright (C) 2007,2013 Michael Plugge <konto_check@yahoo.com> #
4775
4777
  * ###########################################################################
4776
4778
  */
4777
4779
 
@@ -4883,7 +4885,7 @@ DLL_EXPORT const char *lut_bic_hi(int b,int zweigstelle,int *retval)
4883
4885
  * # automatisiert eine eindeutige Nummer vergeben. Eine einmal verwendete #
4884
4886
  * # Nummer wird nicht noch einmal vergeben. #
4885
4887
  * # #
4886
- * # Copyright (C) 2009 Michael Plugge <m.plugge@hs-mannheim.de> #
4888
+ * # Copyright (C) 2009 Michael Plugge <konto_check@yahoo.com> #
4887
4889
  * ###########################################################################
4888
4890
  */
4889
4891
 
@@ -4912,7 +4914,7 @@ DLL_EXPORT int lut_nr_i(int b,int zweigstelle,int *retval)
4912
4914
  * # lut_pz(): Pr�fzifferverfahren f�r eine Bankleitzahl. Das Verfahren wird #
4913
4915
  * # numerisch zur�ckgegeben, also z.B. 108 f�r die Methode A8. #
4914
4916
  * # #
4915
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
4917
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
4916
4918
  * ###########################################################################
4917
4919
  */
4918
4920
 
@@ -4945,7 +4947,7 @@ DLL_EXPORT int lut_pz_i(int b,int zweigstelle,int *retval)
4945
4947
  * # G�ltigkeitstermin der Bankleitzahlendatei im Zahlungsverkehr nicht mehr #
4946
4948
  * # zu verwenden. #
4947
4949
  * # #
4948
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
4950
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
4949
4951
  * ###########################################################################
4950
4952
  */
4951
4953
 
@@ -4985,7 +4987,7 @@ DLL_EXPORT int lut_aenderung_i(int b,int zweigstelle,int *retval)
4985
4987
  * # Das Feld enth�lt das Merkmal 0 (keine Angabe) oder 1 (BLZ im Feld 1 #
4986
4988
  * # ist zur L�schung vorgesehen). Die R�ckgabe erfolgt als ASCII '0' '1'. #
4987
4989
  * # #
4988
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
4990
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
4989
4991
  * ###########################################################################
4990
4992
  */
4991
4993
 
@@ -5018,7 +5020,7 @@ DLL_EXPORT int lut_loeschung_i(int b,int zweigstelle,int *retval)
5018
5020
  * # wurde (lut_loeschung()==1) oder die Bankleitzahl zum aktuellen G�ltig- #
5019
5021
  * # keitstermin gel�scht wird (lut_aenderung()=='D'). #
5020
5022
  * # #
5021
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
5023
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
5022
5024
  * ###########################################################################
5023
5025
  */
5024
5026
 
@@ -5052,7 +5054,7 @@ DLL_EXPORT int lut_nachfolge_blz_i(int b,int zweigstelle,int *retval)
5052
5054
  * # aus einer vierstelligen Nummer und einer zweistelligen Versionszahl; #
5053
5055
  * # sie wird in konto_check als eine sechsstellige Nummer dargestellt. #
5054
5056
  * # #
5055
- * # Copyright (C) 2013 Michael Plugge <m.plugge@hs-mannheim.de> #
5057
+ * # Copyright (C) 2013 Michael Plugge <konto_check@yahoo.com> #
5056
5058
  * ###########################################################################
5057
5059
  */
5058
5060
 
@@ -5087,7 +5089,7 @@ DLL_EXPORT int lut_iban_regel_i(int b,int zweigstelle,int *retval)
5087
5089
  * # Berechnung notwendig sind, schon geladen wurden; falls nicht, werden #
5088
5090
  * # die fehlenden Daten (per inkrementeller Initialisierung) nachgeladen. #
5089
5091
  * # #
5090
- * # Copyright (C) 2013 Michael Plugge <m.plugge@hs-mannheim.de> #
5092
+ * # Copyright (C) 2013 Michael Plugge <konto_check@yahoo.com> #
5091
5093
  * ###########################################################################
5092
5094
  */
5093
5095
 
@@ -5128,7 +5130,7 @@ static int iban_init(void)
5128
5130
  * # Der R�ckgabewert gibt n�here Aufschl�sse �ber die Anwendung der Regeln #
5129
5131
  * # und ob eine IBAN berechnet werden darf. #
5130
5132
  * # #
5131
- * # Copyright (C) 2013 Michael Plugge <m.plugge@hs-mannheim.de> #
5133
+ * # Copyright (C) 2013 Michael Plugge <konto_check@yahoo.com> #
5132
5134
  * ###########################################################################
5133
5135
  */
5134
5136
 
@@ -5232,7 +5234,8 @@ static int iban_regel_cvt(char *blz,char *kto,const char **bicp,int regel_versio
5232
5234
  * IBAN-Regel 5 auf S. 14); alle anderen BLZs der Commerzbank
5233
5235
  * bekommen COBADEFFXXX.
5234
5236
  */
5235
- if(blz[3]=='4' && strcasecmp(lut_name(blz,0,NULL),"comdirect bank"))*bicp="COBADEFFXXX";
5237
+ // if(blz[3]=='4' && strcasecmp(lut_name(blz,0,NULL),"comdirect bank"))*bicp="COBADEFFXXX";
5238
+ if(blz[3]=='4' && blz[4]!='1')*bicp="COBADEFFXXX"; /* comdirect Bank */
5236
5239
 
5237
5240
  /* BLZs ohne Pr�fzifferberechnung */
5238
5241
  if(pz_methode==9)return OK_NO_CHK;
@@ -8316,7 +8319,7 @@ static int iban_regel_cvt(char *blz,char *kto,const char **bicp,int regel_versio
8316
8319
  * # mit den Indizes der Hauptstellen wird in der letzten Variable zur�ck- #
8317
8320
  * # gegeben (start_idx). #
8318
8321
  * # #
8319
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
8322
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
8320
8323
  * ###########################################################################
8321
8324
  */
8322
8325
 
@@ -8527,7 +8530,7 @@ static int lut_multiple_int(int idx,int *cnt,int **p_blz,char ***p_name,char **
8527
8530
  * # Die Funktion lut_cleanup() gibt allen belegten Speicher frei und setzt #
8528
8531
  * # die entsprechenden Variablen auf NULL. #
8529
8532
  * # #
8530
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
8533
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
8531
8534
  * ###########################################################################
8532
8535
  */
8533
8536
 
@@ -8666,7 +8669,7 @@ DLL_EXPORT int lut_cleanup(void)
8666
8669
  * # Pr�fziffermethoden; das Problem wird mit dem neuen Dateiformat #
8667
8670
  * # noch einmal angegangen. #
8668
8671
  * # #
8669
- * # Copyright (C) 2002-2005 Michael Plugge <m.plugge@hs-mannheim.de> #
8672
+ * # Copyright (C) 2002-2005 Michael Plugge <konto_check@yahoo.com> #
8670
8673
  * ###########################################################################
8671
8674
  */
8672
8675
 
@@ -8688,7 +8691,7 @@ DLL_EXPORT int generate_lut(char *inputname,char *outputname,char *user_info,int
8688
8691
  * # #
8689
8692
  * # Bugs: f�r eine BLZ wird nur eine Pr�fziffermethode unterst�tzt (s.o.). #
8690
8693
  * # #
8691
- * # Copyright (C) 2002-2005 Michael Plugge <m.plugge@hs-mannheim.de> #
8694
+ * # Copyright (C) 2002-2005 Michael Plugge <konto_check@yahoo.com> #
8692
8695
  * ###########################################################################
8693
8696
  */
8694
8697
 
@@ -8806,7 +8809,7 @@ static int read_lut(char *filename,int *cnt_blz)
8806
8809
  * # zur�ckf�hren, was wesentlich schneller ist, als die sonst n�tigen acht #
8807
8810
  * # Multiplikationen mit dem jeweiligen Stellenwert. #
8808
8811
  * # #
8809
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
8812
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
8810
8813
  * ###########################################################################
8811
8814
  */
8812
8815
 
@@ -8950,6 +8953,8 @@ static void init_atoi_table(void)
8950
8953
  lut2_feld_namen[LUT2_2_SCL_NAME]="LUT2_2_SCL_NAME";
8951
8954
  lut2_feld_namen[LUT2_SCL_FLAGS]="LUT2_SCL_FLAGS";
8952
8955
  lut2_feld_namen[LUT2_2_SCL_FLAGS]="LUT2_2_SCL_FLAGS";
8956
+ lut2_feld_namen[LUT2_SCL_FLAGS_ORIG]="LUT2_SCL_FLAGS_ORIG";
8957
+ lut2_feld_namen[LUT2_2_SCL_FLAGS_ORIG]="LUT2_2_SCL_FLAGS_ORIG";
8953
8958
 
8954
8959
  lut_block_idx[1]=0;
8955
8960
  lut_block_idx[2]=0;
@@ -8982,6 +8987,7 @@ static void init_atoi_table(void)
8982
8987
  lut_block_idx[29]=-1;
8983
8988
  lut_block_idx[30]=-1;
8984
8989
  lut_block_idx[31]=-1;
8990
+ lut_block_idx[32]=-1;
8985
8991
 
8986
8992
  lut_block_name1[1]="BLZ";
8987
8993
  lut_block_name1[2]="FILIALEN";
@@ -9014,6 +9020,7 @@ static void init_atoi_table(void)
9014
9020
  lut_block_name1[29]="SCL_BIC";
9015
9021
  lut_block_name1[30]="SCL_NAME";
9016
9022
  lut_block_name1[31]="SCL_FLAGS";
9023
+ lut_block_name1[32]="SCL_FLAGS_ORIG";
9017
9024
  lut_block_name1[101]="BLZ (2)";
9018
9025
  lut_block_name1[102]="FILIALEN (2)";
9019
9026
  lut_block_name1[103]="NAME (2)";
@@ -9045,6 +9052,7 @@ static void init_atoi_table(void)
9045
9052
  lut_block_name1[129]="SCL_BIC (2)";
9046
9053
  lut_block_name1[130]="SCL_NAME (2)";
9047
9054
  lut_block_name1[131]="SCL_FLAGS (2)";
9055
+ lut_block_name1[132]="SCL_FLAGS_ORIG (2)";
9048
9056
 
9049
9057
  lut_block_name2[1]="1. BLZ";
9050
9058
  lut_block_name2[2]="1. Anzahl Fil.";
@@ -9077,6 +9085,7 @@ static void init_atoi_table(void)
9077
9085
  lut_block_name2[29]="1. SCL BIC";
9078
9086
  lut_block_name2[30]="1. SCL Banknamen";
9079
9087
  lut_block_name2[31]="1. SCL Flags";
9088
+ lut_block_name2[32]="1. SCL Flags orig";
9080
9089
  lut_block_name2[101]="2. BLZ";
9081
9090
  lut_block_name2[102]="2. Anzahl Fil.";
9082
9091
  lut_block_name2[103]="2. Name";
@@ -9108,7 +9117,8 @@ static void init_atoi_table(void)
9108
9117
  lut_block_name2[129]="2. SCL BIC";
9109
9118
  lut_block_name2[130]="2. SCL Banknamen";
9110
9119
  lut_block_name2[131]="2. SCL Flags";
9111
- lut_blocklen_max=521;
9120
+ lut_block_name2[132]="2. SCL Flags orig";
9121
+ lut_blocklen_max=544;
9112
9122
  init_status|=1;
9113
9123
  }
9114
9124
 
@@ -9132,7 +9142,7 @@ static void init_atoi_table(void)
9132
9142
  * # retvals: Struktur, um Pr�fziffermethode und Pr�fziffer in einer #
9133
9143
  * # threadfesten Version zur�ckzugeben #
9134
9144
  * # #
9135
- * # Copyright (C) 2002-2009 Michael Plugge <m.plugge@hs-mannheim.de> #
9145
+ * # Copyright (C) 2002-2009 Michael Plugge <konto_check@yahoo.com> #
9136
9146
  * ###########################################################################
9137
9147
  */
9138
9148
 
@@ -20143,7 +20153,7 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
20143
20153
  * # blz: Bankleitzahl (immer 8-stellig) #
20144
20154
  * # kto: Kontonummer #
20145
20155
  * # #
20146
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
20156
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
20147
20157
  * ###########################################################################
20148
20158
  */
20149
20159
 
@@ -20208,7 +20218,7 @@ DLL_EXPORT int kto_check_blz(char *blz,char *kto)
20208
20218
  * # retvals: Struktur, in der die benutzte Pr�fziffermethode und die #
20209
20219
  * # berechnete Pr�fziffer zur�ckgegeben werden #
20210
20220
  * # #
20211
- * # Copyright (C) 2013 Michael Plugge <m.plugge@hs-mannheim.de> #
20221
+ * # Copyright (C) 2013 Michael Plugge <konto_check@yahoo.com> #
20212
20222
  * ###########################################################################
20213
20223
  */
20214
20224
 
@@ -20315,7 +20325,7 @@ DLL_EXPORT int kto_check_regel(char *blz,char *kto)
20315
20325
  * # kto: Kontonummer #
20316
20326
  * # blz: Bankleitzahl (immer 8-stellig) #
20317
20327
  * # #
20318
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
20328
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
20319
20329
  * ###########################################################################
20320
20330
  */
20321
20331
 
@@ -20357,7 +20367,7 @@ DLL_EXPORT int kto_check_pz(char *pz,char *kto,char *blz)
20357
20367
  * # retvals: Struktur, in der die benutzte Pr�fziffermethode und die #
20358
20368
  * # berechnete Pr�fziffer zur�ckgegeben werden #
20359
20369
  * # #
20360
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
20370
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
20361
20371
  * ###########################################################################
20362
20372
  */
20363
20373
 
@@ -20410,7 +20420,7 @@ DLL_EXPORT int kto_check_blz_dbg(char *blz,char *kto,RETVAL *retvals)
20410
20420
  * # retvals: Struktur, in der die benutzte Pr�fziffermethode und die #
20411
20421
  * # berechnete Pr�fziffer zur�ckgegeben werden #
20412
20422
  * # #
20413
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
20423
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
20414
20424
  * ###########################################################################
20415
20425
  */
20416
20426
  DLL_EXPORT int kto_check_pz_dbg(char *pz,char *kto,char *blz,RETVAL *retvals)
@@ -20448,7 +20458,7 @@ DLL_EXPORT int kto_check_pz_dbg(char *pz,char *kto,char *blz,RETVAL *retvals){re
20448
20458
  * # statt eines numerischen Wertes. Die Funktion wurde zun�chst f�r die #
20449
20459
  * # Perl-Variante eingef�hrt. #
20450
20460
  * # #
20451
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
20461
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
20452
20462
  * ###########################################################################
20453
20463
  */
20454
20464
 
@@ -20500,7 +20510,7 @@ DLL_EXPORT const char *kto_check_str(char *x_blz,char *kto,char *lut_name)
20500
20510
  * # kto: Kontonummer #
20501
20511
  * # lut_name: Name der Lookup-Datei oder NULL (f�r DEFAULT_LUT_NAME) #
20502
20512
  * # #
20503
- * # Copyright (C) 2002-2007 Michael Plugge <m.plugge@hs-mannheim.de> #
20513
+ * # Copyright (C) 2002-2007 Michael Plugge <konto_check@yahoo.com> #
20504
20514
  * ###########################################################################
20505
20515
  */
20506
20516
 
@@ -20582,7 +20592,7 @@ DLL_EXPORT int kto_check(char *pz_or_blz,char *kto,char *lut_name)
20582
20592
  * # die Anzahl der Banken die zu dem BIC geh�ren, in der Variablen cnt #
20583
20593
  * # zur�ckgegeben (optional). #
20584
20594
  * # #
20585
- * # Copyright (C) 2013 Michael Plugge <m.plugge@hs-mannheim.de> #
20595
+ * # Copyright (C) 2013 Michael Plugge <konto_check@yahoo.com> #
20586
20596
  * ###########################################################################
20587
20597
  */
20588
20598
 
@@ -20673,7 +20683,7 @@ DLL_EXPORT int get_lut_info2_b(char *lutname,int *version,char **prolog_p,char *
20673
20683
  * # INVALID_LUT_FILE Fehler in der LUT-Datei (Format, CRC...) #
20674
20684
  * # OK Erfolg #
20675
20685
  * # #
20676
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
20686
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
20677
20687
  * ######################################################################
20678
20688
  */
20679
20689
 
@@ -20712,7 +20722,7 @@ DLL_EXPORT int get_lut_info(char **info,char *lut_name)
20712
20722
  * # keinen Speicher freigeben kann, der von C aus allokiert wurde. #
20713
20723
  * # Auch in C# ist die Speicherverwaltung nicht einfach m�glich. #
20714
20724
  * # #
20715
- * # Copyright (C) 2010 Michael Plugge <m.plugge@hs-mannheim.de> #
20725
+ * # Copyright (C) 2010 Michael Plugge <konto_check@yahoo.com> #
20716
20726
  * ######################################################################
20717
20727
  */
20718
20728
 
@@ -20738,7 +20748,7 @@ DLL_EXPORT void *kc_alloc(int size,int *retval)
20738
20748
  * # Diese Funktion ist Teil des alten Interfaces und wurde als Wrapper #
20739
20749
  * # zu den neuen Routinen umgestellt. #
20740
20750
  * # #
20741
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
20751
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
20742
20752
  * ###########################################################################
20743
20753
  */
20744
20754
 
@@ -20757,7 +20767,7 @@ DLL_EXPORT int cleanup_kto(void)
20757
20767
  * # Diese Funktion gibt die Version und das Datum der Kompilierung der #
20758
20768
  * # konto_check library als String zur�ck. .#
20759
20769
  * # #
20760
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
20770
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
20761
20771
  * ###########################################################################
20762
20772
  */
20763
20773
 
@@ -20789,13 +20799,13 @@ DLL_EXPORT const char *get_kto_check_version_x(int mode)
20789
20799
  case 5:
20790
20800
  return "09.09.2019";
20791
20801
  case 6:
20792
- return "16. Dezember 2020"; /* Klartext-Datum der Bibliotheksversion */
20802
+ return "13. April 2023"; /* Klartext-Datum der Bibliotheksversion */
20793
20803
  case 7:
20794
20804
  return "final"; /* Versions-Typ der Bibliotheksversion (development, beta, final) */
20795
20805
  case 8:
20796
20806
  return "6"; /* Hauptversionszahl */
20797
20807
  case 9:
20798
- return "13"; /* Unterversionszahl */
20808
+ return "15"; /* Unterversionszahl */
20799
20809
  }
20800
20810
  }
20801
20811
 
@@ -20810,7 +20820,7 @@ DLL_EXPORT const char *get_kto_check_version_x(int mode)
20810
20820
  * # Variante vor allem f�r Perl gedacht ist; in der Umgebung ist es #
20811
20821
  * # etwas komplizierter, ein Array zu �bergeben. #
20812
20822
  * # #
20813
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de> #
20823
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com> #
20814
20824
  * ###########################################################################
20815
20825
  */
20816
20826
 
@@ -20841,7 +20851,7 @@ DLL_EXPORT int dump_lutfile_p(char *outputname,UINT4 felder)
20841
20851
  * # dem Array required spezifiziert. Es werden nur Felder der Deutschen #
20842
20852
  * # Bundesbank ber�cksichtigt; andere Felder werden ignoriert. #
20843
20853
  * # #
20844
- * # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
20854
+ * # Copyright (C) 2007 Michael Plugge <konto_check@yahoo.com> #
20845
20855
  * ###########################################################################
20846
20856
  */
20847
20857
 
@@ -21036,7 +21046,7 @@ DLL_EXPORT int dump_lutfile(char *outputname,UINT4 *required)
21036
21046
  * # #
21037
21047
  * # Update 2014: die IBAN-Regeln werden jetzt auch ausgegeben. #
21038
21048
  * # #
21039
- * # Copyright (C) 2007,2009 Michael Plugge <m.plugge@hs-mannheim.de> #
21049
+ * # Copyright (C) 2007,2009 Michael Plugge <konto_check@yahoo.com> #
21040
21050
  * ###########################################################################
21041
21051
  */
21042
21052
 
@@ -21147,7 +21157,7 @@ DLL_EXPORT int rebuild_blzfile(char *inputname,char *outputname,UINT4 set)
21147
21157
  * # #
21148
21158
  * # R�ckgabe: der zu der �bergebenen IBAN geh�rende BIC #
21149
21159
  * # #
21150
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de> #
21160
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com> #
21151
21161
  * ###########################################################################
21152
21162
  */
21153
21163
 
@@ -21250,7 +21260,7 @@ DLL_EXPORT const char *iban2bic(char *iban,int *retval,char *blz,char *kto)
21250
21260
  * # die Parameter blz und kto wird allerdings Speicher allokiert und per #
21251
21261
  * # Handle wieder zur�ckgegeben. #
21252
21262
  * # #
21253
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
21263
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
21254
21264
  * ###########################################################################
21255
21265
  */
21256
21266
 
@@ -21336,7 +21346,7 @@ DLL_EXPORT const char *iban2bic_id(char *iban,int *retval,int *blz,int *kto)
21336
21346
  * # fehlschl�gt, wird der entsprechende Fehlercode in die #
21337
21347
  * # Variable retval geschrieben und NULL zur�ckgegeben. #
21338
21348
  * # #
21339
- * # Copyright (C) 2008,2013 Michael Plugge <m.plugge@hs-mannheim.de> #
21349
+ * # Copyright (C) 2008,2013 Michael Plugge <konto_check@yahoo.com> #
21340
21350
  * ###########################################################################
21341
21351
  */
21342
21352
 
@@ -21588,7 +21598,7 @@ DLL_EXPORT char *iban_bic_gen(char *blz,char *kto,const char **bicp,char *blz2,c
21588
21598
  * # Parameter: #
21589
21599
  * # ci: Creditor Identifiers der getestet werden soll #
21590
21600
  * # #
21591
- * # Copyright (C) 2013 Michael Plugge <m.plugge@hs-mannheim.de> #
21601
+ * # Copyright (C) 2013 Michael Plugge <konto_check@yahoo.com> #
21592
21602
  * ###########################################################################
21593
21603
  */
21594
21604
 
@@ -21674,7 +21684,7 @@ DLL_EXPORT int ci_check(char *ci)
21674
21684
  * # retval: NULL oder Adresse einer Variablen, in die der R�ckgabe- #
21675
21685
  * # wert der Kontopr�fung geschrieben wird #
21676
21686
  * # #
21677
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de> #
21687
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com> #
21678
21688
  * ###########################################################################
21679
21689
  */
21680
21690
 
@@ -21945,7 +21955,7 @@ DLL_EXPORT int iban_check(char *iban,int *retval)
21945
21955
  * # zeichen nach jeweils 5 Zeichen) geschrieben wird, oder #
21946
21956
  * # NULL (falls nicht ben�tigt) #
21947
21957
  * # #
21948
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de> #
21958
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com> #
21949
21959
  * ###########################################################################
21950
21960
  */
21951
21961
 
@@ -22011,7 +22021,7 @@ DLL_EXPORT int ipi_gen(char *zweck,char *dst,char *papier)
22011
22021
  * # kc_id2ptr() kann das Handle in einen String umgewandelt werden, sowie #
22012
22022
  * # mittels der Funktion kc_id_free() wieder freigegeben werden. #
22013
22023
  * # #
22014
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
22024
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
22015
22025
  * ###########################################################################
22016
22026
  */
22017
22027
 
@@ -22040,7 +22050,7 @@ DLL_EXPORT int ipi_gen_id(char *zweck,int *dst,int *papier)
22040
22050
  * # Parameter: #
22041
22051
  * # zweck: der Strukturierte Verwendungszweck, der getestet werden soll #
22042
22052
  * # #
22043
- * # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de> #
22053
+ * # Copyright (C) 2008 Michael Plugge <konto_check@yahoo.com> #
22044
22054
  * ###########################################################################
22045
22055
  */
22046
22056
 
@@ -22094,7 +22104,7 @@ DLL_EXPORT int ipi_check(char *zweck)
22094
22104
  * # Felder der LUT-Datei, z.B. Banken in einem bestimmten Ort oder mit #
22095
22105
  * # einem bestimmten Namen etc. #
22096
22106
  * # #
22097
- * # Copyright (C) 2009,2011 Michael Plugge <m.plugge@hs-mannheim.de> #
22107
+ * # Copyright (C) 2009,2011 Michael Plugge <konto_check@yahoo.com> #
22098
22108
  * ###########################################################################
22099
22109
  */
22100
22110
 
@@ -23988,6 +23998,7 @@ DLL_EXPORT int lut_suche_blz(int such1,int such2,int *anzahl,int **start_idx,int
23988
23998
  return suche_int1(such1,such2,anzahl,start_idx,zweigstellen_base,blz_base,&blz_f,&sort_blz,qcmp_blz,cnt,0);
23989
23999
  }
23990
24000
 
24001
+ #line 22564 "konto_check.lxx"
23991
24002
  /* Funktion lut_suche_bic() +���2 */
23992
24003
  DLL_EXPORT int lut_suche_bic(char *such_name,int *anzahl,int **start_idx,int **zweigstellen_base,
23993
24004
  char ***base_name,int **blz_base)
@@ -24041,7 +24052,6 @@ DLL_EXPORT int lut_suche_pz(int such1,int such2,int *anzahl,int **start_idx,int
24041
24052
  {
24042
24053
  int retval;
24043
24054
 
24044
-
24045
24055
  if(anzahl)*anzahl=0;
24046
24056
  if(such2 && such1>such2)return INVALID_SEARCH_RANGE;
24047
24057
  if((init_status&7)<7)return LUT2_NOT_INITIALIZED;
@@ -24055,7 +24065,6 @@ DLL_EXPORT int lut_suche_pz(int such1,int such2,int *anzahl,int **start_idx,int
24055
24065
  /* Funktion lut_suche_plz() +���2 */
24056
24066
  DLL_EXPORT int lut_suche_plz(int such1,int such2,int *anzahl,int **start_idx,int **zweigstellen_base,int **base_name,int **blz_base)
24057
24067
  {
24058
-
24059
24068
  if(anzahl)*anzahl=0;
24060
24069
  if(such2 && such1>such2)return INVALID_SEARCH_RANGE;
24061
24070
  if((init_status&7)<7)return LUT2_NOT_INITIALIZED;
@@ -24068,7 +24077,6 @@ DLL_EXPORT int lut_suche_plz(int such1,int such2,int *anzahl,int **start_idx,int
24068
24077
  /* Funktion lut_suche_regel() +���2 */
24069
24078
  DLL_EXPORT int lut_suche_regel(int such1,int such2,int *anzahl,int **start_idx,int **zweigstellen_base,int **base_name,int **blz_base)
24070
24079
  {
24071
-
24072
24080
  if(anzahl)*anzahl=0;
24073
24081
  if(such2 && such1>such2)return INVALID_SEARCH_RANGE;
24074
24082
  if((init_status&7)<7)return LUT2_NOT_INITIALIZED;
@@ -24169,7 +24177,7 @@ DLL_EXPORT int bic_info(char *bic1,int mode,int *anzahl,int *start_idx)
24169
24177
  /* ###############################################################################
24170
24178
  * # Diese Funktionen bestimmen das �nderungsflag zu einem BIC bzw. einer IBAN #
24171
24179
  * # #
24172
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
24180
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
24173
24181
  * ###############################################################################
24174
24182
  */
24175
24183
 
@@ -24192,7 +24200,7 @@ DLL_EXPORT int iban_aenderung(char *iban,int filiale,int*retval)
24192
24200
  /* ###############################################################################
24193
24201
  * # Diese Funktionen bestimmen das L�schflag zu einem BIC bzw. einer IBAN #
24194
24202
  * # #
24195
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
24203
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
24196
24204
  * ###############################################################################
24197
24205
  */
24198
24206
 
@@ -24215,7 +24223,7 @@ DLL_EXPORT int iban_loeschung(char *iban,int filiale,int*retval)
24215
24223
  /* ###############################################################################
24216
24224
  * # Diese Funktionen bestimmen die IBAN-Regel zu einem BIC bzw. einer IBAN #
24217
24225
  * # #
24218
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
24226
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
24219
24227
  * ###############################################################################
24220
24228
  */
24221
24229
 
@@ -24238,7 +24246,7 @@ DLL_EXPORT int iban_iban_regel(char *iban,int filiale,int*retval)
24238
24246
  /* ###############################################################################
24239
24247
  * # Diese Funktionen bestimmen die Nachfolge-BLZ zu einem BIC bzw. einer IBAN #
24240
24248
  * # #
24241
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
24249
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
24242
24250
  * ###############################################################################
24243
24251
  */
24244
24252
 
@@ -24261,7 +24269,7 @@ DLL_EXPORT int iban_nachfolge_blz(char *iban,int filiale,int*retval)
24261
24269
  /* ###############################################################################
24262
24270
  * # Diese Funktionen bestimmen die Laufende Nr. zu einem BIC bzw. einer IBAN #
24263
24271
  * # #
24264
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
24272
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
24265
24273
  * ###############################################################################
24266
24274
  */
24267
24275
 
@@ -24284,7 +24292,7 @@ DLL_EXPORT int iban_nr(char *iban,int filiale,int*retval)
24284
24292
  /* ###############################################################################
24285
24293
  * # Diese Funktionen bestimmen den PAN zu einem BIC bzw. einer IBAN #
24286
24294
  * # #
24287
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
24295
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
24288
24296
  * ###############################################################################
24289
24297
  */
24290
24298
 
@@ -24307,7 +24315,7 @@ DLL_EXPORT int iban_pan(char *iban,int filiale,int*retval)
24307
24315
  /* ###############################################################################
24308
24316
  * # Diese Funktionen bestimmen die PLZ der Bank zu einem BIC bzw. einer IBAN #
24309
24317
  * # #
24310
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
24318
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
24311
24319
  * ###############################################################################
24312
24320
  */
24313
24321
 
@@ -24330,7 +24338,7 @@ DLL_EXPORT int iban_plz(char *iban,int filiale,int*retval)
24330
24338
  /* ###############################################################################
24331
24339
  * # Diese Funktionen bestimmen die Pr�fziffer zu einem BIC bzw. einer IBAN #
24332
24340
  * # #
24333
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
24341
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
24334
24342
  * ###############################################################################
24335
24343
  */
24336
24344
 
@@ -24353,7 +24361,7 @@ DLL_EXPORT int iban_pz(char *iban,int filiale,int*retval)
24353
24361
  /* ###############################################################################
24354
24362
  * # Diese Funktionen bestimmen den BIC zu einem BIC bzw. einer IBAN #
24355
24363
  * # #
24356
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
24364
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
24357
24365
  * ###############################################################################
24358
24366
  */
24359
24367
 
@@ -24376,7 +24384,7 @@ DLL_EXPORT const char *iban_bic(char *iban,int filiale,int*retval)
24376
24384
  /* ###############################################################################
24377
24385
  * # Diese Funktionen bestimmen den BIC der Hauptstelle zu einem BIC bzw. einer IBAN#
24378
24386
  * # #
24379
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
24387
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
24380
24388
  * ###############################################################################
24381
24389
  */
24382
24390
 
@@ -24399,7 +24407,7 @@ DLL_EXPORT const char *iban_bic_h(char *iban,int filiale,int*retval)
24399
24407
  /* ###############################################################################
24400
24408
  * # Diese Funktionen bestimmen den Name der Bank zu einem BIC bzw. einer IBAN #
24401
24409
  * # #
24402
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
24410
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
24403
24411
  * ###############################################################################
24404
24412
  */
24405
24413
 
@@ -24422,7 +24430,7 @@ DLL_EXPORT const char *iban_name(char *iban,int filiale,int*retval)
24422
24430
  /* ###############################################################################
24423
24431
  * # Diese Funktionen bestimmen den Kurzname der Bank zu einem BIC bzw. einer IBAN#
24424
24432
  * # #
24425
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
24433
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
24426
24434
  * ###############################################################################
24427
24435
  */
24428
24436
 
@@ -24445,7 +24453,7 @@ DLL_EXPORT const char *iban_name_kurz(char *iban,int filiale,int*retval)
24445
24453
  /* ###############################################################################
24446
24454
  * # Diese Funktionen bestimmen den Ort einer Bank zu einem BIC bzw. einer IBAN #
24447
24455
  * # #
24448
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
24456
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
24449
24457
  * ###############################################################################
24450
24458
  */
24451
24459
 
@@ -24771,7 +24779,7 @@ static const char *iban_fkt_s(char *iban,int filiale,int *retval,const char*(*fk
24771
24779
  * # val: Daten #
24772
24780
  * # size: Gr��e des Datenblocks (nur bei set_default_bin() ) #
24773
24781
  * # #
24774
- * # Copyright (C) 2010 Michael Plugge <m.plugge@hs-mannheim.de> #
24782
+ * # Copyright (C) 2010 Michael Plugge <konto_check@yahoo.com> #
24775
24783
  * ###########################################################################
24776
24784
  */
24777
24785
 
@@ -24827,7 +24835,7 @@ DLL_EXPORT int kto_check_set_default_bin(char *key,char *val,int size)
24827
24835
  * # Diese Funktion initialisiert die Variablen f�r den Default-Block und #
24828
24836
  * # l�scht evl. vorhandene Werte. #
24829
24837
  * # #
24830
- * # Copyright (C) 2010 Michael Plugge <m.plugge@hs-mannheim.de> #
24838
+ * # Copyright (C) 2010 Michael Plugge <konto_check@yahoo.com> #
24831
24839
  * ###########################################################################
24832
24840
  */
24833
24841
 
@@ -24863,7 +24871,7 @@ static int kto_check_clear_default(void)
24863
24871
  * # lut_name: Name der LUT-Datei #
24864
24872
  * # block_id: ID in der LUT-Datei f�r den Block #
24865
24873
  * # #
24866
- * # Copyright (C) 2010 Michael Plugge <m.plugge@hs-mannheim.de> #
24874
+ * # Copyright (C) 2010 Michael Plugge <konto_check@yahoo.com> #
24867
24875
  * ###########################################################################
24868
24876
  */
24869
24877
 
@@ -24942,7 +24950,7 @@ DLL_EXPORT int kto_check_init_default(char *lut_name,int block_id)
24942
24950
  * # val: Wert (R�ckgabe per Referenz) #
24943
24951
  * # size: Gr��e des Datenblocks (per Referenz) #
24944
24952
  * # #
24945
- * # Copyright (C) 2010 Michael Plugge <m.plugge@hs-mannheim.de> #
24953
+ * # Copyright (C) 2010 Michael Plugge <konto_check@yahoo.com> #
24946
24954
  * ###########################################################################
24947
24955
  */
24948
24956
 
@@ -24974,7 +24982,7 @@ DLL_EXPORT int kto_check_get_default(char *key,char **val,int *size)
24974
24982
  * # keys: Array mit den Schl�sseln (R�ckgabe per Referenz) #
24975
24983
  * # cnt: Anzahl (R�ckgabe per Referenz) #
24976
24984
  * # #
24977
- * # Copyright (C) 2010 Michael Plugge <m.plugge@hs-mannheim.de> #
24985
+ * # Copyright (C) 2010 Michael Plugge <konto_check@yahoo.com> #
24978
24986
  * ###########################################################################
24979
24987
  */
24980
24988
 
@@ -25002,7 +25010,7 @@ DLL_EXPORT int kto_check_default_keys(char ***keys,int *cnt)
25002
25010
  * # lutfile: LUT-Datei in die der Block geschrieben werden soll #
25003
25011
  * # block_id: ID in der LUT-Datei f�r den Block #
25004
25012
  * # #
25005
- * # Copyright (C) 2010 Michael Plugge <m.plugge@hs-mannheim.de> #
25013
+ * # Copyright (C) 2010 Michael Plugge <konto_check@yahoo.com> #
25006
25014
  * ###########################################################################
25007
25015
  */
25008
25016
 
@@ -25047,7 +25055,7 @@ DLL_EXPORT int kto_check_write_default(char *lutfile,int block_id)
25047
25055
  * # Funktion mit dem Parameter 0 aufgerufen wird, wird nur die aktuelle #
25048
25056
  * # Kodierung zur�ckgegeben. #
25049
25057
  * # #
25050
- * # Copyright (C) 2011 Michael Plugge <m.plugge@hs-mannheim.de> #
25058
+ * # Copyright (C) 2011 Michael Plugge <konto_check@yahoo.com> #
25051
25059
  * ###########################################################################
25052
25060
  */
25053
25061
 
@@ -25198,7 +25206,7 @@ DLL_EXPORT int kto_check_encoding(int mode)
25198
25206
  * # Diese Funktion entspricht der Funktion kto_check_encoding(); allerdings #
25199
25207
  * # ist der R�ckgabewert nicht numerisch, sondern ein String. #
25200
25208
  * # #
25201
- * # Copyright (C) 2011 Michael Plugge <m.plugge@hs-mannheim.de> #
25209
+ * # Copyright (C) 2011 Michael Plugge <konto_check@yahoo.com> #
25202
25210
  * ###########################################################################
25203
25211
  */
25204
25212
 
@@ -25256,7 +25264,7 @@ DLL_EXPORT const char *kto_check_encoding_str(int mode)
25256
25264
  * # 0: Flag abfragen, nicht ver�ndern #
25257
25265
  * # -1: Flag l�schen, Speicher der raw-Daten freigeben #
25258
25266
  * # #
25259
- * # Copyright (C) 2011 Michael Plugge <m.plugge@hs-mannheim.de> #
25267
+ * # Copyright (C) 2011 Michael Plugge <konto_check@yahoo.com> #
25260
25268
  * ###########################################################################
25261
25269
  */
25262
25270
 
@@ -25293,7 +25301,7 @@ DLL_EXPORT int keep_raw_data(int mode)
25293
25301
  * # Diese Funktion konvertiert einen gelesenen LUT-Block in die gew�nschte #
25294
25302
  * # Kodierung. Der urspr�nglich allokierte Speicher wird wieder freigegeben.#
25295
25303
  * # #
25296
- * # Copyright (C) 2011 Michael Plugge <m.plugge@hs-mannheim.de> #
25304
+ * # Copyright (C) 2011 Michael Plugge <konto_check@yahoo.com> #
25297
25305
  * ###########################################################################
25298
25306
  */
25299
25307
 
@@ -25875,7 +25883,7 @@ DLL_EXPORT int lut_keine_iban_berechnung(char *iban_blacklist,char *lutfile,int
25875
25883
  * # anderer Wert: nur Abfrage des Status #
25876
25884
  * # R�ckgabe: aktueller Status des Flags # #
25877
25885
  * # #
25878
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
25886
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
25879
25887
  * ###########################################################################
25880
25888
  */
25881
25889
 
@@ -25899,7 +25907,7 @@ DLL_EXPORT int pz_aenderungen_enable(int set)
25899
25907
  * # txt: Textvariable #
25900
25908
  * # i: Integervariable (4 Byte) #
25901
25909
  * # #
25902
- * # Copyright (C) 2006 Michael Plugge <m.plugge@hs-mannheim.de> #
25910
+ * # Copyright (C) 2006 Michael Plugge <konto_check@yahoo.com> #
25903
25911
  * ###########################################################################
25904
25912
  */
25905
25913
 
@@ -25927,7 +25935,7 @@ DLL_EXPORT char *kto_check_test_vars(char *txt,UINT4 i)
25927
25935
  * # Da der Aufruf f�r jede Funktionsgruppe gleich ist, wird er per Makro #
25928
25936
  * # gemacht. #
25929
25937
  * # #
25930
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
25938
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
25931
25939
  * ###########################################################################
25932
25940
  */
25933
25941
  /* numerische R�ckgabewerte in eine id umwandeln */
@@ -26070,7 +26078,7 @@ DLL_EXPORT int current_lutfile_name_id(int *set,int *level,int *retval)
26070
26078
  * # den etwas eigenwilligen (Schleich-)Weg �ber IntPtr nehmen, damit der #
26071
26079
  * # Speicher wieder freigegeben werden kann... #
26072
26080
  * # #
26073
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
26081
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
26074
26082
  * ###########################################################################
26075
26083
  */
26076
26084
 
@@ -26088,7 +26096,7 @@ DLL_EXPORT int current_lutfile_name_id(int *set,int *level,int *retval)
26088
26096
  * # von kc_id_free() wird es auch nicht gel�scht, der Funktionsaufruf gibt #
26089
26097
  * # nur OK zur�ck, ohne etwas zu tun. #
26090
26098
  * # #
26091
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
26099
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
26092
26100
  * ###########################################################################
26093
26101
  */
26094
26102
 
@@ -26132,7 +26140,7 @@ static int kc_ptr2id(char *ptr,int *handle,int release_mem)
26132
26140
  * # Diese Funktion gibt den Pointer zu einem Handle zur�ck. Dieser Wert #
26133
26141
  * # kann dann als String-Pointer in den DLL-Routinen verwendet werden. #
26134
26142
  * # #
26135
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
26143
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
26136
26144
  * ###########################################################################
26137
26145
  */
26138
26146
 
@@ -26153,7 +26161,7 @@ DLL_EXPORT char *kc_id2ptr(int handle,int *retval)
26153
26161
  * # Diese Funktion gibt den Speicher, der zu einem Handle geh�rt, wieder #
26154
26162
  * # frei und setzt den entsprechenden Slot-Eintrag auf NULL. #
26155
26163
  * # #
26156
- * # Copyright (C) 2014 Michael Plugge <m.plugge@hs-mannheim.de> #
26164
+ * # Copyright (C) 2014 Michael Plugge <konto_check@yahoo.com> #
26157
26165
  * ###########################################################################
26158
26166
  */
26159
26167
 
@@ -26177,7 +26185,7 @@ DLL_EXPORT int kc_id_free(int handle)
26177
26185
  * # cmp_bic() ist die Vergleichsfunktion f�r bic_binsearch() und #
26178
26186
  * # lut_write_scl_blocks() (zum Sortieren der BICs). #
26179
26187
  * # #
26180
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
26188
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com> #
26181
26189
  * ###########################################################################
26182
26190
  */
26183
26191
  static int cmp_bic(const void *ap,const void *bp)
@@ -26197,7 +26205,7 @@ static int cmp_bic(const void *ap,const void *bp)
26197
26205
  * # Die Funktion bic_binsearch() implementiert eine bin�re Suche im #
26198
26206
  * # BIC-Array (rekursiv) #
26199
26207
  * # #
26200
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
26208
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com> #
26201
26209
  * ###########################################################################
26202
26210
  */
26203
26211
  static int bic_binsearch(int links,int rechts,char *bic)
@@ -26222,10 +26230,18 @@ static int bic_binsearch(int links,int rechts,char *bic)
26222
26230
  * # letzten Stellen existiert (Extension BIC); falls dieser auch nicht #
26223
26231
  * # existiert, wird als Letztes ein 8-stelliger BIC gesucht (Wildcard-BIC). #
26224
26232
  * # #
26225
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
26233
+ * # Der zus�tzliche Parameter raw wurde eingef�hrt, da bei den Flags #
26234
+ * # �fters bei 11-stelligen BICs nicht die richtigen Flags angegeben sind #
26235
+ * # (bei den zugeh�rigen Wildcard-BICs (8-stellig) sind mehr Optionen #
26236
+ * # gesetzt), wie z.B. bei WELADEDLLEV oder DEUTDEDBPAL. Falls als erstes #
26237
+ * # Zeichen der BIC ein ! �bergeben wird, werden die originalen Flags #
26238
+ * # zur�ckgegeben, andernfalls die "richtigen". So ist die R�ckgabe von #
26239
+ * # DEUTDEDBPAL z.B. 11011, von !DEUTDEDBPAL jedoch 10000. #
26240
+ * # #
26241
+ * # Copyright (C) 2018, 2023 Michael Plugge <konto_check@yahoo.com> #
26226
26242
  * ###########################################################################
26227
26243
  */
26228
- static int scl_idx(const char *bic,int *retval)
26244
+ static int scl_idx(const char *bic,int *retval,int *raw)
26229
26245
  {
26230
26246
  char such_bic[12];
26231
26247
  int i,idx;
@@ -26234,7 +26250,14 @@ static int scl_idx(const char *bic,int *retval)
26234
26250
  if(retval)*retval=NO_SCL_BLOCKS_LOADED;
26235
26251
  return -1;
26236
26252
  }
26237
- strcpy(such_bic,bic);
26253
+ if(*bic=='!'){
26254
+ *raw=1;
26255
+ strcpy(such_bic,bic+1);
26256
+ }
26257
+ else{
26258
+ *raw=0;
26259
+ strcpy(such_bic,bic);
26260
+ }
26238
26261
  for(i=0;i<11 && such_bic[i];i++)such_bic[i]=toupper(such_bic[i]);
26239
26262
 
26240
26263
  /*
@@ -26258,6 +26281,9 @@ static int scl_idx(const char *bic,int *retval)
26258
26281
  * Punkt 2 hat eine h�here Priorit�t als Punkt 1, denn eine 8-stellige BIC ist mit selbiger
26259
26282
  * um 'XXX' erweiterten BIC identisch.
26260
26283
  *
26284
+ * (Update April 23: das gilt wohl doch nicht so ganz, zumindest nicht bei den Flags...
26285
+ * - die Flags werden jetzt vom Eintrag und dem Wildcard kombiniert)
26286
+ *
26261
26287
  */
26262
26288
 
26263
26289
  if(such_bic[8]==0){ /* Such-BIC 8-stellig angegeben; BIC zuerst mit XXX extension suchen */
@@ -26309,21 +26335,22 @@ static int scl_idx(const char *bic,int *retval)
26309
26335
  * # direkter Download-Link: #
26310
26336
  * # https://www.bundesbank.de/Redaktion/DE/Downloads/Aufgaben/Unbarer_Zahlungsverkehr/SEPA/verzeichnis_der_erreichbaren_zahlungsdienstleister.csv?__blob=publicationFile
26311
26337
  * # #
26312
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
26338
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com> #
26313
26339
  * ###########################################################################
26314
26340
  */
26315
26341
  DLL_EXPORT int lut_write_scl_blocks(char *inputfile,char *lutfile)
26316
26342
  {
26317
- char c,*ptr,buffer[512],*scl_name_block_s,*scl_bic_block_s,*scl_flags_block_s,*ptr1,*ptr2,*ptr3;
26343
+ char c,*ptr,buffer[512],buffer2[128],*scl_name_block_s,*scl_bic_block_s,
26344
+ *scl_flags_block_s,*scl_flags_block_o,*ptr1,*ptr2,*ptr3,*ptr4,*base_ptr="";
26318
26345
  char scl_gueltigkeit[16],scl_gueltigkeit_iso[16];
26319
- int cnt,i,rv,j,*iptr,jahr,monat,tag;
26346
+ int cnt,i,j,rv,*iptr,jahr,monat,tag,f1,f2,f3,f4,f5;
26320
26347
  FILE *in,*lut;
26321
26348
  struct stat stat_buffer;
26322
26349
  struct tm z;
26323
26350
  time_t ts;
26324
26351
 
26325
26352
  if(!(in=fopen(inputfile,"r")))RETURN(FILE_READ_ERROR);
26326
- fgets(buffer,512,in);
26353
+ if(!fgets(buffer,512,in))RETURN(SCL_INPUT_FORMAT_ERROR);
26327
26354
  if(strncmp(buffer,"Gueltig ab / valid from ",24))return SCL_INPUT_FORMAT_ERROR;
26328
26355
  for(ptr=buffer;!isdigit(*ptr);ptr++);
26329
26356
  strncpy(scl_gueltigkeit,ptr,16);
@@ -26337,26 +26364,31 @@ DLL_EXPORT int lut_write_scl_blocks(char *inputfile,char *lutfile)
26337
26364
  z.tm_mon=monat;
26338
26365
  z.tm_year=jahr-1900;
26339
26366
  ts=mktime(&z);
26340
- snprintf(scl_gueltigkeit_iso,16,"%4d-%02d-%02d",jahr,monat,tag);
26341
- fgets(buffer,512,in);
26342
- if(strncmp(buffer,"BIC;Name;Service SCT;Service SDD;Service COR1;Service B2B;Service SCC",69))RETURN(SCL_INPUT_FORMAT_ERROR);
26343
-
26367
+ snprintf(scl_gueltigkeit_iso,16,"%4d-%02d-%02d",jahr%10000,monat%100,tag%100);
26368
+ if(!fgets(buffer,512,in))RETURN(SCL_INPUT_FORMAT_ERROR);
26369
+ /* Leerzeichen aus dem �berschrift-String entfernen */
26370
+ for(ptr=buffer,ptr2=buffer2;*ptr;ptr++)if(!isspace(*ptr))*ptr2++=*ptr;
26371
+ if(strncmp(buffer2,"BIC;Name;SERVICESCT;SERVICECOR;SERVICECOR1;SERVICEB2B;SERVICESCC",64))RETURN(SCL_INPUT_FORMAT_ERROR);
26344
26372
  stat(inputfile,&stat_buffer);
26345
- cnt=stat_buffer.st_size/163+100; /* etwas gro�z�gig die Anzahl rechnen */
26373
+
26374
+ cnt=stat_buffer.st_size/163+300; /* etwas gro�z�gig die Anzahl rechnen; jede Zeile hat 163 Bytes und ist am Ende mit Leerzeichen aufgef�llt */
26346
26375
 
26347
26376
  scl_bic_array=(char **)calloc(sizeof(char*),cnt);
26348
26377
  scl_name_array=(char **)calloc(sizeof(char*),cnt);
26349
26378
  scl_flags_array=(char **)calloc(sizeof(char*),cnt);
26379
+ scl_flags_array_o=(char **)calloc(sizeof(char*),cnt);
26350
26380
 
26351
26381
  scl_bic_block=ptr1=(char *)calloc(12,cnt);
26352
26382
  scl_name_block=ptr2=(char *)calloc(150,cnt);
26353
26383
  scl_flags_block=ptr3=(char *)calloc(6,cnt);
26384
+ scl_flags_block_orig=ptr4=(char *)calloc(6,cnt);
26354
26385
 
26355
26386
  /* SCL-Datei einlesen */
26356
26387
  for(cnt=0;fgets(buffer,512,in);){
26357
26388
  scl_bic_array[cnt]=ptr1;
26358
26389
  scl_name_array[cnt]=ptr2;
26359
26390
  scl_flags_array[cnt]=ptr3;
26391
+ scl_flags_array_o[cnt]=ptr4;
26360
26392
  cnt++;
26361
26393
  for(ptr=buffer;*ptr!=';' && !isspace(*ptr);*ptr1++=*ptr++);
26362
26394
  c=*ptr;
@@ -26371,12 +26403,12 @@ DLL_EXPORT int lut_write_scl_blocks(char *inputfile,char *lutfile)
26371
26403
  ptr2++;
26372
26404
 
26373
26405
  /* ptr steht nun auf den Flags */
26374
- *ptr3++=*ptr;
26375
- *ptr3++=*(ptr+2);
26376
- *ptr3++=*(ptr+4);
26377
- *ptr3++=*(ptr+6);
26378
- *ptr3++=*(ptr+8);
26379
- *ptr3++=0;
26406
+ *ptr4++=*ptr3++=*ptr;
26407
+ *ptr4++=*ptr3++=*(ptr+2);
26408
+ *ptr4++=*ptr3++=*(ptr+4);
26409
+ *ptr4++=*ptr3++=*(ptr+6);
26410
+ *ptr4++=*ptr3++=*(ptr+8);
26411
+ *ptr4++=*ptr3++=0;
26380
26412
  }
26381
26413
  fclose(in);
26382
26414
 
@@ -26387,14 +26419,68 @@ DLL_EXPORT int lut_write_scl_blocks(char *inputfile,char *lutfile)
26387
26419
  /* vor dem Abspeichern der Blocks nach BICs sortieren */
26388
26420
  qsort(iptr,cnt,sizeof(int),cmp_bic);
26389
26421
 
26422
+ /* Auszug aus dem SCL-Merkblatt:
26423
+ * Das SCL-Directory enth�lt elfstellige und achtstellige BICs. Dabei gilt:
26424
+ *
26425
+ * - Ein achtstelliger BIC ist eine sog. Wildcard und repr�sentiert die Erreichbarkeit eines
26426
+ * jeden elfstelligen BICs mit identischen ersten acht Stellen sowie die Erreichbarkeit
26427
+ * des achtstelligen BICs selbst.
26428
+ *
26429
+ * - Ein elfstelliger BIC mit der Branch Code Extension XXX repr�sentiert sich selbst
26430
+ * sowie die Erreichbarkeit des zugeh�rigen achtstelligen BICs. Er stellt jedoch keine
26431
+ * Wildcard dar.
26432
+ *
26433
+ * - Alle �brigen elfstelligen BICs repr�sentieren ausschlie�lich die Erreichbarkeit des
26434
+ * jeweiligen einzelnen elfstelligen BICs.
26435
+ *
26436
+ * Ein Zahlungsdienstleister, der mit einer Wildcard im SCL-Directory ausgewiesen wird, muss
26437
+ * Zahlungen f�r alle denkbaren elfstelligen BICs, die durch die Wildcard repr�sentiert werden,
26438
+ * aufnehmen.
26439
+ *
26440
+ * D.h., bei 11-stelligen BICs, zu denen eine 8-stellige Wildcard-BIC existiert, sind die Flags
26441
+ * aus beiden Varianten zu kombinieren. Beispiel:
26442
+ *
26443
+ * WELADEDL;SPARKASSE LEVERKUSEN;1;1;0;1;1
26444
+ * WELADEDLLEV;SPARKASSE LEVERKUSEN;1;0;0;0;0
26445
+ *
26446
+ * Die resultierenden Flags f�r WELADEDLLEV werden aus den beiden BICs zusammengesetzt zu 1;1;0;1;1
26447
+ *
26448
+ * Um das Verhalten auch f�r �ltere Installationen von konto_check zu implementieren, wird in die LUT-Datei
26449
+ * ein Block mit den resultierenden Flags als SCL Flags (ID 31) geschrieben; die Original-Version findet sich
26450
+ * als ID 32 mit der Bezeichnung SCL Flags orig, und wird von �teren Installationen ignoriert.
26451
+ *
26452
+ * Von der Problematik betroffen sind in der aktuellen Datei (Stand April 2023) 68 BICs, davon 8 deutsche.
26453
+ */
26454
+
26455
+ f1=f2=f3=f4=f5=0;
26390
26456
  ptr1=scl_bic_block_s=(char *)calloc(1,ptr1-scl_bic_block+16);
26391
26457
  ptr2=scl_name_block_s=(char *)calloc(1,ptr2-scl_name_block+16);
26392
26458
  ptr3=scl_flags_block_s=(char *)calloc(1,ptr3-scl_flags_block+16);
26459
+ ptr4=scl_flags_block_o=(char *)calloc(1,ptr4-scl_flags_block_orig+16);
26393
26460
  for(i=0;i<cnt;i++){
26394
26461
  j=iptr[i];
26395
26462
  for(ptr=scl_bic_array[j];(*ptr1++=*ptr++););
26396
26463
  for(ptr=scl_name_array[j];(*ptr2++=*ptr++););
26397
26464
  for(ptr=scl_flags_array[j];(*ptr3++=*ptr++););
26465
+ if(strlen(scl_bic_array[j])==8){
26466
+ base_ptr=scl_bic_array[j]; /* 8-stelliger BIC, Flags merken */
26467
+ f1=*(scl_flags_array[j]+0)-'0';
26468
+ f2=*(scl_flags_array[j]+1)-'0';
26469
+ f3=*(scl_flags_array[j]+2)-'0';
26470
+ f4=*(scl_flags_array[j]+3)-'0';
26471
+ f5=*(scl_flags_array[j]+4)-'0';
26472
+ }
26473
+ if(!strncmp(scl_bic_array[j],base_ptr,8)){
26474
+ ptr=scl_flags_array_o[j];
26475
+ if(*ptr++=='1' || f1)*ptr4++='1'; else *ptr4++='0';
26476
+ if(*ptr++=='1' || f2)*ptr4++='1'; else *ptr4++='0';
26477
+ if(*ptr++=='1' || f3)*ptr4++='1'; else *ptr4++='0';
26478
+ if(*ptr++=='1' || f4)*ptr4++='1'; else *ptr4++='0';
26479
+ if(*ptr++=='1' || f5)*ptr4++='1'; else *ptr4++='0';
26480
+ *ptr4++=0;
26481
+ }
26482
+ else
26483
+ for(ptr=scl_flags_array_o[j];(*ptr4++=*ptr++););
26398
26484
  }
26399
26485
  free(iptr);
26400
26486
 
@@ -26408,13 +26494,14 @@ DLL_EXPORT int lut_write_scl_blocks(char *inputfile,char *lutfile)
26408
26494
  if(strcmp(buffer,"BLZ Lookup Table/Format 2."))RETURN(INVALID_LUT_FILE); /* keine LUT-Datei */
26409
26495
 
26410
26496
  /* nun die Blocks schreiben */
26411
- rewind(lut);
26412
- sprintf(buffer,"cnt: %d, TS: %ld, Gueltigkeit: %s %s",cnt,(long)ts,scl_gueltigkeit,scl_gueltigkeit_iso);
26497
+ rewind(lut); /* Info schreiben da� korrigierte Flags */
26498
+ sprintf(buffer,"cnt: %d, TS: %ld, Gueltigkeit: %s %s korrigiert",cnt,(long)ts,scl_gueltigkeit,scl_gueltigkeit_iso);
26413
26499
  if((rv=write_lut_block_int(lut,LUT2_SCL_INFO,strlen(buffer)+1,buffer))!=OK){
26414
26500
  fclose(lut);
26415
26501
  FREE(scl_bic_block_s);
26416
26502
  FREE(scl_name_block_s);
26417
26503
  FREE(scl_flags_block_s);
26504
+ FREE(scl_flags_block_o);
26418
26505
  RETURN(rv);
26419
26506
  }
26420
26507
  if((rv=write_lut_block_int(lut,LUT2_SCL_BIC,(UINT4)(ptr1-scl_bic_block_s+1),scl_bic_block_s))!=OK){
@@ -26422,6 +26509,7 @@ DLL_EXPORT int lut_write_scl_blocks(char *inputfile,char *lutfile)
26422
26509
  FREE(scl_bic_block_s);
26423
26510
  FREE(scl_name_block_s);
26424
26511
  FREE(scl_flags_block_s);
26512
+ FREE(scl_flags_block_o);
26425
26513
  RETURN(rv);
26426
26514
  }
26427
26515
  if((rv=write_lut_block_int(lut,LUT2_SCL_NAME,(UINT4)(ptr2-scl_name_block_s+1),scl_name_block_s))!=OK){
@@ -26429,13 +26517,23 @@ DLL_EXPORT int lut_write_scl_blocks(char *inputfile,char *lutfile)
26429
26517
  FREE(scl_bic_block_s);
26430
26518
  FREE(scl_name_block_s);
26431
26519
  FREE(scl_flags_block_s);
26520
+ FREE(scl_flags_block_o);
26521
+ RETURN(rv);
26522
+ }
26523
+ if((rv=write_lut_block_int(lut,LUT2_SCL_FLAGS,(UINT4)(ptr4-scl_flags_block_o+1),scl_flags_block_o))!=OK){
26524
+ fclose(lut);
26525
+ FREE(scl_bic_block_s);
26526
+ FREE(scl_name_block_s);
26527
+ FREE(scl_flags_block_s);
26528
+ FREE(scl_flags_block_o);
26432
26529
  RETURN(rv);
26433
26530
  }
26434
- if((rv=write_lut_block_int(lut,LUT2_SCL_FLAGS,(UINT4)(ptr3-scl_flags_block_s+1),scl_flags_block_s))!=OK){
26531
+ if((rv=write_lut_block_int(lut,LUT2_SCL_FLAGS_ORIG,(UINT4)(ptr3-scl_flags_block_s+1),scl_flags_block_s))!=OK){
26435
26532
  fclose(lut);
26436
26533
  FREE(scl_bic_block_s);
26437
26534
  FREE(scl_name_block_s);
26438
26535
  FREE(scl_flags_block_s);
26536
+ FREE(scl_flags_block_o);
26439
26537
  RETURN(rv);
26440
26538
  }
26441
26539
 
@@ -26443,6 +26541,7 @@ DLL_EXPORT int lut_write_scl_blocks(char *inputfile,char *lutfile)
26443
26541
  FREE(scl_bic_block_s);
26444
26542
  FREE(scl_name_block_s);
26445
26543
  FREE(scl_flags_block_s);
26544
+ FREE(scl_flags_block_o);
26446
26545
  RETURN(OK);
26447
26546
  }
26448
26547
 
@@ -26451,17 +26550,17 @@ DLL_EXPORT int lut_write_scl_blocks(char *inputfile,char *lutfile)
26451
26550
  * # Die Funktion lut_scl_init() liest die SCL-Blocks aus einer LUT-Datei #
26452
26551
  * # und initialisiert die zugeh�rigen internen Datenstrukturen. #
26453
26552
  * # #
26454
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
26553
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com> #
26455
26554
  * ###########################################################################
26456
26555
  */
26457
26556
  DLL_EXPORT int lut_scl_init(char *lut_name)
26458
26557
  {
26459
26558
  char *ptr,*end;
26460
26559
  int i,cnt,rv;
26461
- static UINT4 block_size_0,block_size_1,block_size_2,block_size_3;
26560
+ static UINT4 block_size_0,block_size_1,block_size_2,block_size_3,block_size_4;
26462
26561
  FILE *lut;
26463
26562
 
26464
- if(scl_bic_array && scl_name_array && scl_flags_array)return OK; /* schon initialisiert */
26563
+ if(scl_bic_array && scl_name_array && scl_flags_array && scl_flags_array_o)return OK; /* schon initialisiert */
26465
26564
 
26466
26565
  if(!(lut=fopen(lut_name,"rb")))RETURN(FILE_READ_ERROR);
26467
26566
  if((rv=read_lut_block_int(lut,0,LUT2_SCL_INFO,&block_size_0,&scl_info_block))<0){
@@ -26492,6 +26591,15 @@ DLL_EXPORT int lut_scl_init(char *lut_name)
26492
26591
  else
26493
26592
  return rv;
26494
26593
  }
26594
+ if((rv=read_lut_block_int(lut,0,LUT2_SCL_FLAGS_ORIG,&block_size_4,&scl_flags_block_orig))<0){
26595
+ /* hier retval<0 ignorieren, denn bei alten LUT_Dateien ist der Block nicht enthalten.
26596
+ * In dem Fall kann der Block durch den Block LUT2_SCL_FLAGS ersetzt werden. Die BIC Flags
26597
+ * sind in dem Fall dann nicht korrigiert. Lohnt sich nicht, das hier zu machen, da die
26598
+ * LUT-Dateien die mit dieser Version erzeugt werden, den Block enthalten.
26599
+ */
26600
+ scl_flags_block_orig=scl_flags_block;
26601
+ block_size_4=block_size_3;
26602
+ }
26495
26603
  fclose(lut);
26496
26604
  if((i=sscanf(scl_info_block,"cnt: %d, TS: %ld, Gueltigkeit: %15s %15s",
26497
26605
  &cnt,&scl_ts,(char *)&scl_gueltigkeit,(char *)&scl_gueltigkeit_iso))!=4)RETURN(INVALID_SCL_INFO_BLOCK);
@@ -26499,6 +26607,7 @@ DLL_EXPORT int lut_scl_init(char *lut_name)
26499
26607
  scl_bic_array=(char **)calloc(sizeof(char*),cnt);
26500
26608
  scl_name_array=(char **)calloc(sizeof(char*),cnt);
26501
26609
  scl_flags_array=(char **)calloc(sizeof(char*),cnt);
26610
+ scl_flags_array_o=(char **)calloc(sizeof(char*),cnt);
26502
26611
 
26503
26612
  for(i=0,ptr=scl_bic_block,end=scl_bic_block+block_size_1;i<cnt && ptr<end;i++){
26504
26613
  scl_bic_array[i]=ptr;
@@ -26514,6 +26623,11 @@ DLL_EXPORT int lut_scl_init(char *lut_name)
26514
26623
  scl_flags_array[i++]=ptr;
26515
26624
  while(*ptr++ && ptr<end);
26516
26625
  }
26626
+
26627
+ for(i=0,ptr=scl_flags_block_orig,end=scl_flags_block_orig+block_size_4;i<cnt && ptr<end;){
26628
+ scl_flags_array_o[i++]=ptr;
26629
+ while(*ptr++ && ptr<end);
26630
+ }
26517
26631
  scl_cnt=cnt;
26518
26632
  RETURN(OK);
26519
26633
  }
@@ -26523,7 +26637,7 @@ DLL_EXPORT int lut_scl_init(char *lut_name)
26523
26637
  * # Die Funktion lut_scl_info() gibt Infos �ber die Anzahl der Eintr�ge im #
26524
26638
  * # SCL-Verzeichnis sowie das Datum, ab wann die Datei g�ltig ist. #
26525
26639
  * # #
26526
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
26640
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com> #
26527
26641
  * ###########################################################################
26528
26642
  */
26529
26643
  DLL_EXPORT int lut_scl_info(char *lutfile,int *cnt,const char **gueltigkeit,const char **gueltigkeit_iso)
@@ -26559,16 +26673,16 @@ DLL_EXPORT int lut_scl_info(char *lutfile,int *cnt,const char **gueltigkeit,cons
26559
26673
  * # Die Funktion lut_scl_multi() gibt alle Eintr�ge des SCL-Verzeichnisses #
26560
26674
  * # zu einem gegebenen BIC zur�ck. #
26561
26675
  * # #
26562
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
26676
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com> #
26563
26677
  * ###########################################################################
26564
26678
  */
26565
26679
  DLL_EXPORT int lut_scl_multi(char *bic,const char **scl_flags,const char **used_bic,const char **scl_name)
26566
26680
  {
26567
- int i,rv;
26681
+ int i,rv,raw;
26568
26682
 
26569
- i=scl_idx(bic,&rv);
26683
+ i=scl_idx(bic,&rv,&raw);
26570
26684
  if(rv<0)return rv;
26571
- if(scl_flags)*scl_flags=scl_flags_array[i];
26685
+ if(scl_flags)*scl_flags=raw?scl_flags_array_o[i]:scl_flags_array[i];
26572
26686
  if(used_bic)*used_bic=scl_bic_array[i];
26573
26687
  if(scl_name)*scl_name=scl_name_array[i];
26574
26688
  return rv;
@@ -26581,15 +26695,15 @@ DLL_EXPORT int lut_scl_multi(char *bic,const char **scl_flags,const char **used_
26581
26695
  * # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den #
26582
26696
  * # entsprechende Fehlercode (<0) gesetzt. #
26583
26697
  * # #
26584
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
26698
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com> #
26585
26699
  * ###########################################################################
26586
26700
  */
26587
26701
  DLL_EXPORT int lut_scl_sct(char *bic,int *retval)
26588
26702
  {
26589
26703
  char *flags;
26590
- int i,rv;
26704
+ int i,rv,raw;
26591
26705
 
26592
- i=scl_idx(bic,&rv);
26706
+ i=scl_idx(bic,&rv,&raw);
26593
26707
  if(rv<0){
26594
26708
  if(retval)*retval=rv;
26595
26709
  return -1;
@@ -26607,15 +26721,15 @@ DLL_EXPORT int lut_scl_sct(char *bic,int *retval)
26607
26721
  * # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den #
26608
26722
  * # entsprechende Fehlercode (<0) gesetzt. #
26609
26723
  * # #
26610
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
26724
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com> #
26611
26725
  * ###########################################################################
26612
26726
  */
26613
26727
  DLL_EXPORT int lut_scl_sdd(char *bic,int *retval)
26614
26728
  {
26615
26729
  char *flags;
26616
- int i,rv;
26730
+ int i,rv,raw;
26617
26731
 
26618
- i=scl_idx(bic,&rv);
26732
+ i=scl_idx(bic,&rv,&raw);
26619
26733
  if(rv<0){
26620
26734
  if(retval)*retval=rv;
26621
26735
  return -1;
@@ -26634,15 +26748,15 @@ DLL_EXPORT int lut_scl_sdd(char *bic,int *retval)
26634
26748
  * # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den #
26635
26749
  * # entsprechende Fehlercode (<0) gesetzt. #
26636
26750
  * # #
26637
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
26751
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com> #
26638
26752
  * ###########################################################################
26639
26753
  */
26640
26754
  DLL_EXPORT int lut_scl_cor1(char *bic,int *retval)
26641
26755
  {
26642
26756
  char *flags;
26643
- int i,rv;
26757
+ int i,rv,raw;
26644
26758
 
26645
- i=scl_idx(bic,&rv);
26759
+ i=scl_idx(bic,&rv,&raw);
26646
26760
  if(rv<0){
26647
26761
  if(retval)*retval=rv;
26648
26762
  return -1;
@@ -26660,15 +26774,15 @@ DLL_EXPORT int lut_scl_cor1(char *bic,int *retval)
26660
26774
  * # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den #
26661
26775
  * # entsprechende Fehlercode (<0) gesetzt. #
26662
26776
  * # #
26663
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
26777
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com> #
26664
26778
  * ###########################################################################
26665
26779
  */
26666
26780
  DLL_EXPORT int lut_scl_b2b(char *bic,int *retval)
26667
26781
  {
26668
26782
  char *flags;
26669
- int i,rv;
26783
+ int i,rv,raw;
26670
26784
 
26671
- i=scl_idx(bic,&rv);
26785
+ i=scl_idx(bic,&rv,&raw);
26672
26786
  if(rv<0){
26673
26787
  if(retval)*retval=rv;
26674
26788
  return -1;
@@ -26686,15 +26800,15 @@ DLL_EXPORT int lut_scl_b2b(char *bic,int *retval)
26686
26800
  * # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den #
26687
26801
  * # entsprechende Fehlercode (<0) gesetzt. #
26688
26802
  * # #
26689
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
26803
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com> #
26690
26804
  * ###########################################################################
26691
26805
  */
26692
26806
  DLL_EXPORT int lut_scl_scc(char *bic,int *retval)
26693
26807
  {
26694
26808
  char *flags;
26695
- int i,rv;
26809
+ int i,rv,raw;
26696
26810
 
26697
- i=scl_idx(bic,&rv);
26811
+ i=scl_idx(bic,&rv,&raw);
26698
26812
  if(rv<0){
26699
26813
  if(retval)*retval=rv;
26700
26814
  return -1;
@@ -26712,17 +26826,17 @@ DLL_EXPORT int lut_scl_scc(char *bic,int *retval)
26712
26826
  * # einen BIC umgewandelt werden mu�, m�ssen auch die Blocks BLZ und BIC #
26713
26827
  * # der LUT-Datei initialisiert sein, sonst wird ein Fehler zur�ckgegeben. #
26714
26828
  * # #
26715
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
26829
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com> #
26716
26830
  * ###########################################################################
26717
26831
  */
26718
26832
  DLL_EXPORT int lut_scl_multi_blz(char *blz,const char **scl_flags,const char **used_bic,const char **scl_name)
26719
26833
  {
26720
26834
  const char *bic;
26721
- int i,rv;
26835
+ int i,rv,raw;
26722
26836
 
26723
26837
  bic=lut_bic(blz,0,&rv);
26724
26838
  if(rv<0)return rv;
26725
- i=scl_idx(bic,&rv);
26839
+ i=scl_idx(bic,&rv,&raw);
26726
26840
  if(rv<0)return rv;
26727
26841
  if(scl_flags)*scl_flags=scl_flags_array[i];
26728
26842
  if(used_bic)*used_bic=scl_bic_array[i];
@@ -26737,14 +26851,14 @@ DLL_EXPORT int lut_scl_multi_blz(char *blz,const char **scl_flags,const char **u
26737
26851
  * # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den #
26738
26852
  * # entsprechende Fehlercode (<0) gesetzt. #
26739
26853
  * # #
26740
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
26854
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com> #
26741
26855
  * ###########################################################################
26742
26856
  */
26743
26857
  DLL_EXPORT int lut_scl_sct_blz(char *blz,int *retval,const char **used_bic)
26744
26858
  {
26745
26859
  char *flags;
26746
26860
  const char *bic;
26747
- int i,rv;
26861
+ int i,rv,raw;
26748
26862
 
26749
26863
  bic=lut_bic(blz,0,&rv);
26750
26864
  if(rv<0){
@@ -26753,7 +26867,7 @@ DLL_EXPORT int lut_scl_sct_blz(char *blz,int *retval,const char **used_bic)
26753
26867
  }
26754
26868
  else
26755
26869
  if(retval)*retval=OK;
26756
- i=scl_idx(bic,&rv);
26870
+ i=scl_idx(bic,&rv,&raw);
26757
26871
  if(rv<0){
26758
26872
  if(retval)*retval=rv;
26759
26873
  return -1;
@@ -26772,14 +26886,14 @@ DLL_EXPORT int lut_scl_sct_blz(char *blz,int *retval,const char **used_bic)
26772
26886
  * # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den #
26773
26887
  * # entsprechende Fehlercode (<0) gesetzt. #
26774
26888
  * # #
26775
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
26889
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com> #
26776
26890
  * ###########################################################################
26777
26891
  */
26778
26892
  DLL_EXPORT int lut_scl_sdd_blz(char *blz,int *retval,const char **used_bic)
26779
26893
  {
26780
26894
  char *flags;
26781
26895
  const char *bic;
26782
- int i,rv;
26896
+ int i,rv,raw;
26783
26897
 
26784
26898
  bic=lut_bic(blz,0,&rv);
26785
26899
  if(rv<0){
@@ -26788,7 +26902,7 @@ DLL_EXPORT int lut_scl_sdd_blz(char *blz,int *retval,const char **used_bic)
26788
26902
  }
26789
26903
  else
26790
26904
  if(retval)*retval=OK;
26791
- i=scl_idx(bic,&rv);
26905
+ i=scl_idx(bic,&rv,&raw);
26792
26906
  if(rv<0){
26793
26907
  if(retval)*retval=rv;
26794
26908
  return -1;
@@ -26808,14 +26922,14 @@ DLL_EXPORT int lut_scl_sdd_blz(char *blz,int *retval,const char **used_bic)
26808
26922
  * # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den #
26809
26923
  * # entsprechende Fehlercode (<0) gesetzt. #
26810
26924
  * # #
26811
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
26925
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com> #
26812
26926
  * ###########################################################################
26813
26927
  */
26814
26928
  DLL_EXPORT int lut_scl_cor1_blz(char *blz,int *retval,const char **used_bic)
26815
26929
  {
26816
26930
  char *flags;
26817
26931
  const char *bic;
26818
- int i,rv;
26932
+ int i,rv,raw;
26819
26933
 
26820
26934
  bic=lut_bic(blz,0,&rv);
26821
26935
  if(rv<0){
@@ -26824,7 +26938,7 @@ DLL_EXPORT int lut_scl_cor1_blz(char *blz,int *retval,const char **used_bic)
26824
26938
  }
26825
26939
  else
26826
26940
  if(retval)*retval=OK;
26827
- i=scl_idx(bic,&rv);
26941
+ i=scl_idx(bic,&rv,&raw);
26828
26942
  if(rv<0){
26829
26943
  if(retval)*retval=rv;
26830
26944
  return -1;
@@ -26843,14 +26957,14 @@ DLL_EXPORT int lut_scl_cor1_blz(char *blz,int *retval,const char **used_bic)
26843
26957
  * # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den #
26844
26958
  * # entsprechende Fehlercode (<0) gesetzt. #
26845
26959
  * # #
26846
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
26960
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com> #
26847
26961
  * ###########################################################################
26848
26962
  */
26849
26963
  DLL_EXPORT int lut_scl_b2b_blz(char *blz,int *retval,const char **used_bic)
26850
26964
  {
26851
26965
  char *flags;
26852
26966
  const char *bic;
26853
- int i,rv;
26967
+ int i,rv,raw;
26854
26968
 
26855
26969
  bic=lut_bic(blz,0,&rv);
26856
26970
  if(rv<0){
@@ -26859,7 +26973,7 @@ DLL_EXPORT int lut_scl_b2b_blz(char *blz,int *retval,const char **used_bic)
26859
26973
  }
26860
26974
  else
26861
26975
  if(retval)*retval=OK;
26862
- i=scl_idx(bic,&rv);
26976
+ i=scl_idx(bic,&rv,&raw);
26863
26977
  if(rv<0){
26864
26978
  if(retval)*retval=rv;
26865
26979
  return -1;
@@ -26878,14 +26992,14 @@ DLL_EXPORT int lut_scl_b2b_blz(char *blz,int *retval,const char **used_bic)
26878
26992
  * # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den #
26879
26993
  * # entsprechende Fehlercode (<0) gesetzt. #
26880
26994
  * # #
26881
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
26995
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com> #
26882
26996
  * ###########################################################################
26883
26997
  */
26884
26998
  DLL_EXPORT int lut_scl_scc_blz(char *blz,int *retval,const char **used_bic)
26885
26999
  {
26886
27000
  char *flags;
26887
27001
  const char *bic;
26888
- int i,rv;
27002
+ int i,rv,raw;
26889
27003
 
26890
27004
  bic=lut_bic(blz,0,&rv);
26891
27005
  if(rv<0){
@@ -26894,7 +27008,7 @@ DLL_EXPORT int lut_scl_scc_blz(char *blz,int *retval,const char **used_bic)
26894
27008
  }
26895
27009
  else
26896
27010
  if(retval)*retval=OK;
26897
- i=scl_idx(bic,&rv);
27011
+ i=scl_idx(bic,&rv,&raw);
26898
27012
  if(rv<0){
26899
27013
  if(retval)*retval=rv;
26900
27014
  return -1;
@@ -26911,17 +27025,17 @@ DLL_EXPORT int lut_scl_scc_blz(char *blz,int *retval,const char **used_bic)
26911
27025
  * # Diese Funktion entspricht der Funktion lut_scl_multi_blz(), nur wird #
26912
27026
  * # die BLZ als Integer-Wert statt als String �bergeben. #
26913
27027
  * # #
26914
- * # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
27028
+ * # Copyright (C) 2018 Michael Plugge <konto_check@yahoo.com> #
26915
27029
  * ###########################################################################
26916
27030
  */
26917
27031
  DLL_EXPORT int lut_scl_multi_blz_i(int blz,const char **scl_flags,const char **used_bic,const char **scl_name)
26918
27032
  {
26919
27033
  const char *bic;
26920
- int i,rv;
27034
+ int i,rv,raw;
26921
27035
 
26922
27036
  bic=lut_bic_i(blz,0,&rv);
26923
27037
  if(rv<0)return rv;
26924
- i=scl_idx(bic,&rv);
27038
+ i=scl_idx(bic,&rv,&raw);
26925
27039
  if(rv<0)return rv;
26926
27040
  if(scl_flags)*scl_flags=scl_flags_array[i];
26927
27041
  if(used_bic)*used_bic=scl_bic_array[i];