int AH_User_SetPinStatus(AB_USER *u,
const char *pin,
GWEN_GUI_PASSWORD_STATUS status){
GWEN_BUFFER *nbuf;
int rv;
nbuf=GWEN_Buffer_new(0, 256 ,0 ,1);
AH_User_MkPinName(u, nbuf);
rv=GWEN_Gui_SetPasswordStatus(GWEN_Buffer_GetStart(nbuf),
pin,
status,
0);
GWEN_Buffer_free(nbuf);
return rv;
}
AB_PROVIDER *AB_Provider_new(AB_BANKING *ab, const char *name){
AB_PROVIDER *pro;
GWEN_BUFFER *nbuf;
assert(ab);
assert(name);
nbuf=GWEN_Buffer_new(0, 256, 0, 1);
if (GWEN_Text_EscapeToBufferTolerant(name, nbuf)) {
DBG_ERROR(AQBANKING_LOGDOMAIN,
"Bad backend name, aborting.");
GWEN_Buffer_free(nbuf);
abort();
}
else {
char *s;
s=GWEN_Buffer_GetStart(nbuf);
while(*s) {
*s=tolower(*s);
s++;
}
}
GWEN_NEW_OBJECT(AB_PROVIDER, pro);
pro->usage=1;
GWEN_INHERIT_INIT(AB_PROVIDER, pro);
GWEN_LIST_INIT(AB_PROVIDER, pro);
pro->banking=ab;
pro->name=strdup(name);
pro->escName=strdup(GWEN_Buffer_GetStart(nbuf));
GWEN_Buffer_free(nbuf);
return pro;
}
int AIO_OfxXmlCtx_SanitizeData(GWEN_XML_CONTEXT *ctx,
const char *data,
GWEN_BUFFER *buf) {
AIO_OFX_XMLCTX *xctx;
assert(ctx);
xctx=GWEN_INHERIT_GETDATA(GWEN_XML_CONTEXT, AIO_OFX_XMLCTX, ctx);
assert(xctx);
if (xctx->charset) {
GWEN_BUFFER *tbuf;
int rv;
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
rv=AIO_OfxXmlCtx_CleanupData(ctx, data, tbuf);
if (rv<0) {
DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
return rv;
}
rv=GWEN_Text_ConvertCharset(xctx->charset, "UTF-8",
GWEN_Buffer_GetStart(tbuf),
GWEN_Buffer_GetUsedBytes(tbuf),
buf);
if (rv<0) {
DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
return rv;
}
GWEN_Buffer_free(tbuf);
return 0;
}
else
return AIO_OfxXmlCtx_CleanupData(ctx, data, buf);
}
int GWEN_Logger_Log(const char *logDomain,
GWEN_LOGGER_LEVEL priority, const char *s) {
if (!GWEN_Gui_LogHook(logDomain, priority, s)) {
const char *p;
int rv;
unsigned int i;
GWEN_BUFFER *mbuf;
GWEN_LOGGER *lg;
lg=GWEN_LoggerDomain_GetLogger(logDomain);
assert(lg);
if (!lg->enabled)
return 1;
if (priority>lg->logLevel)
/* priority too low, don't log */
return 0;
/* temporarily disable logging to avoid endless loops */
lg->enabled=0;
/* copy buffer, exchange all newlines by 0 */
mbuf=GWEN_Buffer_new(0, strlen(s)+1, 0, 1);
for (i=0; i<strlen(s)+1; i++) {
if (s[i]=='\n') {
GWEN_Buffer_AppendByte(mbuf, 0);
}
else
GWEN_Buffer_AppendByte(mbuf, s[i]);
}
/* now log each line */
rv=0;
p=GWEN_Buffer_GetStart(mbuf);
while (*p) {
rv|=GWEN_Logger__Log(lg, priority, p);
while(*p)
p++;
p++;
}
GWEN_Buffer_free(mbuf);
/* reenable logging */
lg->enabled=1;
return rv;
}
else
return 0;
}
int GWEN_XML_AddNameSpace(GWEN_STRINGLIST2 *sl,
const char *prefix,
const char *name) {
GWEN_BUFFER *nbuf;
int rv;
nbuf=GWEN_Buffer_new(0, 32, 0, 1);
if (prefix)
GWEN_Buffer_AppendString(nbuf, prefix);
GWEN_Buffer_AppendByte(nbuf, ':');
GWEN_Buffer_AppendString(nbuf, name);
rv=GWEN_StringList2_AppendString(sl, GWEN_Buffer_GetStart(nbuf), 0,
GWEN_StringList2_IntertMode_NoDouble);
GWEN_Buffer_free(nbuf);
return rv;
}
void AB_Value_Dump(const AB_VALUE *v, FILE *f, unsigned int indent) {
unsigned int i;
for (i=0; i<indent; i++)
fprintf(f, " ");
fprintf(f, "Value: ");
if (v) {
GWEN_BUFFER *nbuf;
nbuf=GWEN_Buffer_new(0, 128, 0, 1);
AB_Value_toHumanReadableString(v, nbuf, 2);
gmp_fprintf(f, "%Qi (%s)\n", v->value, GWEN_Buffer_GetStart(nbuf));
GWEN_Buffer_free(nbuf);
}
else
fprintf(f, "[none]\n");
}
int GWEN_Directory_GetFileEntries(const char *folder, GWEN_STRINGLIST *sl,
const char *mask) {
GWEN_DIRECTORY *d;
int rv;
char buffer[256];
GWEN_BUFFER *pbuf;
uint32_t pos;
d=GWEN_Directory_new();
rv=GWEN_Directory_Open(d, folder);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Directory_free(d);
return rv;
}
pbuf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendString(pbuf, folder);
GWEN_Buffer_AppendString(pbuf, GWEN_DIR_SEPARATOR_S);
pos=GWEN_Buffer_GetPos(pbuf);
while(0==GWEN_Directory_Read(d, buffer, sizeof(buffer))) {
if (strcmp(buffer, ".")!=0 &&
strcmp(buffer, "..")!=0 &&
(mask==NULL ||
GWEN_Text_ComparePattern(buffer+1, mask, 0)!=-1)) {
struct stat st;
GWEN_Buffer_AppendString(pbuf, buffer);
if (stat(GWEN_Buffer_GetStart(pbuf), &st)==0) {
if (S_ISREG(st.st_mode))
GWEN_StringList_AppendString(sl, buffer, 0, 1);
}
GWEN_Buffer_Crop(pbuf, 0, pos);
}
}
GWEN_Buffer_free(pbuf);
GWEN_Directory_Close(d);
GWEN_Directory_free(d);
return 0;
}
int AHB_DTAUS__AddWord(GWEN_BUFFER *dst,
unsigned int size,
const char *s) {
unsigned int i;
unsigned int ssize;
GWEN_BUFFER *nbuf;
assert(dst);
assert(size);
assert(s);
DBG_DEBUG(AQBANKING_LOGDOMAIN, "Adding word: %s", s);
nbuf=GWEN_Buffer_new(0, size, 0, 1);
AB_ImExporter_Utf8ToDta(s, -1, nbuf);
s=GWEN_Buffer_GetStart(nbuf);
ssize=strlen(s);
if (ssize>size) {
/* Error out here because e.g. truncated accountid will lead to failed jobs. */
DBG_ERROR(AQBANKING_LOGDOMAIN, "Word \"%s\" too long: Has length %d but must not be longer than %d characters",
s, ssize, size);
return -1;
}
for (i=0; i<size; i++) {
char c;
if (i>=ssize)
c=0;
else
c=s[i];
if (c)
GWEN_Buffer_AppendByte(dst, c);
else
GWEN_Buffer_AppendByte(dst, ' ');
} /* for */
GWEN_Buffer_free(nbuf);
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 AH_NewKeyFileDialog_HandleActivatedFileButton(GWEN_DIALOG *dlg) {
AH_NEWKEYFILE_DIALOG *xdlg;
int rv;
const char *s;
GWEN_BUFFER *pathBuffer;
assert(dlg);
xdlg=GWEN_INHERIT_GETDATA(GWEN_DIALOG, AH_NEWKEYFILE_DIALOG, dlg);
assert(xdlg);
pathBuffer=GWEN_Buffer_new(0, 256, 0, 1);
s=GWEN_Dialog_GetCharProperty(dlg, "wiz_filename_edit", GWEN_DialogProperty_Value, 0, NULL);
if (s && *s)
GWEN_Buffer_AppendString(pathBuffer, s);
rv=GWEN_Gui_GetFileName(I18N("Create Keyfile"),
GWEN_Gui_FileNameType_SaveFileName,
0,
I18N("All Files (*)\tOHBCI Files (*ohbci;*.medium)"),
pathBuffer,
GWEN_Dialog_GetGuiId(dlg));
if (rv==0) {
GWEN_Dialog_SetCharProperty(dlg,
"wiz_filename_edit",
GWEN_DialogProperty_Value,
0,
GWEN_Buffer_GetStart(pathBuffer),
0);
rv=AH_NewKeyFileDialog_GetFilePageData(dlg);
if (rv<0)
GWEN_Dialog_SetIntProperty(dlg, "wiz_next_button", GWEN_DialogProperty_Enabled, 0, 0, 0);
else
GWEN_Dialog_SetIntProperty(dlg, "wiz_next_button", GWEN_DialogProperty_Enabled, 0, 1, 0);
}
else {
DBG_NOTICE(AQHBCI_LOGDOMAIN, "here (%d)", rv);
}
GWEN_Buffer_free(pathBuffer);
return GWEN_DialogEvent_ResultHandled;
}
int GWEN_Crypt_Token_ModuleInit(void)
{
GWEN_PLUGIN_MANAGER *pm;
int err;
GWEN_STRINGLIST *sl;
pm=GWEN_PluginManager_new(GWEN_CRYPT_TOKEN_PLUGIN_TYPENAME, GWEN_PM_LIBNAME);
err=GWEN_PluginManager_Register(pm);
if (err) {
DBG_ERROR(GWEN_LOGDOMAIN, "Could not register CryptToken plugin manager");
return err;
}
/* create plugin paths */
sl=GWEN_PathManager_GetPaths(GWEN_PM_LIBNAME, GWEN_PM_PLUGINDIR);
if (sl) {
GWEN_STRINGLISTENTRY *se;
GWEN_BUFFER *pbuf;
pbuf=GWEN_Buffer_new(0, 256, 0, 1);
se=GWEN_StringList_FirstEntry(sl);
while (se) {
GWEN_Buffer_AppendString(pbuf, GWEN_StringListEntry_Data(se));
GWEN_Buffer_AppendString(pbuf, DIRSEP GWEN_CRYPT_TOKEN_FOLDER);
DBG_INFO(GWEN_LOGDOMAIN, "Adding plugin path [%s]",
GWEN_Buffer_GetStart(pbuf));
GWEN_PluginManager_AddPath(pm, GWEN_PM_LIBNAME,
GWEN_Buffer_GetStart(pbuf));
GWEN_Buffer_Reset(pbuf);
se=GWEN_StringListEntry_Next(se);
}
GWEN_Buffer_free(pbuf);
GWEN_StringList_free(sl);
}
return 0;
}
int 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;
}
LC_CLIENT_RESULT CHIPCARD_CB LC_DDVCard_Open(LC_CARD *card){
LC_CLIENT_RESULT res;
LC_DDVCARD *ddv;
DBG_INFO(LC_LOGDOMAIN, "Opening card as DDV card");
assert(card);
ddv=GWEN_INHERIT_GETDATA(LC_CARD, LC_DDVCARD, card);
assert(ddv);
ddv->ddvType=-1;
GWEN_DB_Group_free(ddv->db_ef_id_1);
ddv->db_ef_id_1=0;
GWEN_Buffer_free(ddv->bin_ef_id_1);
ddv->bin_ef_id_1=0;
if (strcasecmp(LC_Card_GetCardType(card), "PROCESSOR")!=0) {
DBG_ERROR(LC_LOGDOMAIN, "Not a processor card (%s)",
LC_Card_GetCardType(card));
return LC_Client_ResultNotSupported;
}
res=ddv->openFn(card);
if (res!=LC_Client_ResultOk) {
DBG_INFO(LC_LOGDOMAIN, "here");
return res;
}
res=LC_DDVCard_Reopen(card);
if (res!=LC_Client_ResultOk) {
DBG_INFO(LC_LOGDOMAIN, "here");
ddv->closeFn(card);
return res;
}
return LC_Client_ResultOk;
}
void GWEN_DBIO__XmlDb_ReadDataTags(GWEN_XMLNODE *node, GWEN_BUFFER *buf) {
GWEN_XMLNODE *ndata;
GWEN_BUFFER *tbuf;
int rv;
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
ndata=GWEN_XMLNode_GetFirstData(node);
while(ndata) {
const char *s;
s=GWEN_XMLNode_GetData(ndata);
if (s) {
if (GWEN_Buffer_GetUsedBytes(tbuf))
GWEN_Buffer_AppendByte(tbuf, ' ');
GWEN_Buffer_AppendString(tbuf, s);
}
ndata=GWEN_XMLNode_GetNextData(node);
}
rv=GWEN_Text_UnescapeXmlToBuffer(GWEN_Buffer_GetStart(tbuf), buf);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
}
GWEN_Buffer_free(tbuf);
}
static int addToList(const char *fname, int recursive, GWEN_STRINGLIST *sl) {
struct stat st;
int rv;
/* stat file to be added */
#if _BSD_SOURCE || _XOPEN_SOURCE >= 500 || _XOPEN_SOURCE && _XOPEN_SOURCE_EXTENDED
rv=lstat(fname, &st);
#else
rv=stat(fname, &st);
#endif
if (rv) {
DBG_ERROR(GSA_LOGDOMAIN, "stat(%s): %d (%s)",
fname, errno, strerror(errno));
fprintf(stderr, "Ignoring file \"%s\"\n", fname);
}
else {
/* always append this entry */
GWEN_StringList_AppendString(sl, fname, 0, 1);
if (recursive && S_ISDIR(st.st_mode)) {
GWEN_STRINGLIST *sll;
GWEN_STRINGLISTENTRY *se;
GWEN_DIRECTORY *d;
int rv;
char buffer[256];
GWEN_BUFFER *tbuf;
uint32_t pos;
/* add entries */
sll=GWEN_StringList_new();
d=GWEN_Directory_new();
rv=GWEN_Directory_Open(d, fname);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Directory_free(d);
GWEN_StringList_free(sll);
return rv;
}
while(0==GWEN_Directory_Read(d, buffer, sizeof(buffer))) {
if (strcmp(buffer, ".")!=0 &&
strcmp(buffer, "..")!=0)
GWEN_StringList_AppendString(sll, buffer, 0, 1);
}
GWEN_Directory_Close(d);
GWEN_Directory_free(d);
/* recurse */
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendString(tbuf, fname);
GWEN_Buffer_AppendString(tbuf, GWEN_DIR_SEPARATOR_S);
pos=GWEN_Buffer_GetPos(tbuf);
se=GWEN_StringList_FirstEntry(sll);
while(se) {
const char *s;
s=GWEN_StringListEntry_Data(se);
if (s && *s) {
GWEN_Buffer_AppendString(tbuf, s);
rv=addToList(GWEN_Buffer_GetStart(tbuf), recursive, sl);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
GWEN_StringList_free(sll);
return rv;
}
}
GWEN_Buffer_Crop(tbuf, 0, pos);
se=GWEN_StringListEntry_Next(se);
} /* while se */
GWEN_Buffer_free(tbuf);
GWEN_StringList_free(sll);
} /* if dir and recursive */
} /* if stat was ok */
return 0;
}
int 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 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;
}
LC_CLIENT_RESULT LC_ZkaCard_Reopen(LC_CARD *card) {
LC_CLIENT_RESULT res;
LC_ZKACARD *xc;
GWEN_BUFFER *mbuf;
DBG_INFO(LC_LOGDOMAIN, "Opening ZkaCard card");
assert(card);
xc=GWEN_INHERIT_GETDATA(LC_CARD, LC_ZKACARD, card);
assert(xc);
LC_Card_SetLastResult(card, 0, 0, 0, 0);
GWEN_Buffer_free(xc->bin_ef_gd_0);
xc->bin_ef_gd_0=NULL;
GWEN_Buffer_free(xc->bin_ef_id);
xc->bin_ef_id=NULL;
GWEN_Buffer_free(xc->bin_ef_ssd);
xc->bin_ef_ssd=NULL;
res=LC_Card_SelectCard(card, "zkacard");
if (res!=LC_Client_ResultOk) {
DBG_INFO(LC_LOGDOMAIN, "here");
return res;
}
/* first select generic app for all ZKACARD HBCI cards */
res=LC_Card_SelectApp(card, "zkacard");
if (res!=LC_Client_ResultOk) {
DBG_INFO(LC_LOGDOMAIN, "here");
return res;
}
DBG_INFO(LC_LOGDOMAIN, "Selecting MF...");
res=LC_Card_SelectMf(card);
if (res!=LC_Client_ResultOk) {
DBG_INFO(LC_LOGDOMAIN, "here");
return res;
}
/* read EF_ID */
DBG_INFO(LC_LOGDOMAIN, "Selecting EF_ID...");
res=LC_Card_SelectEf(card, "EF_ID");
if (res!=LC_Client_ResultOk) {
DBG_INFO(LC_LOGDOMAIN, "here");
return res;
}
DBG_INFO(LC_LOGDOMAIN, "Reading record...");
mbuf=GWEN_Buffer_new(0, 32, 0, 1);
res=LC_Card_IsoReadRecord(card, LC_CARD_ISO_FLAGS_RECSEL_GIVEN, 1, mbuf);
if (res!=LC_Client_ResultOk) {
DBG_INFO(LC_LOGDOMAIN, "here");
GWEN_Buffer_free(mbuf);
return res;
}
xc->bin_ef_id=mbuf;
/* read EG_GD0 */
DBG_INFO(LC_LOGDOMAIN, "Selecting EF_GD0...");
res=LC_Card_SelectEf(card, "EF_GD0");
if (res!=LC_Client_ResultOk) {
DBG_INFO(LC_LOGDOMAIN, "here");
return res;
}
DBG_INFO(LC_LOGDOMAIN, "Reading data...");
mbuf=GWEN_Buffer_new(0, 16, 0, 1);
res=LC_Card_IsoReadBinary(card, 0, 0, 12, mbuf);
if (res!=LC_Client_ResultOk) {
DBG_INFO(LC_LOGDOMAIN, "here");
GWEN_Buffer_free(mbuf);
return res;
}
if (GWEN_Buffer_GetUsedBytes(mbuf)<12) {
DBG_INFO(LC_LOGDOMAIN, "here");
GWEN_Buffer_free(mbuf);
return LC_Client_ResultDataError;
}
xc->bin_ef_gd_0=mbuf;
/* select DF_SIG */
DBG_INFO(LC_LOGDOMAIN, "Selecting DF_SIG...");
res=LC_Card_SelectDf(card, "DF_SIG");
if (res!=LC_Client_ResultOk) {
DBG_INFO(LC_LOGDOMAIN, "here");
return res;
}
/* read EG_SSD */
DBG_INFO(LC_LOGDOMAIN, "Selecting EF_SSD...");
res=LC_Card_SelectEf(card, "EF_SSD");
if (res!=LC_Client_ResultOk) {
DBG_INFO(LC_LOGDOMAIN, "here");
return res;
}
DBG_INFO(LC_LOGDOMAIN, "Reading data...");
mbuf=GWEN_Buffer_new(0, 16, 0, 1);
res=LC_Card_ReadBinary(card, 0, 65535, mbuf);
if (res!=LC_Client_ResultOk) {
DBG_INFO(LC_LOGDOMAIN, "here (%d)", res);
GWEN_Buffer_free(mbuf);
return res;
}
xc->bin_ef_ssd=mbuf;
return LC_Client_ResultOk;
}
GWENHYWFAR_CB
int GWEN_CryptMgrKeys_VerifyData(GWEN_CRYPTMGR *cm,
const uint8_t *pData, uint32_t lData,
const uint8_t *pSignature, uint32_t lSignature) {
GWEN_CRYPTMGR_KEYS *xcm;
GWEN_MDIGEST *md;
int rv;
GWEN_BUFFER *tbuf;
int ksize;
uint32_t l;
assert(cm);
xcm=GWEN_INHERIT_GETDATA(GWEN_CRYPTMGR, GWEN_CRYPTMGR_KEYS, cm);
assert(xcm);
if (xcm->peerKey==NULL) {
DBG_ERROR(GWEN_LOGDOMAIN, "No peer key");
return GWEN_ERROR_GENERIC;
}
ksize=GWEN_Crypt_Key_GetKeySize(xcm->peerKey);
/* the padding algo uses random numbers, so we must use the encrypt function and
* compare the decoded and unpadded signature with the hash of the source data
*/
tbuf=GWEN_Buffer_new(0, ksize+16, 0, 1);
l=GWEN_Buffer_GetMaxUnsegmentedWrite(tbuf);
rv=GWEN_Crypt_Key_Encipher(xcm->peerKey,
pSignature, lSignature,
(uint8_t*)GWEN_Buffer_GetPosPointer(tbuf),
&l);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
return rv;
}
GWEN_Buffer_IncrementPos(tbuf, l);
GWEN_Buffer_AdjustUsedBytes(tbuf);
/* unpadd */
rv=GWEN_Padd_UnpaddWithIso9796_2(tbuf);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
return rv;
}
/* tbuf now contains the hash */
/* hash source data */
md=GWEN_MDigest_Rmd160_new();
rv=GWEN_MDigest_Begin(md);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_MDigest_free(md);
GWEN_Buffer_free(tbuf);
return rv;
}
rv=GWEN_MDigest_Update(md, pData, lData);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_MDigest_free(md);
GWEN_Buffer_free(tbuf);
return rv;
}
rv=GWEN_MDigest_End(md);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_MDigest_free(md);
GWEN_Buffer_free(tbuf);
return rv;
}
if (GWEN_MDigest_GetDigestSize(md)!=GWEN_Buffer_GetUsedBytes(tbuf)) {
DBG_ERROR(GWEN_LOGDOMAIN, "Invalid signature");
GWEN_MDigest_free(md);
GWEN_Buffer_free(tbuf);
return GWEN_ERROR_VERIFY;
}
if (memcmp(GWEN_MDigest_GetDigestPtr(md),
GWEN_Buffer_GetStart(tbuf),
GWEN_MDigest_GetDigestSize(md))!=0) {
DBG_ERROR(GWEN_LOGDOMAIN, "Invalid signature");
GWEN_MDigest_free(md);
GWEN_Buffer_free(tbuf);
return GWEN_ERROR_VERIFY;
}
GWEN_MDigest_free(md);
GWEN_Buffer_free(tbuf);
return 0;
}
GWENHYWFAR_CB
int GWEN_CryptMgrKeys_SignData(GWEN_CRYPTMGR *cm,
const uint8_t *pData, uint32_t lData,
GWEN_BUFFER *dbuf) {
GWEN_CRYPTMGR_KEYS *xcm;
GWEN_MDIGEST *md;
int rv;
GWEN_BUFFER *tbuf;
int ksize;
uint32_t signatureLen;
assert(cm);
xcm=GWEN_INHERIT_GETDATA(GWEN_CRYPTMGR, GWEN_CRYPTMGR_KEYS, cm);
assert(xcm);
if (xcm->localKey==NULL) {
DBG_ERROR(GWEN_LOGDOMAIN, "No local key");
return GWEN_ERROR_GENERIC;
}
ksize=GWEN_Crypt_Key_GetKeySize(xcm->localKey);
/* hash pData */
md=GWEN_MDigest_Rmd160_new();
rv=GWEN_MDigest_Begin(md);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_MDigest_free(md);
return rv;
}
rv=GWEN_MDigest_Update(md, pData, lData);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_MDigest_free(md);
return rv;
}
rv=GWEN_MDigest_End(md);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_MDigest_free(md);
return rv;
}
/* padd */
tbuf=GWEN_Buffer_new(0, ksize, 0, 1);
GWEN_Buffer_AppendBytes(tbuf,
(const char*)GWEN_MDigest_GetDigestPtr(md),
GWEN_MDigest_GetDigestSize(md));
GWEN_MDigest_free(md);
GWEN_Padd_PaddWithIso9796_2(tbuf, ksize);
/* sign */
GWEN_Buffer_AllocRoom(dbuf, ksize);
signatureLen=GWEN_Buffer_GetMaxUnsegmentedWrite(dbuf);
rv=GWEN_Crypt_Key_Sign(xcm->localKey,
(uint8_t*)GWEN_Buffer_GetStart(tbuf),
GWEN_Buffer_GetUsedBytes(tbuf),
(uint8_t*)GWEN_Buffer_GetPosPointer(dbuf),
&signatureLen);
GWEN_Buffer_free(tbuf);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
return rv;
}
GWEN_Buffer_IncrementPos(dbuf, signatureLen);
GWEN_Buffer_AdjustUsedBytes(dbuf);
return 0;
}
AB_IMEXPORTER_ACCOUNTINFO *AB_ImExporterYN__ReadAccountInfo(AB_IMEXPORTER *ie,
AB_IMEXPORTER_CONTEXT *ctx,
GWEN_XMLNODE *doc)
{
GWEN_XMLNODE *n;
AB_IMEXPORTER_ACCOUNTINFO *ai;
ai=AB_ImExporterAccountInfo_new();
n=GWEN_XMLNode_FindFirstTag(doc, "SG2", 0, 0);
if (n)
n=GWEN_XMLNode_FindFirstTag(n, "FII", 0, 0);
if (n) {
GWEN_XMLNODE *nn;
const char *s;
nn=GWEN_XMLNode_FindFirstTag(n, "C078", 0, 0);
if (nn) {
GWEN_XMLNODE *nnn;
/* account number */
s=GWEN_XMLNode_GetCharValue(nn, "D_3194", 0);
if (s)
AB_ImExporterAccountInfo_SetAccountNumber(ai, s);
/* IBAN */
s=GWEN_XMLNode_GetCharValue(nn, "D_3192", 0);
if (s)
AB_ImExporterAccountInfo_SetIban(ai, s);
/* currency */
nnn=GWEN_XMLNode_FindFirstTag(nn, "D_6345", 0, 0);
if (nnn) {
s=GWEN_XMLNode_GetProperty(nnn, "value", 0);
if (s)
AB_ImExporterAccountInfo_SetCurrency(ai, s);
}
}
/* account number */
s=GWEN_XMLNode_GetCharValue(n, "PF:D_5388", 0);
if (s)
AB_ImExporterAccountInfo_SetAccountName(ai, s);
}
/* owner name */
n=GWEN_XMLNode_GetNodeByXPath(doc, "SG3[1]/NAD",
GWEN_PATH_FLAGS_NAMEMUSTEXIST);
if (n) {
GWEN_XMLNODE *nn;
nn=GWEN_XMLNode_FindFirstTag(n, "D_3035", 0, 0);
if (nn) {
const char *s;
s=GWEN_XMLNode_GetProperty(nn, "Value", 0);
if (s && strcasecmp(s, "HQ")==0) {
nn=GWEN_XMLNode_FindFirstTag(n, "C058", 0, 0);
if (nn) {
s=GWEN_XMLNode_GetCharValue(nn, "D_3124", 0);
if (s && *s) {
GWEN_BUFFER *xbuf;
xbuf=GWEN_Buffer_new(0, 256, 0, 1);
AB_ImExporter_Iso8859_1ToUtf8(s, strlen(s), xbuf);
AB_ImExporterAccountInfo_SetOwner(ai, GWEN_Buffer_GetStart(xbuf));
GWEN_Buffer_free(xbuf);
}
}
}
}
}
return ai;
}
AB_TRANSACTION *AB_ImExporterYN__ReadLNE_LNS(AB_IMEXPORTER *ie,
AB_IMEXPORTER_ACCOUNTINFO *ai,
GWEN_XMLNODE *node)
{
AB_TRANSACTION *t;
GWEN_XMLNODE *nn;
GWEN_DATE *da=NULL;
AB_VALUE *val=NULL;
t=AB_Transaction_new();
/* get date */
nn=GWEN_XMLNode_FindFirstTag(node, "DTM", 0, 0);
if (nn)
da=AB_ImExporterYN__ReadDate(ie, nn, 209);
AB_Transaction_SetValutaDate(t, da);
GWEN_Date_free(da);
da=NULL;
/* read amount */
nn=GWEN_XMLNode_FindFirstTag(node, "MOA", 0, 0);
if (nn) {
/* Gutschrift */
val=AB_ImExporterYN__ReadValue(ie, nn, 210);
if (val) {
if (AB_Value_IsZero(val)) {
AB_Value_free(val);
val=NULL;
}
}
if (val==NULL) {
val=AB_ImExporterYN__ReadValue(ie, nn, 211);
if (val)
AB_Value_Negate(val);
}
}
if (val==NULL)
val=AB_Value_new();
AB_Value_SetCurrency(val, AB_ImExporterAccountInfo_GetCurrency(ai));
AB_Transaction_SetValue(t, val);
AB_Value_free(val);
val=0;
/* read purpose */
nn=GWEN_XMLNode_GetNodeByXPath(node, "FTX/C108",
GWEN_PATH_FLAGS_NAMEMUSTEXIST);
if (nn) {
GWEN_XMLNODE *nnn;
nnn=GWEN_XMLNode_FindFirstTag(nn, "D_4440", 0, 0);
while (nnn) {
GWEN_XMLNODE *nData;
nData=GWEN_XMLNode_GetFirstData(nnn);
if (nData) {
const char *s;
s=GWEN_XMLNode_GetData(nData);
if (s) {
GWEN_BUFFER *xbuf;
xbuf=GWEN_Buffer_new(0, 256, 0, 1);
AB_ImExporter_Iso8859_1ToUtf8(s, strlen(s), xbuf);
AB_Transaction_AddPurposeLine(t, GWEN_Buffer_GetStart(xbuf));
GWEN_Buffer_free(xbuf);
}
}
nnn=GWEN_XMLNode_FindNextTag(nnn, "D_4440", 0, 0);
}
}
return t;
}
int EBC_Provider_XchgHpdRequest(AB_PROVIDER *pro,
GWEN_HTTP_SESSION *sess,
AB_USER *u) {
int rv;
GWEN_BUFFER *buf;
buf=GWEN_Buffer_new(0, 1024, 0, 1);
rv=EBC_Provider_XchgDownloadRequest(pro, sess, u, "HPD", buf, 0, NULL, NULL);
if (rv<0 || rv>=300) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(buf);
return rv;
}
else {
xmlDocPtr orderDoc=NULL;
xmlNodePtr root_node=NULL;
xmlNodePtr node=NULL;
xmlNodePtr nodeX=NULL;
const char *s;
uint32_t uflags=0;
/* parse XML document */
rv=EB_Xml_DocFromBuffer(GWEN_Buffer_GetStart(buf),
GWEN_Buffer_GetUsedBytes(buf),
&orderDoc);
GWEN_Buffer_free(buf);
if (rv<0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
return rv;
}
/* get keys */
root_node=xmlDocGetRootElement(orderDoc);
/* get auth key */
node=EB_Xml_GetNode(root_node, "ProtocolParams",
GWEN_PATH_FLAGS_NAMEMUSTEXIST);
if (node==NULL) {
DBG_ERROR(AQEBICS_LOGDOMAIN,
"No ProtocolParams found");
xmlFreeDoc(orderDoc);
return GWEN_ERROR_BAD_DATA;
}
nodeX=EB_Xml_GetNode(node, "ClientDataDownload",
GWEN_PATH_FLAGS_NAMEMUSTEXIST);
if (nodeX) {
s=(const char*)xmlGetProp(nodeX, BAD_CAST "supported");
if (s && strcasecmp(s, "true")==0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "Client data download supported");
uflags|=EBC_USER_FLAGS_CLIENT_DATA_DOWNLOAD_SPP;
}
}
nodeX=EB_Xml_GetNode(node, "PreValidation",
GWEN_PATH_FLAGS_NAMEMUSTEXIST);
if (nodeX) {
s=(const char*)xmlGetProp(nodeX, BAD_CAST "supported");
if (s && strcasecmp(s, "true")==0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "Prevalidation supported");
uflags|=EBC_USER_FLAGS_PREVALIDATION_SPP;
}
}
nodeX=EB_Xml_GetNode(node, "Recovery",
GWEN_PATH_FLAGS_NAMEMUSTEXIST);
if (nodeX) {
s=(const char*)xmlGetProp(nodeX, BAD_CAST "supported");
if (s && strcasecmp(s, "true")==0) {
DBG_INFO(AQEBICS_LOGDOMAIN, "Recovery supported");
uflags|=EBC_USER_FLAGS_RECOVERY_SPP;
}
}
EBC_User_AddFlags(u, uflags);
xmlFreeDoc(orderDoc);
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 GWEN_PathManager_InsertRelPath(const char *callingLib,
const char *destLib,
const char *pathName,
const char *pathValue,
GWEN_PATHMANAGER_RELMODE rm) {
char cwd[256];
switch(rm) {
case GWEN_PathManager_RelModeCwd: {
const char *pcwd;
pcwd=getcwd(cwd, sizeof(cwd)-1);
if (pcwd) {
GWEN_BUFFER *buf;
int rv;
buf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendString(buf, cwd);
if (*pathValue!=GWEN_DIR_SEPARATOR)
GWEN_Buffer_AppendString(buf, GWEN_DIR_SEPARATOR_S);
GWEN_Buffer_AppendString(buf, pathValue);
rv=GWEN_PathManager_InsertPath(callingLib, destLib, pathName,
GWEN_Buffer_GetStart(buf));
GWEN_Buffer_free(buf);
return rv;
}
else {
DBG_ERROR(GWEN_LOGDOMAIN, "getcwd(): %s", strerror(errno));
return GWEN_ERROR_IO;
}
break;
}
case GWEN_PathManager_RelModeExe: {
int rv;
rv=GWEN_Directory_GetPrefixDirectory(cwd, sizeof(cwd)-1);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
return rv;
}
else {
GWEN_BUFFER *buf;
buf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendString(buf, cwd);
if (*pathValue!=GWEN_DIR_SEPARATOR)
GWEN_Buffer_AppendString(buf, GWEN_DIR_SEPARATOR_S);
GWEN_Buffer_AppendString(buf, pathValue);
DBG_INFO(GWEN_LOGDOMAIN,
"Adding path [%s]",
GWEN_Buffer_GetStart(buf));
rv=GWEN_PathManager_InsertPath(callingLib, destLib, pathName,
GWEN_Buffer_GetStart(buf));
GWEN_Buffer_free(buf);
return rv;
}
}
case GWEN_PathManager_RelModeHome: {
GWEN_BUFFER *buf;
int rv;
rv=GWEN_Directory_GetHomeDirectory(cwd, sizeof(cwd)-1);
if (rv) {
DBG_ERROR(GWEN_LOGDOMAIN,
"Could not determine HOME directory (%d)",
rv);
return rv;
}
buf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendString(buf, cwd);
if (*pathValue!=GWEN_DIR_SEPARATOR)
GWEN_Buffer_AppendString(buf, GWEN_DIR_SEPARATOR_S);
GWEN_Buffer_AppendString(buf, pathValue);
rv=GWEN_PathManager_InsertPath(callingLib, destLib, pathName,
GWEN_Buffer_GetStart(buf));
GWEN_Buffer_free(buf);
return rv;
}
default:
DBG_INFO(GWEN_LOGDOMAIN, "Unknown relative mode %d", rm);
return GWEN_ERROR_INVALID;
}
}
int AH_Msg_SignPinTan(AH_MSG *hmsg,
GWEN_BUFFER *rawBuf,
const char *signer) {
AH_HBCI *h;
GWEN_XMLNODE *node;
GWEN_DB_NODE *cfg;
GWEN_BUFFER *hbuf;
int rv;
char ctrlref[15];
const char *p;
GWEN_MSGENGINE *e;
AB_USER *su;
uint32_t uFlags;
char pin[64];
uint32_t tm;
assert(hmsg);
h=AH_Dialog_GetHbci(hmsg->dialog);
assert(h);
e=AH_Dialog_GetMsgEngine(hmsg->dialog);
assert(e);
GWEN_MsgEngine_SetMode(e, "pintan");
su=AB_Banking_FindUser(AH_HBCI_GetBankingApi(h),
AH_PROVIDER_NAME,
"de", "*",
signer, "*");
if (!su) {
DBG_ERROR(AQHBCI_LOGDOMAIN,
"Unknown user \"%s\"",
signer);
return GWEN_ERROR_NOT_FOUND;
}
uFlags=AH_User_GetFlags(su);
node=GWEN_MsgEngine_FindNodeByPropertyStrictProto(e,
"SEG",
"id",
0,
"SigHead");
if (!node) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Segment \"SigHead\" not found");
return GWEN_ERROR_INTERNAL;
}
/* for iTAN mode: set selected mode (Sicherheitsfunktion, kodiert) */
tm=AH_Msg_GetItanMethod(hmsg);
if (tm==0) {
tm=AH_Dialog_GetItanMethod(hmsg->dialog);
if (tm)
/* this is needed by AH_MsgPinTan_PrepareCryptoSeg */
AH_Msg_SetItanMethod(hmsg, tm);
}
/* prepare config for segment */
cfg=GWEN_DB_Group_new("sighead");
rv=AH_MsgPinTan_PrepareCryptoSeg(hmsg, su, cfg, 0, 1);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
GWEN_DB_Group_free(cfg);
return rv;
}
/* set expected signer */
if (!(uFlags & AH_USER_FLAGS_BANK_DOESNT_SIGN)) {
const char *remoteId;
remoteId=AH_User_GetPeerId(su);
if (!remoteId || *remoteId==0)
remoteId=AB_User_GetUserId(su);
assert(remoteId);
assert(*remoteId);
DBG_DEBUG(AQHBCI_LOGDOMAIN,
"Expecting \"%s\" to sign the response",
remoteId);
AH_Msg_SetExpectedSigner(hmsg, remoteId);
}
/* store system id */
p=NULL;
if (!hmsg->noSysId)
p=AH_User_GetSystemId(su);
if (!p)
p="0";
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT, "SecDetails/SecId", p);
if (tm) {
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"function", tm);
}
/* retrieve control reference for sigtail (to be used later) */
p=GWEN_DB_GetCharValue(cfg, "ctrlref", 0, "");
if (strlen(p)>=sizeof(ctrlref)) {
DBG_INFO(AQHBCI_LOGDOMAIN,
"Control reference too long (14 bytes maximum)");
GWEN_DB_Group_free(cfg);
return -1;
}
strcpy(ctrlref, p);
/* create SigHead */
hbuf=GWEN_Buffer_new(0, 128+GWEN_Buffer_GetUsedBytes(rawBuf), 0, 1);
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"head/seq", hmsg->firstSegment-1);
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"signseq", 1);
/* create signature head segment */
rv=GWEN_MsgEngine_CreateMessageFromNode(e, node, hbuf, cfg);
GWEN_DB_Group_free(cfg);
cfg=0;
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Could not create SigHead");
GWEN_Buffer_free(hbuf);
return rv;
}
/* insert new SigHead at beginning of message buffer */
DBG_DEBUG(AQHBCI_LOGDOMAIN, "Inserting signature head");
GWEN_Buffer_Rewind(hmsg->buffer);
GWEN_Buffer_InsertBytes(hmsg->buffer,
GWEN_Buffer_GetStart(hbuf),
GWEN_Buffer_GetUsedBytes(hbuf));
/* create sigtail */
DBG_DEBUG(AQHBCI_LOGDOMAIN, "Completing signature tail");
cfg=GWEN_DB_Group_new("sigtail");
GWEN_Buffer_Reset(hbuf);
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"head/seq", hmsg->lastSegment+1);
/* store to DB */
GWEN_DB_SetBinValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"signature",
"NOSIGNATURE",
11);
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"ctrlref", ctrlref);
/* handle pin */
memset(pin, 0, sizeof(pin));
rv=AH_User_InputPin(su, pin, 4, sizeof(pin), 0);
if (rv<0) {
DBG_ERROR(AQHBCI_LOGDOMAIN,
"Error getting pin from medium (%d)", rv);
GWEN_DB_Group_free(cfg);
GWEN_Buffer_free(hbuf);
memset(pin, 0, sizeof(pin));
return rv;
}
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT, "pin", pin);
AH_Msg_SetPin(hmsg, pin);
memset(pin, 0, sizeof(pin));
/* handle tan */
if (hmsg->needTan) {
DBG_NOTICE(AQHBCI_LOGDOMAIN,
"This queue needs a TAN");
if (hmsg->usedTan) {
DBG_NOTICE(AQHBCI_LOGDOMAIN,
"Using existing TAN");
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"tan", hmsg->usedTan);
}
else {
char tan[16];
memset(tan, 0, sizeof(tan));
DBG_NOTICE(AQHBCI_LOGDOMAIN, "Asking for TAN");
rv=AH_User_InputTan(su, tan, 4, sizeof(tan));
if (rv<0) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Error getting TAN from medium");
GWEN_DB_Group_free(cfg);
GWEN_Buffer_free(hbuf);
return rv;
}
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"tan", tan);
AH_Msg_SetTan(hmsg, tan);
}
}
else {
DBG_NOTICE(AQHBCI_LOGDOMAIN,
"This queue doesn't need a TAN");
}
/* get node */
node=GWEN_MsgEngine_FindNodeByPropertyStrictProto(e,
"SEG",
"id",
0,
"SigTail");
if (!node) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Segment \"SigTail\"not found");
GWEN_Buffer_free(hbuf);
GWEN_DB_Group_free(cfg);
return GWEN_ERROR_INTERNAL;
}
rv=GWEN_MsgEngine_CreateMessageFromNode(e, node, hbuf, cfg);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Could not create SigTail (%d)", rv);
GWEN_Buffer_free(hbuf);
GWEN_DB_Group_free(cfg);
return rv;
}
/* append sigtail */
DBG_DEBUG(AQHBCI_LOGDOMAIN, "Appending signature tail");
if (GWEN_Buffer_AppendBuffer(hmsg->buffer, hbuf)) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here");
GWEN_Buffer_free(hbuf);
GWEN_DB_Group_free(cfg);
return GWEN_ERROR_MEMORY_FULL;
}
DBG_DEBUG(AQHBCI_LOGDOMAIN, "Appending signature tail: done");
GWEN_Buffer_free(hbuf);
GWEN_DB_Group_free(cfg);
/* adjust segment numbers (for next signature and message tail */
hmsg->firstSegment--;
hmsg->lastSegment++;
return 0;
}
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_Msg_EncryptPinTan(AH_MSG *hmsg) {
AH_HBCI *h;
GWEN_XMLNODE *node;
GWEN_DB_NODE *cfg;
GWEN_BUFFER *hbuf;
int rv;
const char *p;
GWEN_MSGENGINE *e;
AB_USER *u;
const char *peerId;
// uint32_t uFlags;
assert(hmsg);
h=AH_Dialog_GetHbci(hmsg->dialog);
assert(h);
e=AH_Dialog_GetMsgEngine(hmsg->dialog);
assert(e);
GWEN_MsgEngine_SetMode(e, "pintan");
u=AH_Dialog_GetDialogOwner(hmsg->dialog);
// uFlags=AH_User_GetFlags(u);
peerId=AH_User_GetPeerId(u);
if (!peerId || *peerId==0)
peerId=AB_User_GetUserId(u);
/* create crypt head */
node=GWEN_MsgEngine_FindNodeByPropertyStrictProto(e,
"SEG",
"id",
0,
"CryptHead");
if (!node) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Segment \"CryptHead\" not found");
return GWEN_ERROR_INTERNAL;
}
/* create CryptHead */
cfg=GWEN_DB_Group_new("crypthead");
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"head/seq", 998);
rv=AH_MsgPinTan_PrepareCryptoSeg(hmsg, u, cfg, 1, 0);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
GWEN_DB_Group_free(cfg);
return rv;
}
/* store system id */
p=NULL;
if (!hmsg->noSysId)
p=AH_User_GetSystemId(u);
if (!p)
p="0";
GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT, "SecDetails/SecId", p);
/* store encrypted message key */
GWEN_DB_SetBinValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"CryptAlgo/MsgKey",
"NOKEY", 5);
hbuf=GWEN_Buffer_new(0, 256+GWEN_Buffer_GetUsedBytes(hmsg->buffer), 0, 1);
rv=GWEN_MsgEngine_CreateMessageFromNode(e,
node,
hbuf,
cfg);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Could not create CryptHead (%d)", rv);
GWEN_Buffer_free(hbuf);
GWEN_DB_Group_free(cfg);
return rv;
}
GWEN_DB_Group_free(cfg);
/* create cryptdata */
cfg=GWEN_DB_Group_new("cryptdata");
GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"head/seq", 999);
GWEN_DB_SetBinValue(cfg, GWEN_DB_FLAGS_DEFAULT,
"cryptdata",
GWEN_Buffer_GetStart(hmsg->buffer),
GWEN_Buffer_GetUsedBytes(hmsg->buffer));
node=GWEN_MsgEngine_FindNodeByPropertyStrictProto(e,
"SEG",
"id",
0,
"CryptData");
if (!node) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Segment \"CryptData\"not found");
GWEN_Buffer_free(hbuf);
GWEN_DB_Group_free(cfg);
return -1;
}
rv=GWEN_MsgEngine_CreateMessageFromNode(e,
node,
hbuf,
cfg);
if (rv) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Could not create CryptData (%d)", rv);
GWEN_Buffer_free(hbuf);
GWEN_DB_Group_free(cfg);
return rv;
}
/* replace existing buffer by encrypted one */
GWEN_Buffer_free(hmsg->buffer);
hmsg->buffer=hbuf;
GWEN_DB_Group_free(cfg);
return 0;
}
int 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;
}
