konto_check 6.02.0 → 6.13.0
Sign up to get free protection for your applications and to get access to all the features.
- 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
|