void GWENHYWFAR_CB AB_SetupNewUserDialog_FreeData(void *bp, void *p) {
AB_SETUP_NEWUSER_DIALOG *xdlg;
xdlg=(AB_SETUP_NEWUSER_DIALOG*) p;
GWEN_Dialog_List2_free(xdlg->backendDialogs); /* don't use _freeAll here! */
GWEN_StringList_free(xdlg->backendRadioNames);
GWEN_StringList_free(xdlg->backendNames);
GWEN_FREE_OBJECT(xdlg);
}
void Typemaker2_TypeManager_free(TYPEMAKER2_TYPEMANAGER *tym) {
if (tym) {
Typemaker2_Type_List_free(tym->typeList);
GWEN_StringList_free(tym->folders);
GWEN_FREE_OBJECT(tym);
}
}
void AB_TransactionLimits_SetValuesTextKey(AB_TRANSACTION_LIMITS *st, GWEN_STRINGLIST *d) {
assert(st);
if (st->valuesTextKey)
GWEN_StringList_free(st->valuesTextKey);
if (d)
st->valuesTextKey=GWEN_StringList_dup(d);
else
st->valuesTextKey=0;
st->_modified=1;
}
void AB_TransactionLimits_SetValuesExecutionDayMonth(AB_TRANSACTION_LIMITS *st, GWEN_STRINGLIST *d) {
assert(st);
if (st->valuesExecutionDayMonth)
GWEN_StringList_free(st->valuesExecutionDayMonth);
if (d)
st->valuesExecutionDayMonth=GWEN_StringList_dup(d);
else
st->valuesExecutionDayMonth=0;
st->_modified=1;
}
void AB_TransactionLimits_free(AB_TRANSACTION_LIMITS *st) {
if (st) {
assert(st->_usage);
if (--(st->_usage)==0) {
if (st->valuesTextKey)
GWEN_StringList_free(st->valuesTextKey);
if (st->textKeys)
AB_TextKeyDescr_List_free(st->textKeys);
if (st->valuesCycleWeek)
GWEN_StringList_free(st->valuesCycleWeek);
if (st->valuesCycleMonth)
GWEN_StringList_free(st->valuesCycleMonth);
if (st->valuesExecutionDayWeek)
GWEN_StringList_free(st->valuesExecutionDayWeek);
if (st->valuesExecutionDayMonth)
GWEN_StringList_free(st->valuesExecutionDayMonth);
GWEN_LIST_FINI(AB_TRANSACTION_LIMITS, st)
GWEN_FREE_OBJECT(st);
}
}
}
void GWENHYWFAR_CB AH_User_freeData(void *bp, void *p) {
AH_USER *ue;
ue=(AH_USER*)p;
free(ue->peerId);
free(ue->systemId);
free(ue->httpContentType);
free(ue->httpUserAgent);
free(ue->tokenType);
free(ue->tokenName);
free(ue->prompt);
GWEN_Url_free(ue->serverUrl);
GWEN_DB_Group_free(ue->dbUpd);
AH_Bpd_free(ue->bpd);
GWEN_MsgEngine_free(ue->msgEngine);
AH_TanMethod_List_free(ue->tanMethodDescriptions);
GWEN_StringList_free(ue->sepaDescriptors);
GWEN_FREE_OBJECT(ue);
}
GWEN_STRINGLIST *GWEN_PathManager_GetPaths(const char *destLib,
const char *pathName) {
GWEN_DB_NODE *dbT;
assert(gwen__paths);
dbT=GWEN_DB_GetGroup(gwen__paths, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
destLib);
if (dbT) {
dbT=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
pathName);
if (dbT) {
GWEN_STRINGLIST *sl;
int i;
const char *s;
GWEN_DB_NODE *dbN;
sl=GWEN_StringList_new();
/* then add all paths from other libs */
dbN=GWEN_DB_FindFirstGroup(dbT, "pair");
while(dbN) {
for (i=0; ; i++) {
s=GWEN_DB_GetCharValue(dbN, "path", i, 0);
if (!s)
break;
GWEN_StringList_AppendString(sl, s, 0, 1);
}
dbN=GWEN_DB_FindNextGroup(dbN, "pair");
}
if (GWEN_StringList_Count(sl)==0) {
GWEN_StringList_free(sl);
DBG_DEBUG(GWEN_LOGDOMAIN, "no entries");
return 0;
}
return sl;
}
}
return 0;
}
int GWEN_Crypt_Token_ModuleInit(void)
{
GWEN_PLUGIN_MANAGER *pm;
int err;
GWEN_STRINGLIST *sl;
pm=GWEN_PluginManager_new(GWEN_CRYPT_TOKEN_PLUGIN_TYPENAME, GWEN_PM_LIBNAME);
err=GWEN_PluginManager_Register(pm);
if (err) {
DBG_ERROR(GWEN_LOGDOMAIN, "Could not register CryptToken plugin manager");
return err;
}
/* create plugin paths */
sl=GWEN_PathManager_GetPaths(GWEN_PM_LIBNAME, GWEN_PM_PLUGINDIR);
if (sl) {
GWEN_STRINGLISTENTRY *se;
GWEN_BUFFER *pbuf;
pbuf=GWEN_Buffer_new(0, 256, 0, 1);
se=GWEN_StringList_FirstEntry(sl);
while (se) {
GWEN_Buffer_AppendString(pbuf, GWEN_StringListEntry_Data(se));
GWEN_Buffer_AppendString(pbuf, DIRSEP GWEN_CRYPT_TOKEN_FOLDER);
DBG_INFO(GWEN_LOGDOMAIN, "Adding plugin path [%s]",
GWEN_Buffer_GetStart(pbuf));
GWEN_PluginManager_AddPath(pm, GWEN_PM_LIBNAME,
GWEN_Buffer_GetStart(pbuf));
GWEN_Buffer_Reset(pbuf);
se=GWEN_StringListEntry_Next(se);
}
GWEN_Buffer_free(pbuf);
GWEN_StringList_free(sl);
}
return 0;
}
int EBC_Provider_Init(AB_PROVIDER *pro, GWEN_DB_NODE *dbData) {
EBC_PROVIDER *dp;
const char *logLevelName;
assert(pro);
dp=GWEN_INHERIT_GETDATA(AB_PROVIDER, EBC_PROVIDER, pro);
assert(dp);
if (!GWEN_Logger_IsOpen(AQEBICS_LOGDOMAIN)) {
GWEN_Logger_Open(AQEBICS_LOGDOMAIN,
"aqebics", 0,
GWEN_LoggerType_Console,
GWEN_LoggerFacility_User);
}
logLevelName=getenv("AQEBICS_LOGLEVEL");
if (logLevelName) {
GWEN_LOGGER_LEVEL ll;
ll=GWEN_Logger_Name2Level(logLevelName);
if (ll!=GWEN_LoggerLevel_Unknown) {
GWEN_Logger_SetLevel(AQEBICS_LOGDOMAIN, ll);
DBG_WARN(AQEBICS_LOGDOMAIN,
"Overriding loglevel for AqEBICS with \"%s\"",
logLevelName);
}
else {
DBG_ERROR(AQEBICS_LOGDOMAIN, "Unknown loglevel \"%s\"",
logLevelName);
}
}
DBG_INFO(AQEBICS_LOGDOMAIN, "Please remember to purchase a license if you want to use the EBICS backend.");
if (1) {
GWEN_STRINGLIST *sl=GWEN_PathManager_GetPaths(AB_PM_LIBNAME,
AB_PM_LOCALEDIR);
const char *localedir=GWEN_StringList_FirstString(sl);
int rv;
rv=GWEN_I18N_BindTextDomain_Dir(PACKAGE, localedir);
if (rv) {
DBG_ERROR(AQEBICS_LOGDOMAIN, "Could not bind textdomain (%d)", rv);
}
else {
rv=GWEN_I18N_BindTextDomain_Codeset(PACKAGE, "UTF-8");
if (rv) {
DBG_ERROR(AQEBICS_LOGDOMAIN, "Could not set codeset (%d)", rv);
}
}
GWEN_StringList_free(sl);
}
DBG_NOTICE(AQEBICS_LOGDOMAIN, "Initializing AqEBICS backend");
dp->connectTimeout=GWEN_DB_GetIntValue(dbData, "connectTimeout", 0,
EBC_DEFAULT_CONNECT_TIMEOUT);
dp->transferTimeout=GWEN_DB_GetIntValue(dbData, "transferTimeout", 0,
EBC_DEFAULT_TRANSFER_TIMEOUT);
return 0;
}
int add2Archive(GWEN_DB_NODE *dbArgs, int argc, char **argv) {
GWEN_DB_NODE *db;
const char *aname;
GWEN_SAR *sr;
int rv;
int recursive;
int verbosity;
const GWEN_ARGS args[]={
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"archive", /* name */
1, /* minnum */
1, /* maxnum */
"a", /* short option */
"archive", /* long option */
"Specify the archive file name", /* short description */
"Specify the archive file name" /* long description */
},
{
0, /* flags */
GWEN_ArgsType_Int, /* type */
"recursive", /* name */
0, /* minnum */
1, /* maxnum */
"r", /* short option */
"recursive", /* long option */
"add folders recursively", /* short description */
"add folders recursively" /* long description */
},
{
0, /* flags */
GWEN_ArgsType_Int, /* type */
"verbosity", /* name */
0, /* minnum */
10, /* maxnum */
"v", /* short option */
NULL, /* long option */
"set verbosity", /* short description */
"set verbosity" /* 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,
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;
}
aname=GWEN_DB_GetCharValue(db, "archive", 0, NULL);
assert(aname);
recursive=GWEN_DB_GetIntValue(db, "recursive", 0, 0);
verbosity=GWEN_DB_GetIntValue(db, "verbosity", 0, 0);
sr=GWEN_Sar_new();
rv=GWEN_Sar_OpenArchive(sr, aname,
GWEN_SyncIo_File_CreationMode_OpenExisting,
GWEN_SYNCIO_FILE_FLAGS_READ|GWEN_SYNCIO_FILE_FLAGS_WRITE);
if (rv<0) {
fprintf(stderr, "ERROR: Error opening archive (%d)\n", rv);
return 2;
}
else {
int i;
GWEN_STRINGLIST *sl;
GWEN_STRINGLISTENTRY *se;
sl=GWEN_StringList_new();
for (i=0; ; i++) {
const char *fname;
fname=GWEN_DB_GetCharValue(db, "params", i, 0);
if (fname && *fname) {
rv=addToList(fname, recursive, sl);
if (rv<0) {
fprintf(stderr, "ERROR: Error adding entry \"%s\" to archive \"%s\" (%d)\n",
fname, aname, rv);
GWEN_StringList_free(sl);
return 2;
}
}
else
break;
}
se=GWEN_StringList_FirstEntry(sl);
while(se) {
const char *s;
s=GWEN_StringListEntry_Data(se);
if (s && *s) {
rv=GWEN_Sar_AddFile(sr, s);
if (rv<0) {
fprintf(stderr, "ERROR: Error adding file \"%s\" to archive \"%s\" (%d)\n",
s, aname, rv);
GWEN_Sar_CloseArchive(sr, 1);
GWEN_Sar_free(sr);
return 2;
}
if (verbosity>0) {
fprintf(stdout, "added \"%s\"\n", s);
}
}
se=GWEN_StringListEntry_Next(se);
} /* while se */
GWEN_StringList_free(sl);
rv=GWEN_Sar_CloseArchive(sr, 0);
if (rv<0) {
fprintf(stderr, "ERROR: Error closing archive (%d)\n", rv);
return 2;
}
return 0;
}
}
int AHB_DTAUS__CreateSetC(GWEN_BUFFER *dst,
GWEN_DB_NODE *cfg,
GWEN_DB_NODE *xa,
AB_VALUE *sumEUR,
AB_VALUE *sumDEM,
AB_VALUE *sumBankCodes,
AB_VALUE *sumAccountIds){
unsigned int i;
const char *p;
char buffer[32];
int isDebitNote;
int isEuro;
unsigned int extSets;
//unsigned int startPos;
AB_VALUE *val;
GWEN_STRINGLIST *purposeList;
DBG_DEBUG(AQBANKING_LOGDOMAIN, "Creating C set");
/* ______________________________________________________________________
* preparations
*/
purposeList=GWEN_StringList_new();
/* cut purpose lines into manageable portions (max 27 chars) */
for (i=0; ; i++) {
int slen;
GWEN_BUFFER *nbuf;
p=GWEN_DB_GetCharValue(xa, "purpose", i, 0);
if (p==NULL)
break;
if (i>14) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Too many purpose lines (maxmimum is 14)");
GWEN_StringList_free(purposeList);
return -1;
}
slen=strlen(p);
nbuf=GWEN_Buffer_new(0, slen+1, 0, 1);
AB_ImExporter_Utf8ToDta(p, -1, nbuf);
p=GWEN_Buffer_GetStart(nbuf);
while(*p) {
while(*p>0 && *p<33)
p++;
slen=strlen(p);
if (slen==0)
break;
else if (slen>27) {
char *ns;
ns=(char*) malloc(28);
assert(ns);
memmove(ns, p, 27);
ns[27]=0;
/* let stringlist take over ownership of the the string */
GWEN_StringList_AppendString(purposeList, ns, 1, 0);
p+=27;
}
else {
GWEN_StringList_AppendString(purposeList, p, 0, 0);
break;
}
}
GWEN_Buffer_free(nbuf);
} /* for */
//startPos=GWEN_Buffer_GetPos(dst);
GWEN_Buffer_AllocRoom(dst, 256);
isDebitNote=(strcasecmp(GWEN_DB_GetCharValue(cfg, "type", 0, "transfer"),
"debitnote")==0);
isEuro=(strcasecmp(GWEN_DB_GetCharValue(cfg, "currency", 0, "EUR"),
"EUR")==0);
/* compute number of extension sets */
extSets=0;
/* add purpose */
if (GWEN_StringList_Count(purposeList))
extSets+=GWEN_StringList_Count(purposeList)-1;
/* add name */
for (i=1; i<2; i++) { /* max 1 extset for local name */
if (GWEN_DB_GetCharValue(xa, "localName", i, 0)==0)
break;
if (i>1) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Too many name lines (maxmimum is 2)");
GWEN_StringList_free(purposeList);
return -1;
}
extSets++;
} /* for */
/* add other name */
for (i=1; i<2; i++) { /* max 1 extset for remote name */
if (GWEN_DB_GetCharValue(xa, "remoteName", i, 0)==0)
break;
if (i>1) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Too many peer name lines (maxmimum is 2)");
GWEN_StringList_free(purposeList);
return -1;
}
extSets++;
} /* for */
/* check number of extension sets */
if (extSets>15) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Too many extension sets (%d)", extSets);
GWEN_StringList_free(purposeList);
return -1;
}
/* ______________________________________________________________________
* actually write C set
*/
/* field 1, 2: record header */
snprintf(buffer, sizeof(buffer), "%04d", 187+(extSets*29));
GWEN_Buffer_AppendString(dst, buffer);
GWEN_Buffer_AppendByte(dst, 'C');
/* field 3: acting bank code */
if (AHB_DTAUS__AddNum(dst, 8, GWEN_DB_GetCharValue(cfg, "bankCode", 0, ""))) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
/* field 4: destination bank code */
p=GWEN_DB_GetCharValue(xa, "remoteBankCode", 0, 0);
if (p) {
val=AB_Value_fromString(p);
if (val==NULL) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Bad bank code");
GWEN_StringList_free(purposeList);
return -1;
}
AB_Value_AddValue(sumBankCodes, val);
AB_Value_free(val);
if (AHB_DTAUS__AddNum(dst, 8, p)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
}
else {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Peer bank code missing");
GWEN_StringList_free(purposeList);
return -1;
}
/* field 5: destination account id */
p=GWEN_DB_GetCharValue(xa, "remoteAccountNumber", 0, 0);
if (p) {
val=AB_Value_fromString(p);
if (val==NULL) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Bad account id");
GWEN_StringList_free(purposeList);
return -1;
}
AB_Value_AddValue(sumAccountIds, val);
AB_Value_free(val);
if (AHB_DTAUS__AddNum(dst, 10, p)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
}
else {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Peer account id missing");
GWEN_StringList_free(purposeList);
return -1;
}
/* field 6: internal customer number (0s for now) */
for (i=0; i<13; i++) GWEN_Buffer_AppendByte(dst, '0');
/* field 7a: text key */
snprintf(buffer, sizeof(buffer), "%02d", GWEN_DB_GetIntValue(xa, "textkey", 0, isDebitNote?5:51));
if (AHB_DTAUS__AddNum(dst, 2, buffer)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
/* field 7b: text key extension */
snprintf(buffer, sizeof(buffer), "%03d", GWEN_DB_GetIntValue(xa, "textkeyext", 0, 0));
if (AHB_DTAUS__AddNum(dst, 3, buffer)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
/* field 8: bank internal field */
GWEN_Buffer_AppendByte(dst, ' ');
/* field 9: value in DEM */
if (!isEuro) {
val=AB_Value_fromString(GWEN_DB_GetCharValue(xa, "value/value", 0, "0,0"));
if (val==NULL || AB_Value_IsZero(val)) {
AB_Value_free(val);
DBG_ERROR(AQBANKING_LOGDOMAIN, "Bad DEM value:");
GWEN_StringList_free(purposeList);
return -1;
}
AB_Value_AddValue(sumDEM, val);
snprintf(buffer, sizeof(buffer), "%011.0f", AB_Value_GetValueAsDouble(val)*100.0);
AB_Value_free(val);
if (AHB_DTAUS__AddNum(dst, 11, buffer)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
}
else {
if (AHB_DTAUS__AddNum(dst, 11, "0")) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
}
/* field 10: local bank code */
p=GWEN_DB_GetCharValue(xa, "localbankCode", 0, 0);
if (!p)
p=GWEN_DB_GetCharValue(cfg, "bankCode", 0, 0);
if (!p) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "No local bank code");
GWEN_StringList_free(purposeList);
return -1;
}
if (AHB_DTAUS__AddNum(dst, 8, p)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
/* field 11: local account id */
p=GWEN_DB_GetCharValue(xa, "localAccountNumber", 0, 0);
if (!p)
GWEN_DB_GetCharValue(cfg, "accountId", 0, 0);
if (!p) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "No local account number");
GWEN_StringList_free(purposeList);
return -1;
}
if (AHB_DTAUS__AddNum(dst, 10, p)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
/* field 12: value in EUR */
if (isEuro) {
val=AB_Value_fromString(GWEN_DB_GetCharValue(xa, "value/value", 0, "0,0"));
if (val==NULL || AB_Value_IsZero(val)) {
AB_Value_free(val);
DBG_ERROR(AQBANKING_LOGDOMAIN, "Bad EUR value:");
GWEN_StringList_free(purposeList);
return -1;
}
AB_Value_AddValue(sumEUR, val);
snprintf(buffer, sizeof(buffer), "%011.0f", AB_Value_GetValueAsDouble(val)*100.0);
AB_Value_free(val);
if (AHB_DTAUS__AddNum(dst, 11, buffer)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
}
else {
if (AHB_DTAUS__AddNum(dst, 11, "0")) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
}
/* field 13: blanks */
for (i=0; i<3; i++) GWEN_Buffer_AppendByte(dst, ' ');
/* field 14a: peer name */
if (AHB_DTAUS__AddWord(dst, 27, GWEN_DB_GetCharValue(xa, "remoteName", 0, ""))) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
/* field 14b: blanks */
for (i=0; i<8; i++) GWEN_Buffer_AppendByte(dst, ' ');
/* field 15: name */
if (AHB_DTAUS__AddWord(dst, 27, GWEN_DB_GetCharValue(xa, "localname", 0, ""))) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
/* field 16: purpose */
p=GWEN_StringList_FirstString(purposeList);
if (p==NULL)
p="";
if (AHB_DTAUS__AddWord(dst, 27, p)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
/* field 17a: currency */
if (isEuro)
GWEN_Buffer_AppendByte(dst, '1');
else
GWEN_Buffer_AppendByte(dst, ' ');
/* field 17b: blanks */
for (i=0; i<2; i++) GWEN_Buffer_AppendByte(dst, ' ');
/* field 18: number of extension sets */
snprintf(buffer, sizeof(buffer), "%02d", extSets);
if (AHB_DTAUS__AddNum(dst, 2, buffer)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
if (extSets) {
unsigned int writtenExtSets=0;
/* now append extension sets */
/* add peer name lines */
for (i=1; i<2; i++) { /* max: 1 extset */
unsigned int j;
p=GWEN_DB_GetCharValue(xa, "remoteName", i, 0);
if (!p)
break;
/* append extension set */
GWEN_Buffer_AppendString(dst, "01");
if (AHB_DTAUS__AddWord(dst, 27, p)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
writtenExtSets++;
if (writtenExtSets==2)
/* 2 ext sets written, so we need to align "C 2.Satzabschnitt" to 128 now */
for (j=0; j<11; j++) GWEN_Buffer_AppendByte(dst, ' ');
else if (writtenExtSets>2 && ((writtenExtSets-2) % 4)==0)
/* "C 3-5.Satzabschnitt" complete, align to 128 bytes */
for (j=0; j<12; j++) GWEN_Buffer_AppendByte(dst, ' ');
} /* for */
/* add purpose lines */
for (i=1; i<GWEN_StringList_Count(purposeList); i++) {
unsigned int j;
p=GWEN_StringList_StringAt(purposeList, i);
if (!p)
break;
/* append extension set */
GWEN_Buffer_AppendString(dst, "02");
/* strings in the list are already in DTA charset */
if (AHB_DTAUS__AddDtaWord(dst, 27, p)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
writtenExtSets++;
if (writtenExtSets==2)
/* 2 ext sets written, so we need to align "C 2.Satzabschnitt" to 128 now */
for (j=0; j<11; j++) GWEN_Buffer_AppendByte(dst, ' ');
else if (writtenExtSets>2 && ((writtenExtSets-2) % 4)==0)
/* "C 3-5.Satzabschnitt" complete, align to 128 bytes */
for (j=0; j<12; j++) GWEN_Buffer_AppendByte(dst, ' ');
} /* for */
/* add name lines */
for (i=1; i<2; i++) { /* max: 1 extset */
unsigned int j;
p=GWEN_DB_GetCharValue(xa, "localname", i, 0);
if (!p)
break;
/* append extension set */
GWEN_Buffer_AppendString(dst, "03");
if (AHB_DTAUS__AddWord(dst, 27, p)) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error writing to buffer");
GWEN_StringList_free(purposeList);
return -1;
}
writtenExtSets++;
if (writtenExtSets==2)
/* 2 ext sets written, so we need to align "C 2.Satzabschnitt" to 128 now */
for (j=0; j<11; j++) GWEN_Buffer_AppendByte(dst, ' ');
else if (writtenExtSets>2 && ((writtenExtSets-2) % 4)==0)
/* "C 3-5.Satzabschnitt" complete, align to 128 bytes */
for (j=0; j<12; j++) GWEN_Buffer_AppendByte(dst, ' ');
} /* for */
}
i=((GWEN_Buffer_GetUsedBytes(dst)+127) & ~127)-GWEN_Buffer_GetUsedBytes(dst);
while(i--)
GWEN_Buffer_AppendByte(dst, ' ');
GWEN_StringList_free(purposeList);
return 0;
}
int LC_Client_InitCommon() {
if (lc_client__initcounter==0) {
int rv;
GWEN_STRINGLIST *paths;
rv=GWEN_Init();
if (rv) {
DBG_ERROR_ERR(LC_LOGDOMAIN, rv);
return rv;
}
if (!GWEN_Logger_IsOpen(LC_LOGDOMAIN)) {
const char *s;
/* only set our logger if it not already has been */
GWEN_Logger_Open(LC_LOGDOMAIN, "chipcard3-client", 0,
GWEN_LoggerType_Console,
GWEN_LoggerFacility_User);
GWEN_Logger_SetLevel(LC_LOGDOMAIN, GWEN_LoggerLevel_Warning);
s=getenv("LC_LOGLEVEL");
if (s) {
GWEN_LOGGER_LEVEL ll;
ll=GWEN_Logger_Name2Level(s);
if (ll!=GWEN_LoggerLevel_Unknown) {
GWEN_Logger_SetLevel(LC_LOGDOMAIN, ll);
DBG_WARN(LC_LOGDOMAIN,
"Overriding loglevel for Libchipcard-Client with \"%s\"",
s);
}
else {
DBG_ERROR(0, "Unknown loglevel \"%s\"", s);
}
}
else {
GWEN_Logger_SetLevel(LC_LOGDOMAIN, GWEN_LoggerLevel_Warning);
}
}
/* define sysconf path */
GWEN_PathManager_DefinePath(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR);
#if defined(OS_WIN32) || defined(ENABLE_LOCAL_INSTALL)
/* add folder relative to EXE */
GWEN_PathManager_AddRelPath(LCC_PM_LIBNAME,
LCC_PM_LIBNAME,
LCC_PM_SYSCONFDIR,
LC_CLIENT_CONFIG_DIR,
GWEN_PathManager_RelModeExe);
#else
/* add absolute folder */
GWEN_PathManager_AddPath(LCC_PM_LIBNAME,
LCC_PM_LIBNAME,
LCC_PM_SYSCONFDIR,
LC_CLIENT_CONFIG_DIR);
#endif
/* define data path */
GWEN_PathManager_DefinePath(LCC_PM_LIBNAME, LCC_PM_DATADIR);
#if defined(OS_WIN32) || defined(ENABLE_LOCAL_INSTALL)
/* add folder relative to EXE */
GWEN_PathManager_AddRelPath(LCC_PM_LIBNAME,
LCC_PM_LIBNAME,
LCC_PM_DATADIR,
LC_CLIENT_XML_DIR,
GWEN_PathManager_RelModeExe);
#else
/* add absolute folder */
GWEN_PathManager_AddPath(LCC_PM_LIBNAME,
LCC_PM_LIBNAME,
LCC_PM_DATADIR,
LC_CLIENT_XML_DIR);
#endif
/* load configuration file */
#if 0
paths=GWEN_PathManager_GetPaths(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR);
if (paths) {
GWEN_DB_NODE *db;
GWEN_BUFFER *fbuf;
db=GWEN_DB_Group_new("config");
fbuf=GWEN_Buffer_new(0, 256, 0, 1);
rv=GWEN_Directory_FindFileInPaths(paths,
LC_CLIENT_CONFIG_FILE,
fbuf);
if (rv) {
DBG_INFO(LC_LOGDOMAIN,
"Trying config file with suffix \".default\"");
rv=GWEN_Directory_FindFileInPaths(paths,
LC_CLIENT_CONFIG_FILE".default",
fbuf);
}
GWEN_StringList_free(paths);
if (rv) {
DBG_WARN(LC_LOGDOMAIN,
"No configuration file found, using defaults");
}
else {
DBG_INFO(LC_LOGDOMAIN,
"Reading configuration file \"%s\"",
GWEN_Buffer_GetStart(fbuf));
rv=GWEN_DB_ReadFile(db, GWEN_Buffer_GetStart(fbuf),
GWEN_DB_FLAGS_DEFAULT |
GWEN_PATH_FLAGS_CREATE_GROUP);
if (rv<0) {
DBG_ERROR(LC_LOGDOMAIN,
"Error in configuration file \"%s\" (%d)",
GWEN_Buffer_GetStart(fbuf), rv);
GWEN_Buffer_free(fbuf);
/* undo all init stuff so far */
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_DATADIR);
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR);
return rv;
}
}
GWEN_Buffer_free(fbuf);
lc_client__config=db;
}
else {
DBG_ERROR(LC_LOGDOMAIN, "Internal error: Paths not found");
return GWEN_ERROR_INTERNAL;
}
#else
lc_client__config=GWEN_DB_Group_new("config");
#endif
/* load XML files */
paths=GWEN_PathManager_GetPaths(LCC_PM_LIBNAME, LCC_PM_DATADIR);
if (paths) {
GWEN_XMLNODE *n;
GWEN_DB_NODE *db;
GWEN_BUFFER *fbuf;
uint32_t bpos;
fbuf=GWEN_Buffer_new(0, 256, 0, 1);
rv=GWEN_Directory_FindPathForFile(paths,
"cards/README",
fbuf);
GWEN_StringList_free(paths);
if (rv) {
DBG_ERROR(LC_LOGDOMAIN, "Data files not found (%d)", rv);
/* undo all init stuff so far */
GWEN_Buffer_free(fbuf);
GWEN_DB_Group_free(lc_client__config);
lc_client__config=NULL;
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_DATADIR);
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR);
return rv;
}
/* load card files */
n=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "cards");
if (LC_Client_ReadXmlFiles(n,
GWEN_Buffer_GetStart(fbuf),
"cards", "card")) {
DBG_ERROR(LC_LOGDOMAIN, "Could not read card files");
GWEN_XMLNode_free(n);
/* undo all init stuff so far */
GWEN_Buffer_free(fbuf);
GWEN_DB_Group_free(lc_client__config);
lc_client__config=NULL;
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_DATADIR);
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR);
return GWEN_ERROR_GENERIC;
}
lc_client__card_nodes=n;
/* load app files */
n=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "apps");
if (LC_Client_ReadXmlFiles(n,
GWEN_Buffer_GetStart(fbuf),
"apps", "app")) {
DBG_ERROR(LC_LOGDOMAIN, "Could not read app files");
GWEN_XMLNode_free(n);
/* undo all init stuff so far */
GWEN_XMLNode_free(lc_client__card_nodes);
lc_client__card_nodes=NULL;
GWEN_Buffer_free(fbuf);
GWEN_DB_Group_free(lc_client__config);
lc_client__config=NULL;
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_DATADIR);
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR);
return GWEN_ERROR_GENERIC;
}
lc_client__app_nodes=n;
/*GWEN_XMLNode_WriteFile(n, "/tmp/apps", GWEN_XML_FLAGS_DEFAULT);*/
/* load driver files (if any) */
bpos=GWEN_Buffer_GetPos(fbuf);
GWEN_Buffer_AppendString(fbuf, DIRSEP "drivers");
db=GWEN_DB_Group_new("drivers");
rv=LC_DriverInfo_ReadDrivers(GWEN_Buffer_GetStart(fbuf), db, 0, 1);
if (rv) {
DBG_INFO(LC_LOGDOMAIN, "here (%d)", rv);
GWEN_DB_Group_free(db);
/* undo all init stuff so far */
GWEN_XMLNode_free(lc_client__app_nodes);
lc_client__app_nodes=NULL;
GWEN_XMLNode_free(lc_client__card_nodes);
lc_client__card_nodes=NULL;
GWEN_Buffer_free(fbuf);
GWEN_DB_Group_free(lc_client__config);
lc_client__config=NULL;
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_DATADIR);
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR);
return rv;
}
lc_client__driver_db=db;
GWEN_Buffer_Crop(fbuf, 0, bpos);
/* insert more loading here */
GWEN_Buffer_free(fbuf);
}
else {
DBG_ERROR(LC_LOGDOMAIN, "No data files found.");
/* undo all init stuff so far */
GWEN_DB_Group_free(lc_client__config);
lc_client__config=NULL;
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_DATADIR);
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR);
return GWEN_ERROR_GENERIC;
}
}
lc_client__initcounter++;
return 0;
}
FOX16_HtmlLabel::~FOX16_HtmlLabel() {
if (m_htmlCtx)
delete m_htmlCtx;
GWEN_StringList_free(m_mediaPaths);
}
int doBuildDefs(GWEN_DB_NODE *dbArgs, const char *fname) {
TYPEMAKER2_TYPEMANAGER *tym;
TYPEMAKER2_BUILDER *tb=NULL;
TYPEMAKER2_TYPE *ty;
GWEN_STRINGLIST *sl;
TYPEMAKER2_TYPE_LIST2 *tlist;
TYPEMAKER2_TYPE_LIST2_ITERATOR *it;
const char *s;
int i;
int rv;
tym=Typemaker2_TypeManager_new();
s=GWEN_DB_GetCharValue(dbArgs, "api", 0, NULL);
if (s && *s)
Typemaker2_TypeManager_SetApiDeclaration(tym, s);
s=GWEN_DB_GetCharValue(dbArgs, "language", 0, "c");
if (s && *s) {
Typemaker2_TypeManager_SetLanguage(tym, s);
if (strcasecmp(s, "c")==0) {
tb=Typemaker2_Builder_C_new();
Typemaker2_Builder_SetTypeManager(tb, tym);
}
else {
DBG_ERROR(GWEN_LOGDOMAIN, "Unsupported language [%s]", s);
return 1;
}
}
else {
DBG_ERROR(GWEN_LOGDOMAIN, "Missing language specification");
return 1;
}
Typemaker2_Builder_SetSourceFileName(tb, fname);
for (i=0; i<99; i++) {
s=GWEN_DB_GetCharValue(dbArgs, "include", i, NULL);
if (s && *s)
Typemaker2_TypeManager_AddFolder(tym, s);
else
break;
}
sl=GWEN_PathManager_GetPaths(GWEN_PM_LIBNAME, GWEN_PM_DATADIR);
if (sl) {
GWEN_STRINGLISTENTRY *se;
se=GWEN_StringList_FirstEntry(sl);
while(se) {
s=GWEN_StringListEntry_Data(se);
if (s) {
GWEN_BUFFER *xbuf;
xbuf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendString(xbuf, s);
GWEN_Buffer_AppendString(xbuf, "/typemaker2/");
s=Typemaker2_TypeManager_GetLanguage(tym);
if (s && *s)
GWEN_Buffer_AppendString(xbuf, s);
Typemaker2_TypeManager_AddFolder(tym, GWEN_Buffer_GetStart(xbuf));
GWEN_Buffer_free(xbuf);
}
se=GWEN_StringListEntry_Next(se);
}
GWEN_StringList_free(sl);
}
tlist=Typemaker2_Type_List2_new();
rv=Typemaker2_TypeManager_LoadTypeFileNoLookup(tym, fname, tlist);
if (rv<0) {
DBG_ERROR(GWEN_LOGDOMAIN, "Unable to load file [%s] (%d)", fname, rv);
return 2;
}
it=Typemaker2_Type_List2_First(tlist);
if(it) {
ty=Typemaker2_Type_List2Iterator_Data(it);
while(ty) {
/* DEBUG */
#if 0
Typemaker2_TypeManager_Dump(tym, stderr, 2);
#endif
/* only write typedef files */
rv=Typemaker2_Builder_WriteFiles(tb, ty, 1);
if (rv<0) {
DBG_ERROR(GWEN_LOGDOMAIN, "here (%d)", rv);
return 2;
}
/* handle next type */
ty=Typemaker2_Type_List2Iterator_Next(it);
}
Typemaker2_Type_List2Iterator_free(it);
}
Typemaker2_Type_List2_free(tlist);
return 0;
}
int GWEN_Directory_GetMatchingFilesRecursively(const char *folder,
GWEN_STRINGLIST *sl,
const char *mask) {
GWEN_DIRECTORY *d;
int rv;
char buffer[256];
GWEN_BUFFER *pbuf;
uint32_t pos;
GWEN_STRINGLIST *folderList;
folderList=GWEN_StringList_new();
d=GWEN_Directory_new();
rv=GWEN_Directory_Open(d, folder);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Directory_free(d);
GWEN_StringList_free(folderList);
return rv;
}
pbuf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendString(pbuf, folder);
GWEN_Buffer_AppendString(pbuf, GWEN_DIR_SEPARATOR_S);
pos=GWEN_Buffer_GetPos(pbuf);
while(0==GWEN_Directory_Read(d, buffer, sizeof(buffer)-2)) {
if (strcmp(buffer, ".")!=0 &&
strcmp(buffer, "..")!=0) {
struct stat st;
GWEN_Buffer_AppendString(pbuf, buffer);
if (stat(GWEN_Buffer_GetStart(pbuf), &st)==0) {
if (S_ISDIR(st.st_mode))
/* add folders to the folder list */
GWEN_StringList_AppendString(folderList, GWEN_Buffer_GetStart(pbuf), 0, 0);
else {
if (mask==NULL || GWEN_Text_ComparePattern(buffer, mask, 0)!=-1)
/* don't check for duplicates here (i.e. last param =0) */
GWEN_StringList_AppendString(sl, GWEN_Buffer_GetStart(pbuf), 0, 0);
}
}
GWEN_Buffer_Crop(pbuf, 0, pos);
}
}
GWEN_Directory_Close(d);
GWEN_Directory_free(d);
if (GWEN_StringList_Count(folderList)) {
GWEN_STRINGLISTENTRY *se;
se=GWEN_StringList_FirstEntry(folderList);
while(se) {
const char *s;
s=GWEN_StringListEntry_Data(se);
if (s && *s)
GWEN_Directory_GetMatchingFilesRecursively(s, sl, mask);
se=GWEN_StringListEntry_Next(se);
}
}
GWEN_StringList_free(folderList);
GWEN_Buffer_free(pbuf);
return 0;
}
int APY_Provider_Init(AB_PROVIDER *pro, GWEN_DB_NODE *dbData)
{
APY_PROVIDER *dp;
const char *logLevelName;
uint32_t currentVersion;
uint32_t lastVersion;
assert(pro);
dp=GWEN_INHERIT_GETDATA(AB_PROVIDER, APY_PROVIDER, pro);
assert(dp);
if (!GWEN_Logger_IsOpen(AQPAYPAL_LOGDOMAIN)) {
GWEN_Logger_Open(AQPAYPAL_LOGDOMAIN,
"aqpaypal", 0,
GWEN_LoggerType_Console,
GWEN_LoggerFacility_User);
}
logLevelName=getenv("AQPAYPAL_LOGLEVEL");
if (logLevelName) {
GWEN_LOGGER_LEVEL ll;
ll=GWEN_Logger_Name2Level(logLevelName);
if (ll!=GWEN_LoggerLevel_Unknown) {
GWEN_Logger_SetLevel(AQPAYPAL_LOGDOMAIN, ll);
DBG_WARN(AQPAYPAL_LOGDOMAIN, "Overriding loglevel for AqPAYPAL with \"%s\"", logLevelName);
}
else {
DBG_ERROR(AQPAYPAL_LOGDOMAIN, "Unknown loglevel \"%s\"", logLevelName);
}
}
/* check whether we need to update */
currentVersion=
(AQBANKING_VERSION_MAJOR<<24) |
(AQBANKING_VERSION_MINOR<<16) |
(AQBANKING_VERSION_PATCHLEVEL<<8) |
AQBANKING_VERSION_BUILD;
lastVersion=GWEN_DB_GetIntValue(dbData, "lastVersion", 0, 0);
if (lastVersion<currentVersion) {
int rv;
DBG_WARN(AQPAYPAL_LOGDOMAIN, "Updating configuration for AqPaypal (before init)");
rv=APY_Provider_UpdatePreInit(pro, lastVersion, currentVersion);
if (rv<0) {
DBG_INFO(AQPAYPAL_LOGDOMAIN, "here (%d)", rv);
return rv;
}
}
/* do some init (currently: none needed) */
/* update post-init */
if (lastVersion<currentVersion) {
int rv;
DBG_WARN(AQPAYPAL_LOGDOMAIN, "Updating configuration for AqPaypal (after init)");
rv=APY_Provider_UpdatePostInit(pro, lastVersion, currentVersion);
if (rv<0) {
DBG_INFO(AQPAYPAL_LOGDOMAIN, "here (%d)", rv);
return rv;
}
}
if (1) {
GWEN_STRINGLIST *sl;
const char *localedir;
int rv;
sl=GWEN_PathManager_GetPaths(AB_PM_LIBNAME, AB_PM_LOCALEDIR);
localedir=GWEN_StringList_FirstString(sl);
rv=GWEN_I18N_BindTextDomain_Dir(PACKAGE, localedir);
if (rv) {
DBG_ERROR(AQPAYPAL_LOGDOMAIN, "Could not bind textdomain (%d)", rv);
}
else {
rv=GWEN_I18N_BindTextDomain_Codeset(PACKAGE, "UTF-8");
if (rv) {
DBG_ERROR(AQPAYPAL_LOGDOMAIN, "Could not set codeset (%d)", rv);
}
}
GWEN_StringList_free(sl);
}
DBG_NOTICE(AQPAYPAL_LOGDOMAIN, "Initializing AqPaypal backend");
return 0;
}
int AH_ImExporterOFX_Import(AB_IMEXPORTER *ie,
AB_IMEXPORTER_CONTEXT *ctx,
GWEN_IO_LAYER *io,
GWEN_DB_NODE *params,
uint32_t guiid)
{
AH_IMEXPORTER_OFX *ieh;
LibofxContextPtr ofxctx;
GWEN_BUFFER *dbuf;
int rv;
GWEN_STRINGLIST *paths;
assert(ie);
ieh=GWEN_INHERIT_GETDATA(AB_IMEXPORTER, AH_IMEXPORTER_OFX, ie);
assert(ieh);
ieh->context=ctx;
ofxctx=libofx_get_new_context();
ofx_set_account_cb(ofxctx,
AH_ImExporterOFX_AccountCallback_cb,
ieh);
ofx_set_transaction_cb(ofxctx,
AH_ImExporterOFX_TransactionCallback_cb,
ieh);
paths=AB_Banking_GetGlobalDataDirs();
if (paths) {
GWEN_BUFFER *fbuf;
int rv;
fbuf=GWEN_Buffer_new(0, 256, 0, 1);
rv=GWEN_Directory_FindPathForFile(paths,
"libofx"
DIRSEP
"dtd"
DIRSEP
"ofx150.dtd",
fbuf);
GWEN_StringList_free(paths);
if (rv==0) {
GWEN_Buffer_AppendString(fbuf,
DIRSEP
"libofx"
DIRSEP
"dtd"
DIRSEP);
#ifdef LIBOFX_GT_0_8_4
DBG_INFO(AQBANKING_LOGDOMAIN,
"Setting path for DTD files to [%s]",
GWEN_Buffer_GetStart(fbuf));
libofx_set_dtd_dir(ofxctx, GWEN_Buffer_GetStart(fbuf));
#else
DBG_INFO(AQBANKING_LOGDOMAIN,
"Cannot set path for DTD files to [%s]: libofx is 0.8.3 or older",
GWEN_Buffer_GetStart(fbuf));
#endif
}
GWEN_Buffer_free(fbuf);
}
/* read whole stream into buffer */
dbuf=GWEN_Buffer_new(0, 2048, 0, 1);
GWEN_Buffer_SetStep(dbuf, 4096);
rv=GWEN_Io_Layer_ReadToBufferUntilEof(io, dbuf, guiid, 2000);
if (rv<0) {
DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(dbuf);
libofx_free_context(ofxctx);
return rv;
}
/* setup debugging parameters */
extern int ofx_PARSER_msg;
extern int ofx_DEBUG_msg;
extern int ofx_WARNING_msg;
extern int ofx_ERROR_msg;
extern int ofx_INFO_msg;
extern int ofx_STATUS_msg;
ofx_PARSER_msg=GWEN_DB_GetIntValue(params, "show_parser_msg", 0, 0);
ofx_DEBUG_msg=GWEN_DB_GetIntValue(params, "show_debug_msg", 0, 0);
ofx_WARNING_msg=GWEN_DB_GetIntValue(params, "show_warning_msg", 0, 1);
ofx_ERROR_msg=GWEN_DB_GetIntValue(params, "show_error_msg", 0, 1);
ofx_INFO_msg=GWEN_DB_GetIntValue(params, "show_info_msg", 0, 1);
ofx_STATUS_msg=GWEN_DB_GetIntValue(params, "show_status_msg", 0, 1);
/* now the buffer contains all the data */
rv=libofx_proc_buffer(ofxctx,
GWEN_Buffer_GetStart(dbuf),
GWEN_Buffer_GetUsedBytes(dbuf));
DBG_ERROR(0, "I'm back");
GWEN_Buffer_free(dbuf);
libofx_free_context(ofxctx);
ieh->context=0;
if (rv)
return GWEN_ERROR_BAD_DATA;
DBG_ERROR(0, "Returning");
return 0;
}
int main(int argc, char **argv) {
GWEN_DB_NODE *db;
const char *cmd;
int rv;
int err;
GWEN_GUI *gui;
const char *localedir;
GWEN_STRINGLIST *slist;
const GWEN_ARGS args[]={
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"cfgfile", /* name */
0, /* minnum */
1, /* maxnum */
"C", /* short option */
"cfgfile", /* long option */
"Specify the configuration file", /* short description */
"Specify the configuration file" /* long description */
},
{
0, /* flags */
GWEN_ArgsType_Int, /* type */
"forcePin", /* name */
0, /* minnum */
1, /* maxnum */
0, /* short option */
"forcepin", /* long option */
"force pin entry", /* short description */
"force pin entry even if the error counter is not zero"
},
{
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 */
}
};
err=GWEN_Init();
if (err) {
fprintf(stderr, "Could not initialize Gwenhywfar.\n");
return 2;
}
gui=GWEN_Gui_CGui_new();
GWEN_Gui_SetGui(gui);
slist =
GWEN_PathManager_GetPaths(GWEN_PM_LIBNAME, GWEN_PM_LOCALEDIR);
assert(GWEN_StringList_Count(slist) > 0);
localedir = GWEN_StringList_FirstString(slist);
#ifdef HAVE_I18N
setlocale(LC_ALL,"");
if (bindtextdomain(PACKAGE, localedir)==0)
fprintf(stderr, "Error binding locale\n");
#endif
GWEN_StringList_free(slist);
GWEN_Logger_Open(GCT_LOGDOMAIN, "gct-tool", 0,
GWEN_LoggerType_Console,
GWEN_LoggerFacility_User);
#ifdef DEBUG_GCT_TOOL
GWEN_Logger_SetLevel(GCT_LOGDOMAIN, GWEN_LoggerLevel_Info);
GWEN_Logger_SetLevel(GWEN_LOGDOMAIN, GWEN_LoggerLevel_Debug);
GWEN_Logger_SetLevel(0, GWEN_LoggerLevel_Info);
#else
GWEN_Logger_SetLevel(GCT_LOGDOMAIN, GWEN_LoggerLevel_Warning);
GWEN_Logger_SetLevel(GWEN_LOGDOMAIN, GWEN_LoggerLevel_Warning);
GWEN_Logger_SetLevel(0, GWEN_LoggerLevel_Warning);
#endif
#ifdef GCT_IS_EXPERIMENTAL
fprintf(stderr, "\n");
fprintf(stderr, "\n");
fprintf(stderr, "=================== WARNING ===================\n");
fprintf(stderr, "This tool is still EXPERIMENTAL !!!\n");
fprintf(stderr, "Please DON'T USE it with your daily key files !\n");
fprintf(stderr, "===============================================\n");
fprintf(stderr, "\n");
fprintf(stderr, "\n");
#endif
db=GWEN_DB_Group_new("arguments");
rv=GWEN_Args_Check(argc, argv, 1,
GWEN_ARGS_MODE_ALLOW_FREEPARAM |
GWEN_ARGS_MODE_STOP_AT_FREEPARAM,
args,
db);
if (rv==GWEN_ARGS_RESULT_ERROR) {
fprintf(stderr, "ERROR: Could not parse arguments main\n");
return -1;
}
else if (rv==GWEN_ARGS_RESULT_HELP) {
GWEN_BUFFER *ubuf;
ubuf=GWEN_Buffer_new(0, 1024, 0, 1);
GWEN_Buffer_AppendString(ubuf,
I18N("Usage: "));
GWEN_Buffer_AppendString(ubuf, argv[0]);
GWEN_Buffer_AppendString(ubuf,
I18N(" [GLOBAL OPTIONS] COMMAND "
"[LOCAL OPTIONS]\n"));
GWEN_Buffer_AppendString(ubuf,
I18N("\nGlobal Options:\n"));
if (GWEN_Args_Usage(args, ubuf, GWEN_ArgsOutType_Txt)) {
fprintf(stderr, "ERROR: Could not create help string\n");
return 1;
}
GWEN_Buffer_AppendString(ubuf,
I18N("\nCommands:\n\n"));
GWEN_Buffer_AppendString(ubuf,
I18N(" create:\n"
" This command creates a crypt token"
"\n\n"));
GWEN_Buffer_AppendString(ubuf,
I18N(" showuser:\n"
" Display user data stored on the "
"token\n\n"));
fprintf(stderr, "%s\n", GWEN_Buffer_GetStart(ubuf));
GWEN_Buffer_free(ubuf);
return 0;
}
if (rv) {
argc-=rv-1;
argv+=rv-1;
}
cmd=GWEN_DB_GetCharValue(db, "params", 0, 0);
if (!cmd) {
fprintf(stderr, "ERROR: Command needed.\n");
return 1;
}
if (strcasecmp(cmd, "sign1")==0) {
rv=signWithOld(db, argc, argv);
}
else if (strcasecmp(cmd, "sign2")==0) {
rv=signWithNew(db, argc, argv);
}
else if (strcasecmp(cmd, "crypt1")==0) {
rv=cryptWithOld(db, argc, argv);
}
else if (strcasecmp(cmd, "crypt2")==0) {
rv=cryptWithNew(db, argc, argv);
}
else if (strcasecmp(cmd, "crypt3")==0) {
rv=cryptWithNew2(db, argc, argv);
}
else {
fprintf(stderr, "ERROR: Unknown command \"%s\".\n", cmd);
rv=1;
}
err=GWEN_Fini();
if (err) {
fprintf(stderr,
"WARNING: Could not deinitialize Gwenhywfar.\n");
}
return rv;
}
int AB_Banking_LoadAllUsers(AB_BANKING *ab) {
GWEN_STRINGLIST *sl;
int rv;
sl=GWEN_StringList_new();
rv=GWEN_ConfigMgr_ListSubGroups(ab->configMgr, AB_CFG_GROUP_USERS, sl);
if (rv<0) {
DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d)", rv);
GWEN_StringList_free(sl);
return rv;
}
if (GWEN_StringList_Count(sl)) {
GWEN_STRINGLISTENTRY *se;
se=GWEN_StringList_FirstEntry(sl);
while(se) {
const char *t;
GWEN_DB_NODE *db=NULL;
t=GWEN_StringListEntry_Data(se);
assert(t);
rv=GWEN_ConfigMgr_GetGroup(ab->configMgr, AB_CFG_GROUP_USERS, t, &db);
if (rv<0) {
DBG_WARN(AQBANKING_LOGDOMAIN,
"Could not load user group [%s] (%d), ignoring",
t, rv);
}
else {
AB_USER *u=NULL;
uint32_t uid;
assert(db);
uid=GWEN_DB_GetIntValue(db, "uniqueId", 0, 0);
if (uid)
u=AB_Banking_GetUser(ab, uid);
if (u) {
/* user already exists, reload existing user */
const char *s;
AB_PROVIDER *pro=NULL;
DBG_INFO(AQBANKING_LOGDOMAIN,
"Loading established user [%08x]",
(unsigned int) uid);
AB_User_SetDbId(u, t);
s=AB_User_GetBackendName(u);
if (s && *s)
pro=AB_Banking_GetProvider(ab, s);
if (!pro) {
DBG_WARN(AQBANKING_LOGDOMAIN,
"Provider \"%s\" not found, ignoring user [%s]",
s?s:"(null)", AB_User_GetUserId(u));
}
else {
int rv;
GWEN_DB_NODE *dbP;
/* reload user from DB */
AB_User_ReadDb(u, db);
/* let provider also reload user data */
dbP=GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_DEFAULT,
"data/backend");
rv=AB_Provider_ExtendUser(pro, u, AB_ProviderExtendMode_Reload, dbP);
if (rv<0) {
DBG_WARN(AQBANKING_LOGDOMAIN, "Could not extend user [%s] (%d)",
AB_User_GetUserId(u), rv);
}
}
}
else {
/* user is new, load and add it */
DBG_INFO(AQBANKING_LOGDOMAIN,
"Loading new user [%08x]",
(unsigned int) uid);
u=AB_User_fromDb(ab, db);
if (u) {
const char *s;
AB_PROVIDER *pro=NULL;
AB_User_SetDbId(u, t);
s=AB_User_GetBackendName(u);
if (s && *s)
pro=AB_Banking_GetProvider(ab, s);
if (!pro) {
DBG_WARN(AQBANKING_LOGDOMAIN,
"Provider \"%s\" not found, ignoring user [%s]",
s, AB_User_GetUserId(u));
}
else {
int rv;
GWEN_DB_NODE *dbP;
dbP=GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_DEFAULT,
"data/backend");
rv=AB_Provider_ExtendUser(pro, u, AB_ProviderExtendMode_Extend, dbP);
if (rv) {
DBG_INFO(AQBANKING_LOGDOMAIN, "here");
AB_User_free(u);
}
else {
DBG_DEBUG(AQBANKING_LOGDOMAIN, "Adding user");
AB_User_List_Add(u, ab->users);
}
}
}
else {
DBG_INFO(AQBANKING_LOGDOMAIN, "Could not load user from DB");
}
}
GWEN_DB_Group_free(db);
}
se=GWEN_StringListEntry_Next(se);
}
}
else {
DBG_INFO(AQBANKING_LOGDOMAIN, "No users");
}
GWEN_StringList_free(sl);
return 0;
}
static int addToList(const char *fname, int recursive, GWEN_STRINGLIST *sl) {
struct stat st;
int rv;
/* stat file to be added */
#if _BSD_SOURCE || _XOPEN_SOURCE >= 500 || _XOPEN_SOURCE && _XOPEN_SOURCE_EXTENDED
rv=lstat(fname, &st);
#else
rv=stat(fname, &st);
#endif
if (rv) {
DBG_ERROR(GSA_LOGDOMAIN, "stat(%s): %d (%s)",
fname, errno, strerror(errno));
fprintf(stderr, "Ignoring file \"%s\"\n", fname);
}
else {
/* always append this entry */
GWEN_StringList_AppendString(sl, fname, 0, 1);
if (recursive && S_ISDIR(st.st_mode)) {
GWEN_STRINGLIST *sll;
GWEN_STRINGLISTENTRY *se;
GWEN_DIRECTORY *d;
int rv;
char buffer[256];
GWEN_BUFFER *tbuf;
uint32_t pos;
/* add entries */
sll=GWEN_StringList_new();
d=GWEN_Directory_new();
rv=GWEN_Directory_Open(d, fname);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Directory_free(d);
GWEN_StringList_free(sll);
return rv;
}
while(0==GWEN_Directory_Read(d, buffer, sizeof(buffer))) {
if (strcmp(buffer, ".")!=0 &&
strcmp(buffer, "..")!=0)
GWEN_StringList_AppendString(sll, buffer, 0, 1);
}
GWEN_Directory_Close(d);
GWEN_Directory_free(d);
/* recurse */
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendString(tbuf, fname);
GWEN_Buffer_AppendString(tbuf, GWEN_DIR_SEPARATOR_S);
pos=GWEN_Buffer_GetPos(tbuf);
se=GWEN_StringList_FirstEntry(sll);
while(se) {
const char *s;
s=GWEN_StringListEntry_Data(se);
if (s && *s) {
GWEN_Buffer_AppendString(tbuf, s);
rv=addToList(GWEN_Buffer_GetStart(tbuf), recursive, sl);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
GWEN_StringList_free(sll);
return rv;
}
}
GWEN_Buffer_Crop(tbuf, 0, pos);
se=GWEN_StringListEntry_Next(se);
} /* while se */
GWEN_Buffer_free(tbuf);
GWEN_StringList_free(sll);
} /* if dir and recursive */
} /* if stat was ok */
return 0;
}
int AB_Banking_LoadAllAccounts(AB_BANKING *ab) {
GWEN_STRINGLIST *sl;
int rv;
sl=GWEN_StringList_new();
rv=GWEN_ConfigMgr_ListSubGroups(ab->configMgr, AB_CFG_GROUP_ACCOUNTS, sl);
if (rv<0) {
DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d)", rv);
GWEN_StringList_free(sl);
return rv;
}
if (GWEN_StringList_Count(sl)) {
GWEN_STRINGLISTENTRY *se;
se=GWEN_StringList_FirstEntry(sl);
while(se) {
const char *t;
GWEN_DB_NODE *db=NULL;
t=GWEN_StringListEntry_Data(se);
assert(t);
rv=GWEN_ConfigMgr_GetGroup(ab->configMgr, AB_CFG_GROUP_ACCOUNTS, t, &db);
if (rv<0) {
DBG_WARN(AQBANKING_LOGDOMAIN,
"Could not load account group [%s] (%d), ignoring",
t, rv);
}
else {
AB_ACCOUNT *a=NULL;
uint32_t uid;
assert(db);
uid=GWEN_DB_GetIntValue(db, "uniqueId", 0, 0);
if (uid)
a=AB_Banking_GetAccount(ab, uid);
if (a) {
/* account already exists, reload existing account */
const char *s;
AB_PROVIDER *pro;
AB_Account_SetDbId(a, t);
s=AB_Account_GetBackendName(a);
assert(s && *s);
pro=AB_Banking_GetProvider(ab, s);
if (!pro) {
DBG_WARN(AQBANKING_LOGDOMAIN,
"Provider \"%s\" not found, ignoring account [%s/%s]",
s,
AB_Account_GetBankCode(a),
AB_Account_GetAccountNumber(a));
}
else {
int rv;
GWEN_DB_NODE *dbP;
/* reload account from DB */
AB_Account_ReadDb(a, db);
/* let provider also reload account data */
dbP=GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_DEFAULT,
"data/backend");
rv=AB_Provider_ExtendAccount(pro, a, AB_ProviderExtendMode_Reload, dbP);
if (rv<0) {
DBG_WARN(AQBANKING_LOGDOMAIN, "Could not extend account [%s/%s] (%d)",
AB_Account_GetBankCode(a), AB_Account_GetAccountNumber(a), rv);
}
}
}
else {
/* account is new, load and add it */
a=AB_Account_fromDb(ab, db);
if (a) {
const char *s;
AB_PROVIDER *pro;
AB_Account_SetDbId(a, t);
s=AB_Account_GetBackendName(a);
assert(s && *s);
pro=AB_Banking_GetProvider(ab, s);
if (!pro) {
DBG_WARN(AQBANKING_LOGDOMAIN,
"Provider \"%s\" not found, ignoring account [%s/%s]",
s, AB_Account_GetBankCode(a), AB_Account_GetAccountNumber(a));
}
else {
int rv;
GWEN_DB_NODE *dbP;
dbP=GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_DEFAULT,
"data/backend");
rv=AB_Provider_ExtendAccount(pro, a, AB_ProviderExtendMode_Extend, dbP);
if (rv) {
DBG_INFO(AQBANKING_LOGDOMAIN, "here");
AB_Account_free(a);
}
else {
DBG_DEBUG(AQBANKING_LOGDOMAIN, "Adding account");
AB_Account_List_Add(a, ab->accounts);
}
}
}
}
GWEN_DB_Group_free(db);
}
se=GWEN_StringListEntry_Next(se);
}
}
GWEN_StringList_free(sl);
return 0;
}
AB_TRANSACTION_LIMITS *AB_TransactionLimits_dup(const AB_TRANSACTION_LIMITS *d) {
AB_TRANSACTION_LIMITS *st;
assert(d);
st=AB_TransactionLimits_new();
st->maxLenLocalName=d->maxLenLocalName;
st->minLenLocalName=d->minLenLocalName;
st->maxLenRemoteName=d->maxLenRemoteName;
st->minLenRemoteName=d->minLenRemoteName;
st->maxLinesRemoteName=d->maxLinesRemoteName;
st->minLinesRemoteName=d->minLinesRemoteName;
st->maxLenLocalBankCode=d->maxLenLocalBankCode;
st->minLenLocalBankCode=d->minLenLocalBankCode;
st->maxLenLocalAccountNumber=d->maxLenLocalAccountNumber;
st->minLenLocalAccountNumber=d->minLenLocalAccountNumber;
st->maxLenLocalSuffix=d->maxLenLocalSuffix;
st->minLenLocalSuffix=d->minLenLocalSuffix;
st->maxLenRemoteBankCode=d->maxLenRemoteBankCode;
st->minLenRemoteBankCode=d->minLenRemoteBankCode;
st->maxLenRemoteAccountNumber=d->maxLenRemoteAccountNumber;
st->minLenRemoteAccountNumber=d->minLenRemoteAccountNumber;
st->maxLenRemoteSuffix=d->maxLenRemoteSuffix;
st->minLenRemoteSuffix=d->minLenRemoteSuffix;
st->maxLenRemoteIban=d->maxLenRemoteIban;
st->minLenRemoteIban=d->minLenRemoteIban;
st->maxLenTextKey=d->maxLenTextKey;
st->minLenTextKey=d->minLenTextKey;
if (d->valuesTextKey) {
GWEN_StringList_free(st->valuesTextKey);
st->valuesTextKey=GWEN_StringList_dup(d->valuesTextKey);
}
if (d->textKeys) {
AB_TextKeyDescr_List_free(st->textKeys);
st->textKeys=AB_TextKeyDescr_List_dup(d->textKeys);
}
st->maxLenCustomerReference=d->maxLenCustomerReference;
st->minLenCustomerReference=d->minLenCustomerReference;
st->maxLenBankReference=d->maxLenBankReference;
st->minLenBankReference=d->minLenBankReference;
st->maxLenPurpose=d->maxLenPurpose;
st->minLenPurpose=d->minLenPurpose;
st->maxLinesPurpose=d->maxLinesPurpose;
st->minLinesPurpose=d->minLinesPurpose;
st->needDate=d->needDate;
st->minValueSetupTime=d->minValueSetupTime;
st->maxValueSetupTime=d->maxValueSetupTime;
st->minValueSetupTimeFirst=d->minValueSetupTimeFirst;
st->maxValueSetupTimeFirst=d->maxValueSetupTimeFirst;
st->minValueSetupTimeOnce=d->minValueSetupTimeOnce;
st->maxValueSetupTimeOnce=d->maxValueSetupTimeOnce;
st->minValueSetupTimeRecurring=d->minValueSetupTimeRecurring;
st->maxValueSetupTimeRecurring=d->maxValueSetupTimeRecurring;
st->minValueSetupTimeFinal=d->minValueSetupTimeFinal;
st->maxValueSetupTimeFinal=d->maxValueSetupTimeFinal;
if (d->valuesCycleWeek) {
GWEN_StringList_free(st->valuesCycleWeek);
st->valuesCycleWeek=GWEN_StringList_dup(d->valuesCycleWeek);
}
if (d->valuesCycleMonth) {
GWEN_StringList_free(st->valuesCycleMonth);
st->valuesCycleMonth=GWEN_StringList_dup(d->valuesCycleMonth);
}
if (d->valuesExecutionDayWeek) {
GWEN_StringList_free(st->valuesExecutionDayWeek);
st->valuesExecutionDayWeek=GWEN_StringList_dup(d->valuesExecutionDayWeek);
}
if (d->valuesExecutionDayMonth) {
GWEN_StringList_free(st->valuesExecutionDayMonth);
st->valuesExecutionDayMonth=GWEN_StringList_dup(d->valuesExecutionDayMonth);
}
st->allowMonthly=d->allowMonthly;
st->allowWeekly=d->allowWeekly;
st->allowChangeRecipientAccount=d->allowChangeRecipientAccount;
st->allowChangeRecipientName=d->allowChangeRecipientName;
st->allowChangeValue=d->allowChangeValue;
st->allowChangeTextKey=d->allowChangeTextKey;
st->allowChangePurpose=d->allowChangePurpose;
st->allowChangeFirstExecutionDate=d->allowChangeFirstExecutionDate;
st->allowChangeLastExecutionDate=d->allowChangeLastExecutionDate;
st->allowChangeCycle=d->allowChangeCycle;
st->allowChangePeriod=d->allowChangePeriod;
st->allowChangeExecutionDay=d->allowChangeExecutionDay;
return st;
}
int AB_Banking_HasConf4(AB_BANKING *ab) {
int rv;
GWEN_DB_NODE *db=NULL;
int backends=0;
int users=0;
int accounts=0;
GWEN_STRINGLIST *sl;
/* 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 correctly?");
return GWEN_ERROR_GENERIC;
}
/* load main group, check version */
rv=GWEN_ConfigMgr_GetGroup(ab->configMgr, AB_CFG_GROUP_MAIN, "config", &db);
if (rv<0) {
DBG_INFO(AQBANKING_LOGDOMAIN, "Could not load main config group (%d)", rv);
return rv;
}
GWEN_DB_Group_free(db);
sl=GWEN_StringList_new();
/* count backends */
rv=GWEN_ConfigMgr_ListSubGroups(ab->configMgr, AB_CFG_GROUP_BACKENDS, sl);
if (rv<0) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not list backend groups (%d)", rv);
GWEN_StringList_free(sl);
return rv;
}
backends=GWEN_StringList_Count(sl);
GWEN_StringList_Clear(sl);
/* count users */
rv=GWEN_ConfigMgr_ListSubGroups(ab->configMgr, AB_CFG_GROUP_USERS, sl);
if (rv<0) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not list user groups (%d)", rv);
GWEN_StringList_free(sl);
return rv;
}
users=GWEN_StringList_Count(sl);
GWEN_StringList_Clear(sl);
/* count accounts */
rv=GWEN_ConfigMgr_ListSubGroups(ab->configMgr, AB_CFG_GROUP_ACCOUNTS, sl);
if (rv<0) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not list account groups (%d)", rv);
GWEN_StringList_free(sl);
return rv;
}
accounts=GWEN_StringList_Count(sl);
GWEN_StringList_free(sl);
if (users)
return 0;
if (backends || accounts)
return GWEN_ERROR_PARTIAL;
return GWEN_ERROR_NO_DATA;
}
int AH_Job_GetTransactionsCreditCard_Process(AH_JOB *j, AB_IMEXPORTER_CONTEXT *ctx)
{
AH_JOB_GETTRANSACTIONS *aj;
AB_ACCOUNT *a;
AB_IMEXPORTER_ACCOUNTINFO *ai;
AB_USER *u;
GWEN_DB_NODE *dbResponses;
GWEN_DB_NODE *dbCurr;
GWEN_BUFFER *tbooked;
GWEN_BUFFER *tnoted;
int rv;
DBG_INFO(AQHBCI_LOGDOMAIN, "Processing JobGetTransactionsCreditCard");
assert(j);
aj=GWEN_INHERIT_GETDATA(AH_JOB, AH_JOB_GETTRANSACTIONS, j);
assert(aj);
tbooked=GWEN_Buffer_new(0, 1024, 0, 1);
tnoted=GWEN_Buffer_new(0, 1024, 0, 1);
dbResponses=AH_Job_GetResponses(j);
assert(dbResponses);
DBG_INFO(AQHBCI_LOGDOMAIN, "Response:");
GWEN_DB_Dump(dbResponses, 2);
DBG_INFO(AQHBCI_LOGDOMAIN, "Response end");
a=AH_AccountJob_GetAccount(j);
assert(a);
ai=AB_ImExporterContext_GetOrAddAccountInfo(ctx,
AB_Account_GetUniqueId(a),
AB_Account_GetIban(a),
AB_Account_GetBankCode(a),
AB_Account_GetAccountNumber(a),
AB_Account_GetAccountType(a));
assert(ai);
AB_ImExporterAccountInfo_SetAccountId(ai, AB_Account_GetUniqueId(a));
u=AH_Job_GetUser(j);
assert(u);
/* search for "Transactions" */
dbCurr=GWEN_DB_GetFirstGroup(dbResponses);
while (dbCurr) {
GWEN_DB_NODE *dbXA;
rv=AH_Job_CheckEncryption(j, dbCurr);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Compromised security (encryption)");
GWEN_Buffer_free(tbooked);
GWEN_Buffer_free(tnoted);
AH_Job_SetStatus(j, AH_JobStatusError);
return rv;
}
rv=AH_Job_CheckSignature(j, dbCurr);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Compromised security (signature)");
GWEN_Buffer_free(tbooked);
GWEN_Buffer_free(tnoted);
AH_Job_SetStatus(j, AH_JobStatusError);
return rv;
}
dbXA=GWEN_DB_GetGroup(dbCurr, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
"data/transactionscreditcard");
if (dbXA) {
GWEN_DB_NODE *dbT;
GWEN_DB_NODE *dbV;
GWEN_DATE *date;
GWEN_DATE *valutaDate;
const char *p;
const char *ref;
int i;
dbT=GWEN_DB_GetGroup(dbXA, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
"entries");
while (dbT) {
AB_VALUE *v1;
AB_VALUE *v2;
GWEN_STRINGLIST *purpose;
AB_TRANSACTION *t;
/* read date (Buchungsdatum) */
p=GWEN_DB_GetCharValue(dbT, "date", 0, 0);
if (p)
date=GWEN_Date_fromStringWithTemplate(p, "YYYYMMDD");
else
date=NULL;
/* read valutaData (Umsatzdatum) */
p=GWEN_DB_GetCharValue(dbT, "valutaDate", 0, 0);
if (p)
valutaDate=GWEN_Date_fromStringWithTemplate(p, "YYYYMMDD");
else
valutaDate=NULL;
/* read value */
dbV=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
"value");
if (dbV)
v1=AB_Value_fromDb(dbV);
else
v1=NULL;
v2=0;
if (!v1) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Error parsing value from DB");
}
else {
p=GWEN_DB_GetCharValue(dbT, "debitMark", 0, 0);
if (p) {
if (strcasecmp(p, "D")==0 ||
strcasecmp(p, "RC")==0) {
v2=AB_Value_dup(v1);
AB_Value_Negate(v2);
}
else if (strcasecmp(p, "C")==0 ||
strcasecmp(p, "RD")==0)
v2=AB_Value_dup(v1);
else {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Bad debit mark \"%s\"", p);
v2=0;
}
}
AB_Value_free(v1);
}
/* read purpose */
purpose=GWEN_StringList_new();
for (i=0; i<10; i++) {
p=GWEN_DB_GetCharValue(dbT, "purpose", i, 0);
if (!p)
break;
GWEN_StringList_AppendString(purpose, p, 0, 0);
}
/* read reference */
ref=GWEN_DB_GetCharValue(dbT, "reference", 0, 0);
if (ref)
GWEN_StringList_AppendString(purpose, ref, 0, 0);
t=AB_Transaction_new();
if (ref)
AB_Transaction_SetFiId(t, ref);
AB_Transaction_SetUniqueAccountId(t, AB_Account_GetUniqueId(a));
AB_Transaction_SetLocalBankCode(t, AB_User_GetBankCode(u));
AB_Transaction_SetLocalAccountNumber(t, AB_Account_GetAccountNumber(a));
AB_Transaction_SetValutaDate(t, valutaDate);
AB_Transaction_SetDate(t, date);
AB_Transaction_SetValue(t, v2);
AB_Transaction_SetPurposeFromStringList(t, purpose);
DBG_INFO(AQHBCI_LOGDOMAIN, "Adding transaction");
AB_ImExporterAccountInfo_AddTransaction(ai, t);
GWEN_StringList_free(purpose);
AB_Value_free(v2);
GWEN_Date_free(date);
GWEN_Date_free(valutaDate);
dbT = GWEN_DB_FindNextGroup(dbT, "entries");
} //while (dbT)
} //if (dbXA)
dbCurr=GWEN_DB_GetNextGroup(dbCurr);
}
return 0;
}
int AB_Banking_PluginSystemInit(void) {
if (ab_plugin_init_count==0) {
const char *s;
GWEN_PLUGIN_MANAGER *pm;
int rv;
rv=GWEN_Init();
if (rv) {
DBG_ERROR_ERR(AQBANKING_LOGDOMAIN, rv);
return rv;
}
if (!GWEN_Logger_IsOpen(AQBANKING_LOGDOMAIN)) {
GWEN_Logger_Open(AQBANKING_LOGDOMAIN,
"aqbanking", 0,
GWEN_LoggerType_Console,
GWEN_LoggerFacility_User);
GWEN_Logger_SetLevel(AQBANKING_LOGDOMAIN, GWEN_LoggerLevel_Notice);
}
s=getenv("AQBANKING_LOGLEVEL");
if (s && *s) {
GWEN_LOGGER_LEVEL ll;
ll=GWEN_Logger_Name2Level(s);
GWEN_Logger_SetLevel(AQBANKING_LOGDOMAIN, ll);
}
DBG_INFO(AQBANKING_LOGDOMAIN,
"AqBanking v"
AQBANKING_VERSION_FULL_STRING
" (compiled at "
COMPILE_DATETIME
"): initialising");
/* define locale paths */
GWEN_PathManager_DefinePath(AB_PM_LIBNAME, AB_PM_LOCALEDIR);
GWEN_PathManager_AddPathFromWinReg(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_LOCALEDIR,
AB_BANKING_REGKEY_PATHS,
AB_BANKING_REGKEY_LOCALEDIR);
#if defined(OS_WIN32) || defined(ENABLE_LOCAL_INSTALL)
/* add folder relative to EXE */
GWEN_PathManager_AddRelPath(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_LOCALEDIR,
LOCALEDIR,
GWEN_PathManager_RelModeExe);
#else
/* add absolute folder */
GWEN_PathManager_AddPath(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_LOCALEDIR,
LOCALEDIR);
#endif
if (1) {
GWEN_STRINGLIST *sl=GWEN_PathManager_GetPaths(AB_PM_LIBNAME,
AB_PM_LOCALEDIR);
const char *localedir=GWEN_StringList_FirstString(sl);
rv=GWEN_I18N_BindTextDomain_Dir(PACKAGE, localedir);
if (rv) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not bind textdomain (%d)", rv);
}
else {
rv=GWEN_I18N_BindTextDomain_Codeset(PACKAGE, "UTF-8");
if (rv) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not set codeset (%d)", rv);
}
}
GWEN_StringList_free(sl);
}
/* define sysconf paths */
GWEN_PathManager_DefinePath(AB_PM_LIBNAME, AB_PM_SYSCONFDIR);
GWEN_PathManager_AddPathFromWinReg(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_SYSCONFDIR,
AB_BANKING_REGKEY_PATHS,
AB_BANKING_REGKEY_SYSCONFDIR);
#if defined(OS_WIN32) || defined(ENABLE_LOCAL_INSTALL)
/* add folder relative to EXE */
GWEN_PathManager_AddRelPath(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_SYSCONFDIR,
AQBANKING_SYSCONF_DIR,
GWEN_PathManager_RelModeExe);
#else
/* add absolute folder */
GWEN_PathManager_AddPath(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_SYSCONFDIR,
AQBANKING_SYSCONF_DIR);
#endif
/* define data paths */
GWEN_PathManager_DefinePath(AB_PM_LIBNAME, AB_PM_DATADIR);
GWEN_PathManager_AddPathFromWinReg(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_DATADIR,
AB_BANKING_REGKEY_PATHS,
AB_BANKING_REGKEY_DATADIR);
#if defined(OS_WIN32) || defined(ENABLE_LOCAL_INSTALL)
/* add folder relative to EXE */
GWEN_PathManager_AddRelPath(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_DATADIR,
AQBANKING_DATA_DIR,
GWEN_PathManager_RelModeExe);
#else
/* add absolute folder */
GWEN_PathManager_AddPath(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_DATADIR,
AQBANKING_DATA_DIR);
#endif
/* define wizard paths */
GWEN_PathManager_DefinePath(AB_PM_LIBNAME, AB_PM_WIZARDDIR);
GWEN_PathManager_AddPathFromWinReg(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_WIZARDDIR,
AB_BANKING_REGKEY_PATHS,
AB_BANKING_REGKEY_WIZARDDIR);
#if defined(OS_WIN32) || defined(ENABLE_LOCAL_INSTALL)
/* add folder relative to EXE */
GWEN_PathManager_AddRelPath(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_WIZARDDIR,
AQBANKING_PLUGINS
DIRSEP
AB_WIZARD_FOLDER,
GWEN_PathManager_RelModeExe);
#else
/* add absolute folder */
GWEN_PathManager_AddPath(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_WIZARDDIR,
AQBANKING_PLUGINS
DIRSEP
AB_WIZARD_FOLDER);
#endif
/* create bankinfo plugin manager */
DBG_INFO(AQBANKING_LOGDOMAIN, "Registering bankinfo plugin manager");
pm=GWEN_PluginManager_new("bankinfo", AB_PM_LIBNAME);
if (GWEN_PluginManager_Register(pm)) {
DBG_ERROR(AQBANKING_LOGDOMAIN,
"Could not register bankinfo plugin manager");
return GWEN_ERROR_GENERIC;
}
GWEN_PluginManager_AddPathFromWinReg(pm,
AB_PM_LIBNAME,
AB_BANKING_REGKEY_PATHS,
AB_BANKING_REGKEY_BANKINFODIR);
#if defined(OS_WIN32) || defined(ENABLE_LOCAL_INSTALL)
/* add folder relative to EXE */
GWEN_PluginManager_AddRelPath(pm,
AB_PM_LIBNAME,
AQBANKING_PLUGINS
DIRSEP
AB_BANKINFO_PLUGIN_FOLDER,
GWEN_PathManager_RelModeExe);
#else
/* add absolute folder */
GWEN_PluginManager_AddPath(pm,
AB_PM_LIBNAME,
AQBANKING_PLUGINS
DIRSEP
AB_BANKINFO_PLUGIN_FOLDER);
#endif
ab_pluginManagerBankInfo=pm;
/* create provider plugin manager */
DBG_INFO(AQBANKING_LOGDOMAIN, "Registering provider plugin manager");
pm=GWEN_PluginManager_new("provider", AB_PM_LIBNAME);
if (GWEN_PluginManager_Register(pm)) {
DBG_ERROR(AQBANKING_LOGDOMAIN,
"Could not register provider plugin manager");
return GWEN_ERROR_GENERIC;
}
GWEN_PluginManager_AddPathFromWinReg(pm,
AB_PM_LIBNAME,
AB_BANKING_REGKEY_PATHS,
AB_BANKING_REGKEY_PROVIDERDIR);
#if defined(OS_WIN32) || defined(ENABLE_LOCAL_INSTALL)
/* add folder relative to EXE */
GWEN_PluginManager_AddRelPath(pm,
AB_PM_LIBNAME,
AQBANKING_PLUGINS
DIRSEP
AB_PROVIDER_FOLDER,
GWEN_PathManager_RelModeExe);
#else
/* add absolute folder */
GWEN_PluginManager_AddPath(pm,
AB_PM_LIBNAME,
AQBANKING_PLUGINS
DIRSEP
AB_PROVIDER_FOLDER);
#endif
ab_pluginManagerProvider=pm;
/* create imexporters plugin manager */
DBG_INFO(AQBANKING_LOGDOMAIN, "Registering imexporters plugin manager");
pm=GWEN_PluginManager_new("imexporter", AB_PM_LIBNAME);
if (GWEN_PluginManager_Register(pm)) {
DBG_ERROR(AQBANKING_LOGDOMAIN,
"Could not register imexporters plugin manager");
return GWEN_ERROR_GENERIC;
}
GWEN_PluginManager_AddPathFromWinReg(pm,
AB_PM_LIBNAME,
AB_BANKING_REGKEY_PATHS,
AB_BANKING_REGKEY_IMPORTERDIR);
#if defined(OS_WIN32) || defined(ENABLE_LOCAL_INSTALL)
/* add folder relative to EXE */
GWEN_PluginManager_AddRelPath(pm,
AB_PM_LIBNAME,
AQBANKING_PLUGINS
DIRSEP
AB_IMEXPORTER_FOLDER,
GWEN_PathManager_RelModeExe);
#else
/* add absolute folder */
GWEN_PluginManager_AddPath(pm,
AB_PM_LIBNAME,
AQBANKING_PLUGINS
DIRSEP
AB_IMEXPORTER_FOLDER);
#endif
ab_pluginManagerImExporter=pm;
/* insert DBIO plugin folder */
pm=GWEN_PluginManager_FindPluginManager("dbio");
if (pm) {
#if defined(OS_WIN32) || defined(ENABLE_LOCAL_INSTALL)
/* insert folder relative to EXE */
GWEN_PluginManager_InsertRelPath(pm,
AB_PM_LIBNAME,
AQBANKING_PLUGINS
DIRSEP
AB_DBIO_FOLDER,
GWEN_PathManager_RelModeExe);
#else
/* add absolute folder */
GWEN_PluginManager_InsertPath(pm,
AB_PM_LIBNAME,
AQBANKING_PLUGINS
DIRSEP
AB_DBIO_FOLDER);
#endif
}
else {
DBG_ERROR(AQBANKING_LOGDOMAIN,
"Could not find DBIO plugin manager, maybe GWEN_Init() was not called?");
return GWEN_ERROR_GENERIC;
}
ab_imexporters=AB_ImExporter_List_new();
ab_bankInfoPlugins=AB_BankInfoPlugin_List_new();
}
ab_plugin_init_count++;
return 0;
}
