int GWEN_PathManager_InsertPath(const char *callingLib,
const char *destLib,
const char *pathName,
const char *pathValue) {
GWEN_DB_NODE *dbT;
assert(destLib);
assert(pathName);
assert(pathValue);
assert(gwen__paths);
dbT=GWEN_DB_GetGroup(gwen__paths, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
destLib);
if (!dbT)
return GWEN_ERROR_NOT_FOUND;
dbT=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
pathName);
if (!dbT)
return GWEN_ERROR_NOT_FOUND;
dbT=GWEN_DB_GetGroup(dbT,
GWEN_PATH_FLAGS_CREATE_GROUP |
GWEN_DB_FLAGS_INSERT,
"pair");
assert(dbT);
if (callingLib) {
GWEN_DB_SetCharValue(dbT, GWEN_DB_FLAGS_DEFAULT,
"lib", callingLib);
}
GWEN_DB_SetCharValue(dbT, GWEN_DB_FLAGS_DEFAULT,
"path", pathValue);
return 0;
}
/* --------------------------------------------------------------- FUNCTION */
int AH_Job_SepaStandingOrdersGet_Process(AH_JOB *j, AB_IMEXPORTER_CONTEXT *ctx){
GWEN_DB_NODE *dbResponses;
GWEN_DB_NODE *dbCurr;
const char *responseName;
int rv;
DBG_INFO(AQHBCI_LOGDOMAIN, "Processing JobSepaStandingOrdersGet");
assert(j);
responseName=AH_Job_GetResponseName(j);
dbResponses=AH_Job_GetResponses(j);
assert(dbResponses);
/* search for "Transactions" */
dbCurr=GWEN_DB_GetFirstGroup(dbResponses);
while(dbCurr) {
rv=AH_Job_CheckEncryption(j, dbCurr);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Compromised security (encryption)");
AH_Job_SetStatus(j, AH_JobStatusError);
return rv;
}
rv=AH_Job_CheckSignature(j, dbCurr);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Compromised security (signature)");
AH_Job_SetStatus(j, AH_JobStatusError);
return rv;
}
if (responseName && *responseName) {
GWEN_DB_NODE *dbXA;
dbXA=GWEN_DB_GetGroup(dbCurr, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "data");
if (dbXA)
dbXA=GWEN_DB_GetGroup(dbXA, GWEN_PATH_FLAGS_NAMEMUSTEXIST, responseName);
if (dbXA) {
const void *p;
unsigned int bs;
const char *fiId;
fiId=GWEN_DB_GetCharValue(dbXA, "fiId", 0, NULL);
p=GWEN_DB_GetBinValue(dbXA, "transfer", 0, 0, 0, &bs);
if (p && bs) {
rv=AH_Job_SepaStandingOrdersGet__ReadSto(j, ctx, p, bs, fiId);
if (rv<0) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
DBG_WARN(AQHBCI_LOGDOMAIN, "Error reading standing order from data, ignoring (%d)", rv);
}
}
}
}
dbCurr=GWEN_DB_GetNextGroup(dbCurr);
}
return 0;
}
int GWEN_PathManager_FindFile(const char *destLib,
const char *pathName,
const char *fileName,
GWEN_BUFFER *fbuf) {
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) {
int i;
const char *s;
GWEN_DB_NODE *dbN;
GWEN_BUFFER *tbuf;
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
/* check all paths */
dbN=GWEN_DB_FindFirstGroup(dbT, "pair");
while(dbN) {
for (i=0; ; i++) {
s=GWEN_DB_GetCharValue(dbN, "path", i, 0);
if (!s)
break;
else {
FILE *f;
GWEN_Buffer_AppendString(tbuf, s);
GWEN_Buffer_AppendString(tbuf, GWEN_DIR_SEPARATOR_S);
GWEN_Buffer_AppendString(tbuf, fileName);
DBG_DEBUG(GWEN_LOGDOMAIN, "Trying \"%s\"",
GWEN_Buffer_GetStart(tbuf));
f=fopen(GWEN_Buffer_GetStart(tbuf), "r");
if (f) {
fclose(f);
DBG_DEBUG(GWEN_LOGDOMAIN,
"File \"%s\" found in folder \"%s\"",
fileName,
s);
GWEN_Buffer_AppendBuffer(fbuf, tbuf);
GWEN_Buffer_free(tbuf);
return 0;
}
GWEN_Buffer_Reset(tbuf);
}
}
dbN=GWEN_DB_FindNextGroup(dbN, "pair");
}
GWEN_Buffer_free(tbuf);
}
}
DBG_INFO(GWEN_LOGDOMAIN, "File \"%s\" not found", fileName);
return GWEN_ERROR_NOT_FOUND;
}
int AB_ImExporterContext_ReadDb(AB_IMEXPORTER_CONTEXT *iec,
GWEN_DB_NODE *db) {
GWEN_DB_NODE *dbT;
int i;
dbT=GWEN_DB_GetGroup(db, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
"accountInfoList");
if (dbT) {
dbT=GWEN_DB_FindFirstGroup(dbT, "accountInfo");
while(dbT) {
AB_IMEXPORTER_ACCOUNTINFO *iea;
iea=AB_ImExporterAccountInfo_fromDb(dbT);
assert(iea);
AB_ImExporterAccountInfo_List_Add(iea, iec->accountInfoList);
dbT=GWEN_DB_FindNextGroup(dbT, "accountInfo");
}
}
dbT=GWEN_DB_GetGroup(db, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
"securityList");
if (dbT) {
dbT=GWEN_DB_FindFirstGroup(dbT, "security");
while(dbT) {
AB_SECURITY *sec;
sec=AB_Security_fromDb(dbT);
assert(sec);
AB_Security_List_Add(sec, iec->securityList);
dbT=GWEN_DB_FindNextGroup(dbT, "security");
}
}
dbT=GWEN_DB_GetGroup(db, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
"messageList");
if (dbT) {
dbT=GWEN_DB_FindFirstGroup(dbT, "message");
while(dbT) {
AB_MESSAGE *msg;
msg=AB_Message_fromDb(dbT);
assert(msg);
AB_Message_List_Add(msg, iec->messageList);
dbT=GWEN_DB_FindNextGroup(dbT, "message");
}
}
for (i=0; ; i++) {
const char *s;
s=GWEN_DB_GetCharValue(db, "logs", i, NULL);
if (!s)
break;
GWEN_Buffer_AppendString(iec->logs, s);
}
return 0;
}
int GWEN_PathManager_GetMatchingFilesRecursively(const char *destLib,
const char *pathName,
const char *subFolderName,
GWEN_STRINGLIST *sl,
const char *mask) {
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) {
int i;
const char *s;
GWEN_DB_NODE *dbN;
GWEN_BUFFER *tbuf;
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
/* check all paths */
dbN=GWEN_DB_FindFirstGroup(dbT, "pair");
while(dbN) {
for (i=0; ; i++) {
s=GWEN_DB_GetCharValue(dbN, "path", i, 0);
if (!s)
break;
else {
GWEN_Buffer_AppendString(tbuf, s);
if (subFolderName && *subFolderName) {
GWEN_Buffer_AppendString(tbuf, GWEN_DIR_SEPARATOR_S);
GWEN_Buffer_AppendString(tbuf, subFolderName);
}
DBG_DEBUG(GWEN_LOGDOMAIN, "Trying \"%s\"",
GWEN_Buffer_GetStart(tbuf));
GWEN_Directory_GetMatchingFilesRecursively(GWEN_Buffer_GetStart(tbuf), sl, mask);
GWEN_Buffer_Reset(tbuf);
}
}
dbN=GWEN_DB_FindNextGroup(dbN, "pair");
}
GWEN_Buffer_free(tbuf);
}
}
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 GWEN_Parser__toDbElementAndChildren(GWEN_PARSER_ELEMENT *eData, GWEN_DB_NODE *dbParent, int depth)
{
int rv;
GWEN_PARSER_ELEMENT *eChild;
const char *s;
const char *groupName;
groupName=GWEN_ParserElement_GetDbName(eData);
if (groupName) {
s=GWEN_ParserElement_GetData(eData);
if (s && *s)
GWEN_DB_SetCharValue(dbParent, GWEN_DB_FLAGS_DEFAULT, groupName, s);
}
/* check children */
eChild=GWEN_ParserElement_Tree_GetFirstChild(eData);
if (eChild) {
GWEN_DB_NODE *dbThis=NULL;
if (groupName && *groupName)
dbThis=GWEN_DB_GetGroup(dbParent, GWEN_DB_FLAGS_DEFAULT, groupName);
while (eChild) {
rv=GWEN_Parser__toDbElementAndChildren(eChild, dbThis?dbThis:dbParent, depth+1);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d) [%d]", rv, depth);
return rv;
}
GWEN_ParserElement_Tree_GetNext(eChild);
}
}
return 0;
}
int AB_Banking_SaveUser(AB_BANKING *ab, AB_USER *u) {
GWEN_DB_NODE *db;
GWEN_DB_NODE *dbP;
int rv;
db=GWEN_DB_Group_new("user");
AB_User_toDb(u, db);
dbP=GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_DEFAULT,
"data/backend");
rv=AB_Provider_ExtendUser(AB_User_GetProvider(u), u,
AB_ProviderExtendMode_Save,
dbP);
if (rv) {
DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d)", rv);
GWEN_DB_Group_free(db);
return rv;
}
/* save group (still locked) */
rv=GWEN_ConfigMgr_SetGroup(ab->configMgr,
AB_CFG_GROUP_USERS,
AB_User_GetDbId(u),
db);
if (rv<0) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not save user group (%d)", rv);
GWEN_DB_Group_free(db);
return rv;
}
GWEN_DB_Group_free(db);
return 0;
}
int LC_HIPersonalData_ReadDb(LC_HI_PERSONAL_DATA *st, GWEN_DB_NODE *db) {
assert(st);
assert(db);
LC_HIPersonalData_SetInsuranceId(st, GWEN_DB_GetCharValue(db, "insuranceId", 0, 0));
LC_HIPersonalData_SetPrename(st, GWEN_DB_GetCharValue(db, "prename", 0, 0));
LC_HIPersonalData_SetName(st, GWEN_DB_GetCharValue(db, "name", 0, 0));
LC_HIPersonalData_SetTitle(st, GWEN_DB_GetCharValue(db, "title", 0, 0));
LC_HIPersonalData_SetNameSuffix(st, GWEN_DB_GetCharValue(db, "nameSuffix", 0, 0));
LC_HIPersonalData_SetSex(st, LC_HIPersonalData_Sex_fromString(GWEN_DB_GetCharValue(db, "sex", 0, 0)));
if (1) { /* for local vars */
GWEN_DB_NODE *dbT;
dbT=GWEN_DB_GetGroup(db, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "dateOfBirth");
if (dbT) {
if (st->dateOfBirth)
GWEN_Time_free(st->dateOfBirth);
st->dateOfBirth=GWEN_Time_fromDb(dbT);
}
}
LC_HIPersonalData_SetAddrZipCode(st, GWEN_DB_GetCharValue(db, "addrZipCode", 0, 0));
LC_HIPersonalData_SetAddrCity(st, GWEN_DB_GetCharValue(db, "addrCity", 0, 0));
LC_HIPersonalData_SetAddrState(st, GWEN_DB_GetCharValue(db, "addrState", 0, 0));
LC_HIPersonalData_SetAddrCountry(st, GWEN_DB_GetCharValue(db, "addrCountry", 0, 0));
LC_HIPersonalData_SetAddrStreet(st, GWEN_DB_GetCharValue(db, "addrStreet", 0, 0));
LC_HIPersonalData_SetAddrHouseNum(st, GWEN_DB_GetCharValue(db, "addrHouseNum", 0, 0));
return 0;
}
int GWEN_PathManager_RemovePath(const char *callingLib,
const char *destLib,
const char *pathName,
const char *pathValue) {
GWEN_DB_NODE *dbT;
const char *s;
const char *p;
assert(gwen__paths);
dbT=GWEN_DB_GetGroup(gwen__paths, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
destLib);
if (!dbT)
return GWEN_ERROR_NOT_FOUND;
dbT=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
pathName);
if (!dbT)
return GWEN_ERROR_NOT_FOUND;
dbT=GWEN_DB_FindFirstGroup(dbT, "pair");
while(dbT) {
p=GWEN_DB_GetCharValue(dbT, "path", 0, 0);
assert(p);
s=GWEN_DB_GetCharValue(dbT, "lib", 0, 0);
if (
(
(!callingLib && !s) ||
(callingLib && s && strcasecmp(s, callingLib)==0)
) &&
strcasecmp(p, pathValue)==0
)
break;
dbT=GWEN_DB_FindNextGroup(dbT, "pair");
}
if (dbT) {
GWEN_DB_UnlinkGroup(dbT);
GWEN_DB_Group_free(dbT);
return 0;
}
else
return 1;
}
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 AB_Banking_BeginExclUseAccount(AB_BANKING *ab,
AB_ACCOUNT *a) {
GWEN_DB_NODE *db=NULL;
GWEN_DB_NODE *dbP;
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_ACCOUNTS,
AB_Account_GetDbId(a));
if (rv<0) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Unable to lock account config group (%d)", rv);
return rv;
}
/* load group (is locked now) */
rv=GWEN_ConfigMgr_GetGroup(ab->configMgr,
AB_CFG_GROUP_ACCOUNTS,
AB_Account_GetDbId(a),
&db);
if (rv<0) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not load account group (%d)", rv);
GWEN_ConfigMgr_UnlockGroup(ab->configMgr,
AB_CFG_GROUP_ACCOUNTS,
AB_Account_GetDbId(a));
return rv;
}
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(AB_Account_GetProvider(a), 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);
GWEN_ConfigMgr_UnlockGroup(ab->configMgr,
AB_CFG_GROUP_ACCOUNTS,
AB_Account_GetDbId(a));
GWEN_DB_Group_free(db);
return rv;
}
GWEN_DB_Group_free(db);
return 0;
}
int GWEN_PathManager_PathChanged(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)
return GWEN_ERROR_NOT_FOUND;
dbT=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
pathName);
if (!dbT)
return GWEN_ERROR_NOT_FOUND;
if ((GWEN_DB_GetNodeFlags(dbT) & GWEN_DB_NODE_FLAGS_DIRTY))
return 1;
return 0;
}
int GWEN_PathManager_UndefinePath(const char *destLib,
const char *pathName) {
GWEN_DB_NODE *dbT;
assert(destLib);
assert(pathName);
assert(gwen__paths);
dbT=GWEN_DB_GetGroup(gwen__paths, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
destLib);
if (!dbT)
return GWEN_ERROR_NOT_FOUND;
dbT=GWEN_DB_GetGroup(dbT, GWEN_DB_FLAGS_DEFAULT,
pathName);
if (!dbT)
return GWEN_ERROR_NOT_FOUND;
GWEN_DB_UnlinkGroup(dbT);
GWEN_DB_Group_free(dbT);
return 0;
}
GWEN_DB_NODE *AH_User_GetUpdForAccountIdAndSuffix(const AB_USER *u,
const char *sAccountNumber,
const char *sAccountSuffix) {
AH_USER *ue;
GWEN_DB_NODE *db;
GWEN_BUFFER *tbuf;
assert(u);
ue=GWEN_INHERIT_GETDATA(AB_USER, AH_USER, u);
assert(ue);
db=AH_User_GetUpd(u);
if (db==NULL) {
DBG_INFO(AQHBCI_LOGDOMAIN, "No upd");
return NULL;
}
tbuf=GWEN_Buffer_new(0, 64, 0, 1);
GWEN_Buffer_AppendString(tbuf, sAccountNumber);
GWEN_Buffer_AppendString(tbuf, "-");
/* take into account the "Unterkontomerkmal", don't rely solely on account id */
if (sAccountSuffix && *sAccountSuffix)
GWEN_Buffer_AppendString(tbuf, sAccountSuffix);
else
GWEN_Buffer_AppendString(tbuf, "none");
DBG_INFO(AQHBCI_LOGDOMAIN, "Checking upd for account \"%s\"", GWEN_Buffer_GetStart(tbuf));
db=GWEN_DB_GetGroup(db,
GWEN_PATH_FLAGS_NAMEMUSTEXIST,
GWEN_Buffer_GetStart(tbuf));
GWEN_Buffer_free(tbuf);
if (db==NULL) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Falling back to old storage of UPD for account \"%s\"", sAccountNumber);
db=AH_User_GetUpd(u);
db=GWEN_DB_GetGroup(db,
GWEN_PATH_FLAGS_NAMEMUSTEXIST,
sAccountNumber);
}
return db;
}
int AB_Banking_BeginExclUseUser(AB_BANKING *ab, AB_USER *u) {
GWEN_DB_NODE *db=NULL;
GWEN_DB_NODE *dbP;
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_USERS,
AB_User_GetDbId(u));
if (rv<0) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Unable to lock account config group (%d)", rv);
return rv;
}
/* load group (is locked now) */
rv=GWEN_ConfigMgr_GetGroup(ab->configMgr,
AB_CFG_GROUP_USERS,
AB_User_GetDbId(u),
&db);
if (rv<0) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not load account group (%d)", rv);
GWEN_ConfigMgr_UnlockGroup(ab->configMgr,
AB_CFG_GROUP_USERS,
AB_User_GetDbId(u));
return rv;
}
/* reload user from DB */
AB_User_ReadDb(u, db);
dbP=GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_DEFAULT, "data/backend");
AB_User_toDb(u, db);
rv=AB_Provider_ExtendUser(AB_User_GetProvider(u), u,
AB_ProviderExtendMode_Reload,
dbP);
if (rv) {
DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d)", rv);
GWEN_DB_Group_free(db);
return rv;
}
GWEN_DB_Group_free(db);
return 0;
}
int GWEN_PathManager_DefinePath(const char *destLib,
const char *pathName) {
GWEN_DB_NODE *dbT;
assert(destLib);
assert(pathName);
assert(gwen__paths);
dbT=GWEN_DB_GetGroup(gwen__paths, GWEN_DB_FLAGS_DEFAULT,
destLib);
assert(dbT);
if (GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST, pathName)) {
DBG_ERROR(GWEN_LOGDOMAIN,
"Path \"%s/%s\" already exists",
destLib, pathName);
return GWEN_ERROR_INVALID;
}
dbT=GWEN_DB_GetGroup(dbT,
GWEN_DB_FLAGS_DEFAULT,
pathName);
return 0;
}
GWEN_TIME *GWEN_Time_fromDb(GWEN_DB_NODE *db) {
GWEN_TIME *t;
GWEN_DB_NODE *dbT;
int day, month, year;
int hour, min, sec;
int inUtc;
day=month=year=0;
hour=min=sec=0;
inUtc=GWEN_DB_GetIntValue(db, "inUtc", 0, 0);
dbT=GWEN_DB_GetGroup(db, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "date");
if (dbT) {
day=GWEN_DB_GetIntValue(dbT, "day", 0, 0);
month=GWEN_DB_GetIntValue(dbT, "month", 0, 1)-1;
year=GWEN_DB_GetIntValue(dbT, "year", 0, 0);
if (!day || !year) {
DBG_INFO(GWEN_LOGDOMAIN, "Bad date in DB");
return 0;
}
}
dbT=GWEN_DB_GetGroup(db, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "time");
if (dbT) {
hour=GWEN_DB_GetIntValue(dbT, "hour", 0, 0);
min=GWEN_DB_GetIntValue(dbT, "min", 0, 0);
sec=GWEN_DB_GetIntValue(dbT, "sec", 0, 0);
}
DBG_VERBOUS(GWEN_LOGDOMAIN,
"Creating time from this: %04d/%02d/%02d - %02d:%02d:%02d (%d)",
year, month, day, hour, min, sec, inUtc);
t=GWEN_Time_new(year, month, day, hour, min, sec, inUtc);
if (!t) {
DBG_INFO(GWEN_LOGDOMAIN, "Bad date/time");
return 0;
}
return t;
}
int GWEN_DBIO__XmlDb_ImportGroup(GWEN_DBIO *dbio,
uint32_t flags,
GWEN_DB_NODE *data,
GWEN_DB_NODE *cfg,
GWEN_XMLNODE *node) {
GWEN_XMLNODE *n;
assert(node);
n=GWEN_XMLNode_GetFirstTag(node);
while(n) {
const char *tname;
const char *s;
tname=GWEN_XMLNode_GetData(n);
assert(tname && *tname);
s=GWEN_XMLNode_GetProperty(n, "type", 0);
if (s) {
if (strcasecmp(s, "group")==0) {
GWEN_DB_NODE *db;
int rv;
db=GWEN_DB_GetGroup(data, flags, tname);
if (db==0) {
DBG_INFO(GWEN_LOGDOMAIN, "here");
return GWEN_ERROR_INVALID;
}
rv=GWEN_DBIO__XmlDb_ImportGroup(dbio, flags, db, cfg, n);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
return rv;
}
}
else if (strcasecmp(s, "var")==0) {
int rv;
rv=GWEN_DBIO__XmlDb_ImportVar(dbio, flags, data, cfg, n);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
return rv;
}
}
else {
DBG_ERROR(GWEN_LOGDOMAIN, "Unexpected type \"%s\"", s);
return GWEN_ERROR_INVALID;
}
}
n=GWEN_XMLNode_GetNextTag(n);
}
return 0;
}
int GWEN_PathManager_AddPath(const char *callingLib,
const char *destLib,
const char *pathName,
const char *pathValue) {
GWEN_DB_NODE *dbT;
GWEN_BUFFER *buf;
assert(destLib);
assert(pathName);
assert(pathValue);
assert(gwen__paths);
dbT=GWEN_DB_GetGroup(gwen__paths, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
destLib);
if (!dbT)
return GWEN_ERROR_NOT_FOUND;
dbT=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
pathName);
if (!dbT)
return GWEN_ERROR_NOT_FOUND;
dbT=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_CREATE_GROUP,
"pair");
assert(dbT);
if (callingLib) {
GWEN_DB_SetCharValue(dbT, GWEN_DB_FLAGS_DEFAULT,
"lib", callingLib);
}
buf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Directory_OsifyPath(pathValue, buf, 1);
GWEN_DB_SetCharValue(dbT, GWEN_DB_FLAGS_DEFAULT,
"path",
GWEN_Buffer_GetStart(buf));
GWEN_Buffer_free(buf);
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 AB_Banking_EndExclUseAccount(AB_BANKING *ab,
AB_ACCOUNT *a,
int abandon) {
int rv;
if (!abandon) {
GWEN_DB_NODE *db=GWEN_DB_Group_new("account");
GWEN_DB_NODE *dbP;
AB_Account_toDb(a, db);
dbP=GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_DEFAULT, "data/backend");
rv=AB_Provider_ExtendAccount(AB_Account_GetProvider(a), a,
AB_ProviderExtendMode_Save,
dbP);
if (rv) {
DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d)", rv);
GWEN_DB_Group_free(db);
return rv;
}
/* save group (still locked) */
rv=GWEN_ConfigMgr_SetGroup(ab->configMgr,
AB_CFG_GROUP_ACCOUNTS,
AB_Account_GetDbId(a),
db);
if (rv<0) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not save account group (%d)", rv);
GWEN_ConfigMgr_UnlockGroup(ab->configMgr,
AB_CFG_GROUP_ACCOUNTS,
AB_Account_GetDbId(a));
GWEN_DB_Group_free(db);
return rv;
}
GWEN_DB_Group_free(db);
}
/* unlock group */
rv=GWEN_ConfigMgr_UnlockGroup(ab->configMgr,
AB_CFG_GROUP_ACCOUNTS,
AB_Account_GetDbId(a));
if (rv<0) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not unlock account group (%d)", rv);
return rv;
}
return 0;
}
int LC_HIPersonalData_toDb(const LC_HI_PERSONAL_DATA *st, GWEN_DB_NODE *db) {
assert(st);
assert(db);
if (st->insuranceId)
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "insuranceId", st->insuranceId))
return -1;
if (st->prename)
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "prename", st->prename))
return -1;
if (st->name)
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "name", st->name))
return -1;
if (st->title)
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "title", st->title))
return -1;
if (st->nameSuffix)
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "nameSuffix", st->nameSuffix))
return -1;
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "sex", LC_HIPersonalData_Sex_toString(st->sex)))
return -1;
if (st->dateOfBirth)
if (GWEN_Time_toDb(st->dateOfBirth, GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_DEFAULT, "dateOfBirth")))
return -1;
if (st->addrZipCode)
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "addrZipCode", st->addrZipCode))
return -1;
if (st->addrCity)
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "addrCity", st->addrCity))
return -1;
if (st->addrState)
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "addrState", st->addrState))
return -1;
if (st->addrCountry)
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "addrCountry", st->addrCountry))
return -1;
if (st->addrStreet)
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "addrStreet", st->addrStreet))
return -1;
if (st->addrHouseNum)
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "addrHouseNum", st->addrHouseNum))
return -1;
return 0;
}
int AB_BankInfo_ReadDb(AB_BANKINFO *st, GWEN_DB_NODE *db) {
assert(st);
assert(db);
AB_BankInfo_SetCountry(st, GWEN_DB_GetCharValue(db, "country", 0, 0));
AB_BankInfo_SetBranchId(st, GWEN_DB_GetCharValue(db, "branchId", 0, 0));
AB_BankInfo_SetBankId(st, GWEN_DB_GetCharValue(db, "bankId", 0, 0));
AB_BankInfo_SetBic(st, GWEN_DB_GetCharValue(db, "bic", 0, 0));
AB_BankInfo_SetBankName(st, GWEN_DB_GetCharValue(db, "bankName", 0, 0));
AB_BankInfo_SetLocation(st, GWEN_DB_GetCharValue(db, "location", 0, 0));
AB_BankInfo_SetStreet(st, GWEN_DB_GetCharValue(db, "street", 0, 0));
AB_BankInfo_SetZipcode(st, GWEN_DB_GetCharValue(db, "zipcode", 0, 0));
AB_BankInfo_SetCity(st, GWEN_DB_GetCharValue(db, "city", 0, 0));
AB_BankInfo_SetRegion(st, GWEN_DB_GetCharValue(db, "region", 0, 0));
AB_BankInfo_SetPhone(st, GWEN_DB_GetCharValue(db, "phone", 0, 0));
AB_BankInfo_SetFax(st, GWEN_DB_GetCharValue(db, "fax", 0, 0));
AB_BankInfo_SetEmail(st, GWEN_DB_GetCharValue(db, "email", 0, 0));
AB_BankInfo_SetWebsite(st, GWEN_DB_GetCharValue(db, "website", 0, 0));
st->services=AB_BankInfoService_List_new();
if (1) {/* just for local vars */
GWEN_DB_NODE *dbT;
AB_BANKINFO_SERVICE *e;
dbT=GWEN_DB_GetGroup(db, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "services");
if (dbT) {
GWEN_DB_NODE *dbT2;
dbT2=GWEN_DB_FindFirstGroup(dbT, "element");
while(dbT2) {
e=AB_BankInfoService_fromDb(dbT2);
if (!e) {
DBG_ERROR(0, "Bad element for type \"AB_BANKINFO_SERVICE\"");
if (GWEN_Logger_GetLevel(0)>=GWEN_LoggerLevel_Debug)
GWEN_DB_Dump(dbT2, 2);
AB_BankInfo_free(st);
return 0;
}
AB_BankInfoService_List_Add(e, st->services); dbT2=GWEN_DB_FindNextGroup(dbT2, "element");
} /* while */
} /* if (dbT) */
} /* if (1) */
return 0;
}
int GWEN_Url_ReadDb(GWEN_URL *st, GWEN_DB_NODE *db) {
assert(st);
assert(db);
GWEN_Url_SetProtocol(st, GWEN_DB_GetCharValue(db, "protocol", 0, 0));
GWEN_Url_SetServer(st, GWEN_DB_GetCharValue(db, "server", 0, 0));
GWEN_Url_SetPort(st, GWEN_DB_GetIntValue(db, "port", 0, 0));
GWEN_Url_SetPath(st, GWEN_DB_GetCharValue(db, "path", 0, 0));
GWEN_Url_SetUserName(st, GWEN_DB_GetCharValue(db, "userName", 0, 0));
GWEN_Url_SetPassword(st, GWEN_DB_GetCharValue(db, "password", 0, 0));
if (1) { /* for local vars */
GWEN_DB_NODE *dbT;
dbT=GWEN_DB_GetGroup(db, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "vars");
if (dbT) {
if (st->vars)
GWEN_DB_Group_free(st->vars);
st->vars=GWEN_DB_Group_dup(dbT);
}
}
GWEN_Url_SetUrl(st, GWEN_DB_GetCharValue(db, "url", 0, 0));
return 0;
}
int AH_Control_AddAccount(AB_PROVIDER *pro,
GWEN_DB_NODE *dbArgs,
int argc,
char **argv)
{
GWEN_DB_NODE *db;
AB_USER *u=0;
int rv;
uint32_t userId;
const char *bankId;
const char *accountName;
const char *accountId;
const char *ownerName;
const GWEN_ARGS args[]= {
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"bankId", /* name */
1, /* minnum */
1, /* maxnum */
"b", /* short option */
"bank", /* long option */
"Specify the bank code", /* short description */
"Specify the bank code" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Int, /* type */
"userId", /* name */
1, /* minnum */
1, /* maxnum */
"u", /* short option */
"user", /* long option */
"Specify the unique user id", /* short description */
"Specify the unique user id" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"ownerName", /* name */
0, /* minnum */
1, /* maxnum */
"N" /* short option */
"owner", /* long option */
"Specify the owner name", /* short description */
"Specify the owner name" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"accountName", /* name */
0, /* minnum */
1, /* maxnum */
"n", /* short option */
"name", /* long option */
"Specify the account name (Konto-Name)", /* short description */
"Specify the account name (Konto-Name)" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"accountId", /* name */
1, /* minnum */
1, /* maxnum */
"a", /* short option */
"account", /* long option */
"Specify the account id (Kontonummer)", /* short description */
"Specify the account id (Kontonummer)" /* 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(stdout, "%s\n", GWEN_Buffer_GetStart(ubuf));
GWEN_Buffer_free(ubuf);
return 0;
}
userId=GWEN_DB_GetIntValue(db, "userId", 0, 0);
if (userId<1) {
fprintf(stderr, "ERROR: Invalid user id\n");
return 1;
}
bankId=GWEN_DB_GetCharValue(db, "bankId", 0, "*");
accountId=GWEN_DB_GetCharValue(db, "accountId", 0, "*");
accountName=GWEN_DB_GetCharValue(db, "accountName", 0, "Account");
ownerName=GWEN_DB_GetCharValue(db, "ownerName", 0, NULL);
rv=AB_Provider_HasUser(pro, userId);
if (rv<0) {
fprintf(stderr, "ERROR: User with id %lu not found\n", (unsigned long int) userId);
return 2;
}
rv=AB_Provider_GetUser(pro, userId, 1, 1, &u);
if (rv<0) {
fprintf(stderr, "ERROR: User with id %lu not found\n", (unsigned long int) userId);
return 2;
}
else {
AB_ACCOUNT *account;
AB_BANKINFO_LIST2 *bl;
AB_BANKINFO_LIST2_ITERATOR *bit;
AB_BANKINFO *tbi;
AB_BANKINFO *bi;
int rv;
bl=AB_BankInfo_List2_new();
tbi=AB_BankInfo_new();
AB_BankInfo_SetBankId(tbi, bankId);
rv=AB_Banking_GetBankInfoByTemplate(AB_Provider_GetBanking(pro), "de", tbi, bl);
if (rv) {
fprintf(stderr, "Error looking for bank info: %d\n", rv);
AB_User_free(u);
return 3;
}
bit=AB_BankInfo_List2_First(bl);
if (bit) {
bi=AB_BankInfo_List2Iterator_Data(bit);
assert(bi);
AB_BankInfo_List2Iterator_free(bit);
}
else {
bi=NULL;
fprintf(stderr, "Could not find bank with id %s\n", bankId);
}
AB_BankInfo_List2_free(bl);
account=AB_Provider_CreateAccountObject(pro);
assert(account);
if (!ownerName)
AB_Account_SetOwnerName(account, AB_User_GetUserName(u));
else
AB_Account_SetOwnerName(account, ownerName);
AB_Account_SetAccountNumber(account, accountId);
if (accountName)
AB_Account_SetAccountName(account, accountName);
AB_Account_SetBankCode(account, bankId);
if (bi)
AB_Account_SetBankName(account, AB_BankInfo_GetBankName(bi));
AB_Account_SetUserId(account, userId);
/* add account to system */
rv=AB_Provider_AddAccount(pro, account, 1); /* lock corresponding user */
if (rv<0) {
DBG_ERROR(0, "Error adding account (%d)", rv);
AB_Account_free(account);
AB_User_free(u);
return 3;
}
AB_Account_free(account);
AB_User_free(u);
}
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 addUser(AB_PROVIDER *pro,
GWEN_DB_NODE *dbArgs,
int argc,
char **argv)
{
GWEN_DB_NODE *db;
int rv;
GWEN_BUFFER *nameBuffer=NULL;
const char *tokenName;
const char *tokenType;
const char *bankId;
const char *userId;
const char *customerId;
const char *userName;
const char *hostName;
const char *server;
const char *ebicsVersion;
int importing;
uint32_t cid;
const GWEN_ARGS args[]= {
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"bankId", /* name */
0, /* minnum */
1, /* maxnum */
"b", /* short option */
"bank", /* long option */
"Specify the bank code", /* short description */
"Specify the bank code" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"userId", /* name */
0, /* minnum */
1, /* maxnum */
"u", /* short option */
"user", /* long option */
"Specify the user id (Benutzerkennung)", /* short description */
"Specify the user id (Benutzerkennung)" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"customerId", /* name */
0, /* minnum */
1, /* maxnum */
"c", /* short option */
"customer", /* long option */
"Specify the customer id (Kundennummer)", /* short description */
"Specify the customer id (Kundennummer)" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"tokenType", /* name */
1, /* minnum */
1, /* maxnum */
"t", /* short option */
"tokentype", /* long option */
"Specify the crypt token type", /* short description */
"Specify the crypt token type" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"tokenName", /* name */
0, /* minnum */
1, /* maxnum */
"n", /* short option */
"tokenname", /* long option */
"Specify the crypt token name", /* short description */
"Specify the crypt token name" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"serverAddr", /* name */
0, /* minnum */
1, /* maxnum */
"s", /* short option */
"server", /* long option */
"Specify the server URL", /* short description */
"Specify the server URL" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"hostName", /* name */
1, /* minnum */
1, /* maxnum */
"H", /* short option */
"hostname", /* long option */
"Specify the EBICS hostname", /* short description */
"Specify the EBICS hostname" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"userName", /* name */
1, /* minnum */
1, /* maxnum */
"N", /* short option */
"username", /* long option */
"Specify the realname of the user", /* short description */
"Specify the realname of the user" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"ebicsVersion", /* name */
0, /* minnum */
1, /* maxnum */
"E", /* short option */
"ebicsversion", /* long option */
"Specify the EBICS version to use (e.g. H002)", /* short description */
"Specify the EBICS version to use (e.g. H002)" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Int, /* type */
"context", /* name */
0, /* minnum */
1, /* maxnum */
0, /* short option */
"context", /* long option */
"Select a context on the medium", /* short description */
"Select a context on the medium" /* long description */
},
{
0, /* flags */
GWEN_ArgsType_Int, /* type */
"import", /* name */
0, /* minnum */
1, /* maxnum */
0, /* short option */
"import", /* long option */
"Import a user which has already been in use (e.g. with previous versions)",
"Import a user which has already been in use (e.g. with previous versions)"
},
{
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(stdout, "%s\n", GWEN_Buffer_GetStart(ubuf));
GWEN_Buffer_free(ubuf);
return 0;
}
tokenType=GWEN_DB_GetCharValue(db, "tokenType", 0, 0);
tokenName=GWEN_DB_GetCharValue(db, "tokenName", 0, 0);
bankId=GWEN_DB_GetCharValue(db, "bankId", 0, 0);
userId=GWEN_DB_GetCharValue(db, "userId", 0, 0);
customerId=GWEN_DB_GetCharValue(db, "customerId", 0, 0);
hostName=GWEN_DB_GetCharValue(db, "hostName", 0, 0);
userName=GWEN_DB_GetCharValue(db, "userName", 0, 0);
server=GWEN_DB_GetCharValue(db, "serverAddr", 0, 0);
cid=GWEN_DB_GetIntValue(db, "context", 0, 0);
importing=GWEN_DB_GetIntValue(db, "import", 0, 0);
ebicsVersion=GWEN_DB_GetCharValue(db, "ebicsVersion", 0, "H003");
if (1) {
const char *lbankId;
const char *luserId;
const char *lcustomerId;
const char *lserverAddr;
GWEN_URL *url;
GWEN_CRYPT_TOKEN_CONTEXT *ctx=NULL;
AB_USER *user;
if (1) {
GWEN_PLUGIN_MANAGER *pm;
GWEN_PLUGIN *pl;
GWEN_CRYPT_TOKEN *ct;
const GWEN_CRYPT_TOKEN_CONTEXT *cctx;
if (cid==0) {
DBG_ERROR(0, "No context given.");
return 1;
}
/* get crypt token */
pm=GWEN_PluginManager_FindPluginManager("ct");
if (pm==0) {
DBG_ERROR(0, "Plugin manager not found");
return 3;
}
pl=GWEN_PluginManager_GetPlugin(pm, tokenType);
if (pl==0) {
DBG_ERROR(0, "Plugin not found");
return 3;
}
DBG_INFO(0, "Plugin found");
ct=GWEN_Crypt_Token_Plugin_CreateToken(pl, tokenName);
if (ct==0) {
DBG_ERROR(0, "Could not create crypt token");
return 3;
}
/* open crypt token */
rv=GWEN_Crypt_Token_Open(ct, 0, 0);
if (rv) {
DBG_ERROR(0, "Could not open token (%d)", rv);
return 3;
}
/* get real token name */
nameBuffer=GWEN_Buffer_new(0, 64, 0, 1);
GWEN_Buffer_AppendString(nameBuffer, GWEN_Crypt_Token_GetTokenName(ct));
tokenName=GWEN_Buffer_GetStart(nameBuffer);
cctx=GWEN_Crypt_Token_GetContext(ct, cid, 0);
if (cctx==NULL) {
DBG_ERROR(0, "Context %02x not found", cid);
return 3;
}
ctx=GWEN_Crypt_Token_Context_dup(cctx);
lbankId=bankId?bankId:GWEN_Crypt_Token_Context_GetServiceId(ctx);
luserId=userId?userId:GWEN_Crypt_Token_Context_GetUserId(ctx);
lcustomerId=customerId?customerId:luserId;
lserverAddr=server?server:GWEN_Crypt_Token_Context_GetAddress(ctx);
rv=GWEN_Crypt_Token_Close(ct, 0, 0);
if (rv) {
DBG_ERROR(0, "Could not close token (%d)", rv);
return 3;
}
GWEN_Crypt_Token_free(ct);
}
if (!lbankId || !*lbankId) {
DBG_ERROR(0, "No bank id stored and none given");
return 3;
}
if (!luserId || !*luserId) {
DBG_ERROR(0, "No user id (Benutzerkennung) stored and none given");
return 3;
}
/* TODO: Check for existing users to avoid duplicates */
#if 0
user=AB_Banking_FindUser(ab, EBC_PROVIDER_NAME,
"de",
lbankId, luserId, lcustomerId);
if (user) {
DBG_ERROR(0, "User %s already exists", luserId);
return 3;
}
#endif
user=AB_Provider_CreateUserObject(pro);
assert(user);
AB_User_SetCountry(user, "de");
AB_User_SetBankCode(user, lbankId);
AB_User_SetUserId(user, luserId);
AB_User_SetCustomerId(user, lcustomerId);
EBC_User_SetPeerId(user, hostName);
AB_User_SetUserName(user, userName);
EBC_User_SetTokenType(user, tokenType);
EBC_User_SetTokenName(user, tokenName);
EBC_User_SetTokenContextId(user, cid);
if (ebicsVersion) {
if (strcasecmp(ebicsVersion, "H002")==0) {
EBC_User_SetProtoVersion(user, "H002");
EBC_User_SetSignVersion(user, "A004");
EBC_User_SetAuthVersion(user, "X001");
EBC_User_SetCryptVersion(user, "E001");
}
else if (strcasecmp(ebicsVersion, "H003")==0) {
EBC_User_SetProtoVersion(user, "H003");
EBC_User_SetSignVersion(user, "A005");
EBC_User_SetAuthVersion(user, "X002");
EBC_User_SetCryptVersion(user, "E002");
}
else if (strcasecmp(ebicsVersion, "H004")==0) {
EBC_User_SetProtoVersion(user, "H004");
EBC_User_SetSignVersion(user, "A005");
EBC_User_SetAuthVersion(user, "X002");
EBC_User_SetCryptVersion(user, "E002");
}
else {
fprintf(stderr, "%s",
I18N("Invalid protocol version.\n"
"Possible versions are H002, H003 and H004.\n"));
return 3;
}
}
/* try to get server address from database if still unknown */
if (!lserverAddr || *lserverAddr==0) {
GWEN_BUFFER *tbuf;
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
if (getBankUrl(AB_Provider_GetBanking(pro), lbankId, tbuf)) {
DBG_INFO(0, "Could not find server address for \"%s\"", lbankId);
}
if (GWEN_Buffer_GetUsedBytes(tbuf)==0) {
DBG_ERROR(0, "No address given and none available in internal db");
return 3;
}
url=GWEN_Url_fromString(GWEN_Buffer_GetStart(tbuf));
if (url==NULL) {
DBG_ERROR(0, "Bad URL \"%s\" in internal db",
GWEN_Buffer_GetStart(tbuf));
return 3;
}
GWEN_Buffer_free(tbuf);
}
else {
/* set address */
url=GWEN_Url_fromString(lserverAddr);
if (url==NULL) {
DBG_ERROR(0, "Bad URL \"%s\"", lserverAddr);
return 3;
}
}
GWEN_Url_SetProtocol(url, "https");
if (GWEN_Url_GetPort(url)==0)
GWEN_Url_SetPort(url, 443);
/* set url */
if (1) {
GWEN_BUFFER *tbuf;
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
rv=GWEN_Url_toString(url, tbuf);
if (rv<0) {
DBG_ERROR(0, "Internal error storing URL");
return 3;
}
EBC_User_SetServerUrl(user, GWEN_Buffer_GetStart(tbuf));
GWEN_Buffer_free(tbuf);
}
GWEN_Url_free(url);
if (importing) {
EBC_User_AddFlags(user, EBC_USER_FLAGS_INI | EBC_USER_FLAGS_HIA);
EBC_User_SetStatus(user, EBC_UserStatus_Enabled);
}
rv=AB_Provider_AddUser(pro, user);
if (rv<0) {
DBG_ERROR(AQEBICS_LOGDOMAIN, "Coud not add new user (%d)", rv);
AB_User_free(user);
return 4;
}
AB_User_free(user);
/* context no longer needed */
GWEN_Crypt_Token_Context_free(ctx);
}
return 0;
}
int listAccounts(AB_BANKING *ab,
GWEN_DB_NODE *dbArgs,
int argc,
char **argv) {
GWEN_DB_NODE *db;
int rv;
AB_ACCOUNT_LIST2 *al;
const GWEN_ARGS args[]={
{
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;
}
rv=AB_Banking_Init(ab);
if (rv) {
DBG_ERROR(0, "Error on init (%d)", rv);
return 2;
}
rv=AB_Banking_OnlineInit(ab);
if (rv) {
DBG_ERROR(0, "Error on init (%d)", rv);
return 2;
}
al=AB_Banking_FindAccounts(ab, EBC_PROVIDER_NAME, "*", "*", "*", "*");
if (al) {
AB_ACCOUNT_LIST2_ITERATOR *ait;
ait=AB_Account_List2_First(al);
if (ait) {
AB_ACCOUNT *a;
int i=0;
a=AB_Account_List2Iterator_Data(ait);
assert(a);
while(a) {
fprintf(stdout, "Account %d: Bank: %s Account Number: %s\n",
i++,
AB_Account_GetBankCode(a),
AB_Account_GetAccountNumber(a));
a=AB_Account_List2Iterator_Next(ait);
}
AB_Account_List2Iterator_free(ait);
}
AB_Account_List2_free(al);
}
rv=AB_Banking_OnlineFini(ab);
if (rv) {
fprintf(stderr, "ERROR: Error on deinit (%d)\n", rv);
return 5;
}
rv=AB_Banking_Fini(ab);
if (rv) {
fprintf(stderr, "ERROR: Error on deinit (%d)\n", rv);
return 5;
}
return 0;
}
int AH_Msg_DecryptPinTan(AH_MSG *hmsg, GWEN_DB_NODE *gr){
AH_HBCI *h;
GWEN_BUFFER *mbuf;
uint32_t l;
const uint8_t *p;
GWEN_MSGENGINE *e;
AB_USER *u;
const char *peerId;
// uint32_t uFlags;
GWEN_DB_NODE *nhead=NULL;
GWEN_DB_NODE *ndata=NULL;
const char *crypterId;
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);
/* get encrypted session key */
nhead=GWEN_DB_GetGroup(gr,
GWEN_DB_FLAGS_DEFAULT |
GWEN_PATH_FLAGS_NAMEMUSTEXIST,
"CryptHead");
if (!nhead) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "No crypt head");
return GWEN_ERROR_BAD_DATA;
}
ndata=GWEN_DB_GetGroup(gr,
GWEN_DB_FLAGS_DEFAULT |
GWEN_PATH_FLAGS_NAMEMUSTEXIST,
"CryptData");
if (!ndata) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "No crypt data");
return GWEN_ERROR_BAD_DATA;
}
crypterId=GWEN_DB_GetCharValue(nhead, "key/userId", 0, I18N("unknown"));
/* get encrypted data */
p=GWEN_DB_GetBinValue(ndata,
"CryptData",
0,
0,0,
&l);
if (!p || !l) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "No crypt data");
return GWEN_ERROR_BAD_DATA;
}
/* decipher message with session key */
mbuf=GWEN_Buffer_new(0, l, 0, 1);
GWEN_Buffer_AppendBytes(mbuf, (const char*)p, l);
/* store crypter id */
AH_Msg_SetCrypterId(hmsg, crypterId);
/* store new buffer inside message */
GWEN_Buffer_free(hmsg->origbuffer);
hmsg->origbuffer=hmsg->buffer;
GWEN_Buffer_Rewind(mbuf);
hmsg->buffer=mbuf;
return 0;
}
