void AB_CSV_EditProfileDialog_Fini(GWEN_DIALOG *dlg)
{
AB_CSV_EDIT_PROFILE_DIALOG *xdlg;
int i;
GWEN_DB_NODE *dbPrefs;
assert(dlg);
xdlg=GWEN_INHERIT_GETDATA(GWEN_DIALOG, AB_CSV_EDIT_PROFILE_DIALOG, dlg);
assert(xdlg);
dbPrefs=GWEN_Dialog_GetPreferences(dlg);
/* store dialog width */
i=GWEN_Dialog_GetIntProperty(dlg, "", GWEN_DialogProperty_Width, 0, -1);
if (i<DIALOG_MINWIDTH)
i=DIALOG_MINWIDTH;
GWEN_DB_SetIntValue(dbPrefs,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"dialog_width",
i);
/* store dialog height */
i=GWEN_Dialog_GetIntProperty(dlg, "", GWEN_DialogProperty_Height, 0, -1);
if (i<DIALOG_MINHEIGHT)
i=DIALOG_MINHEIGHT;
GWEN_DB_SetIntValue(dbPrefs,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"dialog_height",
i);
}
void GWEN_DlgShowBox_Fini(GWEN_DIALOG *dlg) {
GWEN_DLGSHOWBOX *xdlg;
int i;
GWEN_DB_NODE *dbParams;
assert(dlg);
xdlg=GWEN_INHERIT_GETDATA(GWEN_DIALOG, GWEN_DLGSHOWBOX, dlg);
assert(xdlg);
dbParams=GWEN_Dialog_GetPreferences(dlg);
assert(dbParams);
/* store dialog width */
i=GWEN_Dialog_GetIntProperty(dlg, "", GWEN_DialogProperty_Width, 0, -1);
if (i<DIALOG_MINWIDTH)
i=DIALOG_MINWIDTH;
GWEN_DB_SetIntValue(dbParams,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"dialog_width",
i);
/* store dialog height */
i=GWEN_Dialog_GetIntProperty(dlg, "", GWEN_DialogProperty_Height, 0, -1);
if (i<DIALOG_MINHEIGHT)
i=DIALOG_MINHEIGHT;
GWEN_DB_SetIntValue(dbParams,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"dialog_height",
i);
}
int EBC_Provider_Fini(AB_PROVIDER *pro, GWEN_DB_NODE *dbData) {
EBC_PROVIDER *dp;
uint32_t currentVersion;
DBG_NOTICE(AQEBICS_LOGDOMAIN, "Deinitializing AqEBICS backend");
assert(pro);
dp=GWEN_INHERIT_GETDATA(AB_PROVIDER, EBC_PROVIDER, pro);
assert(dp);
currentVersion=
(AQEBICS_VERSION_MAJOR<<24) |
(AQEBICS_VERSION_MINOR<<16) |
(AQEBICS_VERSION_PATCHLEVEL<<8) |
AQEBICS_VERSION_BUILD;
/* save configuration */
DBG_NOTICE(AQEBICS_LOGDOMAIN, "Setting version %08x",
currentVersion);
GWEN_DB_SetIntValue(dbData, GWEN_DB_FLAGS_OVERWRITE_VARS,
"lastVersion", currentVersion);
GWEN_DB_SetIntValue(dbData, GWEN_DB_FLAGS_OVERWRITE_VARS,
"connectTimeout", dp->connectTimeout);
GWEN_DB_SetIntValue(dbData, GWEN_DB_FLAGS_OVERWRITE_VARS,
"transferTimeout", dp->transferTimeout);
return 0;
}
void AH_NewKeyFileDialog_Fini(GWEN_DIALOG *dlg) {
AH_NEWKEYFILE_DIALOG *xdlg;
int i;
GWEN_DB_NODE *dbPrefs;
assert(dlg);
xdlg=GWEN_INHERIT_GETDATA(GWEN_DIALOG, AH_NEWKEYFILE_DIALOG, dlg);
assert(xdlg);
dbPrefs=GWEN_Dialog_GetPreferences(dlg);
/* store dialog width */
i=GWEN_Dialog_GetIntProperty(dlg, "", GWEN_DialogProperty_Width, 0, -1);
GWEN_DB_SetIntValue(dbPrefs,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"dialog_width",
i);
/* store dialog height */
i=GWEN_Dialog_GetIntProperty(dlg, "", GWEN_DialogProperty_Height, 0, -1);
GWEN_DB_SetIntValue(dbPrefs,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"dialog_height",
i);
}
void AB_SetupNewUserDialog_Fini(GWEN_DIALOG *dlg) {
AB_SETUP_NEWUSER_DIALOG *xdlg;
int i;
GWEN_DB_NODE *dbPrefs;
assert(dlg);
xdlg=GWEN_INHERIT_GETDATA(GWEN_DIALOG, AB_SETUP_NEWUSER_DIALOG, dlg);
assert(xdlg);
xdlg->selectedType=0;
free(xdlg->selectedBackend);
xdlg->selectedBackend=NULL;
i=AB_SetupNewUserDialog_DetermineBackendIndex(dlg);
if (i>=0) {
const char *s;
GWEN_DIALOG_LIST2_ITERATOR *it;
s=GWEN_StringList_StringAt(xdlg->backendNames, i);
if (s && *s)
xdlg->selectedBackend=strdup(s);
it=GWEN_Dialog_List2_First(xdlg->backendDialogs);
if (it) {
int j=i;
GWEN_DIALOG *cdlg;
cdlg=GWEN_Dialog_List2Iterator_Data(it);
while(cdlg && j>0) {
j--;
cdlg=GWEN_Dialog_List2Iterator_Next(it);
}
GWEN_Dialog_List2Iterator_free(it);
if (cdlg)
xdlg->selectedType=AB_UserTypePageDialog_GetSelectedType(cdlg);
}
}
/* save dialog settings */
dbPrefs=GWEN_Dialog_GetPreferences(dlg);
/* store dialog width */
i=GWEN_Dialog_GetIntProperty(dlg, "", GWEN_DialogProperty_Width, 0, -1);
GWEN_DB_SetIntValue(dbPrefs,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"dialog_width",
i);
/* store dialog height */
i=GWEN_Dialog_GetIntProperty(dlg, "", GWEN_DialogProperty_Height, 0, -1);
GWEN_DB_SetIntValue(dbPrefs,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"dialog_height",
i);
}
int LC_Starcos_KeyDescr_toDb(const LC_STARCOS_KEYDESCR *st, GWEN_DB_NODE *db) {
assert(st);
assert(db);
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "keyId", st->keyId))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "status", st->status))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "keyType", st->keyType))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "keyNum", st->keyNum))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "keyVer", st->keyVer))
return -1;
return 0;
}
int GWEN_Url_toDb(const GWEN_URL *st, GWEN_DB_NODE *db) {
assert(st);
assert(db);
if (st->protocol)
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "protocol", st->protocol))
return -1;
if (st->server)
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "server", st->server))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "port", st->port))
return -1;
if (st->path)
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "path", st->path))
return -1;
if (st->userName)
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "userName", st->userName))
return -1;
if (st->password)
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "password", st->password))
return -1;
if (st->vars)
if (GWEN_DB_AddGroupChildren(st->vars, GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_DEFAULT, "vars")))
return -1;
if (st->url)
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "url", st->url))
return -1;
return 0;
}
int APY_Provider_Fini(AB_PROVIDER *pro, GWEN_DB_NODE *dbData)
{
APY_PROVIDER *dp;
uint32_t currentVersion;
DBG_NOTICE(AQPAYPAL_LOGDOMAIN, "Deinitializing AqPaypal backend");
assert(pro);
dp=GWEN_INHERIT_GETDATA(AB_PROVIDER, APY_PROVIDER, pro);
assert(dp);
currentVersion=
(AQBANKING_VERSION_MAJOR<<24) |
(AQBANKING_VERSION_MINOR<<16) |
(AQBANKING_VERSION_PATCHLEVEL<<8) |
AQBANKING_VERSION_BUILD;
/* save configuration */
DBG_NOTICE(AQPAYPAL_LOGDOMAIN, "Setting version %08x", currentVersion);
GWEN_DB_SetIntValue(dbData, GWEN_DB_FLAGS_OVERWRITE_VARS, "lastVersion", currentVersion);
DBG_INFO(AQPAYPAL_LOGDOMAIN, "Deinit done");
return 0;
}
int LC_DDVCard_GetKeyVersion1(LC_CARD *card, int keyNumber){
LC_DDVCARD *ddv;
GWEN_DB_NODE *dbReq;
GWEN_DB_NODE *dbResp;
LC_CLIENT_RESULT res;
int keyVersion;
assert(card);
ddv=GWEN_INHERIT_GETDATA(LC_CARD, LC_DDVCARD, card);
assert(ddv);
dbReq=GWEN_DB_Group_new("GetKeyInfo");
dbResp=GWEN_DB_Group_new("response");
GWEN_DB_SetIntValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
"keyNumber", keyNumber);
res=LC_Card_ExecCommand(card, "GetKeyInfo", dbReq, dbResp);
if (res!=LC_Client_ResultOk) {
GWEN_DB_Group_free(dbReq);
GWEN_DB_Group_free(dbResp);
return -1;
}
keyVersion=GWEN_DB_GetIntValue(dbResp,
"response/keyVersion", 0, -1);
if (keyVersion==-1) {
DBG_ERROR(LC_LOGDOMAIN, "No keyversion returned by command");
}
GWEN_DB_Group_free(dbReq);
GWEN_DB_Group_free(dbResp);
return keyVersion;
}
int AB_Banking_SaveConfig(AB_BANKING *ab) {
GWEN_DB_NODE *db=NULL;
int rv;
assert(ab);
/* check for config manager (created by AB_Banking_Init) */
if (ab->configMgr==NULL) {
DBG_ERROR(AQBANKING_LOGDOMAIN,
"No config manager (maybe the gwenhywfar plugins are not installed?");
return GWEN_ERROR_GENERIC;
}
/* lock group */
rv=GWEN_ConfigMgr_LockGroup(ab->configMgr, AB_CFG_GROUP_MAIN, "config");
if (rv<0) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Unable to lock main config group (%d)", rv);
return rv;
}
/* load group (is locked now) */
rv=GWEN_ConfigMgr_GetGroup(ab->configMgr, AB_CFG_GROUP_MAIN, "config", &db);
if (rv<0) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not load main config group (%d)", rv);
GWEN_ConfigMgr_UnlockGroup(ab->configMgr, AB_CFG_GROUP_MAIN, "config");
return rv;
}
/* modify group */
GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"lastVersion",
(AQBANKING_VERSION_MAJOR<<24) |
(AQBANKING_VERSION_MINOR<<16) |
(AQBANKING_VERSION_PATCHLEVEL<<8) |
AQBANKING_VERSION_BUILD);
/* save group (still locked) */
rv=GWEN_ConfigMgr_SetGroup(ab->configMgr, AB_CFG_GROUP_MAIN, "config", db);
if (rv<0) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not save main config group (%d)", rv);
GWEN_ConfigMgr_UnlockGroup(ab->configMgr, AB_CFG_GROUP_MAIN, "config");
GWEN_DB_Group_free(db);
return rv;
}
/* unlock group */
rv=GWEN_ConfigMgr_UnlockGroup(ab->configMgr, AB_CFG_GROUP_MAIN, "config");
if (rv<0) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not unlock main config group (%d)", rv);
GWEN_DB_Group_free(db);
return rv;
}
GWEN_DB_Group_free(db);
return 0;
}
int GWEN_Crypt_PaddAlgo_toDb(const GWEN_CRYPT_PADDALGO *a, GWEN_DB_NODE *db)
{
assert(a);
assert(a->refCount);
GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"id",
GWEN_Crypt_PaddAlgoId_toString(a->id));
GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"paddSize", a->paddSize);
return 0;
}
int GWEN_Time_toDb(const GWEN_TIME *t, GWEN_DB_NODE *db) {
GWEN_DB_NODE *dbT;
int i1, i2, i3;
assert(t);
assert(db);
dbT=GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_DEFAULT, "date");
GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"inUtc", 1);
assert(dbT);
if (GWEN_Time_GetBrokenDownUtcDate(t, &i1, &i2, &i3)) {
DBG_INFO(GWEN_LOGDOMAIN, "Could not break down date");
return -1;
}
GWEN_DB_SetIntValue(dbT, GWEN_DB_FLAGS_OVERWRITE_VARS,
"day", i1);
GWEN_DB_SetIntValue(dbT, GWEN_DB_FLAGS_OVERWRITE_VARS,
"month", i2+1);
GWEN_DB_SetIntValue(dbT, GWEN_DB_FLAGS_OVERWRITE_VARS,
"year", i3);
dbT=GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_DEFAULT, "time");
assert(dbT);
if (GWEN_Time_GetBrokenDownUtcTime(t, &i1, &i2, &i3)) {
DBG_INFO(GWEN_LOGDOMAIN, "Could not break down time");
return -1;
}
GWEN_DB_SetIntValue(dbT, GWEN_DB_FLAGS_OVERWRITE_VARS,
"hour", i1);
GWEN_DB_SetIntValue(dbT, GWEN_DB_FLAGS_OVERWRITE_VARS,
"min", i2);
GWEN_DB_SetIntValue(dbT, GWEN_DB_FLAGS_OVERWRITE_VARS,
"sec", i3);
return 0;
}
int AH_Msg_SignPinTan(AH_MSG *hmsg,
GWEN_BUFFER *rawBuf,
const char *signer) {
AH_HBCI *h;
GWEN_XMLNODE *node;
GWEN_DB_NODE *cfg;
GWEN_BUFFER *hbuf;
int rv;
char ctrlref[15];
const char *p;
GWEN_MSGENGINE *e;
AB_USER *su;
uint32_t uFlags;
char pin[64];
uint32_t tm;
assert(hmsg);
h=AH_Dialog_GetHbci(hmsg->dialog);
assert(h);
e=AH_Dialog_GetMsgEngine(hmsg->dialog);
assert(e);
GWEN_MsgEngine_SetMode(e, "pintan");
su=AB_Banking_FindUser(AH_HBCI_GetBankingApi(h),
AH_PROVIDER_NAME,
"de", "*",
signer, "*");
if (!su) {
DBG_ERROR(AQHBCI_LOGDOMAIN,
"Unknown user \"%s\"",
signer);
return GWEN_ERROR_NOT_FOUND;
}
uFlags=AH_User_GetFlags(su);
node=GWEN_MsgEngine_FindNodeByPropertyStrictProto(e,
"SEG",
"id",
0,
"SigHead");
if (!node) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Segment \"SigHead\" not found");
return GWEN_ERROR_INTERNAL;
}
/* for iTAN mode: set selected mode (Sicherheitsfunktion, kodiert) */
tm=AH_Msg_GetItanMethod(hmsg);
if (tm==0) {
tm=AH_Dialog_GetItanMethod(hmsg->dialog);
if (tm)
/* this is needed by AH_MsgPinTan_PrepareCryptoSeg */
AH_Msg_SetItanMethod(hmsg, tm);
}
/* prepare config for segment */
cfg=GWEN_DB_Group_new("sighead");
rv=AH_MsgPinTan_PrepareCryptoSeg(hmsg, su, cfg, 0, 1);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
GWEN_DB_Group_free(cfg);
return rv;
}
/* set expected signer */
if (!(uFlags & AH_USER_FLAGS_BANK_DOESNT_SIGN)) {
const char *remoteId;
remoteId=AH_User_GetPeerId(su);
if (!remoteId || *remoteId==0)
remoteId=AB_User_GetUserId(su);
assert(remoteId);
assert(*remoteId);
DBG_DEBUG(AQHBCI_LOGDOMAIN,
"Expecting \"%s\" to sign the response",
remoteId);
AH_Msg_SetExpectedSigner(hmsg, remoteId);
}
/* store system id */
p=NULL;
if (!hmsg->noSysId)
p=AH_User_GetSystemId(su);
if (!p)
p="0";
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT, "SecDetails/SecId", p);
if (tm) {
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"function", tm);
}
/* retrieve control reference for sigtail (to be used later) */
p=GWEN_DB_GetCharValue(cfg, "ctrlref", 0, "");
if (strlen(p)>=sizeof(ctrlref)) {
DBG_INFO(AQHBCI_LOGDOMAIN,
"Control reference too long (14 bytes maximum)");
GWEN_DB_Group_free(cfg);
return -1;
}
strcpy(ctrlref, p);
/* create SigHead */
hbuf=GWEN_Buffer_new(0, 128+GWEN_Buffer_GetUsedBytes(rawBuf), 0, 1);
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"head/seq", hmsg->firstSegment-1);
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"signseq", 1);
/* create signature head segment */
rv=GWEN_MsgEngine_CreateMessageFromNode(e, node, hbuf, cfg);
GWEN_DB_Group_free(cfg);
cfg=0;
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Could not create SigHead");
GWEN_Buffer_free(hbuf);
return rv;
}
/* insert new SigHead at beginning of message buffer */
DBG_DEBUG(AQHBCI_LOGDOMAIN, "Inserting signature head");
GWEN_Buffer_Rewind(hmsg->buffer);
GWEN_Buffer_InsertBytes(hmsg->buffer,
GWEN_Buffer_GetStart(hbuf),
GWEN_Buffer_GetUsedBytes(hbuf));
/* create sigtail */
DBG_DEBUG(AQHBCI_LOGDOMAIN, "Completing signature tail");
cfg=GWEN_DB_Group_new("sigtail");
GWEN_Buffer_Reset(hbuf);
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"head/seq", hmsg->lastSegment+1);
/* store to DB */
GWEN_DB_SetBinValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"signature",
"NOSIGNATURE",
11);
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"ctrlref", ctrlref);
/* handle pin */
memset(pin, 0, sizeof(pin));
rv=AH_User_InputPin(su, pin, 4, sizeof(pin), 0);
if (rv<0) {
DBG_ERROR(AQHBCI_LOGDOMAIN,
"Error getting pin from medium (%d)", rv);
GWEN_DB_Group_free(cfg);
GWEN_Buffer_free(hbuf);
memset(pin, 0, sizeof(pin));
return rv;
}
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT, "pin", pin);
AH_Msg_SetPin(hmsg, pin);
memset(pin, 0, sizeof(pin));
/* handle tan */
if (hmsg->needTan) {
DBG_NOTICE(AQHBCI_LOGDOMAIN,
"This queue needs a TAN");
if (hmsg->usedTan) {
DBG_NOTICE(AQHBCI_LOGDOMAIN,
"Using existing TAN");
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"tan", hmsg->usedTan);
}
else {
char tan[16];
memset(tan, 0, sizeof(tan));
DBG_NOTICE(AQHBCI_LOGDOMAIN, "Asking for TAN");
rv=AH_User_InputTan(su, tan, 4, sizeof(tan));
if (rv<0) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Error getting TAN from medium");
GWEN_DB_Group_free(cfg);
GWEN_Buffer_free(hbuf);
return rv;
}
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"tan", tan);
AH_Msg_SetTan(hmsg, tan);
}
}
else {
DBG_NOTICE(AQHBCI_LOGDOMAIN,
"This queue doesn't need a TAN");
}
/* get node */
node=GWEN_MsgEngine_FindNodeByPropertyStrictProto(e,
"SEG",
"id",
0,
"SigTail");
if (!node) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Segment \"SigTail\"not found");
GWEN_Buffer_free(hbuf);
GWEN_DB_Group_free(cfg);
return GWEN_ERROR_INTERNAL;
}
rv=GWEN_MsgEngine_CreateMessageFromNode(e, node, hbuf, cfg);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Could not create SigTail (%d)", rv);
GWEN_Buffer_free(hbuf);
GWEN_DB_Group_free(cfg);
return rv;
}
/* append sigtail */
DBG_DEBUG(AQHBCI_LOGDOMAIN, "Appending signature tail");
if (GWEN_Buffer_AppendBuffer(hmsg->buffer, hbuf)) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here");
GWEN_Buffer_free(hbuf);
GWEN_DB_Group_free(cfg);
return GWEN_ERROR_MEMORY_FULL;
}
DBG_DEBUG(AQHBCI_LOGDOMAIN, "Appending signature tail: done");
GWEN_Buffer_free(hbuf);
GWEN_DB_Group_free(cfg);
/* adjust segment numbers (for next signature and message tail */
hmsg->firstSegment--;
hmsg->lastSegment++;
return 0;
}
void OH_GetInstituteDialog_Fini(GWEN_DIALOG *dlg) {
OH_GETINST_DIALOG *xdlg;
int i;
GWEN_DB_NODE *dbPrefs;
assert(dlg);
xdlg=GWEN_INHERIT_GETDATA(GWEN_DIALOG, OH_GETINST_DIALOG, dlg);
assert(xdlg);
dbPrefs=GWEN_Dialog_GetPreferences(dlg);
/* store dialog width */
i=GWEN_Dialog_GetIntProperty(dlg, "", GWEN_DialogProperty_Width, 0, -1);
GWEN_DB_SetIntValue(dbPrefs,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"dialog_width",
i);
/* store dialog height */
i=GWEN_Dialog_GetIntProperty(dlg, "", GWEN_DialogProperty_Height, 0, -1);
GWEN_DB_SetIntValue(dbPrefs,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"dialog_height",
i);
/* store column widths of importer list */
GWEN_DB_DeleteVar(dbPrefs, "bank_list_columns");
for (i=0; i<1; i++) {
int j;
j=GWEN_Dialog_GetIntProperty(dlg, "listBox", GWEN_DialogProperty_ColumnWidth, i, -1);
if (j<LIST_MINCOLWIDTH)
j=LIST_MINCOLWIDTH;
GWEN_DB_SetIntValue(dbPrefs,
GWEN_DB_FLAGS_DEFAULT,
"bank_list_columns",
j);
}
/* store column sorting */
GWEN_DB_SetIntValue(dbPrefs,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"bank_list_sortbycolumn",
-1);
for (i=0; i<1; i++) {
int j;
j=GWEN_Dialog_GetIntProperty(dlg, "listBox", GWEN_DialogProperty_SortDirection, i,
GWEN_DialogSortDirection_None);
if (j!=GWEN_DialogSortDirection_None) {
GWEN_DB_SetIntValue(dbPrefs,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"bank_list_sortbycolumn",
i);
GWEN_DB_SetIntValue(dbPrefs,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"bank_list_sortdir",
(j==GWEN_DialogSortDirection_Up)?1:0);
break;
}
}
}
void AH_User_toDb(AB_USER *u, GWEN_DB_NODE *db) {
AH_USER *ue;
int i;
GWEN_DB_NODE *gr;
const char *s;
assert(u);
ue=GWEN_INHERIT_GETDATA(AB_USER, AH_USER, u);
assert(ue);
/* save crypt mode */
s=AH_CryptMode_toString(ue->cryptMode);
GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"cryptMode", s);
/* save status */
s=AH_User_Status_toString(ue->status);
GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"status", s);
GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"hbciVersion", ue->hbciVersion);
if (ue->httpContentType)
GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"httpContentType", ue->httpContentType);
else
GWEN_DB_DeleteVar(db, "httpContentType");
/* save URL */
if (ue->serverUrl) {
GWEN_BUFFER *nbuf;
nbuf=GWEN_Buffer_new(0, 256, 0, 1);
if (GWEN_Url_toString(ue->serverUrl, nbuf)) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not store url");
GWEN_Buffer_free(nbuf);
assert(0);
}
GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"server", GWEN_Buffer_GetStart(nbuf));
GWEN_Buffer_free(nbuf);
} /* if serverUrl */
/* save BPD */
assert(ue->bpd);
gr=GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_OVERWRITE_GROUPS, "bpd");
assert(gr);
AH_Bpd_ToDb(ue->bpd, gr);
/* save UPD */
if (ue->dbUpd) {
gr=GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_OVERWRITE_GROUPS, "upd");
assert(gr);
GWEN_DB_AddGroupChildren(gr, ue->dbUpd);
}
if (ue->peerId)
GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"peerId", ue->peerId);
if (ue->systemId)
GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"systemId", ue->systemId);
GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"updVersion", ue->updVersion);
/* save http settings */
GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"httpVMajor", ue->httpVMajor);
GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"httpVMinor", ue->httpVMinor);
if (ue->httpUserAgent)
GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"httpUserAgent", ue->httpUserAgent);
/* save flags */
AH_User_Flags_toDb(db, "userFlags", ue->flags);
/* save crypt token settings */
if (ue->tokenType)
GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"tokenType", ue->tokenType);
if (ue->tokenName)
GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"tokenName", ue->tokenName);
GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"tokenContextId", ue->tokenContextId);
GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"rdhType", ue->rdhType);
/* store list of supported/allowed tan methods */
GWEN_DB_DeleteVar(db, "tanMethodList");
for (i=0; i<ue->tanMethodCount; i++) {
if (ue->tanMethodList[i]==-1)
break;
GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_DEFAULT,
"tanMethodList",
ue->tanMethodList[i]);
}
GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"selectedTanMethod",
ue->selectedTanMethod);
/* store some settings */
GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"maxTransfersPerJob",
ue->maxTransfersPerJob);
GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"maxDebitNotesPerJob",
ue->maxDebitNotesPerJob);
if (ue->sepaTransferProfile)
GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"sepaTransferProfile", ue->sepaTransferProfile);
if (ue->sepaDebitNoteProfile)
GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"sepaDebitNoteProfile", ue->sepaDebitNoteProfile);
if (ue->tanMediumId)
GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
"tanMediumId", ue->tanMediumId);
}
int EBC_Provider_AddJob(AB_PROVIDER *pro, AB_JOB *j) {
EBC_PROVIDER *dp;
AB_ACCOUNT *a;
AB_USER *u;
EBC_USERQUEUE *uq;
int doAdd=1;
GWEN_DB_NODE *dbJob;
assert(pro);
dp=GWEN_INHERIT_GETDATA(AB_PROVIDER, EBC_PROVIDER, pro);
assert(dp);
a=AB_Job_GetAccount(j);
assert(a);
u=AB_Account_GetFirstUser(a);
if (u==NULL) {
DBG_ERROR(AQEBICS_LOGDOMAIN, "No user assigned to account.");
GWEN_Gui_ProgressLog(0,
GWEN_LoggerLevel_Error,
I18N("No user assigned to account."));
GWEN_Gui_ShowError(I18N("Setup Error"),
I18N("No user assigned to this account. Please assign one in the online banking setup dialog "
"for this account.\n"));
return GWEN_ERROR_INTERNAL;
}
dbJob=AB_Job_GetProviderData(j, pro);
assert(dbJob);
switch(AB_Job_GetType(j)) {
case AB_Job_TypeGetTransactions:
case AB_Job_TypeTransfer:
case AB_Job_TypeDebitNote:
break;
case AB_Job_TypeGetBalance:
default:
DBG_INFO(AQEBICS_LOGDOMAIN,
"Job not yet supported (%d)",
AB_Job_GetType(j));
return GWEN_ERROR_NOT_SUPPORTED;
} /* switch */
uq=EBC_Queue_GetUserQueue(dp->queue, u);
assert(uq);
if (AB_Job_GetType(j)==AB_Job_TypeGetTransactions) {
AB_JOB *firstJob;
firstJob=EBC_Queue_FindFirstJobLikeThis(dp->queue, u, j);
if (firstJob) {
GWEN_DB_NODE *dbCurrJob;
/* this job is just a copy of the firstJob, reference it */
dbCurrJob=AB_Job_GetProviderData(j, pro);
assert(dbCurrJob);
GWEN_DB_SetIntValue(dbCurrJob,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"refJob",
AB_Job_GetJobId(firstJob));
/* don't add to queues */
doAdd=0;
}
}
if (doAdd) {
/* only add to queue if needed */
EBC_UserQueue_AddJob(uq, j);
}
/* always add to linear list */
AB_Job_List2_PushBack(dp->bankingJobs, j);
return 0;
}
int AH_Msg_SignRdh2(AH_MSG *hmsg,
AB_USER *su,
GWEN_BUFFER *rawBuf,
const char *signer) {
AH_HBCI *h;
GWEN_XMLNODE *node;
GWEN_DB_NODE *cfg;
GWEN_BUFFER *sigbuf;
GWEN_BUFFER *hbuf;
unsigned int l;
int rv;
char ctrlref[15];
const char *p;
GWEN_MSGENGINE *e;
uint32_t uFlags;
GWEN_CRYPT_TOKEN *ct;
const GWEN_CRYPT_TOKEN_CONTEXT *ctx;
const GWEN_CRYPT_TOKEN_KEYINFO *ki;
uint32_t keyId;
uint32_t gid;
assert(hmsg);
h=AH_Dialog_GetHbci(hmsg->dialog);
assert(h);
e=AH_Dialog_GetMsgEngine(hmsg->dialog);
assert(e);
GWEN_MsgEngine_SetMode(e, "rdh");
gid=0;
uFlags=AH_User_GetFlags(su);
/* get crypt token of signer */
rv=AB_Banking_GetCryptToken(AH_HBCI_GetBankingApi(h),
AH_User_GetTokenType(su),
AH_User_GetTokenName(su),
&ct);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN,
"Could not get crypt token for user \"%s\" (%d)",
AB_User_GetUserId(su), rv);
return rv;
}
/* open CryptToken if necessary */
if (!GWEN_Crypt_Token_IsOpen(ct)) {
GWEN_Crypt_Token_AddModes(ct, GWEN_CRYPT_TOKEN_MODE_DIRECT_SIGN);
rv=GWEN_Crypt_Token_Open(ct, 0, gid);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN,
"Could not open crypt token for user \"%s\" (%d)",
AB_User_GetUserId(su), rv);
return rv;
}
}
/* get context and key info */
ctx=GWEN_Crypt_Token_GetContext(ct,
AH_User_GetTokenContextId(su),
gid);
if (ctx==NULL) {
DBG_INFO(AQHBCI_LOGDOMAIN,
"Context %d not found on crypt token [%s:%s]",
AH_User_GetTokenContextId(su),
GWEN_Crypt_Token_GetTypeName(ct),
GWEN_Crypt_Token_GetTokenName(ct));
return GWEN_ERROR_NOT_FOUND;
}
keyId=GWEN_Crypt_Token_Context_GetSignKeyId(ctx);
ki=GWEN_Crypt_Token_GetKeyInfo(ct,
keyId,
0xffffffff,
gid);
if (ki==NULL) {
DBG_INFO(AQHBCI_LOGDOMAIN,
"Keyinfo %04x not found on crypt token [%s:%s]",
keyId,
GWEN_Crypt_Token_GetTypeName(ct),
GWEN_Crypt_Token_GetTokenName(ct));
return GWEN_ERROR_NOT_FOUND;
}
node=GWEN_MsgEngine_FindNodeByPropertyStrictProto(e,
"SEG",
"id",
0,
"SigHead");
if (!node) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Segment \"SigHead\" not found");
return GWEN_ERROR_INTERNAL;
}
/* prepare config for segment */
cfg=GWEN_DB_Group_new("sighead");
rv=AH_MsgRdh_PrepareCryptoSeg2(hmsg, su, ki, cfg, 0, 1);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
GWEN_DB_Group_free(cfg);
return rv;
}
/* set expected signer */
if (!(uFlags & AH_USER_FLAGS_BANK_DOESNT_SIGN)) {
const char *remoteId;
remoteId=AH_User_GetPeerId(su);
if (!remoteId || *remoteId==0)
remoteId=AB_User_GetUserId(su);
assert(remoteId);
assert(*remoteId);
DBG_DEBUG(AQHBCI_LOGDOMAIN,
"Expecting \"%s\" to sign the response",
remoteId);
AH_Msg_SetExpectedSigner(hmsg, remoteId);
}
/* store system id */
if (hmsg->noSysId) {
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"SecDetails/SecId", "0");
}
else {
p=AH_User_GetSystemId(su);
if (p==NULL)
p=GWEN_Crypt_Token_Context_GetSystemId(ctx);
if (p)
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"SecDetails/SecId", p);
else {
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"SecDetails/SecId", "0");
}
}
/* retrieve control reference for sigtail (to be used later) */
p=GWEN_DB_GetCharValue(cfg, "ctrlref", 0, "");
if (strlen(p)>=sizeof(ctrlref)) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Control reference too long (14 bytes maximum)");
GWEN_DB_Group_free(cfg);
return -1;
}
strcpy(ctrlref, p);
/* create SigHead */
hbuf=GWEN_Buffer_new(0, 128+GWEN_Buffer_GetUsedBytes(rawBuf), 0, 1);
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"head/seq", hmsg->firstSegment-1);
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"signseq",
GWEN_Crypt_Token_KeyInfo_GetSignCounter(ki));
/* create signature head segment */
rv=GWEN_MsgEngine_CreateMessageFromNode(e, node, hbuf, cfg);
GWEN_DB_Group_free(cfg);
cfg=0;
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Could not create SigHead");
GWEN_Buffer_free(hbuf);
return rv;
}
/* remember size of sighead for now */
l=GWEN_Buffer_GetUsedBytes(hbuf);
/* add raw data to to-sign data buffer */
GWEN_Buffer_AppendBuffer(hbuf, rawBuf);
/* sign message */
sigbuf=GWEN_Buffer_new(0, 512, 0, 1);
if (1) {
uint32_t signLen;
GWEN_CRYPT_PADDALGO *algo;
GWEN_MDIGEST *md;
uint32_t seq;
/* hash sighead + data */
md=GWEN_MDigest_Rmd160_new();
rv=GWEN_MDigest_Begin(md);
if (rv==0)
rv=GWEN_MDigest_Update(md,
(uint8_t*)GWEN_Buffer_GetStart(hbuf),
GWEN_Buffer_GetUsedBytes(hbuf));
if (rv==0)
rv=GWEN_MDigest_End(md);
if (rv<0) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Hash error (%d)", rv);
GWEN_MDigest_free(md);
GWEN_Buffer_free(sigbuf);
GWEN_Buffer_free(hbuf);
return rv;
}
/* sign hash */
algo=GWEN_Crypt_PaddAlgo_new(GWEN_Crypt_PaddAlgoId_Iso9796_2);
GWEN_Crypt_PaddAlgo_SetPaddSize(algo, GWEN_Crypt_Token_KeyInfo_GetKeySize(ki));
signLen=GWEN_Buffer_GetMaxUnsegmentedWrite(sigbuf);
rv=GWEN_Crypt_Token_Sign(ct, keyId,
algo,
GWEN_MDigest_GetDigestPtr(md),
GWEN_MDigest_GetDigestSize(md),
(uint8_t*)GWEN_Buffer_GetPosPointer(sigbuf),
&signLen,
&seq,
gid);
GWEN_Crypt_PaddAlgo_free(algo);
GWEN_MDigest_free(md);
if (rv) {
DBG_ERROR(AQHBCI_LOGDOMAIN,
"Could not sign data with medium of user \"%s\" (%d)",
AB_User_GetUserId(su), rv);
GWEN_Buffer_free(sigbuf);
GWEN_Buffer_free(hbuf);
return rv;
}
GWEN_Buffer_IncrementPos(sigbuf, signLen);
GWEN_Buffer_AdjustUsedBytes(sigbuf);
}
DBG_DEBUG(AQHBCI_LOGDOMAIN, "Signing done");
/* insert new SigHead at beginning of message buffer */
DBG_DEBUG(AQHBCI_LOGDOMAIN, "Inserting signature head");
GWEN_Buffer_Rewind(hmsg->buffer);
GWEN_Buffer_InsertBytes(hmsg->buffer, GWEN_Buffer_GetStart(hbuf), l);
/* create sigtail */
DBG_DEBUG(AQHBCI_LOGDOMAIN, "Completing signature tail");
cfg=GWEN_DB_Group_new("sigtail");
GWEN_Buffer_Reset(hbuf);
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"head/seq", hmsg->lastSegment+1);
/* store to DB */
GWEN_DB_SetBinValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"signature",
GWEN_Buffer_GetStart(sigbuf),
GWEN_Buffer_GetUsedBytes(sigbuf));
GWEN_Buffer_free(sigbuf);
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"ctrlref", ctrlref);
/* get node */
node=GWEN_MsgEngine_FindNodeByPropertyStrictProto(e,
"SEG",
"id",
0,
"SigTail");
if (!node) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Segment \"SigTail\"not found");
GWEN_Buffer_free(hbuf);
GWEN_DB_Group_free(cfg);
return -1;
}
rv=GWEN_MsgEngine_CreateMessageFromNode(e, node, hbuf, cfg);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Could not create SigTail");
GWEN_Buffer_free(hbuf);
GWEN_DB_Group_free(cfg);
return -1;
}
/* append sigtail */
DBG_DEBUG(AQHBCI_LOGDOMAIN, "Appending signature tail");
if (GWEN_Buffer_AppendBuffer(hmsg->buffer, hbuf)) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here");
GWEN_Buffer_free(hbuf);
GWEN_DB_Group_free(cfg);
return -1;
}
DBG_DEBUG(AQHBCI_LOGDOMAIN, "Appending signature tail: done");
GWEN_Buffer_free(hbuf);
GWEN_DB_Group_free(cfg);
/* adjust segment numbers (for next signature and message tail */
hmsg->firstSegment--;
hmsg->lastSegment++;
return 0;
}
int AB_TransactionLimits_toDb(const AB_TRANSACTION_LIMITS *st, GWEN_DB_NODE *db) {
assert(st);
assert(db);
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxLenLocalName", st->maxLenLocalName))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minLenLocalName", st->minLenLocalName))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxLenRemoteName", st->maxLenRemoteName))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minLenRemoteName", st->minLenRemoteName))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxLinesRemoteName", st->maxLinesRemoteName))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minLinesRemoteName", st->minLinesRemoteName))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxLenLocalBankCode", st->maxLenLocalBankCode))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minLenLocalBankCode", st->minLenLocalBankCode))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxLenLocalAccountNumber", st->maxLenLocalAccountNumber))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minLenLocalAccountNumber", st->minLenLocalAccountNumber))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxLenLocalSuffix", st->maxLenLocalSuffix))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minLenLocalSuffix", st->minLenLocalSuffix))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxLenRemoteBankCode", st->maxLenRemoteBankCode))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minLenRemoteBankCode", st->minLenRemoteBankCode))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxLenRemoteAccountNumber", st->maxLenRemoteAccountNumber))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minLenRemoteAccountNumber", st->minLenRemoteAccountNumber))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxLenRemoteSuffix", st->maxLenRemoteSuffix))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minLenRemoteSuffix", st->minLenRemoteSuffix))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxLenRemoteIban", st->maxLenRemoteIban))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minLenRemoteIban", st->minLenRemoteIban))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxLenTextKey", st->maxLenTextKey))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minLenTextKey", st->minLenTextKey))
return -1;
if (st->valuesTextKey)
{
GWEN_STRINGLISTENTRY *se;
GWEN_DB_DeleteVar(db, "valuesTextKey");
se=GWEN_StringList_FirstEntry(st->valuesTextKey);
while(se) {
const char *s;
s=GWEN_StringListEntry_Data(se);
assert(s);
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_DEFAULT, "valuesTextKey", s))
return -1;
se=GWEN_StringListEntry_Next(se);
} /* while */
}
if (st->textKeys)
if (1) {
GWEN_DB_NODE *dbT;
AB_TEXTKEY_DESCR *e;
dbT=GWEN_DB_GetGroup(db, GWEN_PATH_FLAGS_CREATE_GROUP, "textKeys");
assert(dbT);
e=AB_TextKeyDescr_List_First(st->textKeys);
while(e) {
if (AB_TextKeyDescr_toDb(e, GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_CREATE_GROUP, "element")))
return -1;
e=AB_TextKeyDescr_List_Next(e);
} /* while */
} /* if (1) */
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxLenCustomerReference", st->maxLenCustomerReference))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minLenCustomerReference", st->minLenCustomerReference))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxLenBankReference", st->maxLenBankReference))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minLenBankReference", st->minLenBankReference))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxLenPurpose", st->maxLenPurpose))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minLenPurpose", st->minLenPurpose))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxLinesPurpose", st->maxLinesPurpose))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minLinesPurpose", st->minLinesPurpose))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "needDate", st->needDate))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minValueSetupTime", st->minValueSetupTime))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxValueSetupTime", st->maxValueSetupTime))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minValueSetupTimeFirst", st->minValueSetupTimeFirst))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxValueSetupTimeFirst", st->maxValueSetupTimeFirst))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minValueSetupTimeOnce", st->minValueSetupTimeOnce))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxValueSetupTimeOnce", st->maxValueSetupTimeOnce))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minValueSetupTimeRecurring", st->minValueSetupTimeRecurring))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxValueSetupTimeRecurring", st->maxValueSetupTimeRecurring))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "minValueSetupTimeFinal", st->minValueSetupTimeFinal))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "maxValueSetupTimeFinal", st->maxValueSetupTimeFinal))
return -1;
if (st->valuesCycleWeek)
{
GWEN_STRINGLISTENTRY *se;
GWEN_DB_DeleteVar(db, "valuesCycleWeek");
se=GWEN_StringList_FirstEntry(st->valuesCycleWeek);
while(se) {
const char *s;
s=GWEN_StringListEntry_Data(se);
assert(s);
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_DEFAULT, "valuesCycleWeek", s))
return -1;
se=GWEN_StringListEntry_Next(se);
} /* while */
}
if (st->valuesCycleMonth)
{
GWEN_STRINGLISTENTRY *se;
GWEN_DB_DeleteVar(db, "valuesCycleMonth");
se=GWEN_StringList_FirstEntry(st->valuesCycleMonth);
while(se) {
const char *s;
s=GWEN_StringListEntry_Data(se);
assert(s);
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_DEFAULT, "valuesCycleMonth", s))
return -1;
se=GWEN_StringListEntry_Next(se);
} /* while */
}
if (st->valuesExecutionDayWeek)
{
GWEN_STRINGLISTENTRY *se;
GWEN_DB_DeleteVar(db, "valuesExecutionDayWeek");
se=GWEN_StringList_FirstEntry(st->valuesExecutionDayWeek);
while(se) {
const char *s;
s=GWEN_StringListEntry_Data(se);
assert(s);
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_DEFAULT, "valuesExecutionDayWeek", s))
return -1;
se=GWEN_StringListEntry_Next(se);
} /* while */
}
if (st->valuesExecutionDayMonth)
{
GWEN_STRINGLISTENTRY *se;
GWEN_DB_DeleteVar(db, "valuesExecutionDayMonth");
se=GWEN_StringList_FirstEntry(st->valuesExecutionDayMonth);
while(se) {
const char *s;
s=GWEN_StringListEntry_Data(se);
assert(s);
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_DEFAULT, "valuesExecutionDayMonth", s))
return -1;
se=GWEN_StringListEntry_Next(se);
} /* while */
}
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowMonthly", st->allowMonthly))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowWeekly", st->allowWeekly))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowChangeRecipientAccount", st->allowChangeRecipientAccount))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowChangeRecipientName", st->allowChangeRecipientName))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowChangeValue", st->allowChangeValue))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowChangeTextKey", st->allowChangeTextKey))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowChangePurpose", st->allowChangePurpose))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowChangeFirstExecutionDate", st->allowChangeFirstExecutionDate))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowChangeLastExecutionDate", st->allowChangeLastExecutionDate))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowChangeCycle", st->allowChangeCycle))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowChangePeriod", st->allowChangePeriod))
return -1;
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "allowChangeExecutionDay", st->allowChangeExecutionDay))
return -1;
return 0;
}
int GWEN_DBIO__XmlDb_ImportVar(GWEN_DBIO *dbio,
uint32_t flags,
GWEN_DB_NODE *data,
GWEN_DB_NODE *cfg,
GWEN_XMLNODE *node) {
GWEN_XMLNODE *n;
const char *vname;
GWEN_BUFFER *tbuf;
assert(node);
vname=GWEN_XMLNode_GetData(node);
assert(vname && *vname);
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
n=GWEN_XMLNode_FindFirstTag(node, "value", 0, 0);
while(n) {
const char *s;
const char *d;
int rv;
GWEN_DBIO__XmlDb_ReadDataTags(n, tbuf);
d=GWEN_Buffer_GetStart(tbuf);
if (*d) {
s=GWEN_XMLNode_GetData(n);
assert(s && *s);
s=GWEN_XMLNode_GetProperty(n, "type", 0);
if (s) {
if (strcasecmp(s, "char")==0) {
rv=GWEN_DB_SetCharValue(data, flags, vname, d);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
return rv;
}
}
else if (strcasecmp(s, "int")==0) {
int val;
if (1!=sscanf(d, "%i", &val)) {
DBG_INFO(GWEN_LOGDOMAIN, "Non-integer value [%s]", d);
GWEN_Buffer_free(tbuf);
return GWEN_ERROR_INVALID;
}
rv=GWEN_DB_SetIntValue(data, flags, vname, val);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
return rv;
}
}
else if (strcasecmp(s, "bin")==0) {
GWEN_BUFFER *xbuf;
xbuf=GWEN_Buffer_new(0, 256, 0, 1);
rv=GWEN_Text_FromHexBuffer(d, xbuf);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(xbuf);
GWEN_Buffer_free(tbuf);
return rv;
}
rv=GWEN_DB_SetBinValue(data, flags, vname,
GWEN_Buffer_GetStart(xbuf),
GWEN_Buffer_GetUsedBytes(xbuf));
GWEN_Buffer_free(xbuf);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
return rv;
}
}
else {
DBG_ERROR(GWEN_LOGDOMAIN,
"Unhandled value type \"%s\"", s);
GWEN_Buffer_free(tbuf);
return GWEN_ERROR_INVALID;
}
}
}
else {
DBG_DEBUG(GWEN_LOGDOMAIN, "Empty value");
}
GWEN_Buffer_Reset(tbuf);
n=GWEN_XMLNode_FindNextTag(n, "value", 0, 0);
}
GWEN_Buffer_free(tbuf);
return 0;
}
int GWEN_Param_WriteDb(const GWEN_PARAM *p_struct, GWEN_DB_NODE *p_db)
{
int p_rv;
assert(p_struct);
/* member "name" */
if (p_struct->name)
p_rv=GWEN_DB_SetCharValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "name", p_struct->name);
else {
GWEN_DB_DeleteVar(p_db, "name");
p_rv=0;
}
if (p_rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
return p_rv;
}
/* member "flags" */
p_rv=GWEN_DB_SetIntValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "flags", p_struct->flags);
if (p_rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
return p_rv;
}
/* member "type" */
p_rv=GWEN_DB_SetCharValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "type", GWEN_Param_Type_toString(p_struct->type));
if (p_rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
return p_rv;
}
/* member "dataType" */
p_rv=GWEN_DB_SetCharValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "dataType",
GWEN_Param_DataType_toString(p_struct->dataType));
if (p_rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
return p_rv;
}
/* member "shortDescription" */
if (p_struct->shortDescription)
p_rv=GWEN_DB_SetCharValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "shortDescription", p_struct->shortDescription);
else {
GWEN_DB_DeleteVar(p_db, "shortDescription");
p_rv=0;
}
if (p_rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
return p_rv;
}
/* member "longDescription" */
if (p_struct->longDescription)
p_rv=GWEN_DB_SetCharValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "longDescription", p_struct->longDescription);
else {
GWEN_DB_DeleteVar(p_db, "longDescription");
p_rv=0;
}
if (p_rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
return p_rv;
}
/* member "currentValue" */
if (p_struct->currentValue)
p_rv=GWEN_DB_SetCharValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "currentValue", p_struct->currentValue);
else {
GWEN_DB_DeleteVar(p_db, "currentValue");
p_rv=0;
}
if (p_rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
return p_rv;
}
/* member "defaultValue" */
if (p_struct->defaultValue)
p_rv=GWEN_DB_SetCharValue(p_db, GWEN_DB_FLAGS_OVERWRITE_VARS, "defaultValue", p_struct->defaultValue);
else {
GWEN_DB_DeleteVar(p_db, "defaultValue");
p_rv=0;
}
if (p_rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
return p_rv;
}
/* member "choices" */
if (p_struct->choices) {
p_rv=GWEN_StringList2_toDb(p_struct->choices, p_db, "choices");
}
else {
GWEN_DB_DeleteVar(p_db, "choices");
p_rv=0;
}
if (p_rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)\n", p_rv);
return p_rv;
}
/* member "internalIntValue" is volatile, not writing to db */
/* member "internalFloatValue" is volatile, not writing to db */
/* member "runtimeFlags" is volatile, not writing to db */
return 0;
}
void AB_SetupDialog_Fini(GWEN_DIALOG *dlg)
{
AB_SETUP_DIALOG *xdlg;
int i;
GWEN_DB_NODE *dbPrefs;
assert(dlg);
xdlg=GWEN_INHERIT_GETDATA(GWEN_DIALOG, AB_SETUP_DIALOG, dlg);
assert(xdlg);
/* deactivate providers */
AB_SetupDialog_DeactivateProviders(dlg);
dbPrefs=GWEN_Dialog_GetPreferences(dlg);
/* store dialog width */
i=GWEN_Dialog_GetIntProperty(dlg, "", GWEN_DialogProperty_Width, 0, -1);
GWEN_DB_SetIntValue(dbPrefs,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"dialog_width",
i);
/* store dialog height */
i=GWEN_Dialog_GetIntProperty(dlg, "", GWEN_DialogProperty_Height, 0, -1);
GWEN_DB_SetIntValue(dbPrefs,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"dialog_height",
i);
/* store column widths of user list */
GWEN_DB_DeleteVar(dbPrefs, "user_list_columns");
for (i=0; i<6; i++) {
int j;
j=GWEN_Dialog_GetIntProperty(dlg, "userListBox", GWEN_DialogProperty_ColumnWidth, i, -1);
if (j<USER_LIST_MINCOLWIDTH)
j=USER_LIST_MINCOLWIDTH;
GWEN_DB_SetIntValue(dbPrefs,
GWEN_DB_FLAGS_DEFAULT,
"user_list_columns",
j);
}
/* store column sorting of user list */
GWEN_DB_SetIntValue(dbPrefs,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"user_list_sortbycolumn",
-1);
for (i=0; i<6; i++) {
int j;
j=GWEN_Dialog_GetIntProperty(dlg, "userListBox", GWEN_DialogProperty_SortDirection, i,
GWEN_DialogSortDirection_None);
if (j!=GWEN_DialogSortDirection_None) {
GWEN_DB_SetIntValue(dbPrefs,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"user_list_sortbycolumn",
i);
GWEN_DB_SetIntValue(dbPrefs,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"user_list_sortdir",
(j==GWEN_DialogSortDirection_Up)?1:0);
break;
}
}
/* store column widths of account list */
GWEN_DB_DeleteVar(dbPrefs, "account_list_columns");
for (i=0; i<7; i++) {
int j;
j=GWEN_Dialog_GetIntProperty(dlg, "accountListBox", GWEN_DialogProperty_ColumnWidth, i, -1);
if (j<ACCOUNT_LIST_MINCOLWIDTH)
j=ACCOUNT_LIST_MINCOLWIDTH;
GWEN_DB_SetIntValue(dbPrefs,
GWEN_DB_FLAGS_DEFAULT,
"account_list_columns",
j);
}
/* store column sorting */
GWEN_DB_SetIntValue(dbPrefs,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"account_list_sortbycolumn",
-1);
for (i=0; i<7; i++) {
int j;
j=GWEN_Dialog_GetIntProperty(dlg, "accountListBox", GWEN_DialogProperty_SortDirection, i,
GWEN_DialogSortDirection_None);
if (j!=GWEN_DialogSortDirection_None) {
GWEN_DB_SetIntValue(dbPrefs,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"account_list_sortbycolumn",
i);
GWEN_DB_SetIntValue(dbPrefs,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"account_list_sortdir",
(j==GWEN_DialogSortDirection_Up)?1:0);
break;
}
}
}
int logFile(AB_BANKING *ab,
GWEN_DB_NODE *dbArgs,
int argc,
char **argv) {
int rv;
GWEN_DB_NODE *db;
GWEN_DB_NODE *dbMessages;
const char *s;
GWEN_MSGENGINE *e;
GWEN_SYNCIO *sioOut=NULL;
GWEN_SYNCIO *sioDb=NULL;
const char *inFile;
const char *outFile;
const char *dbOutFile;
int i;
GWEN_DB_NODE *dbT;
int trustLevel;
const GWEN_ARGS args[]={
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"xmlfile", /* name */
0, /* minnum */
99, /* maxnum */
"x", /* short option */
"xmlfile", /* long option */
"Specify XML files to load", /* short description */
"Specify XML files to load" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"infile", /* name */
1, /* minnum */
1, /* maxnum */
"i", /* short option */
"infile", /* long option */
"Specify input file", /* short description */
"Specify input file" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"outfile", /* name */
0, /* minnum */
1, /* maxnum */
"o", /* short option */
"outfile", /* long option */
"Specify output file", /* short description */
"Specify output file" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"dboutfile", /* name */
0, /* minnum */
1, /* maxnum */
"d", /* short option */
"dbfile", /* long option */
"Specify DB output file", /* short description */
"Specify DB output file" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Int, /* type */
"trustLevel", /* name */
0, /* minnum */
1, /* maxnum */
"L", /* short option */
"trustlevel", /* long option */
"Specify the trust level", /* short description */
"Specify the trust level" /* long description */
},
{
GWEN_ARGS_FLAGS_HELP | GWEN_ARGS_FLAGS_LAST, /* flags */
GWEN_ArgsType_Int, /* type */
"help", /* name */
0, /* minnum */
0, /* maxnum */
"h", /* short option */
"help", /* long option */
"Show this help screen", /* short description */
"Show this help screen" /* long description */
}
};
db=GWEN_DB_GetGroup(dbArgs, GWEN_DB_FLAGS_DEFAULT, "local");
rv=GWEN_Args_Check(argc, argv, 1,
0 /*GWEN_ARGS_MODE_ALLOW_FREEPARAM*/,
args,
db);
if (rv==GWEN_ARGS_RESULT_ERROR) {
fprintf(stderr, "ERROR: Could not parse arguments\n");
return 1;
}
else if (rv==GWEN_ARGS_RESULT_HELP) {
GWEN_BUFFER *ubuf;
ubuf=GWEN_Buffer_new(0, 1024, 0, 1);
if (GWEN_Args_Usage(args, ubuf, GWEN_ArgsOutType_Txt)) {
fprintf(stderr, "ERROR: Could not create help string\n");
return 1;
}
fprintf(stderr, "%s\n", GWEN_Buffer_GetStart(ubuf));
GWEN_Buffer_free(ubuf);
return 0;
}
trustLevel=GWEN_DB_GetIntValue(db, "trustLevel", 0, 0);
outFile=GWEN_DB_GetCharValue(db, "outFile", 0, NULL);
dbOutFile=GWEN_DB_GetCharValue(db, "dbOutFile", 0, NULL);
inFile=GWEN_DB_GetCharValue(db, "inFile", 0, NULL);
assert(inFile);
/* do it */
dbMessages=GWEN_DB_Group_new("Messages");
rv=_readLogFile(inFile, dbMessages);
if (rv<0) {
DBG_ERROR(0, "Error reading message (%d)", rv);
return 2;
}
/* create message engine, read XML definitions */
e=AH_MsgEngine_new();
for (i=0; i<99; i++) {
s=GWEN_DB_GetCharValue(dbArgs, "xmlfile", i, NULL);
if (s && *s) {
GWEN_XMLNODE *defs;
defs=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "defs");
if (GWEN_XML_ReadFile(defs, s, GWEN_XML_FLAGS_DEFAULT)){
fprintf(stderr, "Error parsing.\n");
GWEN_MsgEngine_free(e);
return 2;
}
GWEN_MsgEngine_AddDefinitions(e, defs);
GWEN_XMLNode_free(defs);
}
else {
if (i==0) {
GWEN_XMLNODE *defs;
defs=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "defs");
if (GWEN_XML_ReadFile(defs, XMLDATA_DIR "/hbci.xml", GWEN_XML_FLAGS_DEFAULT)){
fprintf(stderr, "Error parsing.\n");
GWEN_MsgEngine_free(e);
return 2;
}
GWEN_MsgEngine_AddDefinitions(e, defs);
GWEN_XMLNode_free(defs);
}
break;
}
}
if (outFile) {
sioOut=GWEN_SyncIo_File_new(outFile, GWEN_SyncIo_File_CreationMode_CreateAlways);
GWEN_SyncIo_AddFlags(sioOut,
GWEN_SYNCIO_FILE_FLAGS_READ |
GWEN_SYNCIO_FILE_FLAGS_WRITE |
GWEN_SYNCIO_FILE_FLAGS_UREAD |
GWEN_SYNCIO_FILE_FLAGS_UWRITE |
GWEN_SYNCIO_FILE_FLAGS_APPEND);
rv=GWEN_SyncIo_Connect(sioOut);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_SyncIo_free(sioOut);
return 2;
}
}
if (dbOutFile) {
sioDb=GWEN_SyncIo_File_new(dbOutFile, GWEN_SyncIo_File_CreationMode_CreateAlways);
GWEN_SyncIo_AddFlags(sioDb,
GWEN_SYNCIO_FILE_FLAGS_READ |
GWEN_SYNCIO_FILE_FLAGS_WRITE |
GWEN_SYNCIO_FILE_FLAGS_UREAD |
GWEN_SYNCIO_FILE_FLAGS_UWRITE |
GWEN_SYNCIO_FILE_FLAGS_APPEND);
rv=GWEN_SyncIo_Connect(sioDb);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_SyncIo_free(sioDb);
return 2;
}
}
dbT=GWEN_DB_GetFirstGroup(dbMessages);
while(dbT) {
const uint8_t *p;
uint32_t len;
GWEN_DB_NODE *dbHeader;
dbHeader=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "header");
assert(dbHeader);
s=GWEN_DB_GetCharValue(dbHeader, "mode", 0, "PINTAN");
GWEN_MsgEngine_SetMode(e, s);
i=GWEN_DB_GetIntValue(dbHeader, "hbciVersion", 0, 220);
GWEN_MsgEngine_SetProtocolVersion(e, i);
p=GWEN_DB_GetBinValue(dbT, "body", 0, NULL, 0, &len);
if (p && len) {
GWEN_BUFFER *tbuf;
GWEN_DB_NODE *gr;
GWEN_MSGENGINE_TRUSTEDDATA *trustedData;
GWEN_MSGENGINE_TRUSTEDDATA *ntd;
GWEN_DB_NODE *repl;
gr=GWEN_DB_Group_new("message");
tbuf=GWEN_Buffer_new((char*) p, len, len, 0);
rv=GWEN_MsgEngine_ReadMessage(e, "SEG", tbuf, gr,
GWEN_MSGENGINE_READ_FLAGS_TRUSTINFO);
if (rv) {
fprintf(stderr, "ERROR.\n");
GWEN_Buffer_Dump(tbuf, 2);
return 2;
}
/* work on trust data */
trustedData=GWEN_MsgEngine_TakeTrustInfo(e);
if (trustedData) {
if (GWEN_MsgEngine_TrustedData_CreateReplacements(trustedData)) {
fprintf(stderr, "Could not anonymize log (createReplacements)\n");
GWEN_MsgEngine_TrustedData_free(trustedData);
GWEN_MsgEngine_free(e);
return 2;
}
}
/* anonymize file */
ntd=trustedData;
repl=GWEN_DB_GetGroup(dbHeader, GWEN_DB_FLAGS_OVERWRITE_GROUPS, "replacements");
assert(repl);
while(ntd) {
if (GWEN_MsgEngine_TrustedData_GetTrustLevel(ntd)>trustLevel) {
int pos;
unsigned int size;
char rbuffer[3];
const char *rpstr;
rpstr=GWEN_MsgEngine_TrustedData_GetReplacement(ntd);
assert(rpstr);
assert(*rpstr);
size=strlen(rpstr);
if (size==1) {
rbuffer[0]=rpstr[0];
rbuffer[1]=0;
}
else {
rbuffer[0]=rpstr[0];
rbuffer[1]=rpstr[1];
rbuffer[2]=0;
}
GWEN_DB_SetCharValue(repl,
GWEN_DB_FLAGS_DEFAULT |
GWEN_PATH_FLAGS_CREATE_VAR,
rbuffer,
GWEN_MsgEngine_TrustedData_GetDescription(ntd));
size=GWEN_MsgEngine_TrustedData_GetSize(ntd);
pos=GWEN_MsgEngine_TrustedData_GetFirstPos(ntd);
while(pos>=0) {
DBG_INFO(0, "Replacing %d bytes at %d", size, pos);
GWEN_Buffer_SetPos(tbuf, pos);
GWEN_Buffer_ReplaceBytes(tbuf,
size,
GWEN_MsgEngine_TrustedData_GetReplacement(ntd),
size);
pos=GWEN_MsgEngine_TrustedData_GetNextPos(ntd);
} // while pos
}
ntd=GWEN_MsgEngine_TrustedData_GetNext(ntd);
} // while ntd
GWEN_DB_SetIntValue(dbHeader, GWEN_DB_FLAGS_OVERWRITE_VARS, "size", GWEN_Buffer_GetUsedBytes(tbuf));
if (outFile) {
rv=dumpMsg(sioOut,
dbHeader,
(const uint8_t*)GWEN_Buffer_GetStart(tbuf),
GWEN_Buffer_GetUsedBytes(tbuf));
if (rv<0) {
fprintf(stderr, "Could not anonymize log (dumpMsg)\n");
GWEN_MsgEngine_TrustedData_free(trustedData);
GWEN_MsgEngine_free(e);
return 2;
}
}
if (dbOutFile) {
GWEN_BUFFER *xbuf;
GWEN_DB_NODE *dbOut;
xbuf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendString(xbuf, "# ========== Message ( ");
s=GWEN_DB_GetCharValue(dbHeader, "sender", 0, "UNK");
if (s && *s) {
GWEN_Buffer_AppendString(xbuf, "sender=");
GWEN_Buffer_AppendString(xbuf, s);
GWEN_Buffer_AppendString(xbuf, " ");
}
s=GWEN_DB_GetCharValue(dbHeader, "crypt", 0, "UNK");
if (s && *s) {
GWEN_Buffer_AppendString(xbuf, "crypt=");
GWEN_Buffer_AppendString(xbuf, s);
GWEN_Buffer_AppendString(xbuf, " ");
}
GWEN_Buffer_AppendString(xbuf, ") ==========\n");
dbOut=GWEN_DB_Group_new("Message");
GWEN_Buffer_Rewind(tbuf);
rv=GWEN_MsgEngine_ReadMessage(e, "SEG", tbuf, dbOut, 0);
if (rv) {
fprintf(stderr, "ERROR.\n");
GWEN_Buffer_Dump(tbuf, 2);
return 2;
}
rv=GWEN_SyncIo_WriteForced(sioDb,
(const uint8_t*) GWEN_Buffer_GetStart(xbuf),
GWEN_Buffer_GetUsedBytes(xbuf));
GWEN_Buffer_free(xbuf);
if (rv<0) {
DBG_INFO(0, "here (%d)", rv);
return rv;
}
rv=GWEN_DB_WriteToIo(dbOut, sioDb, GWEN_DB_FLAGS_DEFAULT);
if (rv<0) {
DBG_INFO(0, "here (%d)", rv);
return 2;
}
/* append empty line to separate header from data */
rv=GWEN_SyncIo_WriteForced(sioDb, (const uint8_t*) "\n", 1);
if (rv<0) {
DBG_INFO(0, "here (%d)", rv);
return rv;
}
}
GWEN_Buffer_free(tbuf);
}
dbT=GWEN_DB_GetNextGroup(dbT);
}
/* close output layer */
if (outFile) {
rv=GWEN_SyncIo_Disconnect(sioOut);
if (rv<0) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
GWEN_SyncIo_free(sioOut);
return 2;
}
GWEN_SyncIo_free(sioOut);
}
if (dbOutFile) {
rv=GWEN_SyncIo_Disconnect(sioDb);
if (rv<0) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
GWEN_SyncIo_free(sioDb);
return 2;
}
GWEN_SyncIo_free(sioDb);
}
return 0;
}
/* --------------------------------------------------------------- FUNCTION */
AH_JOB *AH_AccountJob_new(const char *name,
AB_USER *u,
AB_ACCOUNT *account){
AH_ACCOUNTJOB *aj;
AH_JOB *j;
GWEN_DB_NODE *dbArgs;
const char *s;
int jobVersion=0;
assert(name);
assert(u);
assert(account);
if (!(AH_Account_GetFlags(account) & AH_BANK_FLAGS_KTV2)) {
int maxVer=0;
/* no account suffix, so we try to determine the highest usable
* version of the job which still doesn't need the suffix
*/
if (strcasecmp(name, "JobGetTransactions")==0)
maxVer=4;
else if (strcasecmp(name, "JobGetBalance")==0)
maxVer=4;
else if (strcasecmp(name, "JobSingleTransfer")==0)
maxVer=3;
else if (strcasecmp(name, "JobSingleDebitNote")==0)
maxVer=3;
else if (strcasecmp(name, "JobInternalTransfer")==0 ||
strcasecmp(name, "JobLoadCellPhone")==0)
/* this job needs a suffix, so if there is none you don't get it */
maxVer=-1;
else if (strcasecmp(name, "JobGetDatedTransfers")==0)
maxVer=1;
else if (strcasecmp(name, "JobCreateDatedTransfer")==0)
maxVer=2;
else if (strcasecmp(name, "JobModifyDatedTransfer")==0)
maxVer=2;
else if (strcasecmp(name, "JobDeleteDatedTransfer")==0)
maxVer=1;
else if (strcasecmp(name, "JobCreateStandingOrder")==0)
maxVer=2;
else if (strcasecmp(name, "JobModifyStandingOrder")==0)
maxVer=2;
else if (strcasecmp(name, "JobDeleteStandingOrder")==0)
maxVer=1;
if (maxVer==-1) {
DBG_ERROR(AQHBCI_LOGDOMAIN,
"This job needs an account suffix, but your bank didn't provide one. "
"Therefore this job is not supported with your account.");
GWEN_Gui_ProgressLog(0,
GWEN_LoggerLevel_Error,
I18N("This job needs an account suffix, but your bank did not provide one. "
"Therefore this job is not supported with your account.\n"
"Setting a higher HBCI version in the user settings might fix "
"the problem."));
return NULL;
}
if (maxVer>0) {
jobVersion=AH_Job_GetMaxVersionUpUntil(name, u, maxVer);
if (jobVersion<1) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "No job [%s] below version %d, falling back to 0", name, maxVer);
GWEN_Gui_ProgressLog2(0,
GWEN_LoggerLevel_Warning,
"No version for job [%s] up to %d found, falling back to 0", name, maxVer);
jobVersion=0;
}
else {
DBG_INFO(AQHBCI_LOGDOMAIN, "Reducing version of job [%s] to %d", name, jobVersion);
}
}
}
j=AH_Job_new(name, u,
AB_Account_GetAccountNumber(account),
AB_Account_GetSubAccountId(account),
jobVersion);
if (!j)
return 0;
GWEN_NEW_OBJECT(AH_ACCOUNTJOB, aj);
GWEN_INHERIT_SETDATA(AH_JOB, AH_ACCOUNTJOB, j, aj, AH_AccountJob_FreeData);
aj->account=account;
/* set some known arguments */
dbArgs=AH_Job_GetArguments(j);
assert(dbArgs);
s=AB_Account_GetAccountNumber(account);
if (s && *s)
GWEN_DB_SetCharValue(dbArgs, GWEN_DB_FLAGS_DEFAULT, "accountId", s);
s=AB_Account_GetSubAccountId(account);
if (s && *s)
GWEN_DB_SetCharValue(dbArgs, GWEN_DB_FLAGS_DEFAULT, "accountSubId", s);
s=AB_Account_GetBankCode(account);
if (s && *s)
GWEN_DB_SetCharValue(dbArgs, GWEN_DB_FLAGS_DEFAULT, "bankCode", s);
GWEN_DB_SetIntValue(dbArgs, GWEN_DB_FLAGS_DEFAULT,
"country", 280);
/* new for SEPA jobs */
s=AB_Account_GetIBAN(account);
if (s && *s)
GWEN_DB_SetCharValue(dbArgs, GWEN_DB_FLAGS_DEFAULT, "iban", s);
s=AB_Account_GetBIC(account);
if (s && *s)
GWEN_DB_SetCharValue(dbArgs, GWEN_DB_FLAGS_DEFAULT, "bic", s);
return j;
}
/* --------------------------------------------------------------- FUNCTION */
int AH_Job_GetTransactions__ReadTransactions(AH_JOB *j,
AB_IMEXPORTER_ACCOUNTINFO *ai,
const char *docType,
int noted,
GWEN_BUFFER *buf){
GWEN_DBIO *dbio;
GWEN_SYNCIO *sio;
int rv;
GWEN_DB_NODE *db;
GWEN_DB_NODE *dbDay;
GWEN_DB_NODE *dbParams;
AB_ACCOUNT *a;
AB_USER *u;
uint32_t progressId;
uint64_t cnt=0;
a=AH_AccountJob_GetAccount(j);
assert(a);
u=AH_Job_GetUser(j);
assert(u);
dbio=GWEN_DBIO_GetPlugin("swift");
if (!dbio) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Plugin SWIFT is not found");
GWEN_Gui_ProgressLog(0,
GWEN_LoggerLevel_Error,
I18N("Plugin \"SWIFT\" not found."));
return AB_ERROR_PLUGIN_MISSING;
}
GWEN_Buffer_Rewind(buf);
sio=GWEN_SyncIo_Memory_new(buf, 0);
db=GWEN_DB_Group_new("transactions");
dbParams=GWEN_DB_Group_new("params");
GWEN_DB_SetCharValue(dbParams, GWEN_DB_FLAGS_OVERWRITE_VARS,
"type", docType);
if (AH_User_GetFlags(u) & AH_USER_FLAGS_KEEP_MULTIPLE_BLANKS)
GWEN_DB_SetIntValue(dbParams, GWEN_DB_FLAGS_OVERWRITE_VARS,
"keepMultipleBlanks", 1);
else
GWEN_DB_SetIntValue(dbParams, GWEN_DB_FLAGS_OVERWRITE_VARS,
"keepMultipleBlanks", 0);
rv=GWEN_DBIO_Import(dbio, sio,
db, dbParams,
GWEN_PATH_FLAGS_CREATE_GROUP);
if (rv<0) {
DBG_ERROR(AQHBCI_LOGDOMAIN,
"Error parsing SWIFT %s (%d)",
docType, rv);
GWEN_DB_Group_free(dbParams);
GWEN_DB_Group_free(db);
GWEN_SyncIo_free(sio);
GWEN_DBIO_free(dbio);
return rv;
}
GWEN_DB_Group_free(dbParams);
GWEN_SyncIo_free(sio);
GWEN_DBIO_free(dbio);
/* first count the groups */
dbDay=GWEN_DB_FindFirstGroup(db, "day");
while(dbDay) {
GWEN_DB_NODE *dbT;
dbT=GWEN_DB_FindFirstGroup(dbDay, "transaction");
while(dbT) {
cnt++;
dbT=GWEN_DB_FindNextGroup(dbT, "transaction");
} /* while */
dbDay=GWEN_DB_FindNextGroup(dbDay, "day");
} /* while */
progressId=GWEN_Gui_ProgressStart(GWEN_GUI_PROGRESS_DELAY |
GWEN_GUI_PROGRESS_ALLOW_EMBED |
GWEN_GUI_PROGRESS_SHOW_PROGRESS |
GWEN_GUI_PROGRESS_SHOW_ABORT,
I18N("Importing transactions..."),
NULL,
cnt,
0);
/* add transactions to list */
dbDay=GWEN_DB_FindFirstGroup(db, "day");
while(dbDay) {
GWEN_DB_NODE *dbT;
dbT=GWEN_DB_FindFirstGroup(dbDay, "transaction");
while(dbT) {
AB_TRANSACTION *t;
t=AB_Transaction_fromDb(dbT);
if (!t) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Bad transaction data:");
GWEN_DB_Dump(dbT, 2);
}
else {
const char *s;
AB_Transaction_SetLocalBankCode(t, AB_User_GetBankCode(u));
AB_Transaction_SetLocalAccountNumber(t,
AB_Account_GetAccountNumber(a));
/* some translations */
s=AB_Transaction_GetRemoteIban(t);
if (!(s && *s)) {
const char *sAid;
/* no remote IBAN set, check whether the bank sends this info in the
* fields for national account specifications (instead of the SWIFT
* field "?38" which was specified for this case) */
sAid=AB_Transaction_GetRemoteAccountNumber(t);
if (sAid && *sAid && AB_Banking_CheckIban(sAid)==0) {
/* there is a remote account number specification, and that is an IBAN,
* so we set that accordingly */
DBG_INFO(AQBANKING_LOGDOMAIN, "Setting remote IBAN from account number");
AB_Transaction_SetRemoteIban(t, sAid);
/* set remote BIC if it not already is */
s=AB_Transaction_GetRemoteBic(t);
if (!(s && *s)) {
const char *sBid;
sBid=AB_Transaction_GetRemoteBankCode(t);
if (sBid && *sBid) {
DBG_INFO(AQBANKING_LOGDOMAIN, "Setting remote BIC from bank code");
AB_Transaction_SetRemoteBic(t, sBid);
}
}
}
}
DBG_INFO(AQHBCI_LOGDOMAIN, "Adding transaction");
if (noted)
AB_ImExporterAccountInfo_AddNotedTransaction(ai, t);
else
AB_ImExporterAccountInfo_AddTransaction(ai, t);
}
if (GWEN_ERROR_USER_ABORTED==
GWEN_Gui_ProgressAdvance(progressId, GWEN_GUI_PROGRESS_ONE)) {
GWEN_Gui_ProgressEnd(progressId);
return GWEN_ERROR_USER_ABORTED;
}
dbT=GWEN_DB_FindNextGroup(dbT, "transaction");
} /* while */
/* read all endsaldos */
if (!noted) {
dbT=GWEN_DB_FindFirstGroup(dbDay, "endSaldo");
while (dbT) {
GWEN_DB_NODE *dbX;
GWEN_TIME *ti=0;
dbX=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "date");
if (dbX)
ti=GWEN_Time_fromDb(dbX);
dbX=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "value");
if (dbX) {
AB_VALUE *v;
v=AB_Value_fromDb(dbX);
if (v) {
AB_BALANCE *bal;
AB_ACCOUNT_STATUS *as;
bal=AB_Balance_new(v, ti);
AB_Value_free(v);
as=AB_AccountStatus_new();
if (ti)
AB_AccountStatus_SetTime(as, ti);
AB_AccountStatus_SetNotedBalance(as, bal);
AB_Balance_free(bal);
AB_ImExporterAccountInfo_AddAccountStatus(ai, as);
}
}
GWEN_Time_free(ti);
dbT=GWEN_DB_FindNextGroup(dbT, "endSaldo");
} /* while */
}
dbDay=GWEN_DB_FindNextGroup(dbDay, "day");
} /* while */
GWEN_Gui_ProgressEnd(progressId);
GWEN_DB_Group_free(db);
return 0;
}
int AH_Msg_EncryptRdh2(AH_MSG *hmsg) {
AH_HBCI *h;
GWEN_XMLNODE *node;
GWEN_DB_NODE *cfg;
GWEN_BUFFER *mbuf;
GWEN_BUFFER *hbuf;
uint32_t l;
int rv;
const char *p;
GWEN_MSGENGINE *e;
AB_USER *u;
const char *peerId;
// uint32_t uFlags;
GWEN_CRYPT_TOKEN *ct;
const GWEN_CRYPT_TOKEN_CONTEXT *ctx;
const GWEN_CRYPT_TOKEN_KEYINFO *ki;
uint32_t keyId;
GWEN_CRYPT_KEY *sk;
uint8_t encKey[300];
int encKeyLen;
uint32_t gid;
assert(hmsg);
h=AH_Dialog_GetHbci(hmsg->dialog);
assert(h);
e=AH_Dialog_GetMsgEngine(hmsg->dialog);
assert(e);
GWEN_MsgEngine_SetMode(e, "rdh");
gid=0;
u=AH_Dialog_GetDialogOwner(hmsg->dialog);
// uFlags=AH_User_GetFlags(u);
peerId=AH_User_GetPeerId(u);
if (!peerId || *peerId==0)
peerId=AB_User_GetUserId(u);
/* get crypt token of signer */
rv=AB_Banking_GetCryptToken(AH_HBCI_GetBankingApi(h),
AH_User_GetTokenType(u),
AH_User_GetTokenName(u),
&ct);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN,
"Could not get crypt token for user \"%s\" (%d)",
AB_User_GetUserId(u), rv);
return rv;
}
/* open CryptToken if necessary */
if (!GWEN_Crypt_Token_IsOpen(ct)) {
GWEN_Crypt_Token_AddModes(ct, GWEN_CRYPT_TOKEN_MODE_DIRECT_SIGN);
rv=GWEN_Crypt_Token_Open(ct, 0, gid);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN,
"Could not open crypt token for user \"%s\" (%d)",
AB_User_GetUserId(u), rv);
return rv;
}
}
/* get context and key info */
ctx=GWEN_Crypt_Token_GetContext(ct,
AH_User_GetTokenContextId(u),
gid);
if (ctx==NULL) {
DBG_INFO(AQHBCI_LOGDOMAIN,
"Context %d not found on crypt token [%s:%s]",
AH_User_GetTokenContextId(u),
GWEN_Crypt_Token_GetTypeName(ct),
GWEN_Crypt_Token_GetTokenName(ct));
return GWEN_ERROR_NOT_FOUND;
}
keyId=GWEN_Crypt_Token_Context_GetEncipherKeyId(ctx);
ki=GWEN_Crypt_Token_GetKeyInfo(ct,
keyId,
0xffffffff,
gid);
if (ki==NULL) {
DBG_INFO(AQHBCI_LOGDOMAIN,
"Keyinfo %04x not found on crypt token [%s:%s]",
keyId,
GWEN_Crypt_Token_GetTypeName(ct),
GWEN_Crypt_Token_GetTokenName(ct));
return GWEN_ERROR_NOT_FOUND;
}
rv=GWEN_Padd_PaddWithAnsiX9_23(hmsg->buffer);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN,
"Error padding message with ANSI X9.23 (%d)", rv);
return rv;
}
/* create session key */
sk=GWEN_Crypt_KeyDes3K_Generate(GWEN_Crypt_CryptMode_Cbc, 24, 2);
if (sk==NULL) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Could not generate DES key");
return GWEN_ERROR_INTERNAL;
}
/* encrypt message with that session key */
mbuf=GWEN_Buffer_new(0, GWEN_Buffer_GetUsedBytes(hmsg->buffer), 0, 1);
l=GWEN_Buffer_GetUsedBytes(hmsg->buffer);
rv=GWEN_Crypt_Key_Encipher(sk,
(uint8_t*)GWEN_Buffer_GetStart(hmsg->buffer),
GWEN_Buffer_GetUsedBytes(hmsg->buffer),
(uint8_t*)GWEN_Buffer_GetPosPointer(mbuf),
&l);
if (rv<0) {
DBG_INFO(AQHBCI_LOGDOMAIN,
"Could not encipher with DES session key (%d)",
rv);
GWEN_Buffer_free(mbuf);
GWEN_Crypt_Key_free(sk);
return rv;
}
GWEN_Buffer_IncrementPos(mbuf, l);
GWEN_Buffer_AdjustUsedBytes(mbuf);
/* encrypt session key */
if (1) {
uint32_t elen;
GWEN_CRYPT_PADDALGO *algo;
algo=GWEN_Crypt_PaddAlgo_new(GWEN_Crypt_PaddAlgoId_LeftZero);
GWEN_Crypt_PaddAlgo_SetPaddSize(algo, GWEN_Crypt_Token_KeyInfo_GetKeySize(ki));
elen=sizeof(encKey);
rv=GWEN_Crypt_Token_Encipher(ct,
keyId,
algo,
GWEN_Crypt_KeyDes3K_GetKeyDataPtr(sk),
16,
encKey,
&elen,
gid);
GWEN_Crypt_PaddAlgo_free(algo);
if (rv<0) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(mbuf);
GWEN_Crypt_Key_free(sk);
return rv;
}
encKeyLen=elen;
}
GWEN_Crypt_Key_free(sk);
/* create crypt head */
node=GWEN_MsgEngine_FindNodeByPropertyStrictProto(e,
"SEG",
"id",
0,
"CryptHead");
if (!node) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Segment \"CryptHead\" not found");
GWEN_Buffer_free(mbuf);
GWEN_Crypt_Key_free(sk);
return GWEN_ERROR_INTERNAL;
}
/* create CryptHead */
cfg=GWEN_DB_Group_new("crypthead");
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"head/seq", 998);
rv=AH_MsgRdh_PrepareCryptoSeg2(hmsg, u, ki, cfg, 1, 0);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
GWEN_DB_Group_free(cfg);
GWEN_Buffer_free(mbuf);
return rv;
}
/* store system id */
if (hmsg->noSysId) {
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"SecDetails/SecId", "0");
}
else {
p=AH_User_GetSystemId(u);
if (p==NULL)
p=GWEN_Crypt_Token_Context_GetSystemId(ctx);
if (p)
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"SecDetails/SecId", p);
else {
DBG_INFO(AQHBCI_LOGDOMAIN,
"No System id on RDH medium, using default");
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"SecDetails/SecId", "0");
}
}
/* store encrypted message key */
GWEN_DB_SetBinValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"CryptAlgo/MsgKey",
encKey,
encKeyLen);
hbuf=GWEN_Buffer_new(0, 256+GWEN_Buffer_GetUsedBytes(mbuf), 0, 1);
rv=GWEN_MsgEngine_CreateMessageFromNode(e,
node,
hbuf,
cfg);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Could not create CryptHead (%d)", rv);
GWEN_Buffer_free(hbuf);
GWEN_DB_Group_free(cfg);
GWEN_Buffer_free(mbuf);
return rv;
}
GWEN_DB_Group_free(cfg);
/* create cryptdata */
cfg=GWEN_DB_Group_new("cryptdata");
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"head/seq", 999);
GWEN_DB_SetBinValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"cryptdata",
GWEN_Buffer_GetStart(mbuf),
GWEN_Buffer_GetUsedBytes(mbuf));
GWEN_Buffer_free(mbuf);
node=GWEN_MsgEngine_FindNodeByPropertyStrictProto(e,
"SEG",
"id",
0,
"CryptData");
if (!node) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Segment \"CryptData\"not found");
GWEN_Buffer_free(hbuf);
GWEN_DB_Group_free(cfg);
return -1;
}
rv=GWEN_MsgEngine_CreateMessageFromNode(e,
node,
hbuf,
cfg);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Could not create CryptData (%d)", rv);
GWEN_Buffer_free(hbuf);
GWEN_DB_Group_free(cfg);
return rv;
}
/* replace existing buffer by encrypted one */
GWEN_Buffer_free(hmsg->buffer);
hmsg->buffer=hbuf;
GWEN_DB_Group_free(cfg);
return 0;
}
int AH_MsgPinTan_PrepareCryptoSeg(AH_MSG *hmsg,
AB_USER *u,
GWEN_DB_NODE *cfg,
int crypt,
int createCtrlRef) {
char sdate[9];
char stime[7];
char ctrlref[15];
struct tm *lt;
time_t tt;
const char *userId;
const char *peerId;
assert(hmsg);
assert(u);
assert(cfg);
userId=AB_User_GetUserId(u);
assert(userId);
assert(*userId);
peerId=AH_User_GetPeerId(u);
if (!peerId || *peerId==0)
peerId=userId;
tt=time(0);
lt=localtime(&tt);
if (createCtrlRef) {
/* create control reference */
if (!strftime(ctrlref, sizeof(ctrlref),
"%Y%m%d%H%M%S", lt)) {
DBG_INFO(AQHBCI_LOGDOMAIN, "CtrlRef string too long");
return GWEN_ERROR_INTERNAL;
}
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"ctrlref", ctrlref);
}
/* create date */
if (!strftime(sdate, sizeof(sdate),
"%Y%m%d", lt)) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Date string too long");
return GWEN_ERROR_INTERNAL;
}
/* create time */
if (!strftime(stime, sizeof(stime),
"%H%M%S", lt)) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Date string too long");
return GWEN_ERROR_INTERNAL;
}
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"SecDetails/dir", 1);
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"SecStamp/date", sdate);
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"SecStamp/time", stime);
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"key/bankcode",
AB_User_GetBankCode(u));
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"key/userid",
crypt?peerId:userId);
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"key/keytype",
crypt?"V":"S");
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"key/keynum", 1);
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"key/keyversion", 1);
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"secProfile/code",
"PIN");
if (crypt)
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"secProfile/version", 1);
else
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"secProfile/version",
(hmsg->itanMethod==999)?1:2);
return 0;
}
int AB_CSV_EditProfileDialog_fromGui(GWEN_DIALOG *dlg, GWEN_DB_NODE *db)
{
const char *s;
int i;
s=GWEN_Dialog_GetCharProperty(dlg, "nameEdit", GWEN_DialogProperty_Value, 0, NULL);
if (s && *s)
GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "name", s);
else {
GWEN_Gui_MessageBox(GWEN_GUI_MSG_FLAGS_TYPE_ERROR |
GWEN_GUI_MSG_FLAGS_CONFIRM_B1 |
GWEN_GUI_MSG_FLAGS_SEVERITY_NORMAL,
I18N("Input Error"),
I18N("Please enter a name for the profile."),
I18N("Continue"), 0, 0, 0);
/* change focus */
GWEN_Dialog_SetIntProperty(dlg, "nameEdit", GWEN_DialogProperty_Focus, 0, 1, 0);
return GWEN_ERROR_BAD_DATA;
}
s=GWEN_Dialog_GetCharProperty(dlg, "versionEdit", GWEN_DialogProperty_Value, 0, "");
if (s && *s)
GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "version", s);
s=GWEN_Dialog_GetCharProperty(dlg, "shortDescrEdit", GWEN_DialogProperty_Value, 0, "");
if (s && *s)
GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "shortDescr", s);
s=GWEN_Dialog_GetCharProperty(dlg, "longDescrEdit", GWEN_DialogProperty_Value, 0, "");
if (s && *s)
GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "longDescr", s);
i=GWEN_Dialog_GetIntProperty(dlg, "importCheck", GWEN_DialogProperty_Value, 0, 1);
GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "import", i);
i=GWEN_Dialog_GetIntProperty(dlg, "exportCheck", GWEN_DialogProperty_Value, 0, 1);
GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "export", i);
i=GWEN_Dialog_GetIntProperty(dlg, "ignoreLinesSpin", GWEN_DialogProperty_Value, 0, 0);
GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "params/ignoreLines", i);
i=setDbValueFromDoubleStringsCombo(dlg, db, "params/delimiter", "delimiterCombo", csv_delimiters);
if (i<0) {
GWEN_Gui_MessageBox(GWEN_GUI_MSG_FLAGS_TYPE_ERROR |
GWEN_GUI_MSG_FLAGS_CONFIRM_B1 |
GWEN_GUI_MSG_FLAGS_SEVERITY_NORMAL,
I18N("Input Error"),
I18N("Please select a field delimiter."),
I18N("Continue"), 0, 0, 0);
GWEN_Dialog_SetIntProperty(dlg, "tabBook", GWEN_DialogProperty_Value, 0, 0, 0);
GWEN_Dialog_SetIntProperty(dlg, "delimiterCombo", GWEN_DialogProperty_Focus, 0, 1, 0);
return GWEN_ERROR_BAD_DATA;
}
i=setDbValueFromDoubleStringsCombo(dlg, db, "subject", "subjectCombo", csv_subjects);
if (i<0) {
GWEN_Dialog_SetIntProperty(dlg, "tabBook", GWEN_DialogProperty_Value, 0, 0, 0);
GWEN_Dialog_SetIntProperty(dlg, "subjectCombo", GWEN_DialogProperty_Focus, 0, 1, 0);
return GWEN_ERROR_BAD_DATA;
}
s=GWEN_Dialog_GetCharProperty(dlg, "dateFormatCombo", GWEN_DialogProperty_Value, 0, "");
if (!(s && *s)) {
GWEN_Gui_MessageBox(GWEN_GUI_MSG_FLAGS_TYPE_ERROR |
GWEN_GUI_MSG_FLAGS_CONFIRM_B1 |
GWEN_GUI_MSG_FLAGS_SEVERITY_NORMAL,
I18N("Input Error"),
I18N("Please select a date format."),
I18N("Continue"), 0, 0, 0);
GWEN_Dialog_SetIntProperty(dlg, "tabBook", GWEN_DialogProperty_Value, 0, 0, 0);
GWEN_Dialog_SetIntProperty(dlg, "dateFormatCombo", GWEN_DialogProperty_Focus, 0, 1, 0);
return GWEN_ERROR_BAD_DATA;
}
GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "dateFormat", s);
i=setDbValueFromDoubleStringsCombo(dlg, db, "valueFormat", "amountFormatCombo", csv_amountFormats);
if (i<0) {
GWEN_Gui_MessageBox(GWEN_GUI_MSG_FLAGS_TYPE_ERROR |
GWEN_GUI_MSG_FLAGS_CONFIRM_B1 |
GWEN_GUI_MSG_FLAGS_SEVERITY_NORMAL,
I18N("Input Error"),
I18N("Please select a value format."),
I18N("Continue"), 0, 0, 0);
GWEN_Dialog_SetIntProperty(dlg, "tabBook", GWEN_DialogProperty_Value, 0, 0, 0);
GWEN_Dialog_SetIntProperty(dlg, "amountFormatCombo", GWEN_DialogProperty_Focus, 0, 1, 0);
return GWEN_ERROR_BAD_DATA;
}
i=GWEN_Dialog_GetIntProperty(dlg, "headerCheck", GWEN_DialogProperty_Value, 0, 0);
GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "params/title", i);
i=GWEN_Dialog_GetIntProperty(dlg, "quoteCheck", GWEN_DialogProperty_Value, 0, 1);
GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "params/quote", i);
/* get columns */
GWEN_DB_ClearGroup(db, "params/columns");
for (i=0; i<DIALOG_MAX_COLUMNS; i++) {
char varName[32];
char comboName[32];
int rv;
snprintf(varName, sizeof(varName)-1, "params/columns/%d", i+1);
snprintf(comboName, sizeof(comboName)-1, "col%dCombo", i+1);
rv=setColumnValueFromCombo(dlg, db, varName, comboName, csv_columns);
if (rv<0) {
GWEN_Gui_MessageBox(GWEN_GUI_MSG_FLAGS_TYPE_ERROR |
GWEN_GUI_MSG_FLAGS_CONFIRM_B1 |
GWEN_GUI_MSG_FLAGS_SEVERITY_NORMAL,
I18N("Input Error"),
I18N("Please select a valid column type."),
I18N("Continue"), 0, 0, 0);
GWEN_Dialog_SetIntProperty(dlg, "tabBook", GWEN_DialogProperty_Value, 0, 1, 0);
GWEN_Dialog_SetIntProperty(dlg, comboName, GWEN_DialogProperty_Focus, 0, 1, 0);
return GWEN_ERROR_BAD_DATA;
}
}
return 0;
}
int AH_Msg_EncryptPinTan(AH_MSG *hmsg) {
AH_HBCI *h;
GWEN_XMLNODE *node;
GWEN_DB_NODE *cfg;
GWEN_BUFFER *hbuf;
int rv;
const char *p;
GWEN_MSGENGINE *e;
AB_USER *u;
const char *peerId;
// uint32_t uFlags;
assert(hmsg);
h=AH_Dialog_GetHbci(hmsg->dialog);
assert(h);
e=AH_Dialog_GetMsgEngine(hmsg->dialog);
assert(e);
GWEN_MsgEngine_SetMode(e, "pintan");
u=AH_Dialog_GetDialogOwner(hmsg->dialog);
// uFlags=AH_User_GetFlags(u);
peerId=AH_User_GetPeerId(u);
if (!peerId || *peerId==0)
peerId=AB_User_GetUserId(u);
/* create crypt head */
node=GWEN_MsgEngine_FindNodeByPropertyStrictProto(e,
"SEG",
"id",
0,
"CryptHead");
if (!node) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Segment \"CryptHead\" not found");
return GWEN_ERROR_INTERNAL;
}
/* create CryptHead */
cfg=GWEN_DB_Group_new("crypthead");
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"head/seq", 998);
rv=AH_MsgPinTan_PrepareCryptoSeg(hmsg, u, cfg, 1, 0);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
GWEN_DB_Group_free(cfg);
return rv;
}
/* store system id */
p=NULL;
if (!hmsg->noSysId)
p=AH_User_GetSystemId(u);
if (!p)
p="0";
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT, "SecDetails/SecId", p);
/* store encrypted message key */
GWEN_DB_SetBinValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"CryptAlgo/MsgKey",
"NOKEY", 5);
hbuf=GWEN_Buffer_new(0, 256+GWEN_Buffer_GetUsedBytes(hmsg->buffer), 0, 1);
rv=GWEN_MsgEngine_CreateMessageFromNode(e,
node,
hbuf,
cfg);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Could not create CryptHead (%d)", rv);
GWEN_Buffer_free(hbuf);
GWEN_DB_Group_free(cfg);
return rv;
}
GWEN_DB_Group_free(cfg);
/* create cryptdata */
cfg=GWEN_DB_Group_new("cryptdata");
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"head/seq", 999);
GWEN_DB_SetBinValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"cryptdata",
GWEN_Buffer_GetStart(hmsg->buffer),
GWEN_Buffer_GetUsedBytes(hmsg->buffer));
node=GWEN_MsgEngine_FindNodeByPropertyStrictProto(e,
"SEG",
"id",
0,
"CryptData");
if (!node) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Segment \"CryptData\"not found");
GWEN_Buffer_free(hbuf);
GWEN_DB_Group_free(cfg);
return -1;
}
rv=GWEN_MsgEngine_CreateMessageFromNode(e,
node,
hbuf,
cfg);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Could not create CryptData (%d)", rv);
GWEN_Buffer_free(hbuf);
GWEN_DB_Group_free(cfg);
return rv;
}
/* replace existing buffer by encrypted one */
GWEN_Buffer_free(hmsg->buffer);
hmsg->buffer=hbuf;
GWEN_DB_Group_free(cfg);
return 0;
}
int AH_MsgRdh_PrepareCryptoSeg2(AH_MSG *hmsg,
AB_USER *u,
const GWEN_CRYPT_TOKEN_KEYINFO *ki,
GWEN_DB_NODE *cfg,
int crypt,
int createCtrlRef) {
char sdate[9];
char stime[7];
char ctrlref[15];
struct tm *lt;
time_t tt;
const char *userId;
const char *peerId;
assert(hmsg);
assert(u);
assert(cfg);
userId=AB_User_GetUserId(u);
assert(userId);
assert(*userId);
peerId=AH_User_GetPeerId(u);
if (!peerId || *peerId==0) {
DBG_INFO(AQHBCI_LOGDOMAIN, "No PeerId in user, using user id");
peerId=userId;
}
tt=time(0);
lt=localtime(&tt);
if (createCtrlRef) {
/* create control reference */
if (!strftime(ctrlref, sizeof(ctrlref),
"%Y%m%d%H%M%S", lt)) {
DBG_INFO(AQHBCI_LOGDOMAIN, "CtrlRef string too long");
return GWEN_ERROR_INTERNAL;
}
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"ctrlref", ctrlref);
}
/* create date */
if (!strftime(sdate, sizeof(sdate),
"%Y%m%d", lt)) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Date string too long");
return GWEN_ERROR_INTERNAL;
}
/* create time */
if (!strftime(stime, sizeof(stime),
"%H%M%S", lt)) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Date string too long");
return GWEN_ERROR_INTERNAL;
}
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"SecDetails/dir", 1);
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"SecStamp/date", sdate);
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"SecStamp/time", stime);
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"key/bankcode",
AB_User_GetBankCode(u));
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"key/userid",
crypt?peerId:userId);
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"key/keytype",
crypt?"V":"S");
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"key/keynum",
GWEN_Crypt_Token_KeyInfo_GetKeyNumber(ki));
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"key/keyversion",
GWEN_Crypt_Token_KeyInfo_GetKeyVersion(ki));
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"secProfile/code",
"RDH");
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"secProfile/version",
AH_User_GetRdhType(u));
if (crypt) {
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT, "function", 4); /* crypt */
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT, "cryptAlgo/algo", 13); /* 2-KEY-TRIPLE-DES */
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT, "cryptAlgo/mode", 2); /* CBC (0-Padding) */
}
else {
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT, "function", 2); /* sign with signature key */
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT, "signAlgo/algo", 10); /* RSA */
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT, "signAlgo/mode", 17); /* ISO-9796-2 */
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT, "hashAlgo/algo", 999); /* RMD160 */
}
return 0;
}
