konto_check 6.02.0 → 6.13.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +5 -5
- data/ext/konto_check_raw/konto_check.c +927 -400
- data/ext/konto_check_raw/konto_check.h +52 -12
- data/ext/konto_check_raw/konto_check_raw_ruby.c +545 -3
- data/ext/konto_check_raw/retvals.h +40 -0
- data/lib/konto_check.rb +216 -0
- metadata +5 -4
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
|
-
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
2
|
+
SHA256:
|
|
3
|
+
metadata.gz: aa869ca84203c2f9c627a8ed8c9c2fd6da6d8a1c8cb6450ad8954fffb9ca89b3
|
|
4
|
+
data.tar.gz: b35b73763d3f4234753263a757151a6e0de9332b6305c4bad39fe7cb18e9a1ba
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: 3dcf2deacd64ad3dd65632079d387e32658bb844042b568650b7a333d6cf1f7c20bba4a459bf03750337621a0259988ac9679539a16b4b97c0b56585db3e7448
|
|
7
|
+
data.tar.gz: b5e6a983283ec282981a28cb4d5c0c453353c5965d0c2053fe3d2af006e034e792601978e7fb02f058b553f77a2109f330fd901c8603fe87c5c002890c5d15e6
|
|
@@ -13,7 +13,7 @@
|
|
|
13
13
|
* # wurden aus der aktuellen BLZ-Datei der Deutschen Bundesbank #
|
|
14
14
|
* # �bernommen. #
|
|
15
15
|
* # #
|
|
16
|
-
* # Copyright (C) 2002-
|
|
16
|
+
* # Copyright (C) 2002-2020 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
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 #
|
|
@@ -45,15 +45,14 @@
|
|
|
45
45
|
* # im Internet herunterladen. #
|
|
46
46
|
* ##########################################################################
|
|
47
47
|
*/
|
|
48
|
-
#line 332 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
49
48
|
|
|
50
49
|
/* Definitionen und Includes */
|
|
51
50
|
#ifndef VERSION
|
|
52
|
-
#define VERSION "6.
|
|
51
|
+
#define VERSION "6.13 (final)"
|
|
53
52
|
#define VERSION_MAJOR 6
|
|
54
|
-
#define VERSION_MINOR
|
|
53
|
+
#define VERSION_MINOR 13
|
|
55
54
|
#endif
|
|
56
|
-
#define VERSION_DATE "
|
|
55
|
+
#define VERSION_DATE "2020-12-16"
|
|
57
56
|
|
|
58
57
|
#ifndef INCLUDE_KONTO_CHECK_DE
|
|
59
58
|
#define INCLUDE_KONTO_CHECK_DE 1
|
|
@@ -104,8 +103,8 @@ static lzo_align_t __LZO_MMODEL wrkmem[LZO1X_1_MEM_COMPRESS];
|
|
|
104
103
|
#define KONTO_CHECK_VARS
|
|
105
104
|
#include "konto_check.h"
|
|
106
105
|
|
|
107
|
-
/* Flag, um die �nderungen zum Dezember
|
|
108
|
-
static int
|
|
106
|
+
/* Flag, um die �nderungen zum Dezember 2019 zu aktivieren */
|
|
107
|
+
static int pz_aenderungen_aktivieren_2019_12;
|
|
109
108
|
|
|
110
109
|
/* falls die Variable verbose_debug gesetzt wird, werden bei einigen
|
|
111
110
|
* Funktionen mittels perror() zus�tzliche Debuginfos ausgegeben. Die
|
|
@@ -206,6 +205,13 @@ static int name_raw_len,name_kurz_raw_len,name_name_kurz_raw_len,ort_raw_len;
|
|
|
206
205
|
static char **sortc_buf;
|
|
207
206
|
static int *sorti_buf;
|
|
208
207
|
|
|
208
|
+
/* 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,
|
|
211
|
+
scl_gueltigkeit[16],scl_gueltigkeit_iso[16];
|
|
212
|
+
static int scl_cnt;
|
|
213
|
+
long scl_ts;
|
|
214
|
+
|
|
209
215
|
/* Funktionspointer auf die aktuelle Kodierung */
|
|
210
216
|
DLL_EXPORT const char *(*retval_enc)(int)=NULL;
|
|
211
217
|
|
|
@@ -242,7 +248,6 @@ static int convert_encoding(char **data,UINT4 *len);
|
|
|
242
248
|
#define free(ptr) efree(ptr)
|
|
243
249
|
#endif
|
|
244
250
|
|
|
245
|
-
#line 770 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
246
251
|
|
|
247
252
|
/* Testwert zur Markierung ung�ltiger Ziffern im BLZ-String (>8 Stellen) */
|
|
248
253
|
#define BLZ_FEHLER 100000000
|
|
@@ -378,7 +383,6 @@ static int convert_encoding(char **data,UINT4 *len);
|
|
|
378
383
|
*/
|
|
379
384
|
#define CHECK_RETVAL(fkt) do{if((retval=fkt)!=OK)goto fini;}while(0) /* es mu� noch aufger�umt werden, daher goto */
|
|
380
385
|
#define CHECK_RETURN(fkt) do{if((retval=fkt)!=OK)return retval;}while(0)
|
|
381
|
-
#line 911 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
382
386
|
|
|
383
387
|
/* einige Makros zur Umwandlung zwischen unsigned int und char */
|
|
384
388
|
#define UCP (unsigned char*)
|
|
@@ -435,24 +439,24 @@ DLL_EXPORT_V int
|
|
|
435
439
|
lut_set_1[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_KURZ,0},
|
|
436
440
|
lut_set_2[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_KURZ,LUT2_BIC,0},
|
|
437
441
|
lut_set_3[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME,LUT2_PLZ,LUT2_ORT,0},
|
|
438
|
-
lut_set_4[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,
|
|
439
|
-
lut_set_5[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,
|
|
440
|
-
lut_set_6[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,
|
|
441
|
-
lut_set_7[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,
|
|
442
|
-
lut_set_8[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,
|
|
443
|
-
lut_set_9[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,
|
|
444
|
-
lut_set_iban[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_BLZ,LUT2_BIC,LUT2_NACHFOLGE_BLZ,LUT2_LOESCHUNG,LUT2_IBAN_REGEL,
|
|
442
|
+
lut_set_4[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,LUT2_BIC,0},
|
|
443
|
+
lut_set_5[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,LUT2_BIC,0},
|
|
444
|
+
lut_set_6[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,LUT2_BIC,LUT2_NACHFOLGE_BLZ,0},
|
|
445
|
+
lut_set_7[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,LUT2_BIC,LUT2_NACHFOLGE_BLZ,LUT2_LOESCHUNG,0},
|
|
446
|
+
lut_set_8[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,LUT2_BIC,LUT2_NACHFOLGE_BLZ,LUT2_LOESCHUNG,LUT2_PAN,0},
|
|
447
|
+
lut_set_9[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,LUT2_BIC, LUT2_NACHFOLGE_BLZ,LUT2_LOESCHUNG,LUT2_PAN,LUT2_NR,0},
|
|
448
|
+
lut_set_iban[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_BLZ,LUT2_BIC,LUT2_NACHFOLGE_BLZ,LUT2_LOESCHUNG,LUT2_IBAN_REGEL,0}, /* notwendige Felder f�r IBAN-Bestimmung */
|
|
445
449
|
|
|
446
450
|
lut_set_o0[]={LUT2_BLZ,LUT2_PZ,0},
|
|
447
451
|
lut_set_o1[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_KURZ,0},
|
|
448
452
|
lut_set_o2[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_KURZ,LUT2_BIC,0},
|
|
449
453
|
lut_set_o3[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME,LUT2_PLZ,LUT2_ORT,0},
|
|
450
|
-
lut_set_o4[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,
|
|
451
|
-
lut_set_o5[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,
|
|
452
|
-
lut_set_o6[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,
|
|
453
|
-
lut_set_o7[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,
|
|
454
|
-
lut_set_o8[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,
|
|
455
|
-
lut_set_o9[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,
|
|
454
|
+
lut_set_o4[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,LUT2_BIC,0},
|
|
455
|
+
lut_set_o5[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,LUT2_BIC,0},
|
|
456
|
+
lut_set_o6[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,LUT2_BIC,LUT2_NACHFOLGE_BLZ,0},
|
|
457
|
+
lut_set_o7[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,LUT2_BIC,LUT2_NACHFOLGE_BLZ,LUT2_LOESCHUNG,0},
|
|
458
|
+
lut_set_o8[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,LUT2_BIC,LUT2_NACHFOLGE_BLZ,LUT2_LOESCHUNG,LUT2_PAN,0},
|
|
459
|
+
lut_set_o9[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,LUT2_BIC, LUT2_NACHFOLGE_BLZ,LUT2_LOESCHUNG,LUT2_PAN,LUT2_NR,0};
|
|
456
460
|
|
|
457
461
|
#define COMPRESSION_DEFAULT COMPRESSION_ZLIB
|
|
458
462
|
|
|
@@ -498,7 +502,6 @@ int pz=-777;
|
|
|
498
502
|
|
|
499
503
|
#define E_START(x)
|
|
500
504
|
#define E_END(x)
|
|
501
|
-
#line 1036 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
502
505
|
|
|
503
506
|
/* Variable f�r die Methoden 27, 29 und 69 */
|
|
504
507
|
static const int m10h_digits[4][10]={
|
|
@@ -579,7 +582,7 @@ static unsigned char ee[500],*eeh,*eep,eec[]={
|
|
|
579
582
|
0xb3,0xa2,0xf4,0x0f,0x7e,0xb5,0x0a,0xdd,0x54,0xfb,0x74,0x56,0xf5,
|
|
580
583
|
0x16,0x5a,0x53,0x14,0x3d,0xd8,0xbd,0x00,0x8b,0x59,0x95,0x67,0x00
|
|
581
584
|
};
|
|
582
|
-
#define EE
|
|
585
|
+
#define EE 29
|
|
583
586
|
|
|
584
587
|
/* Arrays f�r die Felder der LUT-Datei u.a. */
|
|
585
588
|
static char *lut_prolog,*lut_sys_info,*lut_user_info;
|
|
@@ -947,7 +950,6 @@ static int create_lutfile_int(char *name, char *prolog, int slots,FILE **lut)
|
|
|
947
950
|
* ###########################################################################
|
|
948
951
|
*/
|
|
949
952
|
|
|
950
|
-
#line 1485 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
951
953
|
DLL_EXPORT int write_lut_block(char *lutname,UINT4 typ,UINT4 len,char *data)
|
|
952
954
|
{
|
|
953
955
|
char buffer[SLOT_BUFFER],*ptr;
|
|
@@ -985,7 +987,6 @@ DLL_EXPORT int write_lut_block(char *lutname,UINT4 typ,UINT4 len,char *data)
|
|
|
985
987
|
* #############################################################################
|
|
986
988
|
*/
|
|
987
989
|
|
|
988
|
-
#line 1523 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
989
990
|
static int write_lut_block_int(FILE *lut,UINT4 typ,UINT4 len,char *data)
|
|
990
991
|
{
|
|
991
992
|
char buffer[SLOT_BUFFER],*ptr,*cptr;
|
|
@@ -1121,7 +1122,6 @@ static int write_lut_block_int(FILE *lut,UINT4 typ,UINT4 len,char *data)
|
|
|
1121
1122
|
* ###########################################################################
|
|
1122
1123
|
*/
|
|
1123
1124
|
|
|
1124
|
-
#line 1659 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
1125
1125
|
DLL_EXPORT int read_lut_block(char *lutname, UINT4 typ,UINT4 *blocklen,char **data)
|
|
1126
1126
|
{
|
|
1127
1127
|
int retval;
|
|
@@ -1144,7 +1144,6 @@ DLL_EXPORT int read_lut_block(char *lutname, UINT4 typ,UINT4 *blocklen,char **da
|
|
|
1144
1144
|
* ###########################################################################
|
|
1145
1145
|
*/
|
|
1146
1146
|
|
|
1147
|
-
#line 1683 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
1148
1147
|
DLL_EXPORT int read_lut_slot(char *lutname,int slot,UINT4 *blocklen,char **data)
|
|
1149
1148
|
{
|
|
1150
1149
|
int retval;
|
|
@@ -1166,7 +1165,6 @@ DLL_EXPORT int read_lut_slot(char *lutname,int slot,UINT4 *blocklen,char **data)
|
|
|
1166
1165
|
* ###########################################################################
|
|
1167
1166
|
*/
|
|
1168
1167
|
|
|
1169
|
-
#line 1706 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
1170
1168
|
static int read_lut_block_int(FILE *lut,int slot,int typ,UINT4 *blocklen,char **data)
|
|
1171
1169
|
{
|
|
1172
1170
|
char buffer[SLOT_BUFFER],*ptr,*sbuffer,*dbuffer;
|
|
@@ -1256,7 +1254,6 @@ static int read_lut_block_int(FILE *lut,int slot,int typ,UINT4 *blocklen,char **
|
|
|
1256
1254
|
FREE(sbuffer);
|
|
1257
1255
|
RETURN(ERROR_MALLOC);
|
|
1258
1256
|
}
|
|
1259
|
-
#line 1811 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
1260
1257
|
|
|
1261
1258
|
if(fread(sbuffer,1,compressed_len,lut)<compressed_len){
|
|
1262
1259
|
FREE(sbuffer);
|
|
@@ -2735,6 +2732,38 @@ DLL_EXPORT int lut_valid(void)
|
|
|
2735
2732
|
RETURN(LUT2_NO_LONGER_VALID);
|
|
2736
2733
|
}
|
|
2737
2734
|
|
|
2735
|
+
DLL_EXPORT int lut_valid_date(char *lut_name,int *v11,int *v12,int *v21,int *v22)
|
|
2736
|
+
{
|
|
2737
|
+
char *ptr,*info1,*info2;
|
|
2738
|
+
int retval,v1,v2;
|
|
2739
|
+
|
|
2740
|
+
*v11=*v12=*v21=*v22=0;
|
|
2741
|
+
if((retval=lut_info(lut_name,&info1,&info2,&v1,&v2))!=OK)return retval;
|
|
2742
|
+
if(info1){
|
|
2743
|
+
for(ptr=info1;*ptr && *ptr!='\n' && !isdigit(*ptr);ptr++);
|
|
2744
|
+
if(*ptr && *ptr!='\n'){
|
|
2745
|
+
*v11=strtoul(ptr,NULL,10); /* Anfangsdatum der G�ltigkeit */
|
|
2746
|
+
if(*ptr && *ptr!='\n'){
|
|
2747
|
+
while(*ptr && *ptr!='\n' && *ptr++!='-'); /* Endedatum suchen */
|
|
2748
|
+
if(*ptr)*v12=strtoul(ptr,NULL,10); /* Endedatum der G�ltigkeit */
|
|
2749
|
+
}
|
|
2750
|
+
}
|
|
2751
|
+
free(info1);
|
|
2752
|
+
}
|
|
2753
|
+
if(info2){
|
|
2754
|
+
for(ptr=info2;*ptr && *ptr!='\n' && !isdigit(*ptr);ptr++);
|
|
2755
|
+
if(*ptr && *ptr!='\n'){
|
|
2756
|
+
*v21=strtoul(ptr,NULL,10); /* Anfangsdatum der G�ltigkeit */
|
|
2757
|
+
if(*ptr && *ptr!='\n'){
|
|
2758
|
+
while(*ptr && *ptr!='\n' && *ptr++!='-'); /* Endedatum suchen */
|
|
2759
|
+
if(*ptr)*v22=strtoul(ptr,NULL,10); /* Endedatum der G�ltigkeit */
|
|
2760
|
+
}
|
|
2761
|
+
}
|
|
2762
|
+
free(info2);
|
|
2763
|
+
}
|
|
2764
|
+
return OK;
|
|
2765
|
+
}
|
|
2766
|
+
|
|
2738
2767
|
|
|
2739
2768
|
/* Funktion lut_info_b() +���1 */
|
|
2740
2769
|
/* ###########################################################################
|
|
@@ -2849,7 +2878,6 @@ DLL_EXPORT int lut_info_id(char *lut_name,int *info1,int *info2,int *valid1,int
|
|
|
2849
2878
|
* ###########################################################################
|
|
2850
2879
|
*/
|
|
2851
2880
|
|
|
2852
|
-
#line 3404 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
2853
2881
|
DLL_EXPORT int lut_info(char *lut_name,char **info1,char **info2,int *valid1,int *valid2)
|
|
2854
2882
|
{
|
|
2855
2883
|
char *ptr,*ptr1,buffer[128];
|
|
@@ -2937,7 +2965,6 @@ DLL_EXPORT int lut_info(char *lut_name,char **info1,char **info2,int *valid1,int
|
|
|
2937
2965
|
|
|
2938
2966
|
/* Infoblocks lesen: 1. Infoblock */
|
|
2939
2967
|
if((ret=read_lut_block_int(in,0,LUT2_INFO,&cnt,&ptr))==OK){
|
|
2940
|
-
#line 3493 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
2941
2968
|
*(ptr+cnt)=0;
|
|
2942
2969
|
if(valid1){
|
|
2943
2970
|
for(ptr1=ptr,v1=v2=0;*ptr1 && *ptr1!='\n' && !isdigit(*ptr1);ptr1++);
|
|
@@ -2985,7 +3012,6 @@ DLL_EXPORT int lut_info(char *lut_name,char **info1,char **info2,int *valid1,int
|
|
|
2985
3012
|
|
|
2986
3013
|
/* Infoblocks lesen: 2. Infoblock */
|
|
2987
3014
|
if((ret=read_lut_block_int(in,0,LUT2_2_INFO,&cnt,&ptr))==OK){
|
|
2988
|
-
#line 3542 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
2989
3015
|
*(ptr+cnt)=0;
|
|
2990
3016
|
if(valid2){
|
|
2991
3017
|
for(ptr1=ptr,v1=v2=0;*ptr1 && *ptr1!='\n' && !isdigit(*ptr1);ptr1++);
|
|
@@ -3204,7 +3230,6 @@ DLL_EXPORT int copy_lutfile(char *old_name,char *new_name,int new_slots)
|
|
|
3204
3230
|
qsort(slotdir,slot_cnt,sizeof(int),cmp_int);
|
|
3205
3231
|
for(last_slot=-1,i=0;i<(int)slot_cnt;i++)if((typ=slotdir[i]) && typ!=(UINT4)last_slot){
|
|
3206
3232
|
read_lut_block_int(lut1,0,typ,&len,&data);
|
|
3207
|
-
#line 3762 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
3208
3233
|
write_lut_block_int(lut2,typ,len,data);
|
|
3209
3234
|
FREE(data);
|
|
3210
3235
|
last_slot=typ;
|
|
@@ -3434,7 +3459,6 @@ DLL_EXPORT int lut_init(char *lut_name,int required,int set)
|
|
|
3434
3459
|
* # Copyright (C) 2008 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
3435
3460
|
* ###########################################################################
|
|
3436
3461
|
*/
|
|
3437
|
-
#line 3992 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
3438
3462
|
DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,int incremental)
|
|
3439
3463
|
{
|
|
3440
3464
|
char *ptr,*dptr,*data,*eptr,*prolog,*info,*user_info,*hs=NULL,*info1,*info2,*ci=NULL,name_buffer[LUT_PATH_LEN];
|
|
@@ -3662,7 +3686,6 @@ DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,
|
|
|
3662
3686
|
typ1=typ;
|
|
3663
3687
|
if(lut2_block_status[typ]==OK)continue; /* jeden Block nur einmal einlesen */
|
|
3664
3688
|
retval=read_lut_block_int(lut,0,typ,&len,&data);
|
|
3665
|
-
#line 4221 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
3666
3689
|
|
|
3667
3690
|
switch(retval){
|
|
3668
3691
|
case LUT_CRC_ERROR:
|
|
@@ -3750,7 +3773,6 @@ DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,
|
|
|
3750
3773
|
if(typ==LUT2_2_NAME || typ==LUT2_2_NAME_KURZ){
|
|
3751
3774
|
FREE(data);
|
|
3752
3775
|
i=read_lut_block_int(lut,0,LUT2_2_NAME_NAME_KURZ,&len,&data);
|
|
3753
|
-
#line 4313 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
3754
3776
|
if(i==OK){ /* was gefunden; Typ �ndern, dann weiter wie bei OK */
|
|
3755
3777
|
typ=LUT2_2_NAME_NAME_KURZ;
|
|
3756
3778
|
typ1=LUT2_NAME_NAME_KURZ;
|
|
@@ -3773,10 +3795,20 @@ DLL_EXPORT int kto_check_init(char *lut_name,int *required,int **status,int set,
|
|
|
3773
3795
|
* LUT2_OWN_IBAN nicht geladen werden konnte, wird der Block in
|
|
3774
3796
|
* der Funktion lut_blocks() als nicht geladen angegeben; bei
|
|
3775
3797
|
* lut_init() wird dagegen OK zur�ckgegeben.
|
|
3798
|
+
*
|
|
3799
|
+
* Die SCL-Blocks sind ebenfalls nicht immer in der LUT-Datei vorhanden.
|
|
3800
|
+
* und sollen daher keine Warnung erzeugen.
|
|
3776
3801
|
*/
|
|
3777
|
-
|
|
3778
|
-
|
|
3779
|
-
|
|
3802
|
+
switch(typ){
|
|
3803
|
+
case LUT2_OWN_IBAN:
|
|
3804
|
+
case LUT2_2_OWN_IBAN:
|
|
3805
|
+
case LUT2_FILIALEN:
|
|
3806
|
+
case LUT2_2_FILIALEN:
|
|
3807
|
+
break;
|
|
3808
|
+
default:
|
|
3809
|
+
alles_ok=0;
|
|
3810
|
+
lut_blocks_missing++;
|
|
3811
|
+
break;
|
|
3780
3812
|
}
|
|
3781
3813
|
lut2_block_len[typ]=lut2_block_len[typ1]=0;
|
|
3782
3814
|
lut2_block_data[typ]=lut2_block_data[typ1]=NULL;
|
|
@@ -4346,7 +4378,6 @@ DLL_EXPORT int lut_blocks_id(int mode,int *lut_filename,int *lut_blocks_ok,int *
|
|
|
4346
4378
|
* ###########################################################################
|
|
4347
4379
|
*/
|
|
4348
4380
|
|
|
4349
|
-
#line 4909 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
4350
4381
|
DLL_EXPORT const char *current_lutfile_name(int *set,int *level,int *retval)
|
|
4351
4382
|
{
|
|
4352
4383
|
if(init_status<7 || !current_lutfile){
|
|
@@ -4754,6 +4785,7 @@ DLL_EXPORT const char *lut_bic(char *b,int zweigstelle,int *retval)
|
|
|
4754
4785
|
if(retval)*retval=ret;
|
|
4755
4786
|
return NULL;
|
|
4756
4787
|
}
|
|
4788
|
+
memcpy(kto2,"0000000000",10); /* f�r valgrind (kto2 ist nur ein Dummy) */
|
|
4757
4789
|
bic=lut_bic_int(b,zweigstelle,retval); /* BIC aus der LUT-Datei holen */
|
|
4758
4790
|
regel=lut_iban_regel(b,0,&ret);
|
|
4759
4791
|
if(retval && ret==OK){ /* Test nur notwendig, falls retval nicht NULL */
|
|
@@ -4761,7 +4793,6 @@ DLL_EXPORT const char *lut_bic(char *b,int zweigstelle,int *retval)
|
|
|
4761
4793
|
*retval=OK_HYPO_REQUIRES_KTO; /* Sonderfall ehemalige Hypobank */
|
|
4762
4794
|
else{
|
|
4763
4795
|
strcpy(blz2,b);
|
|
4764
|
-
strcpy(kto2,"13"); /* nur Dummy f�r Funktionsaufruf */
|
|
4765
4796
|
iban_regel_cvt(blz2,kto2,&bic_neu,regel,NULL); /* R�ckgabewert egal, nur bic_neu interessiert */
|
|
4766
4797
|
if(bic && bic_neu && strcasecmp(bic,bic_neu))*retval=OK_INVALID_FOR_IBAN; /* BIC wurde durch eine Regel ge�ndert */
|
|
4767
4798
|
}
|
|
@@ -5101,7 +5132,6 @@ static int iban_init(void)
|
|
|
5101
5132
|
* ###########################################################################
|
|
5102
5133
|
*/
|
|
5103
5134
|
|
|
5104
|
-
#line 5664 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
5105
5135
|
static int iban_regel_cvt(char *blz,char *kto,const char **bicp,int regel_version,RETVAL *retvals)
|
|
5106
5136
|
{
|
|
5107
5137
|
char tmp_buffer[16];
|
|
@@ -5944,9 +5974,9 @@ static int iban_regel_cvt(char *blz,char *kto,const char **bicp,int regel_versio
|
|
|
5944
5974
|
return OK_BLZ_REPLACED;
|
|
5945
5975
|
|
|
5946
5976
|
|
|
5947
|
-
/* Iban-Regel 0020.
|
|
5977
|
+
/* Iban-Regel 0020.02 +���3 */
|
|
5948
5978
|
/* Deutsche Bank AG
|
|
5949
|
-
* Neuimplementierung nach der Regel-Version 1.
|
|
5979
|
+
* Neuimplementierung nach der Regel-Version 1.51 der Deutschen Bank vom 19.9.2013
|
|
5950
5980
|
*/
|
|
5951
5981
|
case 20:
|
|
5952
5982
|
|
|
@@ -6167,178 +6197,8 @@ static int iban_regel_cvt(char *blz,char *kto,const char **bicp,int regel_versio
|
|
|
6167
6197
|
/* Iban-Regel 0030.00 +���3 */
|
|
6168
6198
|
/* Pommersche Volksbank eG */
|
|
6169
6199
|
case 30:
|
|
6170
|
-
|
|
6171
|
-
|
|
6172
|
-
* fehlerhafter Pr�fziffer umzuwandeln sind. Der Einfachheit halber
|
|
6173
|
-
* werden die Kontonummern in zwei Teile aufgeteilt (die beiden
|
|
6174
|
-
* ersten Stellen und die restlichen 8); diese passen dann bequem
|
|
6175
|
-
* in zwei 32Bit-Integer und k�nnen �ber zwei geschachtelte
|
|
6176
|
-
* switch() Anweisungen verarbeitet werden.
|
|
6177
|
-
*/
|
|
6178
|
-
switch(k1){
|
|
6179
|
-
case 0:
|
|
6180
|
-
switch(k2){
|
|
6181
|
-
case 1718190: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6182
|
-
case 22000225: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6183
|
-
case 49902271: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6184
|
-
case 49902280: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6185
|
-
default: break;
|
|
6186
|
-
}
|
|
6187
|
-
break;
|
|
6188
|
-
|
|
6189
|
-
case 1:
|
|
6190
|
-
switch(k2){
|
|
6191
|
-
case 1680029: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6192
|
-
case 4200028: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6193
|
-
case 6200025: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6194
|
-
case 8000171: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6195
|
-
case 8000279: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6196
|
-
case 8001364: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6197
|
-
case 8001801: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6198
|
-
case 8002514: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6199
|
-
default: break;
|
|
6200
|
-
}
|
|
6201
|
-
break;
|
|
6202
|
-
|
|
6203
|
-
case 3:
|
|
6204
|
-
if(k2==8542) return OK_IBAN_WITHOUT_KC_TEST;
|
|
6205
|
-
break;
|
|
6206
|
-
|
|
6207
|
-
case 91:
|
|
6208
|
-
switch(k2){
|
|
6209
|
-
case 30099995: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6210
|
-
case 30500002: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6211
|
-
case 31100008: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6212
|
-
case 31600000: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6213
|
-
case 31610006: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6214
|
-
case 32200006: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6215
|
-
case 32400005: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6216
|
-
case 32600004: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6217
|
-
case 32700017: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6218
|
-
case 32700025: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6219
|
-
case 32700033: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6220
|
-
case 32700041: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6221
|
-
case 33200700: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6222
|
-
case 33200735: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6223
|
-
case 33200743: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6224
|
-
case 33200751: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6225
|
-
case 33200786: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6226
|
-
case 33200808: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6227
|
-
case 33200816: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6228
|
-
case 33200824: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6229
|
-
case 33200832: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6230
|
-
case 36700003: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6231
|
-
case 77300010: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6232
|
-
case 77300060: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6233
|
-
case 98100002: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6234
|
-
case 98200007: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6235
|
-
case 98200104: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6236
|
-
case 98300001: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6237
|
-
default: break;
|
|
6238
|
-
}
|
|
6239
|
-
break;
|
|
6240
|
-
|
|
6241
|
-
case 93:
|
|
6242
|
-
switch(k2){
|
|
6243
|
-
case 31300141: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6244
|
-
case 31300150: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6245
|
-
case 31401010: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6246
|
-
case 31401061: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6247
|
-
case 49010000: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6248
|
-
case 49100000: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6249
|
-
case 60500001: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6250
|
-
case 64902007: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6251
|
-
case 66101001: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6252
|
-
case 66104000: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6253
|
-
case 70620030: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6254
|
-
case 70620080: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6255
|
-
case 71900010: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6256
|
-
case 73600005: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6257
|
-
default: break;
|
|
6258
|
-
}
|
|
6259
|
-
break;
|
|
6260
|
-
|
|
6261
|
-
case 94:
|
|
6262
|
-
if(k2==2900021)return OK_IBAN_WITHOUT_KC_TEST;
|
|
6263
|
-
break;
|
|
6264
|
-
|
|
6265
|
-
case 96:
|
|
6266
|
-
switch(k2){
|
|
6267
|
-
case 5110000: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6268
|
-
case 14001000: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6269
|
-
case 15000016: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6270
|
-
case 15010003: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6271
|
-
case 18500036: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6272
|
-
case 31020000: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6273
|
-
case 32600051: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6274
|
-
case 32600060: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6275
|
-
case 35000012: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6276
|
-
case 35000020: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6277
|
-
case 35701002: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6278
|
-
case 36010003: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6279
|
-
case 36013002: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6280
|
-
case 36016001: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6281
|
-
case 36018004: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6282
|
-
case 36019000: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6283
|
-
case 36022001: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6284
|
-
case 36024004: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6285
|
-
case 36025000: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6286
|
-
case 36027003: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6287
|
-
case 36028000: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6288
|
-
case 36045001: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6289
|
-
case 36048000: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6290
|
-
case 36051001: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6291
|
-
case 36053004: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6292
|
-
case 36120003: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6293
|
-
case 36140004: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6294
|
-
case 36150000: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6295
|
-
case 36320002: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6296
|
-
case 36700000: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6297
|
-
case 38120000: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6298
|
-
case 39401100: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6299
|
-
case 39801001: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6300
|
-
case 70010004: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6301
|
-
case 80610000: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6302
|
-
default: break;
|
|
6303
|
-
}
|
|
6304
|
-
break;
|
|
6305
|
-
|
|
6306
|
-
case 97:
|
|
6307
|
-
switch(k2){
|
|
6308
|
-
case 5010002: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6309
|
-
case 5403004: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6310
|
-
case 5404000: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6311
|
-
case 5509996: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6312
|
-
case 7901001: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6313
|
-
case 36010000: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6314
|
-
case 80100050: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6315
|
-
case 91000030: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6316
|
-
default: break;
|
|
6317
|
-
}
|
|
6318
|
-
break;
|
|
6319
|
-
|
|
6320
|
-
case 99:
|
|
6321
|
-
switch(k2){
|
|
6322
|
-
case 90001003: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6323
|
-
case 90001100: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6324
|
-
case 90002000: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6325
|
-
case 90004002: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6326
|
-
case 91020001: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6327
|
-
case 91040002: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6328
|
-
case 91060003: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6329
|
-
case 99999993: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6330
|
-
case 99999994: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6331
|
-
case 99999995: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6332
|
-
case 99999996: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6333
|
-
case 99999997: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6334
|
-
case 99999998: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6335
|
-
case 99999999: return OK_IBAN_WITHOUT_KC_TEST;
|
|
6336
|
-
default: break;
|
|
6337
|
-
}
|
|
6338
|
-
break;
|
|
6339
|
-
}
|
|
6340
|
-
RETURN_OK;
|
|
6341
|
-
|
|
6200
|
+
/* ab September 2018 entf�llt die Regel 30, bleibt jedoch frei */
|
|
6201
|
+
return OK;
|
|
6342
6202
|
|
|
6343
6203
|
/* Iban-Regeln 0031.01 ... 0035.01 +���3 */
|
|
6344
6204
|
/* UniCredit Bank AG:
|
|
@@ -8211,21 +8071,29 @@ static int iban_regel_cvt(char *blz,char *kto,const char **bicp,int regel_versio
|
|
|
8211
8071
|
*bicp="VONEDE33XXX";
|
|
8212
8072
|
return OK_BLZ_REPLACED;
|
|
8213
8073
|
|
|
8214
|
-
/* Iban-Regel 0049.
|
|
8215
|
-
/*
|
|
8074
|
+
/* Iban-Regel 0049.01 +���3 */
|
|
8075
|
+
/* DZ Bank */
|
|
8216
8076
|
case 49:
|
|
8217
8077
|
|
|
8218
|
-
/*
|
|
8219
|
-
|
|
8220
|
-
|
|
8221
|
-
|
|
8222
|
-
|
|
8223
|
-
|
|
8224
|
-
|
|
8225
|
-
|
|
8078
|
+
/* Bei der Ermittlung von IBAN und BIC aus Kontonummer und BLZ sind in Abwei-
|
|
8079
|
+
* chung zu der Standard IBAN-Regel folgende Besonderheiten zu beachten:
|
|
8080
|
+
*
|
|
8081
|
+
* 1. F�r die Bankleitzahlen 300 600 10, 400 600 00 und 570 600 00 der DZ BANK ist die
|
|
8082
|
+
* IBAN-Ermittlung f�r Kontonummern mit der 1.-2. Stelle ungleich '92-99' (standardm��ig
|
|
8083
|
+
* links mit Nullen auf 10 Stellen aufgef�llt) mit der Standard-IBAN-Regel m�glich.
|
|
8084
|
+
*
|
|
8085
|
+
* 2. Kontonummern mit einer '92-99' an der 1.-2. Stelle haben keine Pr�fziffer, die daher
|
|
8086
|
+
* nicht gepr�ft werden darf. Auch f�r diese Konten kann die IBAN nach der Standard-
|
|
8087
|
+
* IBAN-Regel ermittelt werden.
|
|
8088
|
+
*
|
|
8089
|
+
* [etwas vereinfacht ausgedr�ckt, k�nnen Konten einfach nach der Standard-Regel konvertiert werden :-) ]
|
|
8090
|
+
*/
|
|
8226
8091
|
|
|
8227
|
-
/*
|
|
8228
|
-
*
|
|
8092
|
+
/* (der folgende Teil wurde nicht gel�scht, da er auch aus realen Kontodaten stammt;
|
|
8093
|
+
* die ehemaligen Sonderkonten tauchen nicht mehr auf und wurden entfernt)
|
|
8094
|
+
*
|
|
8095
|
+
* F�r Kontonummern mit einer '9' an der 5. Stelle muss die Kontonummer, auf deren Basis
|
|
8096
|
+
* die IBAN ermittelt wird, abweichend berechnet werden. Die ersten 4 Stellen (inkl.
|
|
8229
8097
|
* aufgef�llter Nullen) m�ssen ans Ende gestellt werden, so dass die Kontonummer dann
|
|
8230
8098
|
* immer mit der '9' anf�ngt.
|
|
8231
8099
|
*
|
|
@@ -8409,135 +8277,10 @@ static int iban_regel_cvt(char *blz,char *kto,const char **bicp,int regel_versio
|
|
|
8409
8277
|
}
|
|
8410
8278
|
RETURN_OK;
|
|
8411
8279
|
|
|
8412
|
-
/* Iban-Regel 0056.
|
|
8413
|
-
/* Iban-Regel 0056.01 (ab September 2017) +���3 */
|
|
8414
|
-
/* Iban-Regel 0056.01 (ab Dezember 2017) BLZ 51410111 ung�ltig +���3 */
|
|
8415
|
-
|
|
8416
|
-
|
|
8280
|
+
/* Iban-Regel 0056.03 +���3 */
|
|
8417
8281
|
/* SEB AG */
|
|
8418
8282
|
case 56:
|
|
8419
|
-
|
|
8420
|
-
|
|
8421
|
-
/* Spendenkonten: nur mit festgelegten IBANs -> Konto und evl. BLZ/BIC anpassen */
|
|
8422
|
-
if(k1==0)switch(k2){
|
|
8423
|
-
case 36: strcpy(kto,"1010240003"); if(b!=38010111){strcpy(blz,"38010111"); *bicp="ESSEDE5F380"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8424
|
-
case 50: strcpy(kto,"1328506100"); if(b!=48010111){strcpy(blz,"48010111"); *bicp="ESSEDE5F480"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8425
|
-
case 99: strcpy(kto,"1826063000"); if(b!=43010111){strcpy(blz,"43010111"); *bicp="ESSEDE5F430"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8426
|
-
case 110: strcpy(kto,"1015597802"); if(b!=25010111){strcpy(blz,"25010111"); *bicp="ESSEDE5F250"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8427
|
-
case 240: strcpy(kto,"1010240000"); if(b!=38010111){strcpy(blz,"38010111"); *bicp="ESSEDE5F380"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8428
|
-
case 333: strcpy(kto,"1011296100"); if(b!=38010111){strcpy(blz,"38010111"); *bicp="ESSEDE5F380"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8429
|
-
case 555: strcpy(kto,"1600220800"); if(b!=10010111){strcpy(blz,"10010111"); *bicp="ESSEDE5F100"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8430
|
-
case 556: strcpy(kto,"1000556100"); if(b!=39010111){strcpy(blz,"39010111"); *bicp="ESSEDE5F390"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8431
|
-
case 606: strcpy(kto,"1967153801"); if(b!=25010111){strcpy(blz,"25010111"); *bicp="ESSEDE5F250"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8432
|
-
case 700: strcpy(kto,"1070088000"); if(b!=26510111){strcpy(blz,"26510111"); *bicp="ESSEDE5F265"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8433
|
-
case 777: strcpy(kto,"1006015200"); if(b!=25010111){strcpy(blz,"25010111"); *bicp="ESSEDE5F250"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8434
|
-
case 999: strcpy(kto,"1010240001"); if(b!=38010111){strcpy(blz,"38010111"); *bicp="ESSEDE5F380"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8435
|
-
case 1234: strcpy(kto,"1369152400"); if(b!=25010111){strcpy(blz,"25010111"); *bicp="ESSEDE5F250"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8436
|
-
case 1313: strcpy(kto,"1017500000"); if(b!=57010111){strcpy(blz,"57010111"); *bicp="ESSEDE5F570"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8437
|
-
case 1888: strcpy(kto,"1241113000"); if(b!=37010111){strcpy(blz,"37010111"); *bicp="ESSEDE5F370"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8438
|
-
case 1953: strcpy(kto,"1026500901"); if(b!=25010111){strcpy(blz,"25010111"); *bicp="ESSEDE5F250"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8439
|
-
case 1998: strcpy(kto,"1547620500"); if(b!=67010111){strcpy(blz,"67010111"); *bicp="ESSEDE5F670"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8440
|
-
case 2007: strcpy(kto,"1026500907"); if(b!=25010111){strcpy(blz,"25010111"); *bicp="ESSEDE5F250"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8441
|
-
case 4004: strcpy(kto,"1635100100"); if(b!=37010111){strcpy(blz,"37010111"); *bicp="ESSEDE5F370"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8442
|
-
case 4444: strcpy(kto,"1304610900"); if(b!=67010111){strcpy(blz,"67010111"); *bicp="ESSEDE5F670"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8443
|
-
case 5000: strcpy(kto,"1395676000"); if(b!=25010111){strcpy(blz,"25010111"); *bicp="ESSEDE5F250"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8444
|
-
case 5510: strcpy(kto,"1611754300"); if(b!=29010111){strcpy(blz,"29010111"); *bicp="ESSEDE5F290"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8445
|
-
case 6060: strcpy(kto,"1000400200"); if(b!=50010111){strcpy(blz,"50010111"); *bicp="ESSEDE5FXXX"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8446
|
-
case 6800: strcpy(kto,"1296401301"); if(b!=67010111){strcpy(blz,"67010111"); *bicp="ESSEDE5F670"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8447
|
-
case 55555: strcpy(kto,"1027758200"); if(b!=38010111){strcpy(blz,"38010111"); *bicp="ESSEDE5F380"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8448
|
-
case 60000: strcpy(kto,"1005007001"); if(b!=50010111){strcpy(blz,"50010111"); *bicp="ESSEDE5FXXX"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8449
|
-
case 66666: strcpy(kto,"1299807801"); if(b!=20010111){strcpy(blz,"20010111"); *bicp="ESSEDE5F200"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8450
|
-
case 102030: strcpy(kto,"1837501600"); if(b!=37010111){strcpy(blz,"37010111"); *bicp="ESSEDE5F370"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8451
|
-
case 121212: strcpy(kto,"1249461502"); if(b!=70010111){strcpy(blz,"70010111"); *bicp="ESSEDE5F700"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8452
|
-
case 130500: strcpy(kto,"1413482100"); if(b!=30010111){strcpy(blz,"30010111"); *bicp="ESSEDE5F300"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8453
|
-
case 202020: strcpy(kto,"1213431002"); if(b!=37010111){strcpy(blz,"37010111"); *bicp="ESSEDE5F370"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8454
|
-
case 414141: strcpy(kto,"1010555101"); if(b!=38010111){strcpy(blz,"38010111"); *bicp="ESSEDE5F380"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8455
|
-
case 666666: strcpy(kto,"1798758900"); if(b!=20010111){strcpy(blz,"20010111"); *bicp="ESSEDE5F200"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8456
|
-
case 5000000: strcpy(kto,"1403124100"); if(b!=37010111){strcpy(blz,"37010111"); *bicp="ESSEDE5F370"; return OK_BLZ_KTO_REPLACED;} else return OK_KTO_REPLACED;
|
|
8457
|
-
}
|
|
8458
|
-
else if(k1==5 && k2==500500){
|
|
8459
|
-
strcpy(kto,"1045720000");
|
|
8460
|
-
if(b!=60010111){
|
|
8461
|
-
strcpy(blz,"60010111");
|
|
8462
|
-
*bicp="ESSEDE5F600";
|
|
8463
|
-
return OK_BLZ_KTO_REPLACED;
|
|
8464
|
-
}
|
|
8465
|
-
else
|
|
8466
|
-
return OK_KTO_REPLACED;
|
|
8467
|
-
}
|
|
8468
|
-
}
|
|
8469
|
-
|
|
8470
|
-
/* f�r die folgenden BLZs sind nur zehnstelllige Kontonummern erlaubt: */
|
|
8471
|
-
if(pz_aenderungen_aktivieren_2017_12 && b==51410111)return INVALID_BLZ; /* die BLZ wird ab Dezember 2017 ung�ltig */
|
|
8472
|
-
switch(b){
|
|
8473
|
-
case 10010111:
|
|
8474
|
-
case 13010111:
|
|
8475
|
-
case 16010111:
|
|
8476
|
-
case 20010111:
|
|
8477
|
-
case 21010111:
|
|
8478
|
-
case 21210111:
|
|
8479
|
-
case 23010111:
|
|
8480
|
-
case 25010111:
|
|
8481
|
-
case 25410111:
|
|
8482
|
-
case 25910111:
|
|
8483
|
-
case 26010111:
|
|
8484
|
-
case 26510111:
|
|
8485
|
-
case 27010111:
|
|
8486
|
-
case 28010111:
|
|
8487
|
-
case 29010111:
|
|
8488
|
-
case 29210111:
|
|
8489
|
-
case 30010111:
|
|
8490
|
-
case 31010111:
|
|
8491
|
-
case 33010111:
|
|
8492
|
-
case 35010111:
|
|
8493
|
-
case 35211012:
|
|
8494
|
-
case 36010111:
|
|
8495
|
-
case 36210111:
|
|
8496
|
-
case 37010111:
|
|
8497
|
-
case 38010111:
|
|
8498
|
-
case 39010111:
|
|
8499
|
-
case 40010111:
|
|
8500
|
-
case 41010111:
|
|
8501
|
-
case 42010111:
|
|
8502
|
-
case 42610112:
|
|
8503
|
-
case 43010111:
|
|
8504
|
-
case 44010111:
|
|
8505
|
-
case 46010111:
|
|
8506
|
-
case 48010111:
|
|
8507
|
-
case 50010111:
|
|
8508
|
-
case 50510111:
|
|
8509
|
-
case 51010111:
|
|
8510
|
-
case 51310111:
|
|
8511
|
-
case 51410111: /* wird ab Dezember 2017 ung�ltig */
|
|
8512
|
-
case 52010111:
|
|
8513
|
-
case 54210111:
|
|
8514
|
-
case 55010111:
|
|
8515
|
-
case 57010111:
|
|
8516
|
-
case 58510111:
|
|
8517
|
-
case 59010111:
|
|
8518
|
-
case 60010111:
|
|
8519
|
-
case 63010111:
|
|
8520
|
-
case 65310111:
|
|
8521
|
-
case 66010111:
|
|
8522
|
-
case 66610111:
|
|
8523
|
-
case 67010111:
|
|
8524
|
-
case 67210111:
|
|
8525
|
-
case 68010111:
|
|
8526
|
-
case 68310111:
|
|
8527
|
-
case 69010111:
|
|
8528
|
-
case 70010111:
|
|
8529
|
-
case 72010111:
|
|
8530
|
-
case 75010111:
|
|
8531
|
-
case 76010111:
|
|
8532
|
-
case 79010111:
|
|
8533
|
-
case 79510111:
|
|
8534
|
-
case 81010111:
|
|
8535
|
-
case 82010111:
|
|
8536
|
-
case 86010111:
|
|
8537
|
-
if(k1<10)return INVALID_KTO;
|
|
8538
|
-
default:
|
|
8539
|
-
break;
|
|
8540
|
-
}
|
|
8283
|
+
/* ab Dezember 2018 entf�llt die Regel 56, bleibt jedoch frei */
|
|
8541
8284
|
RETURN_OK;
|
|
8542
8285
|
|
|
8543
8286
|
/* Iban-Regel 0057.00 +���3 */
|
|
@@ -8557,7 +8300,6 @@ static int iban_regel_cvt(char *blz,char *kto,const char **bicp,int regel_versio
|
|
|
8557
8300
|
}
|
|
8558
8301
|
}
|
|
8559
8302
|
|
|
8560
|
-
#line 9120 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
8561
8303
|
/* Funktion lut_multiple() +���2 */
|
|
8562
8304
|
/* ###########################################################################
|
|
8563
8305
|
* # lut_multiple(): Universalfunktion, um zu einer gegebenen Bankleitzahl #
|
|
@@ -8825,7 +8567,6 @@ DLL_EXPORT int lut_cleanup(void)
|
|
|
8825
8567
|
FREE(sort_pz_f);
|
|
8826
8568
|
FREE(sort_plz);
|
|
8827
8569
|
FREE(sort_iban_regel);
|
|
8828
|
-
#line 9382 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
8829
8570
|
if(name_raw && name_data!=name_raw)
|
|
8830
8571
|
FREE(name_raw);
|
|
8831
8572
|
else
|
|
@@ -8885,6 +8626,14 @@ DLL_EXPORT int lut_cleanup(void)
|
|
|
8885
8626
|
free(handle_ptr);
|
|
8886
8627
|
}
|
|
8887
8628
|
|
|
8629
|
+
FREE(scl_info_block);
|
|
8630
|
+
FREE(scl_bic_array);
|
|
8631
|
+
FREE(scl_bic_block);
|
|
8632
|
+
FREE(scl_name_array);
|
|
8633
|
+
FREE(scl_name_block);
|
|
8634
|
+
FREE(scl_flags_array);
|
|
8635
|
+
FREE(scl_flags_block);
|
|
8636
|
+
|
|
8888
8637
|
if(init_status&8){
|
|
8889
8638
|
|
|
8890
8639
|
/* bei init_status&8 ist wohl eine Initialisierung dazwischengekommen (sollte
|
|
@@ -8894,7 +8643,6 @@ DLL_EXPORT int lut_cleanup(void)
|
|
|
8894
8643
|
lut_cleanup(); /* neuer Versuch, aufzur�umen */
|
|
8895
8644
|
RETURN(INIT_FATAL_ERROR);
|
|
8896
8645
|
}
|
|
8897
|
-
#line 9456 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
8898
8646
|
init_status&=1;
|
|
8899
8647
|
init_in_progress=0;
|
|
8900
8648
|
return OK;
|
|
@@ -9067,8 +8815,8 @@ static void init_atoi_table(void)
|
|
|
9067
8815
|
int i,ziffer;
|
|
9068
8816
|
unsigned long l;
|
|
9069
8817
|
|
|
9070
|
-
/* �nderungen zum
|
|
9071
|
-
if(time(NULL)>
|
|
8818
|
+
/* �nderungen zum 09.12.2019 aktivieren */
|
|
8819
|
+
if(time(NULL)>1575846000 ||0)pz_aenderungen_aktivieren_2019_12=1;
|
|
9072
8820
|
|
|
9073
8821
|
/* ung�ltige Ziffern; Blanks und Tabs werden ebenfalls als ung�ltig
|
|
9074
8822
|
* angesehen(!), da die Stellenzuordnung sonst nicht mehr stimmt. Ausnahme:
|
|
@@ -9194,6 +8942,14 @@ static void init_atoi_table(void)
|
|
|
9194
8942
|
lut2_feld_namen[LUT2_2_IBAN_REGEL_SORT]="LUT2_2_IBAN_REGEL_SORT";
|
|
9195
8943
|
lut2_feld_namen[LUT2_BIC_H_SORT]="LUT2_BIC_H_SORT";
|
|
9196
8944
|
lut2_feld_namen[LUT2_2_BIC_H_SORT]="LUT2_2_BIC_H_SORT";
|
|
8945
|
+
lut2_feld_namen[LUT2_SCL_INFO]="LUT2_SCL_INFO";
|
|
8946
|
+
lut2_feld_namen[LUT2_2_SCL_INFO]="LUT2_2_SCL_INFO";
|
|
8947
|
+
lut2_feld_namen[LUT2_SCL_BIC]="LUT2_SCL_BIC";
|
|
8948
|
+
lut2_feld_namen[LUT2_2_SCL_BIC]="LUT2_2_SCL_BIC";
|
|
8949
|
+
lut2_feld_namen[LUT2_SCL_NAME]="LUT2_SCL_NAME";
|
|
8950
|
+
lut2_feld_namen[LUT2_2_SCL_NAME]="LUT2_2_SCL_NAME";
|
|
8951
|
+
lut2_feld_namen[LUT2_SCL_FLAGS]="LUT2_SCL_FLAGS";
|
|
8952
|
+
lut2_feld_namen[LUT2_2_SCL_FLAGS]="LUT2_2_SCL_FLAGS";
|
|
9197
8953
|
|
|
9198
8954
|
lut_block_idx[1]=0;
|
|
9199
8955
|
lut_block_idx[2]=0;
|
|
@@ -9222,6 +8978,10 @@ static void init_atoi_table(void)
|
|
|
9222
8978
|
lut_block_idx[25]=0;
|
|
9223
8979
|
lut_block_idx[26]=0;
|
|
9224
8980
|
lut_block_idx[27]=0;
|
|
8981
|
+
lut_block_idx[28]=-1;
|
|
8982
|
+
lut_block_idx[29]=-1;
|
|
8983
|
+
lut_block_idx[30]=-1;
|
|
8984
|
+
lut_block_idx[31]=-1;
|
|
9225
8985
|
|
|
9226
8986
|
lut_block_name1[1]="BLZ";
|
|
9227
8987
|
lut_block_name1[2]="FILIALEN";
|
|
@@ -9250,6 +9010,10 @@ static void init_atoi_table(void)
|
|
|
9250
9010
|
lut_block_name1[25]="IBAN_REGEL";
|
|
9251
9011
|
lut_block_name1[26]="IBAN_REGEL_SORT";
|
|
9252
9012
|
lut_block_name1[27]="BIC_H_SORT";
|
|
9013
|
+
lut_block_name1[28]="SCL_INFO";
|
|
9014
|
+
lut_block_name1[29]="SCL_BIC";
|
|
9015
|
+
lut_block_name1[30]="SCL_NAME";
|
|
9016
|
+
lut_block_name1[31]="SCL_FLAGS";
|
|
9253
9017
|
lut_block_name1[101]="BLZ (2)";
|
|
9254
9018
|
lut_block_name1[102]="FILIALEN (2)";
|
|
9255
9019
|
lut_block_name1[103]="NAME (2)";
|
|
@@ -9277,6 +9041,10 @@ static void init_atoi_table(void)
|
|
|
9277
9041
|
lut_block_name1[125]="IBAN_REGEL (2)";
|
|
9278
9042
|
lut_block_name1[126]="IBAN_REGEL_SORT (2)";
|
|
9279
9043
|
lut_block_name1[127]="BIC_H_SORT (2)";
|
|
9044
|
+
lut_block_name1[128]="SCL_INFO (2)";
|
|
9045
|
+
lut_block_name1[129]="SCL_BIC (2)";
|
|
9046
|
+
lut_block_name1[130]="SCL_NAME (2)";
|
|
9047
|
+
lut_block_name1[131]="SCL_FLAGS (2)";
|
|
9280
9048
|
|
|
9281
9049
|
lut_block_name2[1]="1. BLZ";
|
|
9282
9050
|
lut_block_name2[2]="1. Anzahl Fil.";
|
|
@@ -9305,6 +9073,10 @@ static void init_atoi_table(void)
|
|
|
9305
9073
|
lut_block_name2[25]="1. IBAN Regel";
|
|
9306
9074
|
lut_block_name2[26]="1. IBAN Regel idx";
|
|
9307
9075
|
lut_block_name2[27]="1. BIC Hauptst.idx";
|
|
9076
|
+
lut_block_name2[28]="1. SCL Infoblock";
|
|
9077
|
+
lut_block_name2[29]="1. SCL BIC";
|
|
9078
|
+
lut_block_name2[30]="1. SCL Banknamen";
|
|
9079
|
+
lut_block_name2[31]="1. SCL Flags";
|
|
9308
9080
|
lut_block_name2[101]="2. BLZ";
|
|
9309
9081
|
lut_block_name2[102]="2. Anzahl Fil.";
|
|
9310
9082
|
lut_block_name2[103]="2. Name";
|
|
@@ -9332,8 +9104,11 @@ static void init_atoi_table(void)
|
|
|
9332
9104
|
lut_block_name2[125]="2. IBAN Regel";
|
|
9333
9105
|
lut_block_name2[126]="2. IBAN Regel idx";
|
|
9334
9106
|
lut_block_name2[127]="2. BIC Hauptst.idx";
|
|
9335
|
-
|
|
9336
|
-
|
|
9107
|
+
lut_block_name2[128]="2. SCL Infoblock";
|
|
9108
|
+
lut_block_name2[129]="2. SCL BIC";
|
|
9109
|
+
lut_block_name2[130]="2. SCL Banknamen";
|
|
9110
|
+
lut_block_name2[131]="2. SCL Flags";
|
|
9111
|
+
lut_blocklen_max=521;
|
|
9337
9112
|
init_status|=1;
|
|
9338
9113
|
}
|
|
9339
9114
|
|
|
@@ -9393,7 +9168,6 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
|
9393
9168
|
|
|
9394
9169
|
switch(pz_methode){
|
|
9395
9170
|
|
|
9396
|
-
#line 9759 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
9397
9171
|
/* Berechnungsmethoden 00 bis 09 +���3
|
|
9398
9172
|
Berechnung nach der Methode 00 +���4 */
|
|
9399
9173
|
/*
|
|
@@ -11230,6 +11004,10 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
|
11230
11004
|
* # Stellennr.: 1 2 3 4 5 6 7 8 9 10 #
|
|
11231
11005
|
* # Kontonr.: x x x x x x x x x P #
|
|
11232
11006
|
* # Gewichtung: 0 0 0 0 A 5 8 4 2 (A = 10) #
|
|
11007
|
+
* # #
|
|
11008
|
+
* # Es gibt noch einen Sonderfall, der in der IBAN-Regel 49 angegeben #
|
|
11009
|
+
* # ist: Konten mit 9 an der ersten oder 5. Stelle enthalten keine #
|
|
11010
|
+
* # Pr�fziffer. sondern sind ohne Pr�fung als richtig anzusehen. #
|
|
11233
11011
|
* ######################################################################
|
|
11234
11012
|
*/
|
|
11235
11013
|
case 44:
|
|
@@ -11728,7 +11506,6 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
|
11728
11506
|
* ######################################################################
|
|
11729
11507
|
*/
|
|
11730
11508
|
|
|
11731
|
-
#line 11770 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
11732
11509
|
case 51:
|
|
11733
11510
|
if(*(kto+2)=='9'){ /* Ausnahme */
|
|
11734
11511
|
|
|
@@ -11990,8 +11767,6 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
|
11990
11767
|
else
|
|
11991
11768
|
return FALSE;
|
|
11992
11769
|
|
|
11993
|
-
#line 11984 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
11994
|
-
#line 11986 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
11995
11770
|
/* Berechnung nach der Methode 53 +���4 */
|
|
11996
11771
|
/*
|
|
11997
11772
|
* ######################################################################
|
|
@@ -12290,7 +12065,6 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
|
12290
12065
|
* # bewerten. #
|
|
12291
12066
|
* ######################################################################
|
|
12292
12067
|
*/
|
|
12293
|
-
#line 12255 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
12294
12068
|
case 57:
|
|
12295
12069
|
#if DEBUG>0
|
|
12296
12070
|
if(retvals){
|
|
@@ -12936,7 +12710,6 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
|
12936
12710
|
* # Pr�fzifferberechnung) #
|
|
12937
12711
|
* ######################################################################
|
|
12938
12712
|
*/
|
|
12939
|
-
#line 12835 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
12940
12713
|
case 66:
|
|
12941
12714
|
#if DEBUG>0
|
|
12942
12715
|
case 2066:
|
|
@@ -18007,7 +17780,6 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
|
18007
17780
|
if(pz==10)break;
|
|
18008
17781
|
}
|
|
18009
17782
|
pz=i;
|
|
18010
|
-
INVALID_PZ10;
|
|
18011
17783
|
if(*(kto_alt+5)-'0'==pz)return ok;
|
|
18012
17784
|
#if DEBUG>0
|
|
18013
17785
|
if(untermethode)return FALSE;
|
|
@@ -20257,7 +20029,7 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
|
20257
20029
|
* # Die 10. Stelle der Kontonummer ist die Pr�fziffer. #
|
|
20258
20030
|
* # #
|
|
20259
20031
|
* # Variante 1: #
|
|
20260
|
-
* # Modulus 11, Gewichtung 2, 3, 4, 5, 6, 7, 8, 9, 2
|
|
20032
|
+
* # Modulus 11, Gewichtung 2, 3, 4, 5, 6, 7, 8, 9, 2 #
|
|
20261
20033
|
* # Die Berechnung erfolgt nach der Methode 02. #
|
|
20262
20034
|
* # #
|
|
20263
20035
|
* # F�hrt die Berechnung nach Variante 1 zu einem #
|
|
@@ -20297,7 +20069,6 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
|
20297
20069
|
|
|
20298
20070
|
MOD_11_352; /* pz%=11 */
|
|
20299
20071
|
if(pz)pz=11-pz;
|
|
20300
|
-
INVALID_PZ10;
|
|
20301
20072
|
CHECK_PZX10;
|
|
20302
20073
|
|
|
20303
20074
|
/* Variante 2: Berechnung nach der Methode 00 */
|
|
@@ -20347,7 +20118,6 @@ static int kto_check_int(char *x_blz,int pz_methode,char *kto)
|
|
|
20347
20118
|
return NOT_IMPLEMENTED;
|
|
20348
20119
|
}
|
|
20349
20120
|
}
|
|
20350
|
-
#line 19049 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
20351
20121
|
|
|
20352
20122
|
/*
|
|
20353
20123
|
* ######################################################################
|
|
@@ -20445,7 +20215,6 @@ DLL_EXPORT int kto_check_blz(char *blz,char *kto)
|
|
|
20445
20215
|
#if DEBUG>0 /* es werden einige Funktionen benutzt, die nur in der Debug-Variante enthalten sind */
|
|
20446
20216
|
DLL_EXPORT int kto_check_regel_dbg(char *blz,char *kto,char *blz2,char *kto2,const char **bic,int *regel,RETVAL *retvals)
|
|
20447
20217
|
{
|
|
20448
|
-
#line 19147 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
20449
20218
|
char *blz_o,buffer[32],kto_o[16],*blz_n,*kto_n,*ptr,*dptr;
|
|
20450
20219
|
const char *bicp;
|
|
20451
20220
|
int ret,ret_regel,r,i;
|
|
@@ -20494,7 +20263,6 @@ DLL_EXPORT int kto_check_regel_dbg(char *blz,char *kto,char *blz2,char *kto2,con
|
|
|
20494
20263
|
}
|
|
20495
20264
|
else /* BLZ und Kto gleich */
|
|
20496
20265
|
return ret;
|
|
20497
|
-
#line 19196 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
20498
20266
|
}
|
|
20499
20267
|
|
|
20500
20268
|
#else /* !DEBUG */
|
|
@@ -20645,7 +20413,6 @@ DLL_EXPORT int kto_check_blz_dbg(char *blz,char *kto,RETVAL *retvals)
|
|
|
20645
20413
|
* # Copyright (C) 2007 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
20646
20414
|
* ###########################################################################
|
|
20647
20415
|
*/
|
|
20648
|
-
#line 19347 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
20649
20416
|
DLL_EXPORT int kto_check_pz_dbg(char *pz,char *kto,char *blz,RETVAL *retvals)
|
|
20650
20417
|
{
|
|
20651
20418
|
int untermethode,pz_methode;
|
|
@@ -20881,7 +20648,6 @@ DLL_EXPORT int get_lut_info2_b(char *lutname,int *version,char **prolog_p,char *
|
|
|
20881
20648
|
}
|
|
20882
20649
|
else
|
|
20883
20650
|
**user_info_p=0;
|
|
20884
|
-
#line 19568 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
20885
20651
|
FREE(prolog);
|
|
20886
20652
|
return OK;
|
|
20887
20653
|
}
|
|
@@ -21016,20 +20782,20 @@ DLL_EXPORT const char *get_kto_check_version_x(int mode)
|
|
|
21016
20782
|
case 3:
|
|
21017
20783
|
return __DATE__ ", " __TIME__; /* Compilierdatum und -zeit */
|
|
21018
20784
|
case 4: /* Datum der Pr�fziffermethode */
|
|
21019
|
-
if(
|
|
21020
|
-
return "
|
|
20785
|
+
if(pz_aenderungen_aktivieren_2019_12)
|
|
20786
|
+
return "09.12.2019";
|
|
21021
20787
|
else
|
|
21022
|
-
return "
|
|
20788
|
+
return "09.09.2019 (Aenderungen vom 09.12.2019 enthalten aber noch nicht aktiviert)";
|
|
21023
20789
|
case 5:
|
|
21024
|
-
return "
|
|
20790
|
+
return "09.09.2019";
|
|
21025
20791
|
case 6:
|
|
21026
|
-
return "
|
|
20792
|
+
return "16. Dezember 2020"; /* Klartext-Datum der Bibliotheksversion */
|
|
21027
20793
|
case 7:
|
|
21028
20794
|
return "final"; /* Versions-Typ der Bibliotheksversion (development, beta, final) */
|
|
21029
20795
|
case 8:
|
|
21030
20796
|
return "6"; /* Hauptversionszahl */
|
|
21031
20797
|
case 9:
|
|
21032
|
-
return "
|
|
20798
|
+
return "13"; /* Unterversionszahl */
|
|
21033
20799
|
}
|
|
21034
20800
|
}
|
|
21035
20801
|
|
|
@@ -21175,7 +20941,6 @@ DLL_EXPORT int dump_lutfile(char *outputname,UINT4 *required)
|
|
|
21175
20941
|
default:
|
|
21176
20942
|
break;
|
|
21177
20943
|
}
|
|
21178
|
-
#line 19801 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
21179
20944
|
fputc('\n',out);
|
|
21180
20945
|
while(--i)fputc('=',out);
|
|
21181
20946
|
fputc('\n',out);
|
|
@@ -21500,7 +21265,6 @@ DLL_EXPORT const char *iban2bic_id(char *iban,int *retval,int *blz,int *kto)
|
|
|
21500
21265
|
return iban2bic(iban,retval,b,k);
|
|
21501
21266
|
}
|
|
21502
21267
|
|
|
21503
|
-
#line 20126 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
21504
21268
|
/* Funktion iban_gen(), iban_bic_gen() und iban_bic_gen1 +���1 */
|
|
21505
21269
|
/* ###########################################################################
|
|
21506
21270
|
* # Die Funktion iban_gen generiert aus Bankleitzahl und Kontonummer eine #
|
|
@@ -22333,7 +22097,6 @@ DLL_EXPORT int ipi_check(char *zweck)
|
|
|
22333
22097
|
* # Copyright (C) 2009,2011 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
22334
22098
|
* ###########################################################################
|
|
22335
22099
|
*/
|
|
22336
|
-
#line 20959 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
22337
22100
|
|
|
22338
22101
|
/* Funktion volltext_zeichen() +���2 */
|
|
22339
22102
|
/* Diese Funktion gibt f�r Zeichen die bei der Volltextsuche g�ltig sind
|
|
@@ -23180,7 +22943,6 @@ static int qcmp_bic_h(const void *ap,const void *bp)
|
|
|
23180
22943
|
return a-b;
|
|
23181
22944
|
}
|
|
23182
22945
|
|
|
23183
|
-
#line 21806 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
23184
22946
|
|
|
23185
22947
|
/* Funktion qcmp_bic() +���3 */
|
|
23186
22948
|
static int qcmp_bic(const void *ap,const void *bp)
|
|
@@ -23285,7 +23047,6 @@ static int qcmp_iban_regel(const void *ap,const void *bp)
|
|
|
23285
23047
|
else
|
|
23286
23048
|
return a-b;
|
|
23287
23049
|
}
|
|
23288
|
-
#line 21821 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
23289
23050
|
|
|
23290
23051
|
/* Funktion init_blzf() +���2
|
|
23291
23052
|
* Diese Funktion initialisiert das Array mit den Bankleitzahlen f�r alle
|
|
@@ -23353,7 +23114,6 @@ DLL_EXPORT int konto_check_idx2blz(int idx,int *zweigstelle,int *retval)
|
|
|
23353
23114
|
}
|
|
23354
23115
|
|
|
23355
23116
|
/* Funktion suche_int1() +���2 */
|
|
23356
|
-
#line 21889 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
23357
23117
|
static int suche_int1(int a1,int a2,int *anzahl,int **start_idx,int **zweigstellen_base,int **blz_base,
|
|
23358
23118
|
int **base_name,int **base_sort,int(*cmp)(const void *, const void *),int cnt,int such_idx)
|
|
23359
23119
|
{
|
|
@@ -23404,7 +23164,6 @@ static int suche_int1(int a1,int a2,int *anzahl,int **start_idx,int **zweigstell
|
|
|
23404
23164
|
}
|
|
23405
23165
|
|
|
23406
23166
|
/* Funktion suche_int2() +���2 */
|
|
23407
|
-
#line 21940 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
23408
23167
|
static int suche_int2(int a1,int a2,int *anzahl,int **start_idx,int **zweigstellen_base,int **blz_base,
|
|
23409
23168
|
int **base_name,int **base_sort,int(*cmp)(const void *, const void *),int such_idx,int pz_suche)
|
|
23410
23169
|
{
|
|
@@ -24019,7 +23778,6 @@ static int cmp_suche_sort(const void *ap,const void *bp)
|
|
|
24019
23778
|
DLL_EXPORT int lut_suche_sort1(int anzahl,int *blz_base,int *zweigstellen_base,int *idx,int *anzahl_o,int **idx_op,int **cnt_op,int uniq)
|
|
24020
23779
|
{
|
|
24021
23780
|
int i,j,last_idx,*idx_a,*cnt_o;
|
|
24022
|
-
#line 22556 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
24023
23781
|
|
|
24024
23782
|
if(idx_op)*idx_op=NULL;
|
|
24025
23783
|
if(cnt_op)*cnt_op=NULL;
|
|
@@ -24101,7 +23859,6 @@ DLL_EXPORT int lut_suche_sort2(int anzahl,int *blz,int *zweigstellen,int *anzahl
|
|
|
24101
23859
|
return OK;
|
|
24102
23860
|
}
|
|
24103
23861
|
|
|
24104
|
-
#line 22639 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
24105
23862
|
/* Funktion lut_suche_volltext() +���2 */
|
|
24106
23863
|
DLL_EXPORT int lut_suche_volltext(char *such_wort,int *anzahl,int *base_name_idx,char ***base_name,
|
|
24107
23864
|
int *zweigstellen_anzahl,int **start_idx,int **zweigstellen_base,int **blz_base)
|
|
@@ -24231,7 +23988,6 @@ DLL_EXPORT int lut_suche_blz(int such1,int such2,int *anzahl,int **start_idx,int
|
|
|
24231
23988
|
return suche_int1(such1,such2,anzahl,start_idx,zweigstellen_base,blz_base,&blz_f,&sort_blz,qcmp_blz,cnt,0);
|
|
24232
23989
|
}
|
|
24233
23990
|
|
|
24234
|
-
#line 22789 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
24235
23991
|
/* Funktion lut_suche_bic() +���2 */
|
|
24236
23992
|
DLL_EXPORT int lut_suche_bic(char *such_name,int *anzahl,int **start_idx,int **zweigstellen_base,
|
|
24237
23993
|
char ***base_name,int **blz_base)
|
|
@@ -24322,7 +24078,6 @@ DLL_EXPORT int lut_suche_regel(int such1,int such2,int *anzahl,int **start_idx,i
|
|
|
24322
24078
|
return suche_int2(such1*100,such2*100+99,anzahl,start_idx,zweigstellen_base,blz_base,&iban_regel,&sort_iban_regel,qcmp_iban_regel,LUT2_IBAN_REGEL_SORT,0);
|
|
24323
24079
|
}
|
|
24324
24080
|
|
|
24325
|
-
#line 22822 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
24326
24081
|
|
|
24327
24082
|
/* Funktion lut_suche_bic_h() +���2 */
|
|
24328
24083
|
DLL_EXPORT int lut_suche_bic_h(char *such_name,int *anzahl,int **start_idx,int **zweigstellen_base,
|
|
@@ -24708,7 +24463,6 @@ DLL_EXPORT const char *iban_ort(char *iban,int filiale,int*retval)
|
|
|
24708
24463
|
{
|
|
24709
24464
|
return iban_fkt_s(iban,filiale,retval,lut_ort);
|
|
24710
24465
|
}
|
|
24711
|
-
#line 22911 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
24712
24466
|
|
|
24713
24467
|
static int bic_fkt_c(char *bic1,int mode,int filiale,int *retval,char *base,int error)
|
|
24714
24468
|
{
|
|
@@ -25997,7 +25751,6 @@ DLL_EXPORT const char *pz2str(int pz,int *ret)
|
|
|
25997
25751
|
default: return "???";
|
|
25998
25752
|
}
|
|
25999
25753
|
}
|
|
26000
|
-
#line 23866 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
26001
25754
|
|
|
26002
25755
|
/* Funktion lut_keine_iban_berechnung() +���1 */
|
|
26003
25756
|
/*
|
|
@@ -26112,7 +25865,7 @@ DLL_EXPORT int lut_keine_iban_berechnung(char *iban_blacklist,char *lutfile,int
|
|
|
26112
25865
|
/* Funktion pz_aenderungen_enable() +���1 */
|
|
26113
25866
|
/* ###########################################################################
|
|
26114
25867
|
* # Die Funktion pz_aenderungen_enable() dient dazu, den Status des Flags #
|
|
26115
|
-
* #
|
|
25868
|
+
* # pz_aenderungen_aktivieren_2019_12 abzufragen bzw. zu setzen. Falls die Variable #
|
|
26116
25869
|
* # set 1 ist, werden die �nderungen aktiviert, falls sie 0 ist, werden #
|
|
26117
25870
|
* # die �nderungen deaktiviert. Bei allen anderen Werten wird das aktuelle #
|
|
26118
25871
|
* # Flag nicht ver�ndert, sondern nur der Status zur�ckgegeben. #
|
|
@@ -26128,8 +25881,8 @@ DLL_EXPORT int lut_keine_iban_berechnung(char *iban_blacklist,char *lutfile,int
|
|
|
26128
25881
|
|
|
26129
25882
|
DLL_EXPORT int pz_aenderungen_enable(int set)
|
|
26130
25883
|
{
|
|
26131
|
-
if(set==0 || set==1)
|
|
26132
|
-
return
|
|
25884
|
+
if(set==0 || set==1)pz_aenderungen_aktivieren_2019_12=set;
|
|
25885
|
+
return pz_aenderungen_aktivieren_2019_12;
|
|
26133
25886
|
}
|
|
26134
25887
|
|
|
26135
25888
|
#if DEBUG>0
|
|
@@ -26161,7 +25914,6 @@ DLL_EXPORT char *kto_check_test_vars(char *txt,UINT4 i)
|
|
|
26161
25914
|
#endif
|
|
26162
25915
|
|
|
26163
25916
|
|
|
26164
|
-
#line 24030 "ruby/ext/konto_check_raw/konto_check.lxx"
|
|
26165
25917
|
/* Funktionen *_id() +���1 */
|
|
26166
25918
|
/* ###########################################################################
|
|
26167
25919
|
* # Die folgenden Funktionen sind die id-Varianten von Funktionen, die #
|
|
@@ -26418,6 +26170,764 @@ DLL_EXPORT int kc_id_free(int handle)
|
|
|
26418
26170
|
return INVALID_HANDLE;
|
|
26419
26171
|
}
|
|
26420
26172
|
|
|
26173
|
+
/* Funktionen f�r den Zugriff auf das SCL-Verzeichnis +���1 */
|
|
26174
|
+
/* Hilfsfunktion f�r die SCL-Routinen +���2 */
|
|
26175
|
+
/* Funktion cmp_bic() +���3 */
|
|
26176
|
+
/* ###########################################################################
|
|
26177
|
+
* # cmp_bic() ist die Vergleichsfunktion f�r bic_binsearch() und #
|
|
26178
|
+
* # lut_write_scl_blocks() (zum Sortieren der BICs). #
|
|
26179
|
+
* # #
|
|
26180
|
+
* # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
26181
|
+
* ###########################################################################
|
|
26182
|
+
*/
|
|
26183
|
+
static int cmp_bic(const void *ap,const void *bp)
|
|
26184
|
+
{
|
|
26185
|
+
int a,b,r;
|
|
26186
|
+
|
|
26187
|
+
a=*((int *)ap);
|
|
26188
|
+
b=*((int *)bp);
|
|
26189
|
+
if((r=strcmp(scl_bic_array[a],scl_bic_array[b])))
|
|
26190
|
+
return r;
|
|
26191
|
+
else
|
|
26192
|
+
return a-b;
|
|
26193
|
+
}
|
|
26194
|
+
|
|
26195
|
+
/* Funktion bic_binsearch() +���3 */
|
|
26196
|
+
/* ###########################################################################
|
|
26197
|
+
* # Die Funktion bic_binsearch() implementiert eine bin�re Suche im #
|
|
26198
|
+
* # BIC-Array (rekursiv) #
|
|
26199
|
+
* # #
|
|
26200
|
+
* # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
26201
|
+
* ###########################################################################
|
|
26202
|
+
*/
|
|
26203
|
+
static int bic_binsearch(int links,int rechts,char *bic)
|
|
26204
|
+
{
|
|
26205
|
+
int cmp,mitte;
|
|
26206
|
+
|
|
26207
|
+
if(links>rechts)return -1; /* nicht gefunden */
|
|
26208
|
+
mitte=(rechts+links)/2;
|
|
26209
|
+
if(!(cmp=strcmp(scl_bic_array[mitte],bic)))return mitte; /* Element gefunden */
|
|
26210
|
+
if(cmp>0)
|
|
26211
|
+
return bic_binsearch(links,mitte-1,bic);
|
|
26212
|
+
else
|
|
26213
|
+
return bic_binsearch(mitte+1,rechts,bic);
|
|
26214
|
+
}
|
|
26215
|
+
|
|
26216
|
+
/* Funktion scl_idx() +���3 */
|
|
26217
|
+
/* ###########################################################################
|
|
26218
|
+
* # Die Funktion scl_idx sucht den Index zu einem BIC innerhalb der SCL- #
|
|
26219
|
+
* # Arrays. Der BIC wird zun�chst so gesucht wie er angegeben ist. #
|
|
26220
|
+
* # Falls diese Suche erfolglos ist, wird getestet, ob im BIC-Verzeichnis #
|
|
26221
|
+
* # ein BIC mit �bereinstimmung in den ersten 8 Stellen und XXX in den drei #
|
|
26222
|
+
* # letzten Stellen existiert (Extension BIC); falls dieser auch nicht #
|
|
26223
|
+
* # existiert, wird als Letztes ein 8-stelliger BIC gesucht (Wildcard-BIC). #
|
|
26224
|
+
* # #
|
|
26225
|
+
* # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
26226
|
+
* ###########################################################################
|
|
26227
|
+
*/
|
|
26228
|
+
static int scl_idx(const char *bic,int *retval)
|
|
26229
|
+
{
|
|
26230
|
+
char such_bic[12];
|
|
26231
|
+
int i,idx;
|
|
26232
|
+
|
|
26233
|
+
if(!scl_cnt || !scl_bic_array){
|
|
26234
|
+
if(retval)*retval=NO_SCL_BLOCKS_LOADED;
|
|
26235
|
+
return -1;
|
|
26236
|
+
}
|
|
26237
|
+
strcpy(such_bic,bic);
|
|
26238
|
+
for(i=0;i<11 && such_bic[i];i++)such_bic[i]=toupper(such_bic[i]);
|
|
26239
|
+
|
|
26240
|
+
/*
|
|
26241
|
+
* Auszug aus dem SCL Directory Notice (Seite 13):
|
|
26242
|
+
*
|
|
26243
|
+
* The SCL Directory contains 11-character and 8-character BICs. The following convention
|
|
26244
|
+
* applies.
|
|
26245
|
+
*
|
|
26246
|
+
* - An 8-character BIC is a wild card and represents the reachability of any 11-character
|
|
26247
|
+
* BIC with the same first eight characters, as well as the reachability of the 8-character
|
|
26248
|
+
* BIC itself.
|
|
26249
|
+
*
|
|
26250
|
+
* - An 11-character BIC with the branch code extension "XXX" represents itself as well
|
|
26251
|
+
* as the reachability of the corresponding 8-character BIC. But it is not a wild card.
|
|
26252
|
+
*
|
|
26253
|
+
* - All other 11-character BICs represent the reachability of the respective individual
|
|
26254
|
+
* 11-character BIC only.
|
|
26255
|
+
*
|
|
26256
|
+
* https://www.bundesbank.de/resource/blob/626738/8f82d10dd08993a1941e8441cf5a9fd4/mL/scl-directory-notice-ab-nov2018-data.pdf
|
|
26257
|
+
*
|
|
26258
|
+
* Punkt 2 hat eine h�here Priorit�t als Punkt 1, denn eine 8-stellige BIC ist mit selbiger
|
|
26259
|
+
* um 'XXX' erweiterten BIC identisch.
|
|
26260
|
+
*
|
|
26261
|
+
*/
|
|
26262
|
+
|
|
26263
|
+
if(such_bic[8]==0){ /* Such-BIC 8-stellig angegeben; BIC zuerst mit XXX extension suchen */
|
|
26264
|
+
such_bic[8]=such_bic[9]=such_bic[10]='X';
|
|
26265
|
+
such_bic[11]=0;
|
|
26266
|
+
idx=bic_binsearch(0,scl_cnt-1,such_bic);
|
|
26267
|
+
if(idx>=0){
|
|
26268
|
+
if(retval)*retval=OK_SCL_EXTENSION_BIC_USED;
|
|
26269
|
+
return idx;
|
|
26270
|
+
}
|
|
26271
|
+
else
|
|
26272
|
+
such_bic[8]=0; /* wieder zur�cksetzen */
|
|
26273
|
+
}
|
|
26274
|
+
|
|
26275
|
+
/* nun den BIC suchen wie angegeben */
|
|
26276
|
+
idx=bic_binsearch(0,scl_cnt-1,such_bic);
|
|
26277
|
+
if(idx>=0){
|
|
26278
|
+
if(retval)*retval=OK;
|
|
26279
|
+
return idx;
|
|
26280
|
+
}
|
|
26281
|
+
else if(such_bic[8]==0){
|
|
26282
|
+
if(retval)*retval=SCL_BIC_NOT_FOUND;
|
|
26283
|
+
return -1;
|
|
26284
|
+
}
|
|
26285
|
+
else{
|
|
26286
|
+
/* Wildcard-BIC suchen, nur noch bei 11-stelligen BICs */
|
|
26287
|
+
such_bic[8]=0;
|
|
26288
|
+
idx=bic_binsearch(0,scl_cnt-1,such_bic);
|
|
26289
|
+
if(idx>=0){
|
|
26290
|
+
if(retval)*retval=OK_SCL_WILDCARD_BIC_USED;
|
|
26291
|
+
return idx;
|
|
26292
|
+
}
|
|
26293
|
+
else{
|
|
26294
|
+
if(retval)*retval=SCL_BIC_NOT_FOUND;
|
|
26295
|
+
return -1;
|
|
26296
|
+
}
|
|
26297
|
+
}
|
|
26298
|
+
}
|
|
26299
|
+
|
|
26300
|
+
/* Externe Schnittstelle f�r die SCL-Routinen +���2 */
|
|
26301
|
+
/* Funktion lut_write_scl_blocks() +���3 */
|
|
26302
|
+
/* ###########################################################################
|
|
26303
|
+
* # Die Funktion lut_write_scl_blocks() liest ein SCL-Verzeichnis ein und #
|
|
26304
|
+
* # schreibt die Daten in die angegebene LUT-Datei. #
|
|
26305
|
+
* # #
|
|
26306
|
+
* # Beschreibung und weitere Infos: #
|
|
26307
|
+
* # https://www.bundesbank.de/Redaktion/DE/Standardartikel/Aufgaben/Unbarer_Zahlungsverkehr/emz_scl_directory_fuer_den_sepa_clearer.html #
|
|
26308
|
+
* # #
|
|
26309
|
+
* # direkter Download-Link: #
|
|
26310
|
+
* # https://www.bundesbank.de/Redaktion/DE/Downloads/Aufgaben/Unbarer_Zahlungsverkehr/SEPA/verzeichnis_der_erreichbaren_zahlungsdienstleister.csv?__blob=publicationFile
|
|
26311
|
+
* # #
|
|
26312
|
+
* # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
26313
|
+
* ###########################################################################
|
|
26314
|
+
*/
|
|
26315
|
+
DLL_EXPORT int lut_write_scl_blocks(char *inputfile,char *lutfile)
|
|
26316
|
+
{
|
|
26317
|
+
char c,*ptr,buffer[512],*scl_name_block_s,*scl_bic_block_s,*scl_flags_block_s,*ptr1,*ptr2,*ptr3;
|
|
26318
|
+
char scl_gueltigkeit[16],scl_gueltigkeit_iso[16];
|
|
26319
|
+
int cnt,i,rv,j,*iptr,jahr,monat,tag;
|
|
26320
|
+
FILE *in,*lut;
|
|
26321
|
+
struct stat stat_buffer;
|
|
26322
|
+
struct tm z;
|
|
26323
|
+
time_t ts;
|
|
26324
|
+
|
|
26325
|
+
if(!(in=fopen(inputfile,"r")))RETURN(FILE_READ_ERROR);
|
|
26326
|
+
fgets(buffer,512,in);
|
|
26327
|
+
if(strncmp(buffer,"Gueltig ab / valid from ",24))return SCL_INPUT_FORMAT_ERROR;
|
|
26328
|
+
for(ptr=buffer;!isdigit(*ptr);ptr++);
|
|
26329
|
+
strncpy(scl_gueltigkeit,ptr,16);
|
|
26330
|
+
scl_gueltigkeit[10]=0;
|
|
26331
|
+
jahr=atoi(scl_gueltigkeit+6);
|
|
26332
|
+
monat=(scl_gueltigkeit[3]-'0')*10+scl_gueltigkeit[4]-'0';
|
|
26333
|
+
tag=(scl_gueltigkeit[0]-'0')*10+scl_gueltigkeit[1]-'0';
|
|
26334
|
+
z.tm_sec=z.tm_min=0;
|
|
26335
|
+
z.tm_hour=6; /* Die SCL-Datei wird um 6 Uhr morgens ver�ffentlicht */
|
|
26336
|
+
z.tm_mday=tag;
|
|
26337
|
+
z.tm_mon=monat;
|
|
26338
|
+
z.tm_year=jahr-1900;
|
|
26339
|
+
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
|
+
|
|
26344
|
+
stat(inputfile,&stat_buffer);
|
|
26345
|
+
cnt=stat_buffer.st_size/163+100; /* etwas gro�z�gig die Anzahl rechnen */
|
|
26346
|
+
|
|
26347
|
+
scl_bic_array=(char **)calloc(sizeof(char*),cnt);
|
|
26348
|
+
scl_name_array=(char **)calloc(sizeof(char*),cnt);
|
|
26349
|
+
scl_flags_array=(char **)calloc(sizeof(char*),cnt);
|
|
26350
|
+
|
|
26351
|
+
scl_bic_block=ptr1=(char *)calloc(12,cnt);
|
|
26352
|
+
scl_name_block=ptr2=(char *)calloc(150,cnt);
|
|
26353
|
+
scl_flags_block=ptr3=(char *)calloc(6,cnt);
|
|
26354
|
+
|
|
26355
|
+
/* SCL-Datei einlesen */
|
|
26356
|
+
for(cnt=0;fgets(buffer,512,in);){
|
|
26357
|
+
scl_bic_array[cnt]=ptr1;
|
|
26358
|
+
scl_name_array[cnt]=ptr2;
|
|
26359
|
+
scl_flags_array[cnt]=ptr3;
|
|
26360
|
+
cnt++;
|
|
26361
|
+
for(ptr=buffer;*ptr!=';' && !isspace(*ptr);*ptr1++=*ptr++);
|
|
26362
|
+
c=*ptr;
|
|
26363
|
+
*ptr1++=0; /* bei Leerzeichen am Ende dieses l�schen */
|
|
26364
|
+
*ptr++=0;
|
|
26365
|
+
|
|
26366
|
+
if(c==' ')while(*ptr++!=';' && *ptr!='\n'); /* Fehler in der Datei abfangen (fehlendes Trennzeichen) */
|
|
26367
|
+
while((*ptr2++=*ptr++)!=';'); /* ptr steht zu Beginn der Schleife auf dem Namen */
|
|
26368
|
+
ptr2-=2;
|
|
26369
|
+
while(isspace(*ptr2))ptr2--;
|
|
26370
|
+
*++ptr2=0;
|
|
26371
|
+
ptr2++;
|
|
26372
|
+
|
|
26373
|
+
/* 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;
|
|
26380
|
+
}
|
|
26381
|
+
fclose(in);
|
|
26382
|
+
|
|
26383
|
+
/* Sortierarray aufbauen */
|
|
26384
|
+
iptr=(int* )calloc(sizeof(int),cnt);
|
|
26385
|
+
for(i=0;i<cnt;i++)iptr[i]=i;
|
|
26386
|
+
|
|
26387
|
+
/* vor dem Abspeichern der Blocks nach BICs sortieren */
|
|
26388
|
+
qsort(iptr,cnt,sizeof(int),cmp_bic);
|
|
26389
|
+
|
|
26390
|
+
ptr1=scl_bic_block_s=(char *)calloc(1,ptr1-scl_bic_block+16);
|
|
26391
|
+
ptr2=scl_name_block_s=(char *)calloc(1,ptr2-scl_name_block+16);
|
|
26392
|
+
ptr3=scl_flags_block_s=(char *)calloc(1,ptr3-scl_flags_block+16);
|
|
26393
|
+
for(i=0;i<cnt;i++){
|
|
26394
|
+
j=iptr[i];
|
|
26395
|
+
for(ptr=scl_bic_array[j];(*ptr1++=*ptr++););
|
|
26396
|
+
for(ptr=scl_name_array[j];(*ptr2++=*ptr++););
|
|
26397
|
+
for(ptr=scl_flags_array[j];(*ptr3++=*ptr++););
|
|
26398
|
+
}
|
|
26399
|
+
free(iptr);
|
|
26400
|
+
|
|
26401
|
+
if(!(lut=fopen(lutfile,"rb+")))RETURN(FILE_WRITE_ERROR);
|
|
26402
|
+
|
|
26403
|
+
/* zun�chst mal testen ob es auch eine LUT2 Datei ist */
|
|
26404
|
+
if(!(ptr=fgets(buffer,512,lut)))RETURN(FILE_READ_ERROR);
|
|
26405
|
+
while(*ptr && *ptr!='\n')ptr++;
|
|
26406
|
+
*--ptr=0;
|
|
26407
|
+
if(!strcmp(buffer,"BLZ Lookup Table/Format 1."))RETURN(LUT1_FILE_USED); /* alte LUT-Datei */
|
|
26408
|
+
if(strcmp(buffer,"BLZ Lookup Table/Format 2."))RETURN(INVALID_LUT_FILE); /* keine LUT-Datei */
|
|
26409
|
+
|
|
26410
|
+
/* 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);
|
|
26413
|
+
if((rv=write_lut_block_int(lut,LUT2_SCL_INFO,strlen(buffer)+1,buffer))!=OK){
|
|
26414
|
+
fclose(lut);
|
|
26415
|
+
FREE(scl_bic_block_s);
|
|
26416
|
+
FREE(scl_name_block_s);
|
|
26417
|
+
FREE(scl_flags_block_s);
|
|
26418
|
+
RETURN(rv);
|
|
26419
|
+
}
|
|
26420
|
+
if((rv=write_lut_block_int(lut,LUT2_SCL_BIC,(UINT4)(ptr1-scl_bic_block_s+1),scl_bic_block_s))!=OK){
|
|
26421
|
+
fclose(lut);
|
|
26422
|
+
FREE(scl_bic_block_s);
|
|
26423
|
+
FREE(scl_name_block_s);
|
|
26424
|
+
FREE(scl_flags_block_s);
|
|
26425
|
+
RETURN(rv);
|
|
26426
|
+
}
|
|
26427
|
+
if((rv=write_lut_block_int(lut,LUT2_SCL_NAME,(UINT4)(ptr2-scl_name_block_s+1),scl_name_block_s))!=OK){
|
|
26428
|
+
fclose(lut);
|
|
26429
|
+
FREE(scl_bic_block_s);
|
|
26430
|
+
FREE(scl_name_block_s);
|
|
26431
|
+
FREE(scl_flags_block_s);
|
|
26432
|
+
RETURN(rv);
|
|
26433
|
+
}
|
|
26434
|
+
if((rv=write_lut_block_int(lut,LUT2_SCL_FLAGS,(UINT4)(ptr3-scl_flags_block_s+1),scl_flags_block_s))!=OK){
|
|
26435
|
+
fclose(lut);
|
|
26436
|
+
FREE(scl_bic_block_s);
|
|
26437
|
+
FREE(scl_name_block_s);
|
|
26438
|
+
FREE(scl_flags_block_s);
|
|
26439
|
+
RETURN(rv);
|
|
26440
|
+
}
|
|
26441
|
+
|
|
26442
|
+
fclose(lut);
|
|
26443
|
+
FREE(scl_bic_block_s);
|
|
26444
|
+
FREE(scl_name_block_s);
|
|
26445
|
+
FREE(scl_flags_block_s);
|
|
26446
|
+
RETURN(OK);
|
|
26447
|
+
}
|
|
26448
|
+
|
|
26449
|
+
/* Funktion lut_scl_init() +���3 */
|
|
26450
|
+
/* ###########################################################################
|
|
26451
|
+
* # Die Funktion lut_scl_init() liest die SCL-Blocks aus einer LUT-Datei #
|
|
26452
|
+
* # und initialisiert die zugeh�rigen internen Datenstrukturen. #
|
|
26453
|
+
* # #
|
|
26454
|
+
* # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
26455
|
+
* ###########################################################################
|
|
26456
|
+
*/
|
|
26457
|
+
DLL_EXPORT int lut_scl_init(char *lut_name)
|
|
26458
|
+
{
|
|
26459
|
+
char *ptr,*end;
|
|
26460
|
+
int i,cnt,rv;
|
|
26461
|
+
static UINT4 block_size_0,block_size_1,block_size_2,block_size_3;
|
|
26462
|
+
FILE *lut;
|
|
26463
|
+
|
|
26464
|
+
if(scl_bic_array && scl_name_array && scl_flags_array)return OK; /* schon initialisiert */
|
|
26465
|
+
|
|
26466
|
+
if(!(lut=fopen(lut_name,"rb")))RETURN(FILE_READ_ERROR);
|
|
26467
|
+
if((rv=read_lut_block_int(lut,0,LUT2_SCL_INFO,&block_size_0,&scl_info_block))<0){
|
|
26468
|
+
fclose(lut);
|
|
26469
|
+
if(rv==LUT2_BLOCK_NOT_IN_FILE)
|
|
26470
|
+
RETURN(NO_SCL_BLOCKS);
|
|
26471
|
+
else
|
|
26472
|
+
return rv;
|
|
26473
|
+
}
|
|
26474
|
+
if((rv=read_lut_block_int(lut,0,LUT2_SCL_BIC,&block_size_1,&scl_bic_block))<0){
|
|
26475
|
+
fclose(lut);
|
|
26476
|
+
if(rv==LUT2_BLOCK_NOT_IN_FILE)
|
|
26477
|
+
RETURN(NO_SCL_BLOCKS);
|
|
26478
|
+
else
|
|
26479
|
+
return rv;
|
|
26480
|
+
}
|
|
26481
|
+
if((rv=read_lut_block_int(lut,0,LUT2_SCL_NAME,&block_size_2,&scl_name_block))<0){
|
|
26482
|
+
fclose(lut);
|
|
26483
|
+
if(rv==LUT2_BLOCK_NOT_IN_FILE)
|
|
26484
|
+
RETURN(NO_SCL_BLOCKS);
|
|
26485
|
+
else
|
|
26486
|
+
return rv;
|
|
26487
|
+
}
|
|
26488
|
+
if((rv=read_lut_block_int(lut,0,LUT2_SCL_FLAGS,&block_size_3,&scl_flags_block))<0){
|
|
26489
|
+
fclose(lut);
|
|
26490
|
+
if(rv==LUT2_BLOCK_NOT_IN_FILE)
|
|
26491
|
+
RETURN(NO_SCL_BLOCKS);
|
|
26492
|
+
else
|
|
26493
|
+
return rv;
|
|
26494
|
+
}
|
|
26495
|
+
fclose(lut);
|
|
26496
|
+
if((i=sscanf(scl_info_block,"cnt: %d, TS: %ld, Gueltigkeit: %15s %15s",
|
|
26497
|
+
&cnt,&scl_ts,(char *)&scl_gueltigkeit,(char *)&scl_gueltigkeit_iso))!=4)RETURN(INVALID_SCL_INFO_BLOCK);
|
|
26498
|
+
|
|
26499
|
+
scl_bic_array=(char **)calloc(sizeof(char*),cnt);
|
|
26500
|
+
scl_name_array=(char **)calloc(sizeof(char*),cnt);
|
|
26501
|
+
scl_flags_array=(char **)calloc(sizeof(char*),cnt);
|
|
26502
|
+
|
|
26503
|
+
for(i=0,ptr=scl_bic_block,end=scl_bic_block+block_size_1;i<cnt && ptr<end;i++){
|
|
26504
|
+
scl_bic_array[i]=ptr;
|
|
26505
|
+
while(*ptr++ && ptr<end);
|
|
26506
|
+
}
|
|
26507
|
+
|
|
26508
|
+
for(i=0,ptr=scl_name_block,end=scl_name_block+block_size_2;i<cnt && ptr<end;){
|
|
26509
|
+
scl_name_array[i++]=ptr;
|
|
26510
|
+
while(*ptr++ && ptr<end);
|
|
26511
|
+
}
|
|
26512
|
+
|
|
26513
|
+
for(i=0,ptr=scl_flags_block,end=scl_flags_block+block_size_3;i<cnt && ptr<end;){
|
|
26514
|
+
scl_flags_array[i++]=ptr;
|
|
26515
|
+
while(*ptr++ && ptr<end);
|
|
26516
|
+
}
|
|
26517
|
+
scl_cnt=cnt;
|
|
26518
|
+
RETURN(OK);
|
|
26519
|
+
}
|
|
26520
|
+
|
|
26521
|
+
/* Funktion lut_scl_info() +���3 */
|
|
26522
|
+
/* ###########################################################################
|
|
26523
|
+
* # Die Funktion lut_scl_info() gibt Infos �ber die Anzahl der Eintr�ge im #
|
|
26524
|
+
* # SCL-Verzeichnis sowie das Datum, ab wann die Datei g�ltig ist. #
|
|
26525
|
+
* # #
|
|
26526
|
+
* # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
26527
|
+
* ###########################################################################
|
|
26528
|
+
*/
|
|
26529
|
+
DLL_EXPORT int lut_scl_info(char *lutfile,int *cnt,const char **gueltigkeit,const char **gueltigkeit_iso)
|
|
26530
|
+
{
|
|
26531
|
+
int s_cnt,i,rv;
|
|
26532
|
+
UINT4 block_size;
|
|
26533
|
+
FILE *lut;
|
|
26534
|
+
|
|
26535
|
+
/* falls noch nicht geschehen, den SCL-Infoblock holen */
|
|
26536
|
+
if(!scl_cnt){
|
|
26537
|
+
if(!(lut=fopen(lutfile,"rb")))RETURN(FILE_READ_ERROR);
|
|
26538
|
+
if((rv=read_lut_block_int(lut,0,LUT2_SCL_INFO,&block_size,&scl_info_block))<0){
|
|
26539
|
+
fclose(lut);
|
|
26540
|
+
if(rv==LUT2_BLOCK_NOT_IN_FILE)
|
|
26541
|
+
RETURN(NO_SCL_BLOCKS);
|
|
26542
|
+
else
|
|
26543
|
+
return rv;
|
|
26544
|
+
}
|
|
26545
|
+
if((i=sscanf(scl_info_block,"cnt: %d, TS: %ld, Gueltigkeit: %15s %15s",
|
|
26546
|
+
&s_cnt,&scl_ts,(char *)&scl_gueltigkeit,(char *)&scl_gueltigkeit_iso))!=4)RETURN(INVALID_SCL_INFO_BLOCK);
|
|
26547
|
+
}
|
|
26548
|
+
else
|
|
26549
|
+
s_cnt=scl_cnt;
|
|
26550
|
+
|
|
26551
|
+
if(s_cnt)*cnt=s_cnt;
|
|
26552
|
+
if(gueltigkeit)*gueltigkeit=scl_gueltigkeit;
|
|
26553
|
+
if(gueltigkeit_iso)*gueltigkeit_iso=scl_gueltigkeit_iso;
|
|
26554
|
+
return OK;
|
|
26555
|
+
}
|
|
26556
|
+
|
|
26557
|
+
/* Funktion lut_scl_multi() +���3 */
|
|
26558
|
+
/* ###########################################################################
|
|
26559
|
+
* # Die Funktion lut_scl_multi() gibt alle Eintr�ge des SCL-Verzeichnisses #
|
|
26560
|
+
* # zu einem gegebenen BIC zur�ck. #
|
|
26561
|
+
* # #
|
|
26562
|
+
* # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
26563
|
+
* ###########################################################################
|
|
26564
|
+
*/
|
|
26565
|
+
DLL_EXPORT int lut_scl_multi(char *bic,const char **scl_flags,const char **used_bic,const char **scl_name)
|
|
26566
|
+
{
|
|
26567
|
+
int i,rv;
|
|
26568
|
+
|
|
26569
|
+
i=scl_idx(bic,&rv);
|
|
26570
|
+
if(rv<0)return rv;
|
|
26571
|
+
if(scl_flags)*scl_flags=scl_flags_array[i];
|
|
26572
|
+
if(used_bic)*used_bic=scl_bic_array[i];
|
|
26573
|
+
if(scl_name)*scl_name=scl_name_array[i];
|
|
26574
|
+
return rv;
|
|
26575
|
+
}
|
|
26576
|
+
|
|
26577
|
+
/* Funktion lut_scl_sct() +���3 */
|
|
26578
|
+
/* ###########################################################################
|
|
26579
|
+
* # Die Funktion bestimmt das Flag SCT (SEPA Credit Transfer) des SCL- #
|
|
26580
|
+
* # Verzeichnisses und gibt das Flag (0 bzw. 1) zur�ck. #
|
|
26581
|
+
* # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den #
|
|
26582
|
+
* # entsprechende Fehlercode (<0) gesetzt. #
|
|
26583
|
+
* # #
|
|
26584
|
+
* # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
26585
|
+
* ###########################################################################
|
|
26586
|
+
*/
|
|
26587
|
+
DLL_EXPORT int lut_scl_sct(char *bic,int *retval)
|
|
26588
|
+
{
|
|
26589
|
+
char *flags;
|
|
26590
|
+
int i,rv;
|
|
26591
|
+
|
|
26592
|
+
i=scl_idx(bic,&rv);
|
|
26593
|
+
if(rv<0){
|
|
26594
|
+
if(retval)*retval=rv;
|
|
26595
|
+
return -1;
|
|
26596
|
+
}
|
|
26597
|
+
else
|
|
26598
|
+
if(retval)*retval=OK;
|
|
26599
|
+
flags=scl_flags_array[i];
|
|
26600
|
+
return flags[0]-'0';
|
|
26601
|
+
}
|
|
26602
|
+
|
|
26603
|
+
/* Funktion lut_scl_sdd() +���3 */
|
|
26604
|
+
/* ###########################################################################
|
|
26605
|
+
* # Die Funktion bestimmt das Flag SDD (SEPA CORE Direct Debit (SEPA-Basis- #
|
|
26606
|
+
* # lastschrift) des SCL-Verzeichnisses und gibt das Flag (0 bzw. 1) zur�ck.#
|
|
26607
|
+
* # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den #
|
|
26608
|
+
* # entsprechende Fehlercode (<0) gesetzt. #
|
|
26609
|
+
* # #
|
|
26610
|
+
* # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
26611
|
+
* ###########################################################################
|
|
26612
|
+
*/
|
|
26613
|
+
DLL_EXPORT int lut_scl_sdd(char *bic,int *retval)
|
|
26614
|
+
{
|
|
26615
|
+
char *flags;
|
|
26616
|
+
int i,rv;
|
|
26617
|
+
|
|
26618
|
+
i=scl_idx(bic,&rv);
|
|
26619
|
+
if(rv<0){
|
|
26620
|
+
if(retval)*retval=rv;
|
|
26621
|
+
return -1;
|
|
26622
|
+
}
|
|
26623
|
+
else
|
|
26624
|
+
if(retval)*retval=OK;
|
|
26625
|
+
flags=scl_flags_array[i];
|
|
26626
|
+
return flags[1]-'0';
|
|
26627
|
+
}
|
|
26628
|
+
|
|
26629
|
+
/* Funktion lut_scl_cor1() +���3 */
|
|
26630
|
+
/* ###########################################################################
|
|
26631
|
+
* # Die Funktion bestimmt das Flag COR1 (SEPA COR1 Direct Debit (SEPA-Basis-#
|
|
26632
|
+
* # lastschrift mit verk�rzter Vorlagefrist) des SCL-Verzeichnisses und #
|
|
26633
|
+
* # gibt das Flag (0 bzw. 1) zur�ck. #
|
|
26634
|
+
* # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den #
|
|
26635
|
+
* # entsprechende Fehlercode (<0) gesetzt. #
|
|
26636
|
+
* # #
|
|
26637
|
+
* # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
26638
|
+
* ###########################################################################
|
|
26639
|
+
*/
|
|
26640
|
+
DLL_EXPORT int lut_scl_cor1(char *bic,int *retval)
|
|
26641
|
+
{
|
|
26642
|
+
char *flags;
|
|
26643
|
+
int i,rv;
|
|
26644
|
+
|
|
26645
|
+
i=scl_idx(bic,&rv);
|
|
26646
|
+
if(rv<0){
|
|
26647
|
+
if(retval)*retval=rv;
|
|
26648
|
+
return -1;
|
|
26649
|
+
}
|
|
26650
|
+
else
|
|
26651
|
+
if(retval)*retval=OK;
|
|
26652
|
+
flags=scl_flags_array[i];
|
|
26653
|
+
return flags[2]-'0';
|
|
26654
|
+
}
|
|
26655
|
+
|
|
26656
|
+
/* Funktion lut_scl_b2b() +���3 */
|
|
26657
|
+
/* ###########################################################################
|
|
26658
|
+
* # Die Funktion bestimmt das Flag BCB (SEPA B2B Direct Debit (Sepa-Firmen- #
|
|
26659
|
+
* # lastschrift) des SCL-Verzeichnisses und gibt das Flag (0 bzw. 1) zur�ck.#
|
|
26660
|
+
* # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den #
|
|
26661
|
+
* # entsprechende Fehlercode (<0) gesetzt. #
|
|
26662
|
+
* # #
|
|
26663
|
+
* # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
26664
|
+
* ###########################################################################
|
|
26665
|
+
*/
|
|
26666
|
+
DLL_EXPORT int lut_scl_b2b(char *bic,int *retval)
|
|
26667
|
+
{
|
|
26668
|
+
char *flags;
|
|
26669
|
+
int i,rv;
|
|
26670
|
+
|
|
26671
|
+
i=scl_idx(bic,&rv);
|
|
26672
|
+
if(rv<0){
|
|
26673
|
+
if(retval)*retval=rv;
|
|
26674
|
+
return -1;
|
|
26675
|
+
}
|
|
26676
|
+
else
|
|
26677
|
+
if(retval)*retval=OK;
|
|
26678
|
+
flags=scl_flags_array[i];
|
|
26679
|
+
return flags[3]-'0';
|
|
26680
|
+
}
|
|
26681
|
+
|
|
26682
|
+
/* Funktion lut_scl_scc() +���3 */
|
|
26683
|
+
/* ###########################################################################
|
|
26684
|
+
* # Die Funktion bestimmt das Flag SCC (SEPA Card Clearing, SCC Karten- #
|
|
26685
|
+
* # einz�ge) des SCL-Verzeichnisses und gibt das Flag (0 bzw. 1) zur�ck. #
|
|
26686
|
+
* # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den #
|
|
26687
|
+
* # entsprechende Fehlercode (<0) gesetzt. #
|
|
26688
|
+
* # #
|
|
26689
|
+
* # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
26690
|
+
* ###########################################################################
|
|
26691
|
+
*/
|
|
26692
|
+
DLL_EXPORT int lut_scl_scc(char *bic,int *retval)
|
|
26693
|
+
{
|
|
26694
|
+
char *flags;
|
|
26695
|
+
int i,rv;
|
|
26696
|
+
|
|
26697
|
+
i=scl_idx(bic,&rv);
|
|
26698
|
+
if(rv<0){
|
|
26699
|
+
if(retval)*retval=rv;
|
|
26700
|
+
return -1;
|
|
26701
|
+
}
|
|
26702
|
+
else
|
|
26703
|
+
if(retval)*retval=OK;
|
|
26704
|
+
flags=scl_flags_array[i];
|
|
26705
|
+
return flags[4]-'0';
|
|
26706
|
+
}
|
|
26707
|
+
|
|
26708
|
+
/* Funktion lut_scl_multi_blz() +���3 */
|
|
26709
|
+
/* ###########################################################################
|
|
26710
|
+
* # Die Funktion lut_scl_multi_blz() gibt alle Eintr�ge des SCL- #
|
|
26711
|
+
* # Verzeichnisses zu einer gegebenen BLZ zur�ck. Da die BLZ zun�chst in #
|
|
26712
|
+
* # einen BIC umgewandelt werden mu�, m�ssen auch die Blocks BLZ und BIC #
|
|
26713
|
+
* # der LUT-Datei initialisiert sein, sonst wird ein Fehler zur�ckgegeben. #
|
|
26714
|
+
* # #
|
|
26715
|
+
* # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
26716
|
+
* ###########################################################################
|
|
26717
|
+
*/
|
|
26718
|
+
DLL_EXPORT int lut_scl_multi_blz(char *blz,const char **scl_flags,const char **used_bic,const char **scl_name)
|
|
26719
|
+
{
|
|
26720
|
+
const char *bic;
|
|
26721
|
+
int i,rv;
|
|
26722
|
+
|
|
26723
|
+
bic=lut_bic(blz,0,&rv);
|
|
26724
|
+
if(rv<0)return rv;
|
|
26725
|
+
i=scl_idx(bic,&rv);
|
|
26726
|
+
if(rv<0)return rv;
|
|
26727
|
+
if(scl_flags)*scl_flags=scl_flags_array[i];
|
|
26728
|
+
if(used_bic)*used_bic=scl_bic_array[i];
|
|
26729
|
+
if(scl_name)*scl_name=scl_name_array[i];
|
|
26730
|
+
return rv;
|
|
26731
|
+
}
|
|
26732
|
+
|
|
26733
|
+
/* Funktion lut_scl_sct_blz() +���3 */
|
|
26734
|
+
/* ###########################################################################
|
|
26735
|
+
* # Die Funktion bestimmt das Flag SCT (SEPA Credit Transfer) des SCL- #
|
|
26736
|
+
* # Verzeichnisses und gibt das Flag (0 bzw. 1) zur�ck. #
|
|
26737
|
+
* # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den #
|
|
26738
|
+
* # entsprechende Fehlercode (<0) gesetzt. #
|
|
26739
|
+
* # #
|
|
26740
|
+
* # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
26741
|
+
* ###########################################################################
|
|
26742
|
+
*/
|
|
26743
|
+
DLL_EXPORT int lut_scl_sct_blz(char *blz,int *retval,const char **used_bic)
|
|
26744
|
+
{
|
|
26745
|
+
char *flags;
|
|
26746
|
+
const char *bic;
|
|
26747
|
+
int i,rv;
|
|
26748
|
+
|
|
26749
|
+
bic=lut_bic(blz,0,&rv);
|
|
26750
|
+
if(rv<0){
|
|
26751
|
+
if(retval)*retval=rv;
|
|
26752
|
+
return -1;
|
|
26753
|
+
}
|
|
26754
|
+
else
|
|
26755
|
+
if(retval)*retval=OK;
|
|
26756
|
+
i=scl_idx(bic,&rv);
|
|
26757
|
+
if(rv<0){
|
|
26758
|
+
if(retval)*retval=rv;
|
|
26759
|
+
return -1;
|
|
26760
|
+
}
|
|
26761
|
+
else
|
|
26762
|
+
if(retval)*retval=OK;
|
|
26763
|
+
if(used_bic)*used_bic=scl_bic_array[i];
|
|
26764
|
+
flags=scl_flags_array[i];
|
|
26765
|
+
return flags[0]-'0';
|
|
26766
|
+
}
|
|
26767
|
+
|
|
26768
|
+
/* Funktion lut_scl_sdd_blz() +���3 */
|
|
26769
|
+
/* ###########################################################################
|
|
26770
|
+
* # Die Funktion bestimmt das Flag SDD (SEPA CORE Direct Debit (SEPA-Basis- #
|
|
26771
|
+
* # lastschrift) des SCL-Verzeichnisses und gibt das Flag (0 bzw. 1) zur�ck.#
|
|
26772
|
+
* # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den #
|
|
26773
|
+
* # entsprechende Fehlercode (<0) gesetzt. #
|
|
26774
|
+
* # #
|
|
26775
|
+
* # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
26776
|
+
* ###########################################################################
|
|
26777
|
+
*/
|
|
26778
|
+
DLL_EXPORT int lut_scl_sdd_blz(char *blz,int *retval,const char **used_bic)
|
|
26779
|
+
{
|
|
26780
|
+
char *flags;
|
|
26781
|
+
const char *bic;
|
|
26782
|
+
int i,rv;
|
|
26783
|
+
|
|
26784
|
+
bic=lut_bic(blz,0,&rv);
|
|
26785
|
+
if(rv<0){
|
|
26786
|
+
if(retval)*retval=rv;
|
|
26787
|
+
return -1;
|
|
26788
|
+
}
|
|
26789
|
+
else
|
|
26790
|
+
if(retval)*retval=OK;
|
|
26791
|
+
i=scl_idx(bic,&rv);
|
|
26792
|
+
if(rv<0){
|
|
26793
|
+
if(retval)*retval=rv;
|
|
26794
|
+
return -1;
|
|
26795
|
+
}
|
|
26796
|
+
else
|
|
26797
|
+
if(retval)*retval=OK;
|
|
26798
|
+
if(used_bic)*used_bic=scl_bic_array[i];
|
|
26799
|
+
flags=scl_flags_array[i];
|
|
26800
|
+
return flags[1]-'0';
|
|
26801
|
+
}
|
|
26802
|
+
|
|
26803
|
+
/* Funktion lut_scl_cor1_blz() +���3 */
|
|
26804
|
+
/* ###########################################################################
|
|
26805
|
+
* # Die Funktion bestimmt das Flag COR1 (SEPA COR1 Direct Debit (SEPA-Basis-#
|
|
26806
|
+
* # lastschrift mit verk�rzter Vorlagefrist) des SCL-Verzeichnisses und #
|
|
26807
|
+
* # gibt das Flag (0 bzw. 1) zur�ck. #
|
|
26808
|
+
* # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den #
|
|
26809
|
+
* # entsprechende Fehlercode (<0) gesetzt. #
|
|
26810
|
+
* # #
|
|
26811
|
+
* # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
26812
|
+
* ###########################################################################
|
|
26813
|
+
*/
|
|
26814
|
+
DLL_EXPORT int lut_scl_cor1_blz(char *blz,int *retval,const char **used_bic)
|
|
26815
|
+
{
|
|
26816
|
+
char *flags;
|
|
26817
|
+
const char *bic;
|
|
26818
|
+
int i,rv;
|
|
26819
|
+
|
|
26820
|
+
bic=lut_bic(blz,0,&rv);
|
|
26821
|
+
if(rv<0){
|
|
26822
|
+
if(retval)*retval=rv;
|
|
26823
|
+
return -1;
|
|
26824
|
+
}
|
|
26825
|
+
else
|
|
26826
|
+
if(retval)*retval=OK;
|
|
26827
|
+
i=scl_idx(bic,&rv);
|
|
26828
|
+
if(rv<0){
|
|
26829
|
+
if(retval)*retval=rv;
|
|
26830
|
+
return -1;
|
|
26831
|
+
}
|
|
26832
|
+
else
|
|
26833
|
+
if(retval)*retval=OK;
|
|
26834
|
+
if(used_bic)*used_bic=scl_bic_array[i];
|
|
26835
|
+
flags=scl_flags_array[i];
|
|
26836
|
+
return flags[2]-'0';
|
|
26837
|
+
}
|
|
26838
|
+
|
|
26839
|
+
/* Funktion lut_scl_b2b_blz() +���3 */
|
|
26840
|
+
/* ###########################################################################
|
|
26841
|
+
* # Die Funktion bestimmt das Flag BCB (SEPA B2B Direct Debit (Sepa-Firmen- #
|
|
26842
|
+
* # lastschrift) des SCL-Verzeichnisses und gibt das Flag (0 bzw. 1) zur�ck.#
|
|
26843
|
+
* # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den #
|
|
26844
|
+
* # entsprechende Fehlercode (<0) gesetzt. #
|
|
26845
|
+
* # #
|
|
26846
|
+
* # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
26847
|
+
* ###########################################################################
|
|
26848
|
+
*/
|
|
26849
|
+
DLL_EXPORT int lut_scl_b2b_blz(char *blz,int *retval,const char **used_bic)
|
|
26850
|
+
{
|
|
26851
|
+
char *flags;
|
|
26852
|
+
const char *bic;
|
|
26853
|
+
int i,rv;
|
|
26854
|
+
|
|
26855
|
+
bic=lut_bic(blz,0,&rv);
|
|
26856
|
+
if(rv<0){
|
|
26857
|
+
if(retval)*retval=rv;
|
|
26858
|
+
return -1;
|
|
26859
|
+
}
|
|
26860
|
+
else
|
|
26861
|
+
if(retval)*retval=OK;
|
|
26862
|
+
i=scl_idx(bic,&rv);
|
|
26863
|
+
if(rv<0){
|
|
26864
|
+
if(retval)*retval=rv;
|
|
26865
|
+
return -1;
|
|
26866
|
+
}
|
|
26867
|
+
else
|
|
26868
|
+
if(retval)*retval=OK;
|
|
26869
|
+
if(used_bic)*used_bic=scl_bic_array[i];
|
|
26870
|
+
flags=scl_flags_array[i];
|
|
26871
|
+
return flags[3]-'0';
|
|
26872
|
+
}
|
|
26873
|
+
|
|
26874
|
+
/* Funktion lut_scl_scc_blz() +���3 */
|
|
26875
|
+
/* ###########################################################################
|
|
26876
|
+
* # Die Funktion bestimmt das Flag SCC (SEPA Card Clearing, SCC Karten- #
|
|
26877
|
+
* # einz�ge) des SCL-Verzeichnisses und gibt das Flag (0 bzw. 1) zur�ck. #
|
|
26878
|
+
* # Im Fehlerfall wird -1 zur�ckgegeben und die Variable retval auf den #
|
|
26879
|
+
* # entsprechende Fehlercode (<0) gesetzt. #
|
|
26880
|
+
* # #
|
|
26881
|
+
* # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
26882
|
+
* ###########################################################################
|
|
26883
|
+
*/
|
|
26884
|
+
DLL_EXPORT int lut_scl_scc_blz(char *blz,int *retval,const char **used_bic)
|
|
26885
|
+
{
|
|
26886
|
+
char *flags;
|
|
26887
|
+
const char *bic;
|
|
26888
|
+
int i,rv;
|
|
26889
|
+
|
|
26890
|
+
bic=lut_bic(blz,0,&rv);
|
|
26891
|
+
if(rv<0){
|
|
26892
|
+
if(retval)*retval=rv;
|
|
26893
|
+
return -1;
|
|
26894
|
+
}
|
|
26895
|
+
else
|
|
26896
|
+
if(retval)*retval=OK;
|
|
26897
|
+
i=scl_idx(bic,&rv);
|
|
26898
|
+
if(rv<0){
|
|
26899
|
+
if(retval)*retval=rv;
|
|
26900
|
+
return -1;
|
|
26901
|
+
}
|
|
26902
|
+
else
|
|
26903
|
+
if(retval)*retval=OK;
|
|
26904
|
+
if(used_bic)*used_bic=scl_bic_array[i];
|
|
26905
|
+
flags=scl_flags_array[i];
|
|
26906
|
+
return flags[4]-'0';
|
|
26907
|
+
}
|
|
26908
|
+
|
|
26909
|
+
/* Funktion lut_scl_multi_blz_i() +���3 */
|
|
26910
|
+
/* ###########################################################################
|
|
26911
|
+
* # Diese Funktion entspricht der Funktion lut_scl_multi_blz(), nur wird #
|
|
26912
|
+
* # die BLZ als Integer-Wert statt als String �bergeben. #
|
|
26913
|
+
* # #
|
|
26914
|
+
* # Copyright (C) 2018 Michael Plugge <m.plugge@hs-mannheim.de> #
|
|
26915
|
+
* ###########################################################################
|
|
26916
|
+
*/
|
|
26917
|
+
DLL_EXPORT int lut_scl_multi_blz_i(int blz,const char **scl_flags,const char **used_bic,const char **scl_name)
|
|
26918
|
+
{
|
|
26919
|
+
const char *bic;
|
|
26920
|
+
int i,rv;
|
|
26921
|
+
|
|
26922
|
+
bic=lut_bic_i(blz,0,&rv);
|
|
26923
|
+
if(rv<0)return rv;
|
|
26924
|
+
i=scl_idx(bic,&rv);
|
|
26925
|
+
if(rv<0)return rv;
|
|
26926
|
+
if(scl_flags)*scl_flags=scl_flags_array[i];
|
|
26927
|
+
if(used_bic)*used_bic=scl_bic_array[i];
|
|
26928
|
+
if(scl_name)*scl_name=scl_name_array[i];
|
|
26929
|
+
return rv;
|
|
26930
|
+
}
|
|
26421
26931
|
|
|
26422
26932
|
#else /* !INCLUDE_KONTO_CHECK_DE */
|
|
26423
26933
|
/* Leerdefinitionen f�r !INCLUDE_KONTO_CHECK_DE +���1 */
|
|
@@ -26469,6 +26979,7 @@ XI lut_info(char *lut_name,char **info1,char **info2,int *valid1,int *valid2)EXC
|
|
|
26469
26979
|
XI lut_info_b(char *lut_name,char **info1,char **info2,int *valid1,int *valid2)EXCLUDED
|
|
26470
26980
|
XI lut_info_id(char *lut_name,int *info1,int *info2,int *valid1,int *valid2)EXCLUDED
|
|
26471
26981
|
XI lut_valid(void)EXCLUDED
|
|
26982
|
+
XI lut_valid_date(char *lut_name,int *v11,int *v12,int *v21,int *v22)EXCLUDED
|
|
26472
26983
|
XI lut_multiple(char *b,int *cnt,int **p_blz,char ***p_name,char ***p_name_kurz,int **p_plz,char ***p_ort,
|
|
26473
26984
|
int **p_pan,char ***p_bic,int *p_pz,int **p_nr,char **p_aenderung,char **p_loeschung,int **p_nachfolge_blz,
|
|
26474
26985
|
int *id,int *cnt_all,int **start_idx)EXCLUDED
|
|
@@ -26603,4 +27114,20 @@ XI lut_keine_iban_berechnung(char *iban_blacklist,char *lutfile,int set)EXCLUDED
|
|
|
26603
27114
|
XI pz_aenderungen_enable(int set)EXCLUDED
|
|
26604
27115
|
XC kc_id2ptr(int handle,int *retval)EXCLUDED_S
|
|
26605
27116
|
XI kc_id_free(int handle)EXCLUDED
|
|
27117
|
+
XI lut_scl_init(char *lut_name)EXCLUDED
|
|
27118
|
+
XI lut_scl_info(char *lutfile,int *cnt,const char **gueltigkeit,const char **gueltigkeit_iso)EXCLUDED_V
|
|
27119
|
+
XI lut_write_scl_blocks(char *inputfile,char *lutfile)EXCLUDED
|
|
27120
|
+
XI lut_scl_multi(char *bic,const char **used_bic,const char **scl_name,const char **scl_flags)EXCLUDED
|
|
27121
|
+
XI lut_scl_multi_blz(char *blz,const char **used_bic,const char **scl_name,const char **scl_flags)EXCLUDED
|
|
27122
|
+
XI lut_scl_multi_blz_i(int blz,const char **used_bic,const char **scl_name,const char **scl_flags)EXCLUDED
|
|
27123
|
+
XI lut_scl_sct(char *bic)EXCLUDED
|
|
27124
|
+
XI lut_scl_sdd(char *bic)EXCLUDED
|
|
27125
|
+
XI lut_scl_cor1(char *bic)EXCLUDED
|
|
27126
|
+
XI lut_scl_b2b(char *bic)EXCLUDED
|
|
27127
|
+
XI lut_scl_scc(char *bic)EXCLUDED
|
|
27128
|
+
XI lut_scl_sct_blz(char *blz)EXCLUDED
|
|
27129
|
+
XI lut_scl_sdd_blz(char *blz)EXCLUDED
|
|
27130
|
+
XI lut_scl_cor1_blz(char *blz)EXCLUDED
|
|
27131
|
+
XI lut_scl_b2b_blz(char *blz)EXCLUDED
|
|
27132
|
+
XI lut_scl_scc_blz(char *blz)EXCLUDED
|
|
26606
27133
|
#endif
|