1 /***************************************************************************
2 begin : Mon Mar 01 2004
3 copyright : (C) 2004 by Martin Preuss
4 email : martin@libchipcard.de
5
6 ***************************************************************************
7 * Please see toplevel file COPYING for license details *
8 ***************************************************************************/
9
10 #ifdef HAVE_CONFIG_H
11 # include <config.h>
12 #endif
13
14
15 #include "bpd_p.h"
16 #include "aqhbci_l.h"
17 #include <aqhbci/aqhbci.h>
18
19 #include <gwenhywfar/debug.h>
20 #include <gwenhywfar/misc.h>
21
22 #include <assert.h>
23
24
25 GWEN_LIST_FUNCTIONS(AH_BPD_ADDR, AH_BpdAddr);
26 GWEN_LIST2_FUNCTIONS(AH_BPD_ADDR, AH_BpdAddr);
27
28
AH_Bpd_new()29 AH_BPD *AH_Bpd_new()
30 {
31 AH_BPD *bpd;
32
33 GWEN_NEW_OBJECT(AH_BPD, bpd);
34 bpd->bpdVersion=1;
35 bpd->bpdJobs=GWEN_DB_Group_new("bpdjobs");
36 bpd->addrList=AH_BpdAddr_List_new();
37
38 bpd->isDirty=0;
39 return bpd;
40 }
41
42
43
AH_Bpd_free(AH_BPD * bpd)44 void AH_Bpd_free(AH_BPD *bpd)
45 {
46 if (bpd) {
47 DBG_DEBUG(AQHBCI_LOGDOMAIN, "Destroying AH_BPD");
48 free(bpd->bankName);
49 free(bpd->bankAddr);
50 GWEN_DB_Group_free(bpd->bpdJobs);
51 AH_BpdAddr_List_free(bpd->addrList);
52 GWEN_FREE_OBJECT(bpd);
53 }
54 }
55
56
57
AH_Bpd_dup(const AH_BPD * oldBpd)58 AH_BPD *AH_Bpd_dup(const AH_BPD *oldBpd)
59 {
60 AH_BPD *bpd;
61 GWEN_DB_NODE *db;
62
63 db=GWEN_DB_Group_new("tmp");
64 if (AH_Bpd_ToDb(oldBpd, db)) {
65 DBG_INFO(AQHBCI_LOGDOMAIN, "here");
66 GWEN_DB_Group_free(db);
67 return 0;
68 }
69 bpd=AH_Bpd_FromDb(db);
70 GWEN_DB_Group_free(db);
71 if (!bpd) {
72 DBG_INFO(AQHBCI_LOGDOMAIN, "here");
73 return 0;
74 }
75
76 return bpd;
77 }
78
79
80
AH_Bpd_FromDb(GWEN_DB_NODE * db)81 AH_BPD *AH_Bpd_FromDb(GWEN_DB_NODE *db)
82 {
83 GWEN_DB_NODE *gr;
84 int i;
85 const char *p;
86
87 AH_BPD *bpd;
88
89 GWEN_NEW_OBJECT(AH_BPD, bpd);
90 bpd->addrList=AH_BpdAddr_List_new();
91
92 p=GWEN_DB_GetCharValue(db, "bankAddr", 0, 0);
93 if (p)
94 bpd->bankAddr=strdup(p);
95 bpd->bankPort=GWEN_DB_GetIntValue(db, "bankPort", 0, 3000);
96
97 p=GWEN_DB_GetCharValue(db, "addrType", 0, "tcp");
98 if (strcasecmp(p, "tcp")==0)
99 bpd->addrType=AH_BPD_AddrTypeTCP;
100 else if (strcasecmp(p, "btx")==0)
101 bpd->addrType=AH_BPD_AddrTypeBTX;
102 else if (strcasecmp(p, "ssl")==0)
103 bpd->addrType=AH_BPD_AddrTypeSSL;
104 else {
105 DBG_WARN(AQHBCI_LOGDOMAIN, "Unsupported address type (%s), assuming TCP", p);
106 bpd->addrType=AH_BPD_AddrTypeTCP;
107 }
108
109 p=GWEN_DB_GetCharValue(db, "bankName", 0, 0);
110 if (p)
111 bpd->bankName=strdup(p);
112
113 bpd->jobTypesPerMsg=GWEN_DB_GetIntValue(db, "jobtypespermsg", 0, 0);
114 bpd->maxMsgSize=GWEN_DB_GetIntValue(db, "maxmsgsize", 0, 0);
115 bpd->bpdVersion=GWEN_DB_GetIntValue(db, "bpdversion", 0, 1);
116 gr=GWEN_DB_GetGroup(db,
117 GWEN_PATH_FLAGS_PATHMUSTEXIST,
118 "bpdjobs");
119 if (gr) {
120 bpd->bpdJobs=GWEN_DB_Group_dup(gr);
121 }
122 else
123 bpd->bpdJobs=GWEN_DB_Group_new("bpdjobs");
124
125 /* read supported hbci versions */
126 for (i=0; ; i++) {
127 int j;
128
129 j=GWEN_DB_GetIntValue(db, "hbciversions", i, 0);
130 if (j) {
131 if (AH_Bpd_AddHbciVersion(bpd, j)) {
132 DBG_WARN(AQHBCI_LOGDOMAIN, "Too many HBCI versions");
133 break;
134 }
135 }
136 else
137 break;
138 } /* for */
139
140 /* read supported languages */
141 for (i=0; ; i++) {
142 int j;
143
144 j=GWEN_DB_GetIntValue(db, "languages", i, 0);
145 if (j) {
146 if (AH_Bpd_AddLanguage(bpd, j)) {
147 DBG_WARN(AQHBCI_LOGDOMAIN, "Too many languages");
148 break;
149 }
150 }
151 else
152 break;
153 } /* for */
154
155 /* store BPD addresses */
156 gr=GWEN_DB_GetGroup(db,
157 GWEN_PATH_FLAGS_PATHMUSTEXIST,
158 "addresses");
159 if (gr) {
160 gr=GWEN_DB_FindFirstGroup(gr, "addr");
161 while (gr) {
162 AH_BPD_ADDR *ba;
163
164 ba=AH_BpdAddr_FromDb(gr);
165 if (ba)
166 AH_BpdAddr_List_Add(ba, bpd->addrList);
167 else {
168 DBG_WARN(AQHBCI_LOGDOMAIN, "Bad BPD address");
169 }
170 gr=GWEN_DB_FindNextGroup(gr, "addr");
171 }
172 }
173
174 bpd->isDirty=0;
175 return bpd;
176 }
177
178
179
AH_Bpd_ToDb(const AH_BPD * bpd,GWEN_DB_NODE * db)180 int AH_Bpd_ToDb(const AH_BPD *bpd, GWEN_DB_NODE *db)
181 {
182 GWEN_DB_NODE *gr;
183 unsigned int i;
184 const char *p;
185 AH_BPD_ADDR *ba;
186
187 if (bpd->bankName)
188 GWEN_DB_SetCharValue(db,
189 GWEN_DB_FLAGS_DEFAULT | GWEN_DB_FLAGS_OVERWRITE_VARS,
190 "bankName", bpd->bankName);
191
192 if (bpd->bankAddr)
193 GWEN_DB_SetCharValue(db,
194 GWEN_DB_FLAGS_OVERWRITE_VARS,
195 "bankAddr",
196 bpd->bankAddr);
197 GWEN_DB_SetIntValue(db,
198 GWEN_DB_FLAGS_OVERWRITE_VARS,
199 "bankPort",
200 bpd->bankPort);
201
202 switch (bpd->addrType) {
203 case AH_BPD_AddrTypeTCP:
204 p="tcp";
205 break;
206 case AH_BPD_AddrTypeBTX:
207 p="btx";
208 break;
209 case AH_BPD_AddrTypeSSL:
210 p="ssl";
211 break;
212 default:
213 DBG_ERROR(AQHBCI_LOGDOMAIN, "Unsupported address type (%d)", bpd->addrType);
214 return -1;
215 }
216 GWEN_DB_SetCharValue(db,
217 GWEN_DB_FLAGS_DEFAULT | GWEN_DB_FLAGS_OVERWRITE_VARS,
218 "addrType", p);
219
220 GWEN_DB_SetIntValue(db,
221 GWEN_DB_FLAGS_DEFAULT | GWEN_DB_FLAGS_OVERWRITE_VARS,
222 "jobtypespermsg", bpd->jobTypesPerMsg);
223
224 GWEN_DB_SetIntValue(db,
225 GWEN_DB_FLAGS_DEFAULT | GWEN_DB_FLAGS_OVERWRITE_VARS,
226 "maxmsgsize", bpd->maxMsgSize);
227
228 GWEN_DB_SetIntValue(db,
229 GWEN_DB_FLAGS_DEFAULT | GWEN_DB_FLAGS_OVERWRITE_VARS,
230 "bpdversion", bpd->bpdVersion);
231 if (bpd->bpdJobs) {
232 gr=GWEN_DB_GetGroup(db,
233 GWEN_DB_FLAGS_OVERWRITE_GROUPS,
234 "bpdjobs");
235 assert(gr);
236 GWEN_DB_AddGroupChildren(gr, bpd->bpdJobs);
237 }
238
239 GWEN_DB_DeleteVar(db, "hbciversions");
240 for (i=0; i<AH_BPD_MAXHBCIVERSIONS; i++) {
241 int j;
242
243 j=bpd->hbciVersions[i];
244 if (!j)
245 break;
246 GWEN_DB_SetIntValue(db,
247 GWEN_DB_FLAGS_DEFAULT,
248 "hbciversions", j);
249 }
250
251 GWEN_DB_DeleteVar(db, "languages");
252 for (i=0; i<AH_BPD_MAXLANGUAGES; i++) {
253 int j;
254
255 j=bpd->languages[i];
256 if (!j)
257 break;
258 GWEN_DB_SetIntValue(db,
259 GWEN_DB_FLAGS_DEFAULT,
260 "languages", j);
261 }
262
263 /* store BPD addresses */
264 ba=AH_BpdAddr_List_First(bpd->addrList);
265 if (ba) {
266 gr=GWEN_DB_GetGroup(db,
267 GWEN_DB_FLAGS_OVERWRITE_GROUPS,
268 "addresses");
269 while (ba) {
270 GWEN_DB_NODE *dbA;
271
272 dbA=GWEN_DB_GetGroup(gr,
273 GWEN_PATH_FLAGS_CREATE_GROUP,
274 "addr");
275 assert(dbA);
276 if (AH_BpdAddr_ToDb(ba, dbA)) {
277 DBG_INFO(AQHBCI_LOGDOMAIN, "here");
278 return -1;
279 }
280 ba=AH_BpdAddr_List_Next(ba);
281 }
282 }
283
284 return 0;
285 }
286
287
288
289
290
AH_Bpd_GetJobTypesPerMsg(const AH_BPD * bpd)291 int AH_Bpd_GetJobTypesPerMsg(const AH_BPD *bpd)
292 {
293 assert(bpd);
294 return bpd->jobTypesPerMsg;
295 }
296
297
298
AH_Bpd_SetJobTypesPerMsg(AH_BPD * bpd,int i)299 void AH_Bpd_SetJobTypesPerMsg(AH_BPD *bpd, int i)
300 {
301 assert(bpd);
302 bpd->jobTypesPerMsg=i;
303 bpd->isDirty=1;
304 }
305
306
307
AH_Bpd_GetMaxMsgSize(const AH_BPD * bpd)308 int AH_Bpd_GetMaxMsgSize(const AH_BPD *bpd)
309 {
310 assert(bpd);
311 return bpd->maxMsgSize;
312 }
313
314
315
AH_Bpd_SetMaxMsgSize(AH_BPD * bpd,int i)316 void AH_Bpd_SetMaxMsgSize(AH_BPD *bpd, int i)
317 {
318 assert(bpd);
319 bpd->maxMsgSize=i;
320 bpd->isDirty=1;
321 }
322
323
324
AH_Bpd_GetBpdVersion(const AH_BPD * bpd)325 int AH_Bpd_GetBpdVersion(const AH_BPD *bpd)
326 {
327 assert(bpd);
328 return bpd->bpdVersion;
329 }
330
331
332
AH_Bpd_SetBpdVersion(AH_BPD * bpd,int i)333 void AH_Bpd_SetBpdVersion(AH_BPD *bpd, int i)
334 {
335 assert(bpd);
336 bpd->bpdVersion=i;
337 bpd->isDirty=1;
338 }
339
340
341
AH_Bpd_GetBpdJobs(const AH_BPD * bpd,int hbciVersion)342 GWEN_DB_NODE *AH_Bpd_GetBpdJobs(const AH_BPD *bpd, int hbciVersion)
343 {
344 GWEN_DB_NODE *gr;
345 char numbuf[16];
346
347 assert(bpd);
348 snprintf(numbuf, sizeof(numbuf), "%3d", hbciVersion);
349 gr=GWEN_DB_GetGroup(bpd->bpdJobs, GWEN_PATH_FLAGS_NAMEMUSTEXIST, numbuf);
350 if (gr)
351 return gr;
352 return bpd->bpdJobs;
353 }
354
355
356
AH_Bpd_SetBpdJobs(AH_BPD * bpd,GWEN_DB_NODE * n)357 void AH_Bpd_SetBpdJobs(AH_BPD *bpd, GWEN_DB_NODE *n)
358 {
359 assert(bpd);
360 GWEN_DB_Group_free(bpd->bpdJobs);
361 bpd->bpdJobs=n;
362 bpd->isDirty=1;
363 }
364
365
366
AH_Bpd_ClearBpdJobs(AH_BPD * bpd)367 void AH_Bpd_ClearBpdJobs(AH_BPD *bpd)
368 {
369 assert(bpd);
370 GWEN_DB_ClearGroup(bpd->bpdJobs, 0);
371 bpd->isDirty=1;
372 }
373
374
375
AH_Bpd_GetHbciVersions(const AH_BPD * bpd)376 const int *AH_Bpd_GetHbciVersions(const AH_BPD *bpd)
377 {
378 assert(bpd);
379 return bpd->hbciVersions;
380 }
381
382
383
AH_Bpd_AddHbciVersion(AH_BPD * bpd,int i)384 int AH_Bpd_AddHbciVersion(AH_BPD *bpd, int i)
385 {
386 int j;
387
388 assert(bpd);
389 assert(i);
390
391 for (j=0; j<AH_BPD_MAXHBCIVERSIONS; j++) {
392 if (bpd->hbciVersions[j]==i) {
393 DBG_ERROR(AQHBCI_LOGDOMAIN, "HBCI version %d already enlisted", i);
394 return -1;
395 }
396 if (bpd->hbciVersions[j]==0) {
397 bpd->hbciVersions[j]=i;
398 bpd->isDirty=1;
399 return 0;
400 }
401 }
402 DBG_ERROR(AQHBCI_LOGDOMAIN, "Too many HBCI versions.");
403 return -1;
404 }
405
406
AH_Bpd_ClearHbciVersions(AH_BPD * bpd)407 void AH_Bpd_ClearHbciVersions(AH_BPD *bpd)
408 {
409 unsigned int i;
410
411 assert(bpd);
412 /* note: i<= is correct here, since the field size is k+1 */
413 for (i=0; i<=AH_BPD_MAXHBCIVERSIONS; i++)
414 bpd->hbciVersions[i]=0;
415 bpd->isDirty=1;
416 }
417
418
419
AH_Bpd_AddLanguage(AH_BPD * bpd,int i)420 int AH_Bpd_AddLanguage(AH_BPD *bpd, int i)
421 {
422 int j;
423
424 assert(bpd);
425 assert(i);
426
427 for (j=0; j<AH_BPD_MAXLANGUAGES; j++) {
428 if (bpd->languages[j]==i) {
429 DBG_ERROR(AQHBCI_LOGDOMAIN, "Language %d already enlisted", i);
430 return -1;
431 }
432 if (bpd->languages[j]==0) {
433 bpd->languages[j]=i;
434 bpd->isDirty=1;
435 return 0;
436 }
437 }
438 DBG_ERROR(AQHBCI_LOGDOMAIN, "Too many languages.");
439 return -1;
440 }
441
442
443
AH_Bpd_GetLanguages(const AH_BPD * bpd)444 const int *AH_Bpd_GetLanguages(const AH_BPD *bpd)
445 {
446 assert(bpd);
447 return bpd->languages;
448 }
449
450
451
AH_Bpd_ClearLanguages(AH_BPD * bpd)452 void AH_Bpd_ClearLanguages(AH_BPD *bpd)
453 {
454 unsigned int i;
455
456 assert(bpd);
457 /* note: i<= is correct here, since the field size is k+1 */
458 for (i=0; i<=AH_BPD_MAXLANGUAGES; i++)
459 bpd->languages[i]=0;
460 bpd->isDirty=1;
461 }
462
463
464
AH_Bpd_IsDirty(const AH_BPD * bpd)465 int AH_Bpd_IsDirty(const AH_BPD *bpd)
466 {
467 assert(bpd);
468 if (bpd->isDirty)
469 return 1;
470 return 0;
471 }
472
473
474
AH_Bpd_SetIsDirty(AH_BPD * bpd,int dirty)475 void AH_Bpd_SetIsDirty(AH_BPD *bpd, int dirty)
476 {
477 assert(bpd);
478 bpd->isDirty=dirty;
479 }
480
481
482
AH_Bpd_Dump(const AH_BPD * bpd,int insert)483 void AH_Bpd_Dump(const AH_BPD *bpd, int insert)
484 {
485 uint32_t k;
486 unsigned int i;
487
488 for (k=0; k<insert; k++)
489 fprintf(stderr, " ");
490 fprintf(stderr, "Bpd:\n");
491
492 for (k=0; k<insert; k++)
493 fprintf(stderr, " ");
494 fprintf(stderr, "Version : %d\n", bpd->bpdVersion);
495
496 for (k=0; k<insert; k++)
497 fprintf(stderr, " ");
498 fprintf(stderr, "JobTypesPerMsg : %d\n", bpd->jobTypesPerMsg);
499
500 for (k=0; k<insert; k++)
501 fprintf(stderr, " ");
502 fprintf(stderr, "MaxMsgSize : %d\n", bpd->maxMsgSize);
503
504 for (k=0; k<insert; k++)
505 fprintf(stderr, " ");
506 fprintf(stderr, "HBCI versions : ");
507 for (i=0; i<AH_BPD_MAXHBCIVERSIONS; i++) {
508 if (bpd->hbciVersions[i])
509 fprintf(stderr, "%d ", bpd->hbciVersions[i]);
510 }
511 fprintf(stderr, "\n");
512
513 for (k=0; k<insert; k++)
514 fprintf(stderr, " ");
515 fprintf(stderr, "Languages : ");
516 for (i=0; i<AH_BPD_MAXLANGUAGES; i++) {
517 if (bpd->languages[i])
518 fprintf(stderr, "%d ", bpd->languages[i]);
519 }
520 fprintf(stderr, "\n");
521
522 for (k=0; k<insert; k++)
523 fprintf(stderr, " ");
524 fprintf(stderr, "BPD Jobs :\n");
525 GWEN_DB_Dump(bpd->bpdJobs, insert+17);
526 }
527
528
529
AH_Bpd_GetBankAddr(const AH_BPD * bpd)530 const char *AH_Bpd_GetBankAddr(const AH_BPD *bpd)
531 {
532 assert(bpd);
533 return bpd->bankAddr;
534 }
535
536
537
AH_Bpd_SetBankAddr(AH_BPD * bpd,const char * addr)538 void AH_Bpd_SetBankAddr(AH_BPD *bpd, const char *addr)
539 {
540 assert(bpd);
541 assert(addr);
542 free(bpd->bankAddr);
543 bpd->bankAddr=strdup(addr);
544 bpd->isDirty=1;
545 }
546
547
548
AH_Bpd_GetBankPort(const AH_BPD * bpd)549 int AH_Bpd_GetBankPort(const AH_BPD *bpd)
550 {
551 assert(bpd);
552 return bpd->bankPort;
553 }
554
555
556
AH_Bpd_SetBankPort(AH_BPD * bpd,int p)557 void AH_Bpd_SetBankPort(AH_BPD *bpd, int p)
558 {
559 assert(bpd);
560 bpd->bankPort=p;
561 bpd->isDirty=1;
562 }
563
564
565
AH_Bpd_GetAddrType(const AH_BPD * bpd)566 AH_BPD_ADDR_TYPE AH_Bpd_GetAddrType(const AH_BPD *bpd)
567 {
568 assert(bpd);
569 return bpd->addrType;
570 }
571
572
573
AH_Bpd_SetAddrType(AH_BPD * bpd,AH_BPD_ADDR_TYPE i)574 void AH_Bpd_SetAddrType(AH_BPD *bpd, AH_BPD_ADDR_TYPE i)
575 {
576 bpd->addrType=i;
577 bpd->isDirty=1;
578 }
579
580
581
AH_Bpd_GetBankName(const AH_BPD * bpd)582 const char *AH_Bpd_GetBankName(const AH_BPD *bpd)
583 {
584 assert(bpd);
585 return bpd->bankName;
586 }
587
588
589
AH_Bpd_SetBankName(AH_BPD * bpd,const char * s)590 void AH_Bpd_SetBankName(AH_BPD *bpd, const char *s)
591 {
592 assert(bpd);
593 assert(s);
594 free(bpd->bankName);
595 bpd->bankName=strdup(s);
596 bpd->isDirty=1;
597 }
598
599
600
AH_Bpd_ClearAddr(AH_BPD * bpd)601 void AH_Bpd_ClearAddr(AH_BPD *bpd)
602 {
603 assert(bpd);
604 AH_BpdAddr_List_Clear(bpd->addrList);
605 }
606
607
608
AH_Bpd_AddAddr(AH_BPD * bpd,AH_BPD_ADDR * ba)609 void AH_Bpd_AddAddr(AH_BPD *bpd, AH_BPD_ADDR *ba)
610 {
611 assert(bpd);
612 assert(ba);
613 AH_BpdAddr_List_Add(ba, bpd->addrList);
614 }
615
616
617
AH_Bpd_GetAddrList(const AH_BPD * bpd)618 AH_BPD_ADDR_LIST *AH_Bpd_GetAddrList(const AH_BPD *bpd)
619 {
620 assert(bpd);
621 return bpd->addrList;
622 }
623
624
625
626
627
628
629
630
631
632
AH_BpdAddr_new()633 AH_BPD_ADDR *AH_BpdAddr_new()
634 {
635 AH_BPD_ADDR *ba;
636
637 GWEN_NEW_OBJECT(AH_BPD_ADDR, ba);
638 GWEN_LIST_INIT(AH_BPD_ADDR, ba);
639
640 return ba;
641 }
642
643
644
AH_BpdAddr_free(AH_BPD_ADDR * ba)645 void AH_BpdAddr_free(AH_BPD_ADDR *ba)
646 {
647 if (ba) {
648 GWEN_LIST_FINI(AH_BPD_ADDR, ba);
649 free(ba->addr);
650 free(ba->suffix);
651 GWEN_FREE_OBJECT(ba);
652 }
653 }
654
655
656
AH_BpdAddr_dup(const AH_BPD_ADDR * ba)657 AH_BPD_ADDR *AH_BpdAddr_dup(const AH_BPD_ADDR *ba)
658 {
659 AH_BPD_ADDR *newBa;
660
661 assert(ba);
662 newBa=AH_BpdAddr_new();
663 newBa->type=ba->type;
664 if (ba->addr)
665 newBa->addr=strdup(ba->addr);
666 if (ba->suffix)
667 newBa->suffix=strdup(ba->suffix);
668 newBa->ftype=ba->ftype;
669 newBa->fversion=ba->fversion;
670
671 return newBa;
672 }
673
674
675
AH_BpdAddr_GetType(const AH_BPD_ADDR * ba)676 AH_BPD_ADDR_TYPE AH_BpdAddr_GetType(const AH_BPD_ADDR *ba)
677 {
678 assert(ba);
679 return ba->type;
680 }
681
682
683
AH_BpdAddr_SetType(AH_BPD_ADDR * ba,AH_BPD_ADDR_TYPE t)684 void AH_BpdAddr_SetType(AH_BPD_ADDR *ba, AH_BPD_ADDR_TYPE t)
685 {
686 assert(ba);
687 ba->type=t;
688 }
689
690
691
AH_BpdAddr_GetAddr(const AH_BPD_ADDR * ba)692 const char *AH_BpdAddr_GetAddr(const AH_BPD_ADDR *ba)
693 {
694 assert(ba);
695 return ba->addr;
696 }
697
698
699
AH_BpdAddr_SetAddr(AH_BPD_ADDR * ba,const char * s)700 void AH_BpdAddr_SetAddr(AH_BPD_ADDR *ba, const char *s)
701 {
702 assert(ba);
703 free(ba->addr);
704 if (s)
705 ba->addr=strdup(s);
706 else
707 ba->addr=0;
708 }
709
710
711
AH_BpdAddr_GetSuffix(const AH_BPD_ADDR * ba)712 const char *AH_BpdAddr_GetSuffix(const AH_BPD_ADDR *ba)
713 {
714 assert(ba);
715 return ba->suffix;
716 }
717
718
719
AH_BpdAddr_SetSuffix(AH_BPD_ADDR * ba,const char * s)720 void AH_BpdAddr_SetSuffix(AH_BPD_ADDR *ba, const char *s)
721 {
722 assert(ba);
723 free(ba->suffix);
724 if (s)
725 ba->suffix=strdup(s);
726 else
727 ba->suffix=0;
728 }
729
730
731
AH_BpdAddr_GetFType(const AH_BPD_ADDR * ba)732 AH_BPD_FILTER_TYPE AH_BpdAddr_GetFType(const AH_BPD_ADDR *ba)
733 {
734 assert(ba);
735 return ba->ftype;
736 }
737
738
739
AH_BpdAddr_SetFType(AH_BPD_ADDR * ba,AH_BPD_FILTER_TYPE t)740 void AH_BpdAddr_SetFType(AH_BPD_ADDR *ba, AH_BPD_FILTER_TYPE t)
741 {
742 assert(ba);
743 ba->ftype=t;
744 }
745
746
747
AH_BpdAddr_GetFVersion(const AH_BPD_ADDR * ba)748 int AH_BpdAddr_GetFVersion(const AH_BPD_ADDR *ba)
749 {
750 assert(ba);
751 return ba->fversion;
752 }
753
754
755
AH_BpdAddr_SetFVersion(AH_BPD_ADDR * ba,int i)756 void AH_BpdAddr_SetFVersion(AH_BPD_ADDR *ba, int i)
757 {
758 assert(ba);
759 ba->fversion=i;
760 }
761
762
763
AH_BpdAddr_FromDb(GWEN_DB_NODE * db)764 AH_BPD_ADDR *AH_BpdAddr_FromDb(GWEN_DB_NODE *db)
765 {
766 AH_BPD_ADDR *ba;
767 const char *p;
768
769 ba=AH_BpdAddr_new();
770 p=GWEN_DB_GetCharValue(db, "type", 0, 0);
771 if (!p) {
772 int i;
773
774 i=GWEN_DB_GetIntValue(db, "type", 0, -1);
775 if (i==-1) {
776 DBG_ERROR(AQHBCI_LOGDOMAIN, "bad BPD address");
777 GWEN_DB_Dump(db, 2);
778 AH_BpdAddr_free(ba);
779 return 0;
780 }
781 switch (i) {
782 case 1:
783 ba->type=AH_BPD_AddrTypeBTX;
784 break;
785 case 2:
786 ba->type=AH_BPD_AddrTypeTCP;
787 break;
788 case 3:
789 ba->type=AH_BPD_AddrTypeSSL;
790 break;
791 default:
792 DBG_ERROR(AQHBCI_LOGDOMAIN, "bad BPD address: unknown type %i", i);
793 ba->type=AH_BPD_AddrTypeUnknown;
794 break;
795 GWEN_DB_Dump(db, 2);
796 AH_BpdAddr_free(ba);
797 return 0;
798 }
799 }
800 else {
801 if (strcasecmp(p, "tcp")==0)
802 ba->type=AH_BPD_AddrTypeTCP;
803 else if (strcasecmp(p, "btx")==0)
804 ba->type=AH_BPD_AddrTypeBTX;
805 else if (strcasecmp(p, "ssl")==0)
806 ba->type=AH_BPD_AddrTypeSSL;
807 else {
808 DBG_ERROR(AQHBCI_LOGDOMAIN, "bad BPD address: bad type %s", p);
809 GWEN_DB_Dump(db, 2);
810 AH_BpdAddr_free(ba);
811 return 0;
812 }
813 }
814
815 p=GWEN_DB_GetCharValue(db, "filter", 0, 0);
816 if (p) {
817 if (strcasecmp(p, "mim")==0)
818 ba->ftype=AH_BPD_FilterTypeBase64;
819 else if (strcasecmp(p, "uue")==0)
820 ba->ftype=AH_BPD_FilterTypeUUE;
821 else if (strcasecmp(p, "none")==0)
822 ba->ftype=AH_BPD_FilterTypeNone;
823 else {
824 DBG_ERROR(AQHBCI_LOGDOMAIN,
825 "bad BPD address: bad filter type %s", p);
826 GWEN_DB_Dump(db, 2);
827 AH_BpdAddr_free(ba);
828 return 0;
829 }
830 ba->fversion=GWEN_DB_GetIntValue(db, "fversion", 0, 0);
831 }
832 else {
833 ba->ftype=AH_BPD_FilterTypeNone;
834 }
835
836 p=GWEN_DB_GetCharValue(db, "address", 0, 0);
837 if (!p) {
838 DBG_ERROR(AQHBCI_LOGDOMAIN, "bad BPD address: no address");
839 GWEN_DB_Dump(db, 2);
840 AH_BpdAddr_free(ba);
841 return 0;
842 }
843 ba->addr=strdup(p);
844
845 p=GWEN_DB_GetCharValue(db, "suffix", 0, 0);
846 if (p)
847 ba->suffix=strdup(p);
848
849
850 return ba;
851 }
852
853
854
AH_BpdAddr_ToDb(const AH_BPD_ADDR * ba,GWEN_DB_NODE * db)855 int AH_BpdAddr_ToDb(const AH_BPD_ADDR *ba, GWEN_DB_NODE *db)
856 {
857 assert(ba);
858 assert(db);
859
860 if (!ba->addr) {
861 DBG_ERROR(AQHBCI_LOGDOMAIN, "No address in BPD address");
862 return -1;
863 }
864
865 switch (ba->type) {
866 case AH_BPD_AddrTypeTCP:
867 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
868 "type", "tcp");
869 break;
870 case AH_BPD_AddrTypeBTX:
871 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
872 "type", "btx");
873 break;
874 case AH_BPD_AddrTypeSSL:
875 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
876 "type", "ssl");
877 break;
878 default:
879 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
880 "type", "unknown");
881 break;
882 }
883
884 switch (ba->ftype) {
885 case AH_BPD_FilterTypeBase64:
886 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
887 "ftype", "mim");
888 break;
889 case AH_BPD_FilterTypeUUE:
890 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
891 "ftype", "uue");
892 break;
893 case AH_BPD_FilterTypeNone:
894 default:
895 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
896 "filter", "none");
897 break;
898 }
899
900 GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
901 "fversion", ba->fversion);
902
903 if (ba->addr)
904 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
905 "address", ba->addr);
906 if (ba->suffix)
907 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
908 "suffix", ba->suffix);
909
910 return 0;
911 }
912
913
914
915
916
917
918
919
920
921
922