/* Prints all results that can be found in the outbox into the interactor */
static void gnc_hbci_printresult(HBCI_Outbox *outbox, GNCInteractor *inter)
{
/* Got no sysid. */
GWEN_DB_NODE *rsp, *n;
g_assert(outbox);
if (!inter)
return;
rsp = HBCI_Outbox_response(outbox);
n = GWEN_DB_GetFirstGroup(rsp);
while (n)
{
if (strcasecmp(GWEN_DB_GroupName(n), "msgresult") == 0)
{
GWEN_DB_NODE *r = GWEN_DB_GetFirstGroup(n);
while (r)
{
if (strcasecmp(GWEN_DB_GroupName(r), "result") == 0)
{
gchar *logtext;
int resultcode;
const char *text, *elementref, *param;
resultcode = GWEN_DB_GetIntValue(r, "resultcode", 0, 0);
text = GWEN_DB_GetCharValue(r, "text", 0, "Response without text");
elementref = GWEN_DB_GetCharValue(r, "elementref", 0, "");
param = GWEN_DB_GetCharValue(r, "param", 0, "");
if (strlen(elementref) > 0 || strlen(param) > 0)
logtext = g_strdup_printf("%s (%d; Elementref %s; Param %s)", text,
resultcode, elementref, param);
else
logtext = g_strdup_printf("%s (%d)", text, resultcode);
GNCInteractor_add_log_text(inter, logtext);
g_free(logtext);
}
r = GWEN_DB_GetNextGroup(r);
}
}
else if (strcasecmp(GWEN_DB_GroupName(n), "segresult") == 0)
{
GWEN_DB_NODE *r = GWEN_DB_GetFirstGroup(n);
while (r)
{
if (strcasecmp(GWEN_DB_GroupName(r), "result") == 0)
{
}
r = GWEN_DB_GetNextGroup(r);
}
}
n = GWEN_DB_GetNextGroup(n);
} /* while */
GWEN_DB_Group_free(rsp);
}
int LC_Client_GetReaderAndDriverType(const LC_CLIENT *cl,
const char *readerName,
GWEN_BUFFER *driverType,
GWEN_BUFFER *readerType,
uint32_t *pReaderFlags) {
GWEN_DB_NODE *dbDriver;
dbDriver=GWEN_DB_FindFirstGroup(lc_client__driver_db, "driver");
while(dbDriver) {
const char *sDriverName;
sDriverName=GWEN_DB_GetCharValue(dbDriver, "driverName", 0, NULL);
if (sDriverName) {
GWEN_DB_NODE *dbReader;
dbReader=GWEN_DB_FindFirstGroup(dbDriver, "reader");
while(dbReader) {
const char *sReaderName;
const char *sTmpl;
sReaderName=GWEN_DB_GetCharValue(dbReader, "readerType", 0, NULL);
sTmpl=GWEN_DB_GetCharValue(dbReader, "devicePathTmpl", 0, NULL);
if (sReaderName && sTmpl) {
if (-1!=GWEN_Text_ComparePattern(readerName, sTmpl, 1)) {
/* reader found */
GWEN_Buffer_AppendString(driverType, sDriverName);
GWEN_Buffer_AppendString(readerType, sReaderName);
*pReaderFlags=LC_ReaderFlags_fromDb(dbReader, "flags");
DBG_INFO(LC_LOGDOMAIN,
"Reader [%s] is [%s]/[%s], %08x",
readerName,
sDriverName, sReaderName, *pReaderFlags);
return 0;
}
}
else {
DBG_INFO(LC_LOGDOMAIN,
"Either reader name or template missing");
}
dbReader=GWEN_DB_FindNextGroup(dbReader, "reader");
}
}
else {
DBG_INFO(LC_LOGDOMAIN,
"Driver name is missing");
}
dbDriver=GWEN_DB_FindNextGroup(dbDriver, "driver");
}
return GWEN_ERROR_NOT_FOUND;
}
GWEN_CRYPT_PADDALGO *GWEN_Crypt_PaddAlgo_fromDb(GWEN_DB_NODE *db)
{
const char *s;
assert(db);
s=GWEN_DB_GetCharValue(db, "id", 0, NULL);
if (s) {
GWEN_CRYPT_PADDALGO *a;
GWEN_CRYPT_PADDALGOID id;
id=GWEN_Crypt_PaddAlgoId_fromString(s);
if (id==GWEN_Crypt_PaddAlgoId_Unknown) {
DBG_INFO(GWEN_LOGDOMAIN, "Unknown paddalgo id [%s]", s);
return NULL;
}
a=GWEN_Crypt_PaddAlgo_new(id);
assert(a);
a->paddSize=GWEN_DB_GetIntValue(db, "paddSize", 0, 0);
return a;
}
else {
DBG_INFO(GWEN_LOGDOMAIN, "Missing paddalgo id");
return NULL;
}
}
uint32_t LC_DriverFlags_fromDb(GWEN_DB_NODE *db, const char *name) {
const char *p;
int i;
uint32_t flags=0;
for (i=0; ; i++) {
p=GWEN_DB_GetCharValue(db, name, i, 0);
if (!p)
break;
if (strcasecmp(p, "auto")==0)
flags|=LC_DRIVER_FLAGS_AUTO;
else if (strcasecmp(p, "remote")==0)
flags|=LC_DRIVER_FLAGS_REMOTE;
else if (strcasecmp(p, "has_verify_fn")==0)
flags|=LC_DRIVER_FLAGS_HAS_VERIFY_FN;
else if (strcasecmp(p, "has_modify_fn")==0)
flags|=LC_DRIVER_FLAGS_HAS_MODIFY_FN;
else if (strcasecmp(p, "config")==0)
flags|=LC_DRIVER_FLAGS_CONFIG;
else {
DBG_WARN(0, "Unknown driver flag \"%s\"", p);
}
}
return flags;
}
/* --------------------------------------------------------------- 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;
}
/* --------------------------------------------------------------- FUNCTION */
int AH_Job_SepaStandingOrderGet_Prepare(AH_JOB *j) {
GWEN_DB_NODE *dbArgs;
GWEN_DB_NODE *profile;
DBG_INFO(AQHBCI_LOGDOMAIN, "Preparing job");
dbArgs=AH_Job_GetArguments(j);
/* find the right profile to produce pain.001 messages */
profile=AH_Job_FindSepaProfile(j, "001*", AH_User_GetSepaTransferProfile(AH_Job_GetUser(j)));
if (!profile) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "No suitable profile found");
return GWEN_ERROR_GENERIC;
}
else {
const char *s;
s=GWEN_DB_GetCharValue(profile, "descriptor", 0, 0);
if (s) {
GWEN_DB_SetCharValue(dbArgs,
GWEN_DB_FLAGS_OVERWRITE_VARS,
"SupportedSepaFormats/Format",
s);
}
else {
DBG_ERROR(AQHBCI_LOGDOMAIN, "No matching SEPA descriptor found");
return GWEN_ERROR_GENERIC;
}
}
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 GWEN_DBIO_XmlDb_Import(GWEN_DBIO *dbio,
GWEN_SYNCIO *sio,
GWEN_DB_NODE *data,
GWEN_DB_NODE *cfg,
uint32_t flags) {
int rv;
GWEN_XMLNODE *root;
GWEN_XMLNODE *n;
const char *rootName=0;
GWEN_XML_CONTEXT *ctx;
assert(data);
if (cfg)
rootName=GWEN_DB_GetCharValue(cfg, "rootElement", 0, 0);
root=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "root");
ctx=GWEN_XmlCtxStore_new(root,
GWEN_XML_FLAGS_DEFAULT |
GWEN_XML_FLAGS_HANDLE_HEADERS);
rv=GWEN_XMLContext_ReadFromIo(ctx, sio);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_XmlCtx_free(ctx);
GWEN_XMLNode_free(root);
return rv;
}
GWEN_XmlCtx_free(ctx);
if (rootName) {
n=GWEN_XMLNode_FindFirstTag(root, rootName, 0, 0);
if (!n) {
DBG_ERROR(GWEN_LOGDOMAIN,
"Root node in XML file is not \"%s\"", rootName);
GWEN_XMLNode_free(root);
return GWEN_ERROR_BAD_DATA;
}
}
else {
n=GWEN_XMLNode_GetFirstTag(root);
if (!n) {
DBG_ERROR(GWEN_LOGDOMAIN,
"No root node in XML file");
GWEN_XMLNode_free(root);
return GWEN_ERROR_BAD_DATA;
}
}
rv=GWEN_DBIO__XmlDb_ImportGroup(dbio, flags, data, cfg, n);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_XMLNode_free(root);
return rv;
}
GWEN_XMLNode_free(root);
return 0;
}
void AH_User_LoadSepaDescriptors(AB_USER *u) {
AH_USER *ue;
GWEN_DB_NODE *db;
int rv;
assert(u);
ue=GWEN_INHERIT_GETDATA(AB_USER, AH_USER, u);
assert(ue);
/* read directly from BPD */
GWEN_StringList_Clear(ue->sepaDescriptors);
db=GWEN_DB_Group_new("bpd");
rv=AH_Job_SampleBpdVersions("JobGetAccountSepaInfo", u, db);
if (rv<0) {
DBG_INFO(AQHBCI_LOGDOMAIN, "No BPD for TAN job");
}
else {
GWEN_DB_NODE *dbV;
dbV=GWEN_DB_GetFirstGroup(db);
while(dbV) {
int version;
version=atoi(GWEN_DB_GroupName(dbV));
if (version>0) {
GWEN_DB_NODE *dbT;
/* always overwrite with latest version received */
GWEN_StringList_Clear(ue->sepaDescriptors);
dbT=GWEN_DB_FindFirstGroup(dbV, "SupportedSepaFormats");
if (!dbT) {
DBG_INFO(AQHBCI_LOGDOMAIN, "No SEPA descriptor found");
}
while(dbT) {
int i;
for (i=0; i<100; i++) {
const char *s;
s=GWEN_DB_GetCharValue(dbT, "format", i, NULL);
if (! (s && *s))
break;
GWEN_StringList_AppendString(ue->sepaDescriptors, s, 0, 1);
DBG_INFO(AQHBCI_LOGDOMAIN,
"Adding SEPA descriptor [%s] for GV version %d",
s, version);
}
dbT=GWEN_DB_FindNextGroup(dbT, "SupportedSepaFormats");
}
}
dbV=GWEN_DB_GetNextGroup(dbV);
}
}
GWEN_DB_Group_free(db);
}
AB_VALUE *AB_Value_fromDb(GWEN_DB_NODE *db){
AB_VALUE *vc;
const char *p;
/* read and parse value */
p=GWEN_DB_GetCharValue(db, "value", 0, 0);
if (!p)
return NULL;
vc=AB_Value_fromString(p);
if (vc==NULL)
return NULL;
/* read currency (if any) */
p=GWEN_DB_GetCharValue(db, "currency", 0, "EUR");
if (p)
AB_Value_SetCurrency(vc, p);
return vc;
}
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;
}
/* --------------------------------------------------------------- FUNCTION */
AH_JOB *AH_Job_GetTransactions_new(AB_PROVIDER *pro, AB_USER *u, AB_ACCOUNT *account)
{
AH_JOB *j;
AH_JOB_GETTRANSACTIONS *aj;
GWEN_DB_NODE *dbArgs;
GWEN_DB_NODE *updgroup;
int useCreditCardJob = 0;
//Check if we should use DKKKU
updgroup=AH_User_GetUpdForAccount(u, account);
if (updgroup) {
GWEN_DB_NODE *n;
n=GWEN_DB_GetFirstGroup(updgroup);
while (n) {
if (strcasecmp(GWEN_DB_GetCharValue(n, "job", 0, ""), "DKKKU")==0) {
useCreditCardJob = 1;
break;
}
n=GWEN_DB_GetNextGroup(n);
} /* while */
} /* if updgroup for the given account found */
if (useCreditCardJob)
j=AH_AccountJob_new("JobGetTransactionsCreditCard", pro, u, account);
else
j=AH_AccountJob_new("JobGetTransactions", pro, u, account);
if (!j)
return 0;
GWEN_NEW_OBJECT(AH_JOB_GETTRANSACTIONS, aj);
GWEN_INHERIT_SETDATA(AH_JOB, AH_JOB_GETTRANSACTIONS, j, aj, AH_Job_GetTransactions_FreeData);
AH_Job_SetSupportedCommand(j, AB_Transaction_CommandGetTransactions);
/* overwrite some virtual functions */
if (useCreditCardJob)
AH_Job_SetProcessFn(j, AH_Job_GetTransactionsCreditCard_Process);
else
AH_Job_SetProcessFn(j, AH_Job_GetTransactions_Process);
AH_Job_SetGetLimitsFn(j, AH_Job_GetTransactions_GetLimits);
AH_Job_SetHandleCommandFn(j, AH_Job_GetTransactions_HandleCommand);
AH_Job_SetHandleResultsFn(j, AH_Job_HandleResults_Empty);
/* set some known arguments */
dbArgs=AH_Job_GetArguments(j);
assert(dbArgs);
if (useCreditCardJob)
GWEN_DB_SetCharValue(dbArgs, GWEN_DB_FLAGS_DEFAULT,
"accountNumber", AB_Account_GetAccountNumber(account));
else
GWEN_DB_SetCharValue(dbArgs, GWEN_DB_FLAGS_DEFAULT,
"allAccounts", "N");
return j;
}
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;
}
/* --------------------------------------------------------------- FUNCTION */
AH_JOB *AH_Job_GetBalance_new(AB_USER *u, AB_ACCOUNT *account) {
AH_JOB *j;
AH_JOB_GETBALANCE *aj;
GWEN_DB_NODE *dbArgs;
int useCreditCardJob=0;
GWEN_DB_NODE *updgroup;
//Check if we should use DKKKS
updgroup=AH_User_GetUpdForAccount(u, account);
if (updgroup) {
GWEN_DB_NODE *n;
n=GWEN_DB_GetFirstGroup(updgroup);
while(n) {
if (strcasecmp(GWEN_DB_GetCharValue(n, "job", 0, ""),
"DKKKS")==0) {
useCreditCardJob = 1;
break;
}
n=GWEN_DB_GetNextGroup(n);
} /* while */
} /* if updgroup for the given account found */
if(useCreditCardJob)
j=AH_AccountJob_new("JobGetBalanceCreditCard", u, account);
else
j=AH_AccountJob_new("JobGetBalance", u, account);
if (!j)
return 0;
GWEN_NEW_OBJECT(AH_JOB_GETBALANCE, aj);
GWEN_INHERIT_SETDATA(AH_JOB, AH_JOB_GETBALANCE, j, aj, AH_Job_GetBalance_FreeData);
/* overwrite some virtual functions */
AH_Job_SetProcessFn(j, AH_Job_GetBalance_Process);
AH_Job_SetExchangeFn(j, AH_Job_GetBalance_Exchange);
/* set some known arguments */
dbArgs=AH_Job_GetArguments(j);
assert(dbArgs);
if(useCreditCardJob)
GWEN_DB_SetCharValue(dbArgs, GWEN_DB_FLAGS_DEFAULT,
"accountNumber", AB_Account_GetAccountNumber(account));
else
GWEN_DB_SetCharValue(dbArgs, GWEN_DB_FLAGS_DEFAULT,
"allAccounts", "N");
return j;
}
int GWEN_DBIO_XmlDb_Export(GWEN_DBIO *dbio,
GWEN_SYNCIO *sio,
GWEN_DB_NODE *data,
GWEN_DB_NODE *cfg,
uint32_t flags) {
GWEN_XMLNODE *root;
GWEN_XMLNODE *nh;
int rv;
const char *rootName=0;
GWEN_XML_CONTEXT *ctx;
if (cfg)
rootName=GWEN_DB_GetCharValue(cfg, "rootElement", 0, 0);
root=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "root");
nh=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "?xml");
GWEN_XMLNode_SetProperty(nh, "version", "1.0");
GWEN_XMLNode_SetProperty(nh, "encoding", "utf-8");
GWEN_XMLNode_AddHeader(root, nh);
rv=GWEN_DBIO_XmlDb__ExportGroup(dbio, data, root, rootName);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_XMLNode_free(root);
return rv;
}
ctx=GWEN_XmlCtxStore_new(root,
GWEN_XML_FLAGS_DEFAULT |
GWEN_XML_FLAGS_SIMPLE |
GWEN_XML_FLAGS_HANDLE_HEADERS);
rv=GWEN_XMLNode_WriteToStream(root, ctx, sio);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_XmlCtx_free(ctx);
GWEN_XMLNode_free(root);
return rv;
}
GWEN_XmlCtx_free(ctx);
GWEN_XMLNode_free(root);
return 0;
}
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;
}
GWEN_DATE *GWEN_Date_fromDb(GWEN_DB_NODE *db) {
const char *s;
s=GWEN_DB_GetCharValue(db, "dateString", 0, NULL);
if (s && *s) {
GWEN_DATE *dt;
dt=GWEN_Date_fromString(s);
if (dt==NULL) {
DBG_INFO(GWEN_LOGDOMAIN, "Invalid date [%s]", s);
return NULL;
}
return dt;
}
else {
DBG_VERBOUS(GWEN_LOGDOMAIN, "no or empty date");
return NULL;
}
}
uint32_t LC_ServiceFlags_fromDb(GWEN_DB_NODE *db, const char *name){
const char *p;
int i;
uint32_t flags=0;
for (i=0; ; i++) {
p=GWEN_DB_GetCharValue(db, name, i, 0);
if (!p)
break;
if (strcasecmp(p, "autoload")==0)
flags|=LC_SERVICE_FLAGS_AUTOLOAD;
else if (strcasecmp(p, "client")==0)
flags|=LC_SERVICE_FLAGS_CLIENT;
else if (strcasecmp(p, "silent")==0)
flags|=LC_SERVICE_FLAGS_SILENT;
else {
DBG_WARN(0, "Unknown service flag \"%s\"", p);
}
}
return flags;
}
int buildDefs(GWEN_DB_NODE *dbArgs) {
int i;
for (i=0; i<99; i++) {
const char *fileName;
fileName=GWEN_DB_GetCharValue(dbArgs, "params", i, NULL);
if (fileName) {
int rv=doBuildDefs(dbArgs, fileName);
if (rv != 0) {
DBG_ERROR(GWEN_LOGDOMAIN, "Error building type from [%s]", fileName);
return 2;
}
}
else {
if (i==0) {
DBG_ERROR(GWEN_LOGDOMAIN, "No input");
return 1;
}
}
}
return 0;
}
uint32_t LC_ReaderFlags_fromDb(GWEN_DB_NODE *db, const char *name) {
int i;
const char *p;
uint32_t flags=0;
for (i=0; ; i++) {
p=GWEN_DB_GetCharValue(db, name, i, 0);
if (!p)
break;
if (strcasecmp(p, "keypad")==0)
flags|=LC_READER_FLAGS_KEYPAD;
else if (strcasecmp(p, "display")==0)
flags|=LC_READER_FLAGS_DISPLAY;
else if (strcasecmp(p, "noinfo")==0)
flags|=LC_READER_FLAGS_NOINFO;
else if (strcasecmp(p, "remote")==0)
flags|=LC_READER_FLAGS_REMOTE;
else if (strcasecmp(p, "auto")==0)
flags|=LC_READER_FLAGS_AUTO;
else if (strcasecmp(p, "suspended_checks")==0)
flags|=LC_READER_FLAGS_SUSPENDED_CHECKS;
else if (strcasecmp(p, "driverHasVerify")==0)
flags|=LC_READER_FLAGS_DRIVER_HAS_VERIFY;
else if (strcasecmp(p, "keepRunning")==0)
flags|=LC_READER_FLAGS_KEEP_RUNNING;
else if (strcasecmp(p, "lowWriteBoundary")==0)
flags|=LC_READER_FLAGS_LOW_WRITE_BOUNDARY;
else if (strcasecmp(p, "noMemorySw")==0)
flags|=LC_READER_FLAGS_NO_MEMORY_SW;
else {
DBG_WARN(0, "Unknown flag \"%s\", ignoring", p);
}
} /* for */
return flags;
}
uint32_t AH_User_Flags_fromDb(GWEN_DB_NODE *db, const char *name) {
uint32_t fl=0;
int i;
for (i=0; ; i++) {
const char *s;
s=GWEN_DB_GetCharValue(db, name, i, 0);
if (!s)
break;
if (strcasecmp(s, "bankDoesntSign")==0)
fl|=AH_USER_FLAGS_BANK_DOESNT_SIGN;
else if (strcasecmp(s, "bankUsesSignSeq")==0)
fl|=AH_USER_FLAGS_BANK_USES_SIGNSEQ;
else if (strcasecmp(s, "keepAlive")==0)
fl|=AH_USER_FLAGS_KEEPALIVE;
else if (strcasecmp(s, "ignoreUpd")==0)
fl|=AH_USER_FLAGS_IGNORE_UPD;
else if (strcasecmp(s, "forceSsl3")==0 ||
strcasecmp(s, "forceSslv3")==0)
fl|=AH_USER_FLAGS_FORCE_SSL3;
else if (strcasecmp(s, "noBase64")==0)
fl|=AH_USER_FLAGS_NO_BASE64;
else if (strcasecmp(s, "keepMultipleBlanks")==0)
fl|=AH_USER_FLAGS_KEEP_MULTIPLE_BLANKS;
else if (strcasecmp(s, "omitSmsAccount")==0)
fl|=AH_USER_FLAGS_TAN_OMIT_SMS_ACCOUNT;
else if (strcasecmp(s, "tlsOnlySafeCiphers")==0)
fl|=AH_USER_FLAGS_TLS_ONLY_SAFE_CIPHERS;
else {
DBG_WARN(AQHBCI_LOGDOMAIN, "Unknown user flag \"%s\"", s);
}
}
return fl;
}
int GWEN_PathManager_RemovePaths(const char *callingLib) {
GWEN_DB_NODE *dbT;
const char *s;
assert(gwen__paths);
GWEN_DB_DeleteGroup(gwen__paths, callingLib);
dbT=GWEN_DB_GetFirstGroup(gwen__paths);
while(dbT) {
GWEN_DB_NODE *dbN;
dbN=GWEN_DB_GetFirstGroup(dbT);
while(dbN) {
GWEN_DB_NODE *dbNN;
dbNN=GWEN_DB_FindFirstGroup(dbN, "pair");
while(dbNN) {
GWEN_DB_NODE *dbNext;
dbNext=GWEN_DB_FindNextGroup(dbNN, "pair");
s=GWEN_DB_GetCharValue(dbNN, "lib", 0, 0);
assert(s);
if (s && strcasecmp(s, callingLib)==0) {
GWEN_DB_UnlinkGroup(dbNN);
GWEN_DB_Group_free(dbNN);
}
dbNN=dbNext;
} /* while pairs */
dbN=GWEN_DB_GetNextGroup(dbN);
} /* while paths */
dbT=GWEN_DB_GetNextGroup(dbT);
} /* while destLibs */
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 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 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 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;
}
int AH_Msg_VerifyPinTan(AH_MSG *hmsg, GWEN_DB_NODE *gr) {
AH_HBCI *h;
GWEN_LIST *sigheads;
GWEN_LIST *sigtails;
GWEN_DB_NODE *n;
int nonSigHeads;
int nSigheads;
unsigned int dataBegin;
// char *dataStart;
// unsigned int dataLength;
unsigned int i;
AB_USER *u;
assert(hmsg);
h=AH_Dialog_GetHbci(hmsg->dialog);
assert(h);
u=AH_Dialog_GetDialogOwner(hmsg->dialog);
assert(u);
/* let's go */
sigheads=GWEN_List_new();
/* enumerate signature heads */
nonSigHeads=0;
nSigheads=0;
n=GWEN_DB_GetFirstGroup(gr);
while(n) {
if (strcasecmp(GWEN_DB_GroupName(n), "SigHead")==0) {
/* found a signature head */
if (nonSigHeads) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Found some unsigned parts at the beginning");
GWEN_List_free(sigheads);
return GWEN_ERROR_BAD_DATA;
}
GWEN_List_PushBack(sigheads, n);
nSigheads++;
}
else if (strcasecmp(GWEN_DB_GroupName(n), "MsgHead")!=0) {
if (nSigheads)
break;
nonSigHeads++;
}
n=GWEN_DB_GetNextGroup(n);
} /* while */
if (!n) {
if (nSigheads) {
DBG_ERROR(AQHBCI_LOGDOMAIN,
"Found Signature heads but no other segments");
GWEN_List_free(sigheads);
return GWEN_ERROR_BAD_DATA;
}
DBG_DEBUG(AQHBCI_LOGDOMAIN, "No signatures");
GWEN_List_free(sigheads);
return 0;
}
/* store begin of signed data */
dataBegin=GWEN_DB_GetIntValue(n, "segment/pos", 0, 0);
if (!dataBegin) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "No position specifications in segment");
GWEN_List_free(sigheads);
return GWEN_ERROR_BAD_DATA;
}
/* now get first signature tail */
while(n) {
if (strcasecmp(GWEN_DB_GroupName(n), "SigTail")==0) {
unsigned int currpos;
/* found a signature tail */
currpos=GWEN_DB_GetIntValue(n, "segment/pos", 0, 0);
if (!currpos || dataBegin>currpos) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Bad position specification in Signature tail");
GWEN_List_free(sigheads);
return GWEN_ERROR_BAD_DATA;
}
// dataLength=currpos-dataBegin;
break;
}
n=GWEN_DB_GetNextGroup(n);
} /* while */
if (!n) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "No signature tail found");
GWEN_List_free(sigheads);
return GWEN_ERROR_BAD_DATA;
}
sigtails=GWEN_List_new();
while(n) {
if (strcasecmp(GWEN_DB_GroupName(n), "SigTail")!=0)
break;
GWEN_List_PushBack(sigtails, n);
n=GWEN_DB_GetNextGroup(n);
} /* while */
if (!n) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Message tail expected");
GWEN_List_free(sigheads);
GWEN_List_free(sigtails);
return GWEN_ERROR_BAD_DATA;
}
if (strcasecmp(GWEN_DB_GroupName(n), "MsgTail")!=0) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Unexpected segment (msg tail expected)");
GWEN_List_free(sigheads);
GWEN_List_free(sigtails);
return GWEN_ERROR_BAD_DATA;
}
n=GWEN_DB_GetNextGroup(n);
if (n) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Unexpected segment (end expected)");
GWEN_List_free(sigheads);
GWEN_List_free(sigtails);
return GWEN_ERROR_BAD_DATA;
}
if (GWEN_List_GetSize(sigheads)!=
GWEN_List_GetSize(sigtails)) {
DBG_ERROR(AQHBCI_LOGDOMAIN,
"Number of signature heads (%d) does not match "
"number of signature tails (%d)",
GWEN_List_GetSize(sigheads),
GWEN_List_GetSize(sigtails));
GWEN_List_free(sigheads);
GWEN_List_free(sigtails);
return GWEN_ERROR_BAD_DATA;
}
/* ok, now verify all signatures */
// dataStart=GWEN_Buffer_GetStart(hmsg->buffer)+dataBegin;
for (i=0; i< GWEN_List_GetSize(sigtails); i++) {
GWEN_DB_NODE *sighead;
GWEN_DB_NODE *sigtail;
const char *signerId;
/* get signature tail */
sigtail=(GWEN_DB_NODE*)GWEN_List_GetBack(sigtails);
/* get corresponding signature head */
sighead=(GWEN_DB_NODE*)GWEN_List_GetFront(sigheads);
if (!sighead || !sigtail) {
DBG_ERROR(AQHBCI_LOGDOMAIN,
"No signature head/tail left (internal error)");
GWEN_List_free(sigheads);
GWEN_List_free(sigtails);
return GWEN_ERROR_INTERNAL;
}
GWEN_List_PopBack(sigtails);
GWEN_List_PopFront(sigheads);
signerId=GWEN_DB_GetCharValue(sighead, "key/userid", 0,
I18N("unknown"));
/* some checks */
if (strcasecmp(GWEN_DB_GetCharValue(sighead, "ctrlref", 0, ""),
GWEN_DB_GetCharValue(sigtail, "ctrlref", 0, ""))!=0) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Non-matching signature tail");
GWEN_List_free(sigheads);
GWEN_List_free(sigtails);
return GWEN_ERROR_BAD_DATA;
}
/* verify signature */
DBG_INFO(AQHBCI_LOGDOMAIN, "Message signed by \"%s\"", signerId);
AH_Msg_AddSignerId(hmsg, signerId);
DBG_DEBUG(AQHBCI_LOGDOMAIN, "Verification done");
} /* for */
GWEN_List_free(sigheads);
GWEN_List_free(sigtails);
return 0;
}
int main(int argc, char **argv) {
int rv;
GWEN_DB_NODE *db;
const char *s;
LC_CLIENT *cl;
LC_CLIENT_RESULT res;
GWEN_GUI *gui;
int v;
gui=GWEN_Gui_CGui_new();
GWEN_Gui_SetGui(gui);
db=GWEN_DB_Group_new("arguments");
rv=GWEN_Args_Check(argc, argv, 1,
GWEN_ARGS_MODE_ALLOW_FREEPARAM,
prg_args,
db);
if (rv==GWEN_ARGS_RESULT_HELP) {
GWEN_BUFFER *ubuf;
ubuf=GWEN_Buffer_new(0, 256, 0, 1);
if (GWEN_Args_Usage(prg_args, ubuf, GWEN_ArgsOutType_Txt)) {
fprintf(stderr, "Could not generate usage string.\n");
GWEN_Buffer_free(ubuf);
return RETURNVALUE_PARAM;
}
usage(argv[0], GWEN_Buffer_GetStart(ubuf));
GWEN_Buffer_free(ubuf);
return 0;
}
if (rv<1) {
fprintf(stderr, "ERROR: Error in argument list (%d)\n", rv);
return RETURNVALUE_PARAM;
}
v=GWEN_DB_GetIntValue(db, "verbosity", 0, 0);
if (v<2)
GWEN_Gui_AddFlags(gui, GWEN_GUI_FLAGS_NONINTERACTIVE);
/* get command */
s=GWEN_DB_GetCharValue(db, "params", 0, 0);
if (!s) {
fprintf(stderr, "No command given.\n");
GWEN_DB_Group_free(db);
return RETURNVALUE_PARAM;
}
cl=LC_Client_new("kvkcard", PROGRAM_VERSION);
res=LC_Client_Init(cl);
if (res!=LC_Client_ResultOk) {
showError(0, res, "Init");
return RETURNVALUE_SETUP;
}
/* handle command */
if (strcasecmp(s, "read")==0) {
rv=kvkRead(cl, db);
}
else if (strcasecmp(s, "daemon")==0) {
fprintf(stderr, "KVK daemon no longer supported.\n");
return RETURNVALUE_SETUP;
}
else if (strcasecmp(s, "rdvd")==0) {
rv=rdvd(cl, db);
}
else if (strcasecmp(s, "rdpd")==0) {
rv=rdpd(cl, db);
}
else if (strcasecmp(s, "psvd")==0) {
rv=psvd(cl, db);
}
else {
fprintf(stderr, "Unknown command \"%s\"", s);
rv=RETURNVALUE_PARAM;
}
LC_Client_free(cl);
GWEN_DB_Group_free(db);
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;
}
}
