konto_check 6.02.0 → 6.13.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
- SHA1:
3
- metadata.gz: e4a2b9a4eaf3c213df26bdba2049de70c77dcdba
4
- data.tar.gz: d93390ab90f68728cde22531c7d9ff2e6ab9ec38
2
+ SHA256:
3
+ metadata.gz: aa869ca84203c2f9c627a8ed8c9c2fd6da6d8a1c8cb6450ad8954fffb9ca89b3
4
+ data.tar.gz: b35b73763d3f4234753263a757151a6e0de9332b6305c4bad39fe7cb18e9a1ba
5
5
  SHA512:
6
- metadata.gz: 0316ff43346a0960a890306f58d570a114f58fff702a26f35c3f857c090a6ef39dca17984f6adc58cff4633a8f5ee110afa054daae7976e7d5e4a236a3c403b1
7
- data.tar.gz: b504964df3f12767ece6506e9653e4af0e22855ef970937651ceb84a4917023b6f5c92f14afcddef362033b7a2eb453ee07e802007c8c30ddc994906e8b77f2a
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-2017 Michael Plugge <m.plugge@hs-mannheim.de> #
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.02 (final)"
51
+ #define VERSION "6.13 (final)"
53
52
  #define VERSION_MAJOR 6
54
- #define VERSION_MINOR 02
53
+ #define VERSION_MINOR 13
55
54
  #endif
56
- #define VERSION_DATE "2017-11-26"
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 2017 zu aktivieren */
108
- static int pz_aenderungen_aktivieren_2017_12;
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,LUT2_OWN_IBAN,LUT2_BIC,0},
439
- lut_set_5[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,LUT2_OWN_IBAN,LUT2_BIC,0},
440
- lut_set_6[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,LUT2_OWN_IBAN,LUT2_BIC,LUT2_NACHFOLGE_BLZ,0},
441
- lut_set_7[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,LUT2_OWN_IBAN,LUT2_BIC,LUT2_NACHFOLGE_BLZ,LUT2_LOESCHUNG,0},
442
- lut_set_8[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,LUT2_OWN_IBAN,LUT2_BIC,LUT2_NACHFOLGE_BLZ,LUT2_LOESCHUNG,LUT2_PAN,0},
443
- lut_set_9[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,LUT2_OWN_IBAN,LUT2_BIC,LUT2_NACHFOLGE_BLZ,LUT2_LOESCHUNG,LUT2_PAN,LUT2_NR,0},
444
- lut_set_iban[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_BLZ,LUT2_BIC,LUT2_NACHFOLGE_BLZ,LUT2_LOESCHUNG,LUT2_IBAN_REGEL,LUT2_OWN_IBAN,0}, /* notwendige Felder f�r IBAN-Bestimmung */
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,LUT2_OWN_IBAN,LUT2_BIC,0},
451
- lut_set_o5[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,LUT2_OWN_IBAN,LUT2_BIC,0},
452
- lut_set_o6[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,LUT2_OWN_IBAN,LUT2_BIC,LUT2_NACHFOLGE_BLZ,0},
453
- lut_set_o7[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,LUT2_OWN_IBAN,LUT2_BIC,LUT2_NACHFOLGE_BLZ,LUT2_LOESCHUNG,0},
454
- lut_set_o8[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,LUT2_OWN_IBAN,LUT2_BIC,LUT2_NACHFOLGE_BLZ,LUT2_LOESCHUNG,LUT2_PAN,0},
455
- lut_set_o9[]={LUT2_BLZ,LUT2_PZ,LUT2_AENDERUNG,LUT2_NAME_NAME_KURZ,LUT2_PLZ,LUT2_ORT,LUT2_IBAN_REGEL,LUT2_OWN_IBAN,LUT2_BIC,LUT2_NACHFOLGE_BLZ,LUT2_LOESCHUNG,LUT2_PAN,LUT2_NR,0};
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 27
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
- if(typ!=LUT2_OWN_IBAN && typ!=LUT2_2_OWN_IBAN && typ!=LUT2_FILIALEN && typ!=LUT2_2_FILIALEN){
3778
- alles_ok=0;
3779
- lut_blocks_missing++;
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.01 +���3 */
5977
+ /* Iban-Regel 0020.02 +���3 */
5948
5978
  /* Deutsche Bank AG
5949
- * Neuimplementierung nach der Regel-Version 1.5 der Deutschen Bank vom 30.8.2013
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
- /* diese Bank hat gleich eine lange Reihe Konten, die trotz
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.00 +���3 */
8215
- /* WGZ Bank */
8074
+ /* Iban-Regel 0049.01 +���3 */
8075
+ /* DZ Bank */
8216
8076
  case 49:
8217
8077
 
8218
- /* Sonderkonten */
8219
- if(k1==0)switch(k2){
8220
- case 36: strcpy(kto,"0002310113"); RETURN_OK_KTO_REPLACED;
8221
- case 936: strcpy(kto,"0002310113"); RETURN_OK_KTO_REPLACED;
8222
- case 999: strcpy(kto,"0001310113"); RETURN_OK_KTO_REPLACED;
8223
- case 6060: strcpy(kto,"0000160602"); RETURN_OK_KTO_REPLACED;
8224
- default: break;
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
- /* F�r Kontonummern mit einer '9' an der 5. Stelle muss die Kontonummer, auf deren Ba-
8228
- * sis die IBAN ermittelt wird, abweichend berechnet werden. Die ersten 4 Stellen (inkl.
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.00 +���3 */
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
- if(version<1){
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 04.12.2017 aktivieren */
9071
- if(time(NULL)>1512342000 ||0)pz_aenderungen_aktivieren_2017_12=1;
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
- lut_blocklen_max=453;
9336
- #line 9696 "ruby/ext/konto_check_raw/konto_check.lxx"
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(pz_aenderungen_aktivieren_2017_12)
21020
- return "04.12.2017";
20785
+ if(pz_aenderungen_aktivieren_2019_12)
20786
+ return "09.12.2019";
21021
20787
  else
21022
- return "04.09.2017 (Aenderungen vom 04.12.2017 enthalten aber noch nicht aktiviert)";
20788
+ return "09.09.2019 (Aenderungen vom 09.12.2019 enthalten aber noch nicht aktiviert)";
21023
20789
  case 5:
21024
- return "04.12.2017";
20790
+ return "09.09.2019";
21025
20791
  case 6:
21026
- return "26. November 2017"; /* Klartext-Datum der Bibliotheksversion */
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 "02"; /* Unterversionszahl */
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
- * # pz_aenderungen_aktivieren_2017_12 abzufragen bzw. zu setzen. Falls die Variable #
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)pz_aenderungen_aktivieren_2017_12=set;
26132
- return pz_aenderungen_aktivieren_2017_12;
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