1 /***************************************************************************
2 begin : Tue Jun 03 2018
3 copyright : (C) 2018 by Martin Preuss
4 email : martin@libchipcard.de
5
6 ***************************************************************************
7 * Please see toplevel file COPYING for license details *
8 ***************************************************************************/
9
10
11 #ifdef HAVE_CONFIG_H
12 # include <config.h>
13 #endif
14
15 #include "provider_online.h"
16
17 #include "aqhbci/banking/provider_l.h"
18 #include "aqhbci/applayer/adminjobs_l.h"
19 #include "aqhbci/msglayer/dialog_l.h"
20
21 #include "aqhbci/admjobs/jobgetkeys_l.h"
22 #include "aqhbci/admjobs/jobsendkeys_l.h"
23 #include "aqhbci/admjobs/jobchangekeys_l.h"
24 #include "aqhbci/admjobs/jobgetsepainfo_l.h"
25 #include "aqhbci/admjobs/jobgetsysid_l.h"
26 #include "aqhbci/admjobs/jobgetbankinfo_l.h"
27 #include "aqhbci/admjobs/jobunblockpin_l.h"
28
29 #include <gwenhywfar/gui.h>
30
31
32
33
AH_Provider_GetAccounts(AB_PROVIDER * pro,AB_USER * u,AB_IMEXPORTER_CONTEXT * ctx,int withProgress,int nounmount,int doLock)34 int AH_Provider_GetAccounts(AB_PROVIDER *pro, AB_USER *u,
35 AB_IMEXPORTER_CONTEXT *ctx,
36 int withProgress, int nounmount, int doLock)
37 {
38 AB_BANKING *ab;
39 AH_HBCI *h;
40 AH_JOB *job;
41 AH_OUTBOX *ob;
42 int rv;
43
44 assert(pro);
45 assert(u);
46
47 ab=AB_Provider_GetBanking(pro);
48 assert(ab);
49
50 h=AH_Provider_GetHbci(pro);
51 assert(h);
52
53 job=AH_Job_UpdateBank_new(pro, u);
54 if (!job) {
55 DBG_ERROR(AQHBCI_LOGDOMAIN, "Job not supported, should not happen");
56 return GWEN_ERROR_GENERIC;
57 }
58 AH_Job_AddSigner(job, AB_User_GetUserId(u));
59
60 ob=AH_Outbox_new(pro);
61 AH_Outbox_AddJob(ob, job);
62
63 rv=AH_Outbox_Execute(ob, ctx, withProgress, 1, doLock);
64 AH_Outbox_free(ob);
65 if (rv) {
66 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not execute outbox.\n");
67 AH_Job_free(job);
68 if (!nounmount)
69 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
70 return rv;
71 }
72
73 /* always try to commit, even when there are errors */
74 rv=AH_Job_Commit(job, doLock);
75 if (rv) {
76 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not commit result.\n");
77 AH_Job_free(job);
78 if (!nounmount)
79 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
80 return rv;
81 }
82
83 if (AH_Job_HasErrors(job)) {
84 DBG_ERROR(AQHBCI_LOGDOMAIN, "Job has errors, but accounts may have been received.");
85 AH_Job_free(job);
86 if (!nounmount)
87 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
88 return GWEN_ERROR_GENERIC;
89 }
90
91 AH_Job_free(job);
92 if (!nounmount)
93 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
94 return 0;
95 }
96
97
98
AH_Provider_GetBankInfo(AB_PROVIDER * pro,AB_USER * u,AB_IMEXPORTER_CONTEXT * ctx,int withTanSeg,int withProgress,int nounmount,int doLock)99 int AH_Provider_GetBankInfo(AB_PROVIDER *pro, AB_USER *u,
100 AB_IMEXPORTER_CONTEXT *ctx,
101 int withTanSeg,
102 int withProgress, int nounmount, int doLock)
103 {
104 AB_BANKING *ab;
105 AH_HBCI *h;
106 AH_JOB *job;
107 AH_OUTBOX *ob;
108 int rv;
109
110 assert(pro);
111 assert(u);
112
113 ab=AB_Provider_GetBanking(pro);
114 assert(ab);
115
116 h=AH_Provider_GetHbci(pro);
117 assert(h);
118
119 job=AH_Job_GetBankInfo_new(pro, u, withTanSeg);
120 if (!job) {
121 DBG_ERROR(AQHBCI_LOGDOMAIN, "Job not supported, should not happen");
122 return GWEN_ERROR_GENERIC;
123 }
124
125 ob=AH_Outbox_new(pro);
126 AH_Outbox_AddJob(ob, job);
127
128 rv=AH_Outbox_Execute(ob, ctx, withProgress, 1, doLock);
129 AH_Outbox_free(ob);
130 if (rv) {
131 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not execute outbox.\n");
132 AH_Job_free(job);
133 if (!nounmount)
134 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
135 return rv;
136 }
137
138 if (AH_Job_HasErrors(job)) {
139 DBG_ERROR(AQHBCI_LOGDOMAIN, "Job has errors");
140 // TODO: show errors
141 AH_Job_free(job);
142 if (!nounmount)
143 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
144 return GWEN_ERROR_GENERIC;
145 }
146 else {
147 rv=AH_Job_Commit(job, doLock);
148 if (rv) {
149 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not commit result.\n");
150 AH_Job_free(job);
151 if (!nounmount)
152 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
153 return rv;
154 }
155 }
156
157 AH_Job_free(job);
158 if (!nounmount)
159 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
160 return 0;
161 }
162
163
164
AH_Provider_GetSysId(AB_PROVIDER * pro,AB_USER * u,AB_IMEXPORTER_CONTEXT * ctx,int withProgress,int nounmount,int doLock)165 int AH_Provider_GetSysId(AB_PROVIDER *pro, AB_USER *u,
166 AB_IMEXPORTER_CONTEXT *ctx,
167 int withProgress, int nounmount, int doLock)
168 {
169 AB_BANKING *ab;
170 AH_HBCI *h;
171 AH_JOB *job;
172 int rv;
173 const char *s;
174 int i;
175 char tbuf[256];
176
177 assert(pro);
178 assert(u);
179
180 ab=AB_Provider_GetBanking(pro);
181 assert(ab);
182
183 h=AH_Provider_GetHbci(pro);
184 assert(h);
185
186 job=0;
187 rv=0;
188 for (i=0; ; i++) {
189 AH_OUTBOX *ob;
190
191 job=AH_Job_GetSysId_new(pro, u);
192 if (!job) {
193 DBG_ERROR(AQHBCI_LOGDOMAIN, "Job not supported, should not happen");
194 return GWEN_ERROR_GENERIC;
195 }
196 AH_Job_AddSigner(job, AB_User_GetUserId(u));
197
198 ob=AH_Outbox_new(pro);
199 AH_Outbox_AddJob(ob, job);
200
201 rv=AH_Outbox_Execute(ob, ctx, withProgress, 1, doLock);
202 AH_Outbox_free(ob);
203 if (rv) {
204 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not execute outbox.\n");
205 AH_Job_free(job);
206 if (!nounmount)
207 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
208 return rv;
209 }
210
211 /* check whether we received a sysid */
212 s=AH_Job_GetSysId_GetSysId(job);
213 if (s && *s) {
214 /* we did, commit the job and break loop */
215 rv=AH_Job_Commit(job, doLock);
216 if (rv<0) {
217 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not commit result.\n");
218 AH_Job_free(job);
219 if (!nounmount)
220 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
221 return rv;
222 }
223 break;
224 }
225
226 if (AH_Job_HasItanResult(job)) {
227 GWEN_Gui_ProgressLog(0,
228 GWEN_LoggerLevel_Notice,
229 I18N("Adjusting to iTAN modes of the server"));
230 rv=AH_Job_Commit(job, doLock);
231 if (rv) {
232 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not commit result.\n");
233 AH_Job_free(job);
234 if (!nounmount)
235 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
236 return rv;
237 }
238
239 #if 0
240 /* save user in order to get the info written to config database for
241 * inspection while debugging
242 */
243 rv=AB_Banking_SaveUser(ab, u);
244 if (rv<0) {
245 DBG_ERROR(AQHBCI_LOGDOMAIN, "Error saving user (%d)", rv);
246 AH_Outbox_free(ob);
247 if (!nounmount)
248 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
249 return rv;
250 }
251 #endif
252
253 rv=GWEN_Gui_ProgressLog(0,
254 GWEN_LoggerLevel_Notice,
255 I18N("Retrying to get system id."));
256 if (rv) {
257 DBG_ERROR(AQHBCI_LOGDOMAIN, "Error in progress log, maybe user aborted?");
258 AH_Job_free(job);
259 if (!nounmount)
260 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
261 return rv;
262 }
263 }
264 else {
265 DBG_ERROR(AQHBCI_LOGDOMAIN, "Job has no system id and no iTAN results");
266 // TODO: show errors
267 AH_Job_free(job);
268 if (!nounmount)
269 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
270 return GWEN_ERROR_GENERIC;
271 }
272
273 AH_Job_free(job);
274 if (i>1) {
275 DBG_ERROR(AQHBCI_LOGDOMAIN, "Tried too often, giving up");
276 GWEN_Gui_ProgressLog(0,
277 GWEN_LoggerLevel_Error,
278 I18N("Could not get system id after multiple trials"));
279 if (!nounmount)
280 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
281 return GWEN_ERROR_GENERIC;
282 }
283 } /* for */
284
285 /* lock user */
286 if (doLock) {
287 rv=AB_Provider_BeginExclUseUser(pro, u);
288 if (rv) {
289 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not lock user (%d)\n", rv);
290 AH_Job_free(job);
291 if (!nounmount)
292 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
293 return rv;
294 }
295 }
296
297 s=AH_Job_GetSysId_GetSysId(job);
298 if (!s) {
299 DBG_ERROR(AQHBCI_LOGDOMAIN, "No system id");
300 if (doLock)
301 AB_Provider_EndExclUseUser(pro, u, 1);
302 AH_Job_free(job);
303 if (!nounmount)
304 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
305 return GWEN_ERROR_NO_DATA;
306 }
307
308 AH_User_SetSystemId(u, s);
309 AH_Job_free(job);
310
311 /* unlock user */
312 if (doLock) {
313 rv=AB_Provider_EndExclUseUser(pro, u, 0);
314 if (rv<0) {
315 DBG_INFO(AQHBCI_LOGDOMAIN,
316 "Could not unlock customer [%s] (%d)",
317 AB_User_GetCustomerId(u), rv);
318 snprintf(tbuf, sizeof(tbuf)-1,
319 I18N("Could not unlock user %s (%d)"),
320 AB_User_GetUserId(u), rv);
321 tbuf[sizeof(tbuf)-1]=0;
322 GWEN_Gui_ProgressLog(0,
323 GWEN_LoggerLevel_Error,
324 tbuf);
325 AB_Provider_EndExclUseUser(pro, u, 1);
326 if (!nounmount)
327 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
328 return rv;
329 }
330 }
331
332 if (!nounmount)
333 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
334
335 return 0;
336 }
337
338
339
AH_Provider_GetServerKeys(AB_PROVIDER * pro,AB_USER * u,AB_IMEXPORTER_CONTEXT * ctx,int withProgress,int nounmount,int doLock)340 int AH_Provider_GetServerKeys(AB_PROVIDER *pro, AB_USER *u,
341 AB_IMEXPORTER_CONTEXT *ctx,
342 int withProgress, int nounmount, int doLock)
343 {
344 AB_BANKING *ab;
345 AH_HBCI *h;
346 AH_JOB *job;
347 AH_OUTBOX *ob;
348 int rv;
349 GWEN_CRYPT_TOKEN *ct;
350 const GWEN_CRYPT_TOKEN_CONTEXT *cctx;
351 const char *s;
352
353 assert(pro);
354 assert(u);
355
356 ab=AB_Provider_GetBanking(pro);
357 assert(ab);
358
359 h=AH_Provider_GetHbci(pro);
360 assert(h);
361
362 job=AH_Job_GetKeys_new(pro, u);
363 if (!job) {
364 DBG_ERROR(AQHBCI_LOGDOMAIN, "Job not supported, should not happen");
365 return GWEN_ERROR_GENERIC;
366 }
367
368 ob=AH_Outbox_new(pro);
369 AH_Outbox_AddJob(ob, job);
370
371 rv=AH_Outbox_Execute(ob, ctx, withProgress, 1, doLock);
372
373 AH_Outbox_free(ob);
374 if (rv) {
375 GWEN_Gui_ProgressLog(0,
376 GWEN_LoggerLevel_Error,
377 I18N("Could not execute outbox."));
378 AH_Job_free(job);
379 if (!nounmount)
380 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
381 return rv;
382 }
383
384 /* Store crypt and sign keys in database */
385 if (AH_Job_GetKeys_GetCryptKeyInfo(job)==NULL && AH_Job_GetKeys_GetSignKeyInfo(job)==NULL) {
386 DBG_ERROR(AQHBCI_LOGDOMAIN, "No crypt key and no sign key received");
387 GWEN_Gui_ProgressLog(0,
388 GWEN_LoggerLevel_Error,
389 I18N("No crypt key and no sign key received."));
390 AH_Job_free(job);
391 if (!nounmount)
392 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
393 return GWEN_ERROR_GENERIC;
394 }
395 else {
396 rv=AH_Job_Commit(job, doLock);
397 if (rv) {
398 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not commit result.\n");
399 GWEN_Gui_ProgressLog(0,
400 GWEN_LoggerLevel_Error,
401 I18N("Could not commit result"));
402 AH_Job_free(job);
403 if (!nounmount)
404 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
405 return rv;
406 }
407 }
408
409 /* lock user */
410 if (doLock) {
411 rv=AB_Provider_BeginExclUseUser(pro, u);
412 if (rv) {
413 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not lock user (%d)\n", rv);
414 AH_Job_free(job);
415 if (!nounmount)
416 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
417 return rv;
418 }
419 }
420
421 s=AH_User_GetPeerId(u);
422 if (!s || !*s) {
423 s=AH_Job_GetKeys_GetPeerId(job);
424 if (s && *s) {
425 char tbuf[256];
426
427 snprintf(tbuf, sizeof(tbuf)-1, I18N("Setting peer ID to \"%s\")"), s);
428 tbuf[sizeof(tbuf)-1]=0;
429 GWEN_Gui_ProgressLog(0,
430 GWEN_LoggerLevel_Notice,
431 tbuf);
432 AH_User_SetPeerId(u, s);
433 }
434 }
435
436 /* get crypt token */
437 rv=AB_Banking_GetCryptToken(AH_HBCI_GetBankingApi(h),
438 AH_User_GetTokenType(u),
439 AH_User_GetTokenName(u),
440 &ct);
441 if (rv) {
442 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not get crypt token (%d)", rv);
443 GWEN_Gui_ProgressLog(0,
444 GWEN_LoggerLevel_Error,
445 I18N("Error getting crypt token"));
446 if (doLock)
447 AB_Provider_EndExclUseUser(pro, u, 0);
448 AH_Job_free(job);
449 if (!nounmount)
450 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
451 return rv;
452 }
453
454 /* open crypt token */
455 rv=GWEN_Crypt_Token_Open(ct, 1, 0);
456 if (rv) {
457 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not open crypt token (%d)", rv);
458 GWEN_Gui_ProgressLog(0,
459 GWEN_LoggerLevel_Error,
460 I18N("Error opening crypt token"));
461 if (doLock)
462 AB_Provider_EndExclUseUser(pro, u, 0);
463 AH_Job_free(job);
464 if (!nounmount)
465 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
466 return rv;
467 }
468
469 /* get context */
470 cctx=GWEN_Crypt_Token_GetContext(ct, AH_User_GetTokenContextId(u), 0);
471 if (!cctx) {
472 DBG_ERROR(AQHBCI_LOGDOMAIN, "User context not found on crypt token");
473 GWEN_Gui_ProgressLog(0,
474 GWEN_LoggerLevel_Error,
475 I18N("User context not found on crypt token"));
476 if (doLock)
477 AB_Provider_EndExclUseUser(pro, u, 0);
478 AH_Job_free(job);
479 if (!nounmount)
480 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
481 return GWEN_ERROR_NOT_FOUND;
482 }
483 else {
484 GWEN_CRYPT_TOKEN_KEYINFO *ki;
485 uint32_t kid;
486
487 /* store sign key on token (if any) */
488 kid=GWEN_Crypt_Token_Context_GetVerifyKeyId(cctx);
489 ki=AH_Job_GetKeys_GetSignKeyInfo(job);
490 if (kid && ki) {
491 rv=GWEN_Crypt_Token_SetKeyInfo(ct,
492 kid,
493 ki,
494 0);
495 if (rv) {
496 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not save key info (%d)", rv);
497 GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Error,
498 I18N("Error saving sign key"));
499 if (doLock)
500 AB_Provider_EndExclUseUser(pro, u, 0);
501 AH_Job_free(job);
502 if (!nounmount)
503 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
504 return rv;
505 }
506 DBG_INFO(AQHBCI_LOGDOMAIN, "Sign key saved");
507 }
508
509 /* store crypt key on token */
510 kid=GWEN_Crypt_Token_Context_GetEncipherKeyId(cctx);
511 ki=AH_Job_GetKeys_GetCryptKeyInfo(job);
512 if (kid && ki) {
513 rv=GWEN_Crypt_Token_SetKeyInfo(ct,
514 kid,
515 ki,
516 0);
517 if (rv) {
518 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not save key info (%d)", rv);
519 GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Error,
520 I18N("Error saving crypt key"));
521 if (doLock)
522 AB_Provider_EndExclUseUser(pro, u, 0);
523 AH_Job_free(job);
524 if (!nounmount)
525 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
526 return rv;
527 }
528 DBG_INFO(AQHBCI_LOGDOMAIN, "Crypt key saved");
529 }
530
531 /* store auth key on token (if any) */
532 kid=GWEN_Crypt_Token_Context_GetAuthVerifyKeyId(cctx);
533 ki=AH_Job_GetKeys_GetAuthKeyInfo(job);
534 if (kid && ki) {
535 rv=GWEN_Crypt_Token_SetKeyInfo(ct,
536 kid,
537 ki,
538 0);
539 if (rv) {
540 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not save key info (%d)", rv);
541 GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Error,
542 I18N("Error saving auth key"));
543 if (doLock)
544 AB_Provider_EndExclUseUser(pro, u, 0);
545 AH_Job_free(job);
546 if (!nounmount)
547 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
548 return rv;
549 }
550 DBG_INFO(AQHBCI_LOGDOMAIN, "Auth key saved");
551 }
552 }
553
554 AH_Job_free(job);
555 GWEN_Gui_ProgressLog(0,
556 GWEN_LoggerLevel_Notice,
557 I18N("Keys saved."));
558
559 /* unlock user */
560 if (doLock) {
561 rv=AB_Provider_EndExclUseUser(pro, u, 0);
562 if (rv) {
563 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not unlock user (%d)\n", rv);
564 if (!nounmount)
565 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
566 return rv;
567 }
568 }
569
570 if (!nounmount)
571 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
572
573 return 0;
574 }
575
576
577
AH_Provider_SendUserKeys2(AB_PROVIDER * pro,AB_USER * u,AB_IMEXPORTER_CONTEXT * ctx,int withAuthKey,int withProgress,int nounmount,int doLock)578 int AH_Provider_SendUserKeys2(AB_PROVIDER *pro, AB_USER *u,
579 AB_IMEXPORTER_CONTEXT *ctx,
580 int withAuthKey,
581 int withProgress, int nounmount, int doLock)
582 {
583 AB_BANKING *ab;
584 AH_HBCI *h;
585 AH_JOB *job;
586 AH_OUTBOX *ob;
587 int rv;
588 GWEN_CRYPT_TOKEN *ct;
589 uint32_t kid;
590 const GWEN_CRYPT_TOKEN_CONTEXT *cctx;
591 GWEN_CRYPT_TOKEN_KEYINFO *signKeyInfo=NULL;
592 GWEN_CRYPT_TOKEN_KEYINFO *cryptKeyInfo=NULL;
593 GWEN_CRYPT_TOKEN_KEYINFO *authKeyInfo=NULL;
594 int mounted=0;
595
596 assert(pro);
597 assert(u);
598
599 ab=AB_Provider_GetBanking(pro);
600 assert(ab);
601
602 h=AH_Provider_GetHbci(pro);
603 assert(h);
604
605 /* get crypt token */
606 rv=AB_Banking_GetCryptToken(AH_HBCI_GetBankingApi(h),
607 AH_User_GetTokenType(u),
608 AH_User_GetTokenName(u),
609 &ct);
610 if (rv) {
611 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not get crypt token (%d)", rv);
612 GWEN_Gui_ProgressLog(0,
613 GWEN_LoggerLevel_Error,
614 I18N("Error getting crypt token"));
615 if (!nounmount)
616 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
617 return rv;
618 }
619
620 /* open crypt token */
621 rv=GWEN_Crypt_Token_Open(ct, 1, 0);
622 if (rv) {
623 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not open crypt token (%d)", rv);
624 GWEN_Gui_ProgressLog(0,
625 GWEN_LoggerLevel_Error,
626 I18N("Error opening crypt token"));
627 if (!nounmount)
628 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
629 return rv;
630 }
631
632 /* get context */
633 cctx=GWEN_Crypt_Token_GetContext(ct, AH_User_GetTokenContextId(u), 0);
634 if (!cctx) {
635 DBG_ERROR(AQHBCI_LOGDOMAIN, "User context not found on crypt token");
636 GWEN_Gui_ProgressLog(0,
637 GWEN_LoggerLevel_Error,
638 I18N("User context not found on crypt token"));
639 if (!nounmount)
640 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
641 return GWEN_ERROR_NOT_FOUND;
642 }
643
644 /* get sign key info */
645 kid=GWEN_Crypt_Token_Context_GetSignKeyId(cctx);
646 if (kid) {
647 uint32_t ctxSignKeyNum=GWEN_Crypt_Token_Context_GetSignKeyNum(cctx);
648 const GWEN_CRYPT_TOKEN_KEYINFO *signKeyInfoCT=GWEN_Crypt_Token_GetKeyInfo(ct, kid,
649 GWEN_CRYPT_TOKEN_KEYFLAGS_HASMODULUS |
650 GWEN_CRYPT_TOKEN_KEYFLAGS_HASEXPONENT |
651 GWEN_CRYPT_TOKEN_KEYFLAGS_HASKEYVERSION |
652 GWEN_CRYPT_TOKEN_KEYFLAGS_HASKEYNUMBER,
653 0);
654 if (signKeyInfoCT==NULL) {
655 DBG_ERROR(AQHBCI_LOGDOMAIN, "Sign key info not found on crypt token");
656 GWEN_Gui_ProgressLog(0,
657 GWEN_LoggerLevel_Error,
658 I18N("Sign key info not found on crypt token"));
659 if (!nounmount)
660 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
661 return GWEN_ERROR_NOT_FOUND;
662 }
663 signKeyInfo=GWEN_Crypt_Token_KeyInfo_dup(signKeyInfoCT);
664 if (ctxSignKeyNum) {
665 GWEN_Crypt_Token_KeyInfo_SetKeyNumber(signKeyInfo, ctxSignKeyNum);
666 GWEN_Crypt_Token_KeyInfo_SetKeyVersion(signKeyInfo, GWEN_Crypt_Token_Context_GetSignKeyVer(cctx));
667 }
668
669 }
670 else {
671 DBG_INFO(AQHBCI_LOGDOMAIN, "No sign key id");
672 }
673
674 /* get crypt key info */
675 kid=GWEN_Crypt_Token_Context_GetDecipherKeyId(cctx);
676 if (kid) {
677 uint32_t ctxCryptKeyNum=GWEN_Crypt_Token_Context_GetDecipherKeyNum(cctx);
678 const GWEN_CRYPT_TOKEN_KEYINFO *cryptKeyInfoCT=GWEN_Crypt_Token_GetKeyInfo(ct, kid,
679 GWEN_CRYPT_TOKEN_KEYFLAGS_HASMODULUS |
680 GWEN_CRYPT_TOKEN_KEYFLAGS_HASEXPONENT |
681 GWEN_CRYPT_TOKEN_KEYFLAGS_HASKEYVERSION |
682 GWEN_CRYPT_TOKEN_KEYFLAGS_HASKEYNUMBER,
683 0);
684 if (cryptKeyInfoCT==NULL) {
685 DBG_ERROR(AQHBCI_LOGDOMAIN, "Crypt key info not found on crypt token");
686 GWEN_Gui_ProgressLog(0,
687 GWEN_LoggerLevel_Error,
688 I18N("Crypt key info not found on crypt token"));
689 if (!nounmount)
690 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
691 return GWEN_ERROR_NOT_FOUND;
692 }
693 cryptKeyInfo=GWEN_Crypt_Token_KeyInfo_dup(cryptKeyInfoCT);
694 if (ctxCryptKeyNum) {
695 GWEN_Crypt_Token_KeyInfo_SetKeyNumber(cryptKeyInfo, ctxCryptKeyNum);
696 GWEN_Crypt_Token_KeyInfo_SetKeyVersion(cryptKeyInfo, GWEN_Crypt_Token_Context_GetDecipherKeyVer(cctx));
697 }
698 }
699 else {
700 DBG_INFO(AQHBCI_LOGDOMAIN, "No decipher key id");
701 }
702
703 /* get auth sign key info */
704 if (withAuthKey) {
705 kid=GWEN_Crypt_Token_Context_GetAuthSignKeyId(cctx);
706 if (kid) {
707 uint32_t ctxAuthKeyNum=GWEN_Crypt_Token_Context_GetAuthSignKeyNum(cctx);
708 const GWEN_CRYPT_TOKEN_KEYINFO *authKeyInfoCT=GWEN_Crypt_Token_GetKeyInfo(ct, kid,
709 GWEN_CRYPT_TOKEN_KEYFLAGS_HASMODULUS |
710 GWEN_CRYPT_TOKEN_KEYFLAGS_HASEXPONENT |
711 GWEN_CRYPT_TOKEN_KEYFLAGS_HASKEYVERSION |
712 GWEN_CRYPT_TOKEN_KEYFLAGS_HASKEYNUMBER,
713 0);
714 if (authKeyInfoCT==NULL) {
715 DBG_ERROR(AQHBCI_LOGDOMAIN, "Auth key info not found on crypt token");
716 GWEN_Gui_ProgressLog(0,
717 GWEN_LoggerLevel_Error,
718 I18N("Auth key info not found on crypt token"));
719 if (!nounmount)
720 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
721 return GWEN_ERROR_NOT_FOUND;
722 }
723 authKeyInfo=GWEN_Crypt_Token_KeyInfo_dup(authKeyInfoCT);
724 if (ctxAuthKeyNum) {
725 GWEN_Crypt_Token_KeyInfo_SetKeyNumber(authKeyInfo, ctxAuthKeyNum);
726 GWEN_Crypt_Token_KeyInfo_SetKeyVersion(authKeyInfo, GWEN_Crypt_Token_Context_GetAuthSignKeyVer(cctx));
727 }
728 }
729 else {
730 DBG_INFO(AQHBCI_LOGDOMAIN, "No auth key id");
731 }
732 }
733
734 /* create job */
735 job=AH_Job_SendKeys_new(pro, u, cryptKeyInfo, signKeyInfo, authKeyInfo);
736
737 /* free keyinfos */
738 if (signKeyInfo) {
739 GWEN_Crypt_Token_KeyInfo_free(signKeyInfo);
740 }
741 if (cryptKeyInfo) {
742 GWEN_Crypt_Token_KeyInfo_free(cryptKeyInfo);
743 }
744 if (authKeyInfo) {
745 GWEN_Crypt_Token_KeyInfo_free(authKeyInfo);
746 }
747
748 if (!job) {
749 DBG_ERROR(AQHBCI_LOGDOMAIN, "Job not supported, should not happen");
750 GWEN_Gui_ProgressLog(0,
751 GWEN_LoggerLevel_Error,
752 I18N("Job not supported, should not happen"));
753 if (!nounmount && mounted)
754 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
755 return GWEN_ERROR_GENERIC;
756 }
757 AH_Job_AddSigner(job, AB_User_GetUserId(u));
758
759 /* enqueue job */
760 ob=AH_Outbox_new(pro);
761 AH_Outbox_AddJob(ob, job);
762
763 /* execute queue */
764 rv=AH_Outbox_Execute(ob, ctx, withProgress, 0, doLock);
765 AH_Outbox_free(ob);
766 if (rv) {
767 GWEN_Gui_ProgressLog(0,
768 GWEN_LoggerLevel_Error,
769 I18N("Could not execute outbox."));
770 AH_Job_free(job);
771 if (!nounmount && mounted)
772 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
773 return rv;
774 }
775
776 /* check result */
777 if (AH_Job_HasErrors(job)) {
778 DBG_ERROR(AQHBCI_LOGDOMAIN, "Job has errors");
779 GWEN_Gui_ProgressLog(0,
780 GWEN_LoggerLevel_Error,
781 I18N("Job contains errors."));
782 AH_Job_free(job);
783 if (!nounmount && mounted)
784 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
785 return GWEN_ERROR_GENERIC;
786 }
787 else {
788 rv=AH_Job_Commit(job, doLock);
789 if (rv) {
790 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not commit result.\n");
791 GWEN_Gui_ProgressLog(0,
792 GWEN_LoggerLevel_Error,
793 I18N("Could not commit result"));
794 AH_Job_free(job);
795 if (!nounmount && mounted)
796 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
797 return rv;
798 }
799 }
800
801 GWEN_Gui_ProgressLog(0,
802 GWEN_LoggerLevel_Notice,
803 I18N("Keys sent"));
804
805 AH_Job_free(job);
806 if (!nounmount && mounted)
807 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
808
809 return 0;
810 }
811
812
813
AH_Provider_SendUserKeys(AB_PROVIDER * pro,AB_USER * u,AB_IMEXPORTER_CONTEXT * ctx,int withProgress,int nounmount,int doLock)814 int AH_Provider_SendUserKeys(AB_PROVIDER *pro, AB_USER *u,
815 AB_IMEXPORTER_CONTEXT *ctx,
816 int withProgress, int nounmount, int doLock)
817 {
818 return AH_Provider_SendUserKeys2(pro, u, ctx, 0, withProgress, nounmount, doLock);
819 }
820
821
822
AH_Provider_ChangeUserKeys(AB_PROVIDER * pro,AB_USER * u,GWEN_DB_NODE * args,int withProgress,int nounmount,int doLock)823 int AH_Provider_ChangeUserKeys(AB_PROVIDER *pro, AB_USER *u, GWEN_DB_NODE *args, int withProgress, int nounmount,
824 int doLock)
825 {
826 int res=0;
827 uint8_t canceled=0;
828 AH_JOB *job=NULL;
829 AB_IMEXPORTER_CONTEXT *ctx=NULL;
830
831 assert(u);
832
833 job=AH_Job_ChangeKeys_new(pro, u, args, &canceled);
834 if (!job) {
835 res = -2;
836 if (!canceled) {
837 DBG_ERROR(AQHBCI_LOGDOMAIN, "Unexplainable, 'AH_Job_ChangeKeys_new' not supported.");
838 GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Error, I18N("Unexplainable, 'AH_Job_ChangeKeys_new' not supported."));
839 res = -1;
840 }
841 if (canceled == 2)
842 res = -1;
843 }
844
845 if (!res) {
846 ctx = AB_ImExporterContext_new();
847 if (!ctx) {
848 DBG_ERROR(AQHBCI_LOGDOMAIN, "Error getting ctx.");
849 res = -1;
850 }
851 }
852 if (ctx) {
853 AH_OUTBOX *ob = AH_Outbox_new(pro);
854 if (!ob)
855 GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Error, I18N("Allocate outbox failed."));
856 else {
857 AH_Job_AddSigner(job, AB_User_GetUserId(u));
858 AH_Outbox_AddJob(ob, job);
859
860 GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Info, I18N("Fetching serverkeys."));
861 res = AH_Outbox_Execute(ob, ctx, withProgress, 0, doLock);
862 AH_Outbox_free(ob);
863 if (res)
864 GWEN_Gui_ProgressLog(0, GWEN_LoggerLevel_Error, I18N("Could not execute outbox."));
865 DBG_INFO(AQHBCI_LOGDOMAIN, "res %d, status %d.", res, AH_Job_GetStatus(job));
866 if (res || (AH_Job_GetStatus(job) == AH_JobStatusError))
867 res = -1;
868 }
869 AB_ImExporterContext_free(ctx);
870 }
871
872 res = AH_Job_ChangeKeys_finish(pro, job, res);
873
874 if (job)
875 AH_Job_free(job);
876
877 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(AH_Provider_GetHbci(pro)));
878
879 return (res == -2) ? 0 : res;
880 }
881
882
883
AH_Provider_GetCert(AB_PROVIDER * pro,AB_USER * u,int withProgress,int nounmount,int doLock)884 int AH_Provider_GetCert(AB_PROVIDER *pro,
885 AB_USER *u,
886 int withProgress, int nounmount, int doLock)
887 {
888 AB_BANKING *ab;
889 AH_HBCI *h;
890 int rv;
891 AH_DIALOG *dialog;
892 uint32_t pid;
893
894 assert(pro);
895 assert(u);
896
897 ab=AB_Provider_GetBanking(pro);
898 assert(ab);
899
900 h=AH_Provider_GetHbci(pro);
901 assert(h);
902
903 pid=GWEN_Gui_ProgressStart(GWEN_GUI_PROGRESS_ALLOW_EMBED |
904 GWEN_GUI_PROGRESS_SHOW_PROGRESS |
905 GWEN_GUI_PROGRESS_SHOW_ABORT,
906 I18N("Getting Certificate"),
907 I18N("We are now asking the server for its "
908 "SSL certificate"),
909 GWEN_GUI_PROGRESS_NONE,
910 0);
911 /* first try */
912 dialog=AH_Dialog_new(u, pro);
913 assert(dialog);
914 rv=AH_Dialog_TestServer_Https(dialog);
915 AH_Dialog_Disconnect(dialog);
916 AH_Dialog_free(dialog);
917
918 if (rv) {
919 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not connect to server (%d)", rv);
920 GWEN_Gui_ProgressLog(pid,
921 GWEN_LoggerLevel_Error,
922 I18N("Could not connect to server"));
923 GWEN_Gui_ProgressEnd(pid);
924 return rv;
925 }
926
927 GWEN_Gui_ProgressLog(pid,
928 GWEN_LoggerLevel_Error,
929 I18N("Got certificate"));
930 GWEN_Gui_ProgressEnd(pid);
931
932 return 0;
933 }
934
935
936
AH_Provider_GetItanModes(AB_PROVIDER * pro,AB_USER * u,AB_IMEXPORTER_CONTEXT * ctx,int withProgress,int nounmount,int doLock)937 int AH_Provider_GetItanModes(AB_PROVIDER *pro, AB_USER *u,
938 AB_IMEXPORTER_CONTEXT *ctx,
939 int withProgress, int nounmount, int doLock)
940 {
941 AB_BANKING *ab;
942 AH_HBCI *h;
943 AH_JOB *job;
944 AH_OUTBOX *ob;
945 int rv;
946 const int *tm;
947 char tbuf[256];
948
949 assert(pro);
950 assert(u);
951
952 ab=AB_Provider_GetBanking(pro);
953 assert(ab);
954
955 h=AH_Provider_GetHbci(pro);
956 assert(h);
957
958 if (doLock) {
959 rv=AB_Provider_BeginExclUseUser(pro, u);
960 if (rv<0) {
961 DBG_INFO(AQHBCI_LOGDOMAIN,
962 "Could not lock customer [%s] (%d)",
963 AB_User_GetCustomerId(u), rv);
964 snprintf(tbuf, sizeof(tbuf)-1,
965 I18N("Could not lock user %s (%d)"),
966 AB_User_GetUserId(u), rv);
967 tbuf[sizeof(tbuf)-1]=0;
968 GWEN_Gui_ProgressLog(0,
969 GWEN_LoggerLevel_Error,
970 tbuf);
971 return rv;
972 }
973 }
974
975 job=AH_Job_GetItanModes_new(pro, u);
976 if (!job) {
977 DBG_ERROR(AQHBCI_LOGDOMAIN, "Job not supported, should not happen");
978 if (doLock)
979 AB_Provider_EndExclUseUser(pro, u, 1);
980 return GWEN_ERROR_GENERIC;
981 }
982 AH_Job_AddSigner(job, AB_User_GetUserId(u));
983
984 ob=AH_Outbox_new(pro);
985 AH_Outbox_AddJob(ob, job);
986 rv=AH_Outbox_Execute(ob, ctx, withProgress, 1, 0);
987 AH_Outbox_free(ob);
988 if (rv) {
989 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not execute outbox.");
990 if (doLock)
991 AB_Provider_EndExclUseUser(pro, u, 1);
992 AH_Job_free(job);
993 if (!nounmount)
994 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
995 return rv;
996 }
997
998 tm=AH_Job_GetItanModes_GetModes(job);
999 if (tm[0]==-1) {
1000 DBG_ERROR(AQHBCI_LOGDOMAIN, "No iTAN modes reported");
1001 GWEN_Gui_ProgressLog(0,
1002 GWEN_LoggerLevel_Error,
1003 I18N("No iTAN modes reported."));
1004 if (doLock)
1005 AB_Provider_EndExclUseUser(pro, u, 1);
1006 AH_Job_free(job);
1007 if (!nounmount)
1008 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1009 return GWEN_ERROR_NO_DATA;
1010 }
1011
1012 /* we have received tan methods, so there was a 3920 response. In this
1013 * special case we need to apply the job data, because otherwise we couldn't
1014 * fully connect to the server next time.
1015 */
1016 rv=AH_Job_Commit(job, 0);
1017 if (rv) {
1018 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not commit result.\n");
1019 GWEN_Gui_ProgressLog(0,
1020 GWEN_LoggerLevel_Error,
1021 I18N("Could not commit result to the system"));
1022 if (doLock)
1023 AB_Provider_EndExclUseUser(pro, u, 1);
1024 AH_Job_free(job);
1025 if (!nounmount)
1026 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1027 return rv;
1028 }
1029
1030 if (doLock) {
1031 rv=AB_Provider_EndExclUseUser(pro, u, 0);
1032 if (rv<0) {
1033 DBG_INFO(AQHBCI_LOGDOMAIN,
1034 "Could not unlock customer [%s] (%d)",
1035 AB_User_GetCustomerId(u), rv);
1036 snprintf(tbuf, sizeof(tbuf)-1,
1037 I18N("Could not unlock user %s (%d)"),
1038 AB_User_GetUserId(u), rv);
1039 tbuf[sizeof(tbuf)-1]=0;
1040 GWEN_Gui_ProgressLog(0,
1041 GWEN_LoggerLevel_Error,
1042 tbuf);
1043 AB_Provider_EndExclUseUser(pro, u, 1);
1044 AH_Job_free(job);
1045 if (!nounmount)
1046 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1047 return rv;
1048 }
1049 }
1050
1051 AH_Job_free(job);
1052
1053 if (!nounmount)
1054 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1055
1056 return 0;
1057 }
1058
1059
1060
AH_Provider_ChangePin(AB_PROVIDER * pro,AB_USER * u,AB_IMEXPORTER_CONTEXT * ctx,int withProgress,int nounmount,int doLock)1061 int AH_Provider_ChangePin(AB_PROVIDER *pro, AB_USER *u,
1062 AB_IMEXPORTER_CONTEXT *ctx,
1063 int withProgress, int nounmount, int doLock)
1064 {
1065 AB_BANKING *ab;
1066 AH_HBCI *h;
1067 AH_JOB *job;
1068 AH_OUTBOX *ob;
1069 int rv;
1070 char pwbuf[32];
1071
1072 assert(pro);
1073 assert(u);
1074
1075 ab=AB_Provider_GetBanking(pro);
1076 assert(ab);
1077
1078 h=AH_Provider_GetHbci(pro);
1079 assert(h);
1080
1081 memset(pwbuf, 0, sizeof(pwbuf));
1082 rv=GWEN_Gui_InputBox(GWEN_GUI_INPUT_FLAGS_NUMERIC |
1083 GWEN_GUI_INPUT_FLAGS_CONFIRM,
1084 I18N("Enter New Banking PIN"),
1085 I18N("Please enter a new banking PIN.\n"
1086 "You must only enter numbers, not letters.\n"
1087 "<html>"
1088 "<p>"
1089 "Please enter a new banking PIN."
1090 "</p>"
1091 "<p>"
1092 "You must only enter numbers, not letters."
1093 "</p>"
1094 "</html>"),
1095 pwbuf,
1096 0, 8, 0);
1097 if (rv<0) {
1098 DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
1099 return rv;
1100 }
1101 job=AH_Job_ChangePin_new(pro, u, pwbuf);
1102 if (!job) {
1103 DBG_ERROR(AQHBCI_LOGDOMAIN, "Job not supported, should not happen");
1104 return GWEN_ERROR_GENERIC;
1105 }
1106 AH_Job_AddSigner(job, AB_User_GetUserId(u));
1107
1108 ob=AH_Outbox_new(pro);
1109 AH_Outbox_AddJob(ob, job);
1110
1111 rv=AH_Outbox_Execute(ob, ctx, withProgress, nounmount, doLock);
1112 AH_Outbox_free(ob);
1113 if (rv) {
1114 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not execute outbox.\n");
1115 AH_Job_free(job);
1116 if (!nounmount)
1117 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1118 return rv;
1119 }
1120
1121 if (AH_Job_HasErrors(job)) {
1122 DBG_ERROR(AQHBCI_LOGDOMAIN, "Job has errors");
1123 // TODO: show errors
1124 AH_Job_free(job);
1125 if (!nounmount)
1126 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1127 return GWEN_ERROR_GENERIC;
1128 }
1129 else {
1130 rv=AH_Job_Commit(job, doLock);
1131 if (rv) {
1132 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not commit result.\n");
1133 AH_Job_free(job);
1134 if (!nounmount)
1135 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1136 return rv;
1137 }
1138 }
1139
1140 AH_Job_free(job);
1141
1142 if (!nounmount)
1143 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1144
1145 return 0;
1146 }
1147
1148
1149
AH_Provider_UnblockPin(AB_PROVIDER * pro,AB_USER * u,AB_IMEXPORTER_CONTEXT * ctx,int withProgress,int nounmount,int doLock)1150 int AH_Provider_UnblockPin(AB_PROVIDER *pro,
1151 AB_USER *u,
1152 AB_IMEXPORTER_CONTEXT *ctx,
1153 int withProgress, int nounmount, int doLock)
1154 {
1155 AB_BANKING *ab;
1156 AH_HBCI *h;
1157 AH_OUTBOX *ob;
1158 int rv;
1159 AH_JOB *job;
1160
1161 assert(pro);
1162
1163 ab=AB_Provider_GetBanking(pro);
1164 assert(ab);
1165
1166 h=AH_Provider_GetHbci(pro);
1167 assert(h);
1168
1169 ob=AH_Outbox_new(pro);
1170
1171 /* TODO: store user to free it later */
1172 job=AH_Job_UnblockPin_new(pro, u);
1173 if (!job) {
1174 DBG_WARN(AQHBCI_LOGDOMAIN, "Job not supported with this account");
1175 AH_Outbox_free(ob);
1176 return GWEN_ERROR_GENERIC;
1177 }
1178 AH_Job_AddSigner(job, AB_User_GetUserId(u));
1179
1180 AH_Outbox_AddJob(ob, job);
1181 AH_Job_free(job);
1182
1183 rv=AH_Outbox_Execute(ob, ctx, withProgress, nounmount, doLock);
1184 if (rv) {
1185 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not execute outbox.\n");
1186 AH_Outbox_free(ob);
1187 if (!nounmount)
1188 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1189 return rv;
1190 }
1191
1192 AH_Outbox_free(ob);
1193
1194 if (!nounmount)
1195 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1196
1197 return 0;
1198 }
1199
1200
1201
AH_Provider_GetAccountSepaInfo(AB_PROVIDER * pro,AB_ACCOUNT * a,AB_IMEXPORTER_CONTEXT * ctx,int withProgress,int nounmount,int doLock)1202 int AH_Provider_GetAccountSepaInfo(AB_PROVIDER *pro,
1203 AB_ACCOUNT *a,
1204 AB_IMEXPORTER_CONTEXT *ctx,
1205 int withProgress, int nounmount, int doLock)
1206 {
1207 AB_BANKING *ab;
1208 AH_HBCI *h;
1209 AH_OUTBOX *ob;
1210 uint32_t uid;
1211 int rv;
1212
1213 assert(pro);
1214
1215 ab=AB_Provider_GetBanking(pro);
1216 assert(ab);
1217
1218 h=AH_Provider_GetHbci(pro);
1219 assert(h);
1220
1221
1222 ob=AH_Outbox_new(pro);
1223
1224 uid=AB_Account_GetUserId(a);
1225 if (uid==0) {
1226 DBG_ERROR(AQHBCI_LOGDOMAIN, "No user for this account");
1227 }
1228 else {
1229 AB_USER *u;
1230
1231 rv=AB_Provider_GetUser(pro, uid, 1, 1, &u);
1232 if (rv<0) {
1233 DBG_ERROR(AQHBCI_LOGDOMAIN, "Unknown user for this account");
1234 }
1235 else {
1236 AH_JOB *job;
1237
1238 /* TODO: store user to free it later */
1239 job=AH_Job_GetAccountSepaInfo_new(pro, u, a);
1240 if (!job) {
1241 DBG_WARN(AQHBCI_LOGDOMAIN, "Job not supported with this account");
1242 AH_Outbox_free(ob);
1243 return GWEN_ERROR_GENERIC;
1244 }
1245 AH_Job_AddSigner(job, AB_User_GetUserId(u));
1246 AH_Outbox_AddJob(ob, job);
1247 AH_Job_free(job);
1248 }
1249 }
1250
1251 rv=AH_Outbox_Execute(ob, ctx, withProgress, nounmount, doLock);
1252 if (rv) {
1253 DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not execute outbox.\n");
1254 AH_Outbox_free(ob);
1255 if (!nounmount)
1256 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1257 return rv;
1258 }
1259
1260 AH_Outbox_free(ob);
1261
1262 if (!nounmount)
1263 AB_Banking_ClearCryptTokenList(AH_HBCI_GetBankingApi(h));
1264
1265 return 0;
1266 }
1267
1268
1269
1270
1271
1272