IPCMESSAGE *CTService_Message_Create(int msgCode,
int msgVersion,
int msgId,
int msgReply,
int msgSize) {
IPCMESSAGE *msg;
ERRORCODE err;
DBG_ENTER;
DBG_VERBOUS("Creating message: %d, %d, %d, %d\n",
msgCode, msgVersion, msgId, msgReply);
msg=IPCMessage_new();
err=IPCMessage_SetBuffer(msg, 0, msgSize);
if (!Error_IsOk(err)) {
DBG_ERROR_ERR(err);
IPCMessage_free(msg);
return 0;
}
/* add msg code */
err=IPCMessage_AddIntParameter(msg, msgCode);
if (!Error_IsOk(err)) {
DBG_ERROR_ERR(err);
IPCMessage_free(msg);
DBG_LEAVE;
return 0;
}
/* add msg version */
err=IPCMessage_AddIntParameter(msg,msgVersion);
if (!Error_IsOk(err)) {
DBG_ERROR_ERR(err);
IPCMessage_free(msg);
DBG_LEAVE;
return 0;
}
/* add message id */
err=IPCMessage_AddIntParameter(msg, msgId);
if (!Error_IsOk(err)) {
DBG_ERROR_ERR(err);
IPCMessage_free(msg);
DBG_LEAVE;
return 0;
}
/* add msg reply code */
err=IPCMessage_AddIntParameter(msg, msgReply);
if (!Error_IsOk(err)) {
DBG_ERROR_ERR(err);
IPCMessage_free(msg);
DBG_LEAVE;
return 0;
}
DBG_LEAVE;
return msg;
}
int test1(int argc, char **argv) {
GWEN_GUI *gui;
int rv;
GWEN_DIALOG *dlg;
rv=GWEN_Init();
if (rv) {
DBG_ERROR_ERR(0, rv);
return 2;
}
GWEN_Logger_SetLevel(0, GWEN_LoggerLevel_Info);
gtk_set_locale ();
gtk_init (&argc, &argv);
/* create GUI */
gui=Gtk2_Gui_new();
GWEN_Gui_SetGui(gui);
dlg=Dlg_Test1_new();
if (dlg==NULL) {
fprintf(stderr, "Could not create dialog.\n");
return 2;
}
rv=GWEN_Gui_ExecDialog(dlg, 0);
fprintf(stderr, "Result: %d\n", rv);
return 0;
}
unsigned int Debug_CreateKeyFingerprint(CRYP_RSAKEY *key1) {
IPCMESSAGE *kmsg1;
int ks1;
ERRORCODE err;
const char *ptr1;
unsigned int fp;
kmsg1=IPCMessage_new();
IPCMessage_SetBuffer(kmsg1,0,4096);
err=Cryp_RsaKey_ToMessage(key1, kmsg1, 1);
if (!Error_IsOk(err)) {
DBG_ERROR_ERR(err);
}
ks1=IPCMessage_GetMessageSize(kmsg1);
ptr1=IPCMessage_GetMessageBegin(kmsg1);
fp=0;
while(ks1) {
fp+=(unsigned char)(*ptr1);
ptr1++;
ks1--;
} /* while */
IPCMessage_free(kmsg1);
DBG_DEBUG("Fingerprint is: %08x\n",fp);
return fp;
}
int Debug_CompareKeys(CRYP_RSAKEY *key1, CRYP_RSAKEY *key2) {
IPCMESSAGE *kmsg1, *kmsg2;
int ks1, ks2;
ERRORCODE err;
kmsg1=IPCMessage_new();
IPCMessage_SetBuffer(kmsg1,0,4096);
kmsg2=IPCMessage_new();
IPCMessage_SetBuffer(kmsg2,0,4096);
err=Cryp_RsaKey_ToMessage(key1, kmsg1, 1);
if (!Error_IsOk(err)) {
DBG_ERROR_ERR(err);
}
err=Cryp_RsaKey_ToMessage(key2, kmsg2, 1);
if (!Error_IsOk(err)) {
DBG_ERROR_ERR(err);
}
ks1=IPCMessage_GetMessageSize(kmsg1);
ks2=IPCMessage_GetMessageSize(kmsg2);
DBG_DEBUG("Sizes: Key1=%d, Key2=%d\n",ks1, ks2);
if (ks1==ks2) {
const char *ptr1, *ptr2;
ptr1=IPCMessage_GetMessageBegin(kmsg1);
ptr2=IPCMessage_GetMessageBegin(kmsg2);
while(ks1) {
if (*ptr1!=*ptr2) {
DBG_ERROR("Keys differ !\n");
break;
ptr1++;
ptr2++;
ks1--;
}
} /* while */
}
IPCMessage_free(kmsg1);
IPCMessage_free(kmsg2);
if (!ks1)
return 0;
else
return 1;
}
ERRORCODE CTService_CheckMsgCodeAndVersion(IPCMESSAGE *msg,
int msgCode,
int msgVersion) {
int i;
ERRORCODE err;
DBG_ENTER;
assert(msg);
/* check message code */
err=IPCMessage_FirstIntParameter(msg, &i);
if (!Error_IsOk(err)) {
DBG_ERROR_ERR(err);
DBG_LEAVE;
return err;
}
if (i!=msgCode) {
DBG_ERROR("Bad message code (%04x)",i);
DBG_LEAVE;
return Error_New(0,
ERROR_SEVERITY_ERR,
Error_FindType(CTSERVICE_ERROR_TYPE),
CTSERVICE_ERROR_BAD_MESSAGE_CODE);
}
/* check message version */
err=IPCMessage_NextIntParameter(msg, &i);
if (!Error_IsOk(err)) {
DBG_ERROR_ERR(err);
DBG_LEAVE;
return err;
}
if ((i&0xff00)!=(msgVersion&0xff00)) {
DBG_ERROR("Bad message version (%04x:%04x)",msgCode,i);
DBG_LEAVE;
return Error_New(0,
ERROR_SEVERITY_ERR,
Error_FindType(CTSERVICE_ERROR_TYPE),
CTSERVICE_ERROR_BAD_MESSAGE_VERSION);
}
DBG_LEAVE;
return 0;
}
int mkPinList(AB_BANKING *ab,
GWEN_DB_NODE *dbArgs,
int argc,
char **argv) {
GWEN_DB_NODE *db;
AB_PROVIDER *pro;
GWEN_SYNCIO *sio;
AB_USER_LIST2 *ul;
int rv;
const char *outFile;
const GWEN_ARGS args[]={
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"outFile", /* name */
0, /* minnum */
1, /* maxnum */
"o", /* short option */
"outfile", /* long option */
"Specify the name of the output file", /* short description */
"Specify the name of the output file" /* long description */
},
{
GWEN_ARGS_FLAGS_HELP | GWEN_ARGS_FLAGS_LAST, /* flags */
GWEN_ArgsType_Int, /* type */
"help", /* name */
0, /* minnum */
0, /* maxnum */
"h", /* short option */
"help", /* long option */
"Show this help screen", /* short description */
"Show this help screen" /* long description */
}
};
db=GWEN_DB_GetGroup(dbArgs, GWEN_DB_FLAGS_DEFAULT, "local");
rv=GWEN_Args_Check(argc, argv, 1,
0 /*GWEN_ARGS_MODE_ALLOW_FREEPARAM*/,
args,
db);
if (rv==GWEN_ARGS_RESULT_ERROR) {
fprintf(stderr, "ERROR: Could not parse arguments\n");
return 1;
}
else if (rv==GWEN_ARGS_RESULT_HELP) {
GWEN_BUFFER *ubuf;
ubuf=GWEN_Buffer_new(0, 1024, 0, 1);
if (GWEN_Args_Usage(args, ubuf, GWEN_ArgsOutType_Txt)) {
fprintf(stderr, "ERROR: Could not create help string\n");
return 1;
}
fprintf(stderr, "%s\n", GWEN_Buffer_GetStart(ubuf));
GWEN_Buffer_free(ubuf);
return 0;
}
outFile=GWEN_DB_GetCharValue(db, "outfile", 0, 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;
}
pro=AB_Banking_GetProvider(ab, "aqebics");
assert(pro);
if (outFile==0) {
sio=GWEN_SyncIo_File_fromStdout();
GWEN_SyncIo_AddFlags(sio, GWEN_SYNCIO_FLAGS_DONTCLOSE);
}
else {
sio=GWEN_SyncIo_File_new(outFile, GWEN_SyncIo_File_CreationMode_CreateAlways);
GWEN_SyncIo_AddFlags(sio,
GWEN_SYNCIO_FILE_FLAGS_READ |
GWEN_SYNCIO_FILE_FLAGS_WRITE |
GWEN_SYNCIO_FILE_FLAGS_UREAD |
GWEN_SYNCIO_FILE_FLAGS_UWRITE |
GWEN_SYNCIO_FILE_FLAGS_GREAD |
GWEN_SYNCIO_FILE_FLAGS_GWRITE);
rv=GWEN_SyncIo_Connect(sio);
if (rv<0) {
DBG_ERROR(0, "Error opening output file: %s",
strerror(errno));
return 4;
}
}
GWEN_SyncIo_WriteLine(sio,
"# This is a PIN file to be used "
"with AqBanking");
GWEN_SyncIo_WriteLine(sio,
"# Please insert the PINs/passwords "
"for the users below");
ul=AB_Banking_FindUsers(ab, "aqebics", "*", "*", "*", "*");
if (ul) {
AB_USER_LIST2_ITERATOR *uit;
uit=AB_User_List2_First(ul);
if (uit) {
AB_USER *u;
u=AB_User_List2Iterator_Data(uit);
assert(u);
while(u) {
const char *s;
GWEN_BUFFER *nbuf;
int rv;
GWEN_SyncIo_WriteLine(sio, "");
GWEN_SyncIo_WriteString(sio, "# User \"");
s=AB_User_GetUserId(u);
assert(s);
GWEN_SyncIo_WriteString(sio, s);
GWEN_SyncIo_WriteString(sio, "\" at \"");
s=AB_User_GetBankCode(u);
GWEN_SyncIo_WriteString(sio, s);
GWEN_SyncIo_WriteLine(sio, "\"");
nbuf=GWEN_Buffer_new(0, 256 ,0 ,1);
rv=EBC_User_MkPasswdName(u, nbuf);
if (rv==0) {
GWEN_BUFFER *obuf;
obuf=GWEN_Buffer_new(0, 256 ,0 ,1);
if (GWEN_Text_EscapeToBufferTolerant(GWEN_Buffer_GetStart(nbuf),
obuf)) {
DBG_ERROR(0, "Error escaping name to buffer");
return 3;
}
GWEN_SyncIo_WriteString(sio, GWEN_Buffer_GetStart(obuf));
GWEN_SyncIo_WriteLine(sio, " = \"\"");
GWEN_Buffer_free(obuf);
}
GWEN_Buffer_free(nbuf);
u=AB_User_List2Iterator_Next(uit);
}
AB_User_List2Iterator_free(uit);
}
AB_User_List2_free(ul);
}
rv=GWEN_SyncIo_Disconnect(sio);
if (rv<0) {
DBG_ERROR_ERR(0, rv);
GWEN_SyncIo_free(sio);
return 4;
}
GWEN_SyncIo_free(sio);
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 write_h_elem_c(ARGUMENTS *args, GWEN_XMLNODE *node,
GWEN_SYNCIO *sio)
{
const char *name;
const char *typ;
const char *mode;
GWEN_XMLNODE *tnode;
const char *tmode;
int err;
int isPtr;
name=GWEN_XMLNode_GetProperty(node, "name", 0);
if (!name) {
DBG_ERROR(0, "No name for element");
return -1;
}
typ=GWEN_XMLNode_GetProperty(node, "type", 0);
if (!typ) {
DBG_ERROR(0, "No type for element");
return -1;
}
mode=GWEN_XMLNode_GetProperty(node, "mode", "single");
tnode=get_typedef(node, typ);
if (tnode)
tmode=GWEN_XMLNode_GetProperty(tnode, "mode", "single");
else
tmode=mode;
isPtr=atoi(get_property(node, "ptr", "0"));
err=GWEN_SyncIo_WriteString(sio, " ");
if (err) {
DBG_ERROR_ERR(0, err);
return -1;
}
if (strcasecmp(tmode, "enum")!=0)
GWEN_SyncIo_WriteString(sio, typ);
else {
GWEN_BUFFER *tid;
const char *s;
tid=GWEN_Buffer_new(0, 64, 0, 1);
s=get_struct_property(node, "id", 0);
assert(s);
GWEN_Buffer_AppendString(tid, s);
GWEN_Buffer_AppendString(tid, "_");
GWEN_Buffer_AppendString(tid, typ);
GWEN_SyncIo_WriteString(sio, GWEN_Buffer_GetStart(tid));
GWEN_Buffer_free(tid);
}
GWEN_SyncIo_WriteString(sio, " ");
if (isPtr) {
GWEN_SyncIo_WriteString(sio, "*");
}
GWEN_SyncIo_WriteChar(sio, tolower(*name));
GWEN_SyncIo_WriteString(sio, name+1);
GWEN_SyncIo_WriteLine(sio, ";");
return 0;
}
int write_hp_file_c(ARGUMENTS *args, GWEN_XMLNODE *node)
{
int rv;
const char *f;
GWEN_BUFFER *fname;
GWEN_BUFFER *hbuf;
const char *s;
GWEN_SYNCIO *sio;
int err;
const char *nacc;
const char *constAcc;
const char *constName;
const char *fromDbAcc;
const char *fromDbName;
const char *dupAcc;
const char *dupName;
const char *id;
const char *prefix;
id=get_struct_property(node, "id", 0);
if (!id) {
DBG_ERROR(0, "No id for struct");
return -1;
}
prefix=get_struct_property(node, "prefix", 0);
if (!prefix) {
DBG_ERROR(0, "No prefix for struct");
return -1;
}
f=get_struct_property(node, "filename", 0);
if (!f) {
DBG_ERROR(0, "No filename given");
return -1;
}
nacc=get_struct_property(node, "access", "public");
constAcc=get_struct_property(node, "constructor-access", nacc);
constName=get_struct_property(node, "constructor-name", 0);
fromDbAcc=get_struct_property(node, "fromdb-access", nacc);
fromDbName=get_struct_property(node, "fromdb-name", 0);
dupAcc=get_struct_property(node, "dup-access", nacc);
dupName=get_struct_property(node, "fromdb-name", 0);
fname=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendString(fname, f);
GWEN_Buffer_AppendString(fname, "_p.h");
sio=GWEN_SyncIo_File_new(GWEN_Buffer_GetStart(fname),
GWEN_SyncIo_File_CreationMode_CreateAlways);
GWEN_SyncIo_AddFlags(sio,
GWEN_SYNCIO_FILE_FLAGS_READ |
GWEN_SYNCIO_FILE_FLAGS_WRITE |
GWEN_SYNCIO_FILE_FLAGS_UREAD |
GWEN_SYNCIO_FILE_FLAGS_UWRITE |
GWEN_SYNCIO_FILE_FLAGS_GREAD |
GWEN_SYNCIO_FILE_FLAGS_GWRITE);
rv=GWEN_SyncIo_Connect(sio);
if (rv<0) {
DBG_ERROR(0, "open(%s): %s",
GWEN_Buffer_GetStart(fname),
strerror(errno));
GWEN_Buffer_free(fname);
GWEN_SyncIo_free(sio);
return -1;
}
GWEN_Buffer_free(fname);
/* Insert the auto-generation warning */
GWEN_SyncIo_WriteString(sio, "/* This file is auto-generated from \"");
GWEN_SyncIo_WriteString(sio, f);
GWEN_SyncIo_WriteLine(sio, ".xml\" by the typemaker");
GWEN_SyncIo_WriteLine(sio, " tool of Gwenhywfar. ");
GWEN_SyncIo_WriteLine(sio, " Do not edit this file -- all changes will be lost! */");
hbuf=GWEN_Buffer_new(0, 256, 0, 1);
s=f;
while (*s) {
GWEN_Buffer_AppendByte(hbuf, toupper(*s));
s++;
}
GWEN_Buffer_AppendString(hbuf, "_P_H");
GWEN_SyncIo_WriteString(sio, "#ifndef ");
GWEN_SyncIo_WriteLine(sio, GWEN_Buffer_GetStart(hbuf));
GWEN_SyncIo_WriteString(sio, "#define ");
GWEN_SyncIo_WriteLine(sio, GWEN_Buffer_GetStart(hbuf));
GWEN_SyncIo_WriteLine(sio, "");
if (strcasecmp(get_struct_property(node, "inherit", ""),
"private")==0) {
GWEN_SyncIo_WriteLine(sio, "#include <gwenhywfar/inherit.h>");
}
if (strcasecmp(get_struct_property(node, "list", ""),
"private")==0) {
GWEN_SyncIo_WriteLine(sio, "#include <gwenhywfar/misc.h>");
}
if (strcasecmp(get_struct_property(node, "list2", ""),
"private")==0) {
GWEN_SyncIo_WriteLine(sio, "#include <gwenhywfar/list2.h>");
}
fname=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendString(fname, f);
GWEN_Buffer_AppendString(fname, "_l.h");
GWEN_SyncIo_WriteString(sio, "#include \"");
GWEN_SyncIo_WriteString(sio, GWEN_Buffer_GetStart(fname));
GWEN_SyncIo_WriteLine(sio, "\"");
GWEN_Buffer_free(fname);
GWEN_SyncIo_WriteLine(sio, "");
rv=write_h_struct_c(args, node, sio);
if (rv) {
GWEN_Buffer_free(hbuf);
GWEN_SyncIo_free(sio);
return rv;
}
GWEN_SyncIo_WriteLine(sio, "");
/* include private functions */
if (strcasecmp(constAcc, "private")==0) {
GWEN_SyncIo_WriteString(sio, id);
GWEN_SyncIo_WriteString(sio, " *");
GWEN_SyncIo_WriteString(sio, prefix);
if (constName)
GWEN_SyncIo_WriteString(sio, constName);
else
GWEN_SyncIo_WriteString(sio, "_new");
GWEN_SyncIo_WriteLine(sio, "(void);");
}
/* FromDb */
if (strcasecmp(fromDbAcc, "private")==0) {
GWEN_SyncIo_WriteString(sio, id);
GWEN_SyncIo_WriteString(sio, " *");
GWEN_SyncIo_WriteString(sio, prefix);
if (fromDbName)
GWEN_SyncIo_WriteString(sio, fromDbName);
else
GWEN_SyncIo_WriteString(sio, "_fromDb");
GWEN_SyncIo_WriteLine(sio, "(GWEN_DB_NODE *db);");
}
/* dup */
if (strcasecmp(dupAcc, "private")==0) {
GWEN_SyncIo_WriteString(sio, id);
GWEN_SyncIo_WriteString(sio, " *");
GWEN_SyncIo_WriteString(sio, prefix);
if (dupName)
GWEN_SyncIo_WriteString(sio, dupName);
else
GWEN_SyncIo_WriteString(sio, "_dup");
GWEN_SyncIo_WriteString(sio, "(const ");
GWEN_SyncIo_WriteString(sio, id);
GWEN_SyncIo_WriteLine(sio, "*st);");
}
if (strcasecmp(nacc, "private")==0) {
GWEN_SyncIo_WriteString(sio, "void ");
GWEN_SyncIo_WriteString(sio, prefix);
GWEN_SyncIo_WriteString(sio, "_free(");
GWEN_SyncIo_WriteString(sio, id);
GWEN_SyncIo_WriteLine(sio, " *st);");
GWEN_SyncIo_WriteString(sio, "void ");
GWEN_SyncIo_WriteString(sio, prefix);
GWEN_SyncIo_WriteString(sio, "_Attach(");
GWEN_SyncIo_WriteString(sio, id);
GWEN_SyncIo_WriteLine(sio, " *st);");
/* ReadDb */
GWEN_SyncIo_WriteString(sio, "int ");
GWEN_SyncIo_WriteString(sio, prefix);
GWEN_SyncIo_WriteString(sio, "_ReadDb(");
GWEN_SyncIo_WriteString(sio, id);
GWEN_SyncIo_WriteLine(sio, " *st, GWEN_DB_NODE *db);");
/* ToDb */
GWEN_SyncIo_WriteString(sio, "int ");
GWEN_SyncIo_WriteString(sio, prefix);
GWEN_SyncIo_WriteString(sio, "_toDb(const ");
GWEN_SyncIo_WriteString(sio, id);
GWEN_SyncIo_WriteString(sio, "*st, GWEN_DB_NODE *db);");
GWEN_SyncIo_WriteString(sio, "int ");
GWEN_SyncIo_WriteString(sio, prefix);
GWEN_SyncIo_WriteString(sio, "_IsModified(const ");
GWEN_SyncIo_WriteString(sio, id);
GWEN_SyncIo_WriteLine(sio, " *st);");
GWEN_SyncIo_WriteString(sio, "void ");
GWEN_SyncIo_WriteString(sio, prefix);
GWEN_SyncIo_WriteString(sio, "_SetModified(");
GWEN_SyncIo_WriteString(sio, id);
GWEN_SyncIo_WriteLine(sio, " *st, int i);");
}
rv=write_h_setget_c(args, node, sio, "private");
if (rv) {
GWEN_Buffer_free(hbuf);
GWEN_SyncIo_free(sio);
return rv;
}
/* write trailing endif */
err=GWEN_SyncIo_WriteLine(sio, "");
if (err) {
DBG_ERROR_ERR(0, err);
GWEN_Buffer_free(hbuf);
return -1;
}
err=GWEN_SyncIo_WriteString(sio, "#endif /* ");
if (err) {
DBG_ERROR_ERR(0, err);
GWEN_Buffer_free(hbuf);
return -1;
}
err=GWEN_SyncIo_WriteString(sio, GWEN_Buffer_GetStart(hbuf));
if (err) {
DBG_ERROR_ERR(0, err);
GWEN_Buffer_free(hbuf);
return -1;
}
err=GWEN_SyncIo_WriteLine(sio, " */");
if (err) {
DBG_ERROR_ERR(0, err);
GWEN_Buffer_free(hbuf);
return -1;
}
err=GWEN_SyncIo_Disconnect(sio);
if (err) {
DBG_ERROR_ERR(0, err);
GWEN_SyncIo_free(sio);
GWEN_Buffer_free(hbuf);
return -1;
}
GWEN_Buffer_free(hbuf);
return 0;
}
int LC_Client_InitCommon() {
if (lc_client__initcounter==0) {
int rv;
GWEN_STRINGLIST *paths;
rv=GWEN_Init();
if (rv) {
DBG_ERROR_ERR(LC_LOGDOMAIN, rv);
return rv;
}
if (!GWEN_Logger_IsOpen(LC_LOGDOMAIN)) {
const char *s;
/* only set our logger if it not already has been */
GWEN_Logger_Open(LC_LOGDOMAIN, "chipcard3-client", 0,
GWEN_LoggerType_Console,
GWEN_LoggerFacility_User);
GWEN_Logger_SetLevel(LC_LOGDOMAIN, GWEN_LoggerLevel_Warning);
s=getenv("LC_LOGLEVEL");
if (s) {
GWEN_LOGGER_LEVEL ll;
ll=GWEN_Logger_Name2Level(s);
if (ll!=GWEN_LoggerLevel_Unknown) {
GWEN_Logger_SetLevel(LC_LOGDOMAIN, ll);
DBG_WARN(LC_LOGDOMAIN,
"Overriding loglevel for Libchipcard-Client with \"%s\"",
s);
}
else {
DBG_ERROR(0, "Unknown loglevel \"%s\"", s);
}
}
else {
GWEN_Logger_SetLevel(LC_LOGDOMAIN, GWEN_LoggerLevel_Warning);
}
}
/* define sysconf path */
GWEN_PathManager_DefinePath(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR);
#if defined(OS_WIN32) || defined(ENABLE_LOCAL_INSTALL)
/* add folder relative to EXE */
GWEN_PathManager_AddRelPath(LCC_PM_LIBNAME,
LCC_PM_LIBNAME,
LCC_PM_SYSCONFDIR,
LC_CLIENT_CONFIG_DIR,
GWEN_PathManager_RelModeExe);
#else
/* add absolute folder */
GWEN_PathManager_AddPath(LCC_PM_LIBNAME,
LCC_PM_LIBNAME,
LCC_PM_SYSCONFDIR,
LC_CLIENT_CONFIG_DIR);
#endif
/* define data path */
GWEN_PathManager_DefinePath(LCC_PM_LIBNAME, LCC_PM_DATADIR);
#if defined(OS_WIN32) || defined(ENABLE_LOCAL_INSTALL)
/* add folder relative to EXE */
GWEN_PathManager_AddRelPath(LCC_PM_LIBNAME,
LCC_PM_LIBNAME,
LCC_PM_DATADIR,
LC_CLIENT_XML_DIR,
GWEN_PathManager_RelModeExe);
#else
/* add absolute folder */
GWEN_PathManager_AddPath(LCC_PM_LIBNAME,
LCC_PM_LIBNAME,
LCC_PM_DATADIR,
LC_CLIENT_XML_DIR);
#endif
/* load configuration file */
#if 0
paths=GWEN_PathManager_GetPaths(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR);
if (paths) {
GWEN_DB_NODE *db;
GWEN_BUFFER *fbuf;
db=GWEN_DB_Group_new("config");
fbuf=GWEN_Buffer_new(0, 256, 0, 1);
rv=GWEN_Directory_FindFileInPaths(paths,
LC_CLIENT_CONFIG_FILE,
fbuf);
if (rv) {
DBG_INFO(LC_LOGDOMAIN,
"Trying config file with suffix \".default\"");
rv=GWEN_Directory_FindFileInPaths(paths,
LC_CLIENT_CONFIG_FILE".default",
fbuf);
}
GWEN_StringList_free(paths);
if (rv) {
DBG_WARN(LC_LOGDOMAIN,
"No configuration file found, using defaults");
}
else {
DBG_INFO(LC_LOGDOMAIN,
"Reading configuration file \"%s\"",
GWEN_Buffer_GetStart(fbuf));
rv=GWEN_DB_ReadFile(db, GWEN_Buffer_GetStart(fbuf),
GWEN_DB_FLAGS_DEFAULT |
GWEN_PATH_FLAGS_CREATE_GROUP);
if (rv<0) {
DBG_ERROR(LC_LOGDOMAIN,
"Error in configuration file \"%s\" (%d)",
GWEN_Buffer_GetStart(fbuf), rv);
GWEN_Buffer_free(fbuf);
/* undo all init stuff so far */
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_DATADIR);
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR);
return rv;
}
}
GWEN_Buffer_free(fbuf);
lc_client__config=db;
}
else {
DBG_ERROR(LC_LOGDOMAIN, "Internal error: Paths not found");
return GWEN_ERROR_INTERNAL;
}
#else
lc_client__config=GWEN_DB_Group_new("config");
#endif
/* load XML files */
paths=GWEN_PathManager_GetPaths(LCC_PM_LIBNAME, LCC_PM_DATADIR);
if (paths) {
GWEN_XMLNODE *n;
GWEN_DB_NODE *db;
GWEN_BUFFER *fbuf;
uint32_t bpos;
fbuf=GWEN_Buffer_new(0, 256, 0, 1);
rv=GWEN_Directory_FindPathForFile(paths,
"cards/README",
fbuf);
GWEN_StringList_free(paths);
if (rv) {
DBG_ERROR(LC_LOGDOMAIN, "Data files not found (%d)", rv);
/* undo all init stuff so far */
GWEN_Buffer_free(fbuf);
GWEN_DB_Group_free(lc_client__config);
lc_client__config=NULL;
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_DATADIR);
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR);
return rv;
}
/* load card files */
n=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "cards");
if (LC_Client_ReadXmlFiles(n,
GWEN_Buffer_GetStart(fbuf),
"cards", "card")) {
DBG_ERROR(LC_LOGDOMAIN, "Could not read card files");
GWEN_XMLNode_free(n);
/* undo all init stuff so far */
GWEN_Buffer_free(fbuf);
GWEN_DB_Group_free(lc_client__config);
lc_client__config=NULL;
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_DATADIR);
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR);
return GWEN_ERROR_GENERIC;
}
lc_client__card_nodes=n;
/* load app files */
n=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "apps");
if (LC_Client_ReadXmlFiles(n,
GWEN_Buffer_GetStart(fbuf),
"apps", "app")) {
DBG_ERROR(LC_LOGDOMAIN, "Could not read app files");
GWEN_XMLNode_free(n);
/* undo all init stuff so far */
GWEN_XMLNode_free(lc_client__card_nodes);
lc_client__card_nodes=NULL;
GWEN_Buffer_free(fbuf);
GWEN_DB_Group_free(lc_client__config);
lc_client__config=NULL;
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_DATADIR);
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR);
return GWEN_ERROR_GENERIC;
}
lc_client__app_nodes=n;
/*GWEN_XMLNode_WriteFile(n, "/tmp/apps", GWEN_XML_FLAGS_DEFAULT);*/
/* load driver files (if any) */
bpos=GWEN_Buffer_GetPos(fbuf);
GWEN_Buffer_AppendString(fbuf, DIRSEP "drivers");
db=GWEN_DB_Group_new("drivers");
rv=LC_DriverInfo_ReadDrivers(GWEN_Buffer_GetStart(fbuf), db, 0, 1);
if (rv) {
DBG_INFO(LC_LOGDOMAIN, "here (%d)", rv);
GWEN_DB_Group_free(db);
/* undo all init stuff so far */
GWEN_XMLNode_free(lc_client__app_nodes);
lc_client__app_nodes=NULL;
GWEN_XMLNode_free(lc_client__card_nodes);
lc_client__card_nodes=NULL;
GWEN_Buffer_free(fbuf);
GWEN_DB_Group_free(lc_client__config);
lc_client__config=NULL;
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_DATADIR);
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR);
return rv;
}
lc_client__driver_db=db;
GWEN_Buffer_Crop(fbuf, 0, bpos);
/* insert more loading here */
GWEN_Buffer_free(fbuf);
}
else {
DBG_ERROR(LC_LOGDOMAIN, "No data files found.");
/* undo all init stuff so far */
GWEN_DB_Group_free(lc_client__config);
lc_client__config=NULL;
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_DATADIR);
GWEN_PathManager_UndefinePath(LCC_PM_LIBNAME, LCC_PM_SYSCONFDIR);
return GWEN_ERROR_GENERIC;
}
}
lc_client__initcounter++;
return 0;
}
int AH_Control_GetItanModes(AB_PROVIDER *pro,
GWEN_DB_NODE *dbArgs,
int argc,
char **argv)
{
GWEN_DB_NODE *db;
uint32_t uid;
AB_USER *u=NULL;
int rv;
const GWEN_ARGS args[]= {
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Int, /* type */
"userId", /* name */
0, /* 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_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;
}
/* doit */
uid=(uint32_t) GWEN_DB_GetIntValue(db, "userId", 0, 0);
if (uid==0) {
fprintf(stderr, "ERROR: Invalid or missing unique user id\n");
return 1;
}
rv=AB_Provider_HasUser(pro, uid);
if (rv<0) {
fprintf(stderr, "ERROR: User with id %lu not found\n", (unsigned long int) uid);
return 2;
}
rv=AB_Provider_GetUser(pro, uid, 1, 1, &u);
if (rv<0) {
fprintf(stderr, "ERROR: User with id %lu not found\n", (unsigned long int) uid);
return 2;
}
else {
AB_IMEXPORTER_CONTEXT *ctx;
ctx=AB_ImExporterContext_new();
rv=AH_Provider_GetItanModes(pro, u, ctx, 1, 0, 1);
AB_ImExporterContext_free(ctx);
if (rv) {
DBG_ERROR_ERR(0, rv);
AB_User_free(u);
return 3;
}
}
AB_User_free(u);
return 0;
}
IPCMESSAGE *CTService_DecryptMessage(CTSERVICEDATA *pd,
IPCMESSAGE *msg) {
ERRORCODE err;
unsigned char *decryptbuffer;
int decryptbuffersize;
char *endbuffer;
char *pencmsg;
int encmsgsize;
char *pomsg;
int omsgsize;
int i;
IPCMESSAGE *tmpmsg;
IPCMESSAGE *endmsg;
assert(pd);
assert(msg);
assert(pd->sessionKey);
/* get message code */
err=IPCMessage_FirstIntParameter(msg,
&i);
if (!Error_IsOk(err)) {
DBG_ERROR("No message code");
DBG_ERROR_ERR(err);
return 0;
}
if (i!=CTSERVICE_MSGCODE_BF) {
DBG_ERROR("Bad message code");
return 0;
}
/* get message version */
err=IPCMessage_NextIntParameter(msg,
&i);
if (!Error_IsOk(err)) {
DBG_ERROR("No message version");
DBG_ERROR_ERR(err);
return 0;
}
/* check message version (only major number) */
if ((i&0xff00)!=(CTSERVICE_MSGCODE_BF_VERSION&0xff00)) {
DBG_ERROR("Bad message version");
return 0;
}
/* get encrypted message */
err=IPCMessage_NextParameter(msg,
&pencmsg,
&encmsgsize);
if (!Error_IsOk(err)) {
DBG_ERROR("No encrypted message within");
DBG_ERROR_ERR(err);
return 0;
}
/* decrypt message */
DBG_VERBOUS("Decrypting message");
err=Cryp_Decrypt(pd->sessionKey,
CryptAlgoBlowfish,
pencmsg,
encmsgsize,
&decryptbuffer,
&decryptbuffersize);
if (!Error_IsOk(err)) {
DBG_ERROR("Error when decrypting");
DBG_ERROR_ERR(err);
return 0;
}
/* analyze message */
DBG_VERBOUS("Analyzing Decrypted message");
tmpmsg=IPCMessage_new();
err=IPCMessage_SetBuffer(tmpmsg,
decryptbuffer,
decryptbuffersize);
if (!Error_IsOk(err)) {
DBG_ERROR("Could not set buffer");
DBG_ERROR_ERR(err);
IPCMessage_free(tmpmsg);
return 0;
}
/* get original message */
DBG_VERBOUS("Getting original message");
err=IPCMessage_FirstParameter(tmpmsg,
&pomsg,
&omsgsize);
if (!Error_IsOk(err)) {
DBG_ERROR("No original message");
DBG_ERROR_ERR(err);
IPCMessage_free(tmpmsg);
return 0;
}
/* copy original message into new buffer */
endbuffer=(char*)malloc(omsgsize);
assert(endbuffer);
memmove(endbuffer, pomsg, omsgsize);
IPCMessage_free(tmpmsg);
/* create final message */
endmsg=IPCMessage_new();
err=IPCMessage_SetBuffer(endmsg,
endbuffer,
omsgsize);
if (!Error_IsOk(err)) {
DBG_ERROR("Could not set buffer in endmessage");
DBG_ERROR_ERR(err);
IPCMessage_free(endmsg);
return 0;
}
/* return decoded message */
DBG_DEBUG("Message decoded");
#if DEBUGMODE>5
Chameleon_DumpString(IPCMessage_GetMessageBegin(endmsg),
IPCMessage_GetMessageSize(endmsg));
#endif
return endmsg;
}
IPCMESSAGE *CTService_EncryptMessage(CTSERVICEDATA *pd,
IPCMESSAGE *msg) {
unsigned char *cryptbuffer;
int cryptbuffersize;
int endbuffersize;
ERRORCODE err;
IPCMESSAGE *tmpmsg;
IPCMESSAGE *endmsg;
DBG_ENTER;
assert(pd);
assert(msg);
assert(pd->sessionKey);
/* create intermediate message
* This message contains:
* - original message
* - signature id (if sign!=0)
* - signature (if sign!=0)
*/
tmpmsg=IPCMessage_new();
IPCMessage_SetBuffer(tmpmsg,0,IPCMESSAGE_MAXMSGSIZE);
/* add original message */
DBG_VERBOUS("Adding original message");
err=IPCMessage_AddParameter(tmpmsg,
IPCMessage_GetMessageBegin(msg),
IPCMessage_GetMessageSize(msg));
if (!Error_IsOk(err)) {
DBG_ERROR_ERR(err);
IPCMessage_free(tmpmsg);
DBG_LEAVE;
return 0;
}
/* finalize intermediate message */
DBG_VERBOUS("Finalizing message");
err=IPCMessage_BuildMessage(tmpmsg);
if (!Error_IsOk(err)) {
DBG_ERROR_ERR(err);
IPCMessage_free(tmpmsg);
DBG_LEAVE;
return 0;
}
/* encrypt intermediate message */
DBG_VERBOUS("Encrypting message");
err=Cryp_Encrypt((CRYP_BFKEY*)pd->sessionKey,
CryptAlgoBlowfish,
IPCMessage_GetMessageBegin(tmpmsg),
IPCMessage_GetMessageSize(tmpmsg),
&cryptbuffer,
&cryptbuffersize);
if (!Error_IsOk(err)) {
DBG_ERROR_ERR(err);
IPCMessage_free(tmpmsg);
DBG_LEAVE;
return 0;
}
/* now the cryptbuffer contains the encrypted message */
/* free unneeded buffers */
IPCMessage_free(tmpmsg);
/* create final message */
DBG_VERBOUS("Building final message");
endbuffersize=cryptbuffersize+32;
if (endbuffersize>IPCMESSAGE_MAXMSGSIZE)
endbuffersize=IPCMESSAGE_MAXMSGSIZE;
endmsg=IPCMessage_new();
IPCMessage_SetBuffer(endmsg,0, endbuffersize);
/* add message code */
err=IPCMessage_AddIntParameter(endmsg,CTSERVICE_MSGCODE_BF);
if (!Error_IsOk(err)) {
DBG_ERROR_ERR(err);
IPCMessage_free(endmsg);
free(cryptbuffer);
DBG_LEAVE;
return 0;
}
/* add message version */
err=IPCMessage_AddIntParameter(endmsg,CTSERVICE_MSGCODE_BF_VERSION);
if (!Error_IsOk(err)) {
DBG_ERROR_ERR(err);
IPCMessage_free(endmsg);
free(cryptbuffer);
DBG_LEAVE;
return 0;
}
/* add encrypted message */
err=IPCMessage_AddParameter(endmsg,
cryptbuffer,
cryptbuffersize);
free(cryptbuffer);
if (!Error_IsOk(err)) {
DBG_ERROR_ERR(err);
IPCMessage_free(endmsg);
DBG_LEAVE;
return 0;
}
/* finalize final message */
err=IPCMessage_BuildMessage(endmsg);
if (!Error_IsOk(err)) {
DBG_ERROR_ERR(err);
IPCMessage_free(endmsg);
DBG_LEAVE;
return 0;
}
/* return encrypted message */
DBG_LEAVE;
return endmsg;
}
int AB_Banking_PluginSystemInit(void) {
if (ab_plugin_init_count==0) {
const char *s;
GWEN_PLUGIN_MANAGER *pm;
int rv;
rv=GWEN_Init();
if (rv) {
DBG_ERROR_ERR(AQBANKING_LOGDOMAIN, rv);
return rv;
}
if (!GWEN_Logger_IsOpen(AQBANKING_LOGDOMAIN)) {
GWEN_Logger_Open(AQBANKING_LOGDOMAIN,
"aqbanking", 0,
GWEN_LoggerType_Console,
GWEN_LoggerFacility_User);
GWEN_Logger_SetLevel(AQBANKING_LOGDOMAIN, GWEN_LoggerLevel_Notice);
}
s=getenv("AQBANKING_LOGLEVEL");
if (s && *s) {
GWEN_LOGGER_LEVEL ll;
ll=GWEN_Logger_Name2Level(s);
GWEN_Logger_SetLevel(AQBANKING_LOGDOMAIN, ll);
}
DBG_INFO(AQBANKING_LOGDOMAIN,
"AqBanking v"
AQBANKING_VERSION_FULL_STRING
" (compiled at "
COMPILE_DATETIME
"): initialising");
/* define locale paths */
GWEN_PathManager_DefinePath(AB_PM_LIBNAME, AB_PM_LOCALEDIR);
GWEN_PathManager_AddPathFromWinReg(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_LOCALEDIR,
AB_BANKING_REGKEY_PATHS,
AB_BANKING_REGKEY_LOCALEDIR);
#if defined(OS_WIN32) || defined(ENABLE_LOCAL_INSTALL)
/* add folder relative to EXE */
GWEN_PathManager_AddRelPath(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_LOCALEDIR,
LOCALEDIR,
GWEN_PathManager_RelModeExe);
#else
/* add absolute folder */
GWEN_PathManager_AddPath(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_LOCALEDIR,
LOCALEDIR);
#endif
if (1) {
GWEN_STRINGLIST *sl=GWEN_PathManager_GetPaths(AB_PM_LIBNAME,
AB_PM_LOCALEDIR);
const char *localedir=GWEN_StringList_FirstString(sl);
rv=GWEN_I18N_BindTextDomain_Dir(PACKAGE, localedir);
if (rv) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not bind textdomain (%d)", rv);
}
else {
rv=GWEN_I18N_BindTextDomain_Codeset(PACKAGE, "UTF-8");
if (rv) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not set codeset (%d)", rv);
}
}
GWEN_StringList_free(sl);
}
/* define sysconf paths */
GWEN_PathManager_DefinePath(AB_PM_LIBNAME, AB_PM_SYSCONFDIR);
GWEN_PathManager_AddPathFromWinReg(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_SYSCONFDIR,
AB_BANKING_REGKEY_PATHS,
AB_BANKING_REGKEY_SYSCONFDIR);
#if defined(OS_WIN32) || defined(ENABLE_LOCAL_INSTALL)
/* add folder relative to EXE */
GWEN_PathManager_AddRelPath(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_SYSCONFDIR,
AQBANKING_SYSCONF_DIR,
GWEN_PathManager_RelModeExe);
#else
/* add absolute folder */
GWEN_PathManager_AddPath(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_SYSCONFDIR,
AQBANKING_SYSCONF_DIR);
#endif
/* define data paths */
GWEN_PathManager_DefinePath(AB_PM_LIBNAME, AB_PM_DATADIR);
GWEN_PathManager_AddPathFromWinReg(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_DATADIR,
AB_BANKING_REGKEY_PATHS,
AB_BANKING_REGKEY_DATADIR);
#if defined(OS_WIN32) || defined(ENABLE_LOCAL_INSTALL)
/* add folder relative to EXE */
GWEN_PathManager_AddRelPath(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_DATADIR,
AQBANKING_DATA_DIR,
GWEN_PathManager_RelModeExe);
#else
/* add absolute folder */
GWEN_PathManager_AddPath(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_DATADIR,
AQBANKING_DATA_DIR);
#endif
/* define wizard paths */
GWEN_PathManager_DefinePath(AB_PM_LIBNAME, AB_PM_WIZARDDIR);
GWEN_PathManager_AddPathFromWinReg(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_WIZARDDIR,
AB_BANKING_REGKEY_PATHS,
AB_BANKING_REGKEY_WIZARDDIR);
#if defined(OS_WIN32) || defined(ENABLE_LOCAL_INSTALL)
/* add folder relative to EXE */
GWEN_PathManager_AddRelPath(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_WIZARDDIR,
AQBANKING_PLUGINS
DIRSEP
AB_WIZARD_FOLDER,
GWEN_PathManager_RelModeExe);
#else
/* add absolute folder */
GWEN_PathManager_AddPath(AB_PM_LIBNAME,
AB_PM_LIBNAME,
AB_PM_WIZARDDIR,
AQBANKING_PLUGINS
DIRSEP
AB_WIZARD_FOLDER);
#endif
/* create bankinfo plugin manager */
DBG_INFO(AQBANKING_LOGDOMAIN, "Registering bankinfo plugin manager");
pm=GWEN_PluginManager_new("bankinfo", AB_PM_LIBNAME);
if (GWEN_PluginManager_Register(pm)) {
DBG_ERROR(AQBANKING_LOGDOMAIN,
"Could not register bankinfo plugin manager");
return GWEN_ERROR_GENERIC;
}
GWEN_PluginManager_AddPathFromWinReg(pm,
AB_PM_LIBNAME,
AB_BANKING_REGKEY_PATHS,
AB_BANKING_REGKEY_BANKINFODIR);
#if defined(OS_WIN32) || defined(ENABLE_LOCAL_INSTALL)
/* add folder relative to EXE */
GWEN_PluginManager_AddRelPath(pm,
AB_PM_LIBNAME,
AQBANKING_PLUGINS
DIRSEP
AB_BANKINFO_PLUGIN_FOLDER,
GWEN_PathManager_RelModeExe);
#else
/* add absolute folder */
GWEN_PluginManager_AddPath(pm,
AB_PM_LIBNAME,
AQBANKING_PLUGINS
DIRSEP
AB_BANKINFO_PLUGIN_FOLDER);
#endif
ab_pluginManagerBankInfo=pm;
/* create provider plugin manager */
DBG_INFO(AQBANKING_LOGDOMAIN, "Registering provider plugin manager");
pm=GWEN_PluginManager_new("provider", AB_PM_LIBNAME);
if (GWEN_PluginManager_Register(pm)) {
DBG_ERROR(AQBANKING_LOGDOMAIN,
"Could not register provider plugin manager");
return GWEN_ERROR_GENERIC;
}
GWEN_PluginManager_AddPathFromWinReg(pm,
AB_PM_LIBNAME,
AB_BANKING_REGKEY_PATHS,
AB_BANKING_REGKEY_PROVIDERDIR);
#if defined(OS_WIN32) || defined(ENABLE_LOCAL_INSTALL)
/* add folder relative to EXE */
GWEN_PluginManager_AddRelPath(pm,
AB_PM_LIBNAME,
AQBANKING_PLUGINS
DIRSEP
AB_PROVIDER_FOLDER,
GWEN_PathManager_RelModeExe);
#else
/* add absolute folder */
GWEN_PluginManager_AddPath(pm,
AB_PM_LIBNAME,
AQBANKING_PLUGINS
DIRSEP
AB_PROVIDER_FOLDER);
#endif
ab_pluginManagerProvider=pm;
/* create imexporters plugin manager */
DBG_INFO(AQBANKING_LOGDOMAIN, "Registering imexporters plugin manager");
pm=GWEN_PluginManager_new("imexporter", AB_PM_LIBNAME);
if (GWEN_PluginManager_Register(pm)) {
DBG_ERROR(AQBANKING_LOGDOMAIN,
"Could not register imexporters plugin manager");
return GWEN_ERROR_GENERIC;
}
GWEN_PluginManager_AddPathFromWinReg(pm,
AB_PM_LIBNAME,
AB_BANKING_REGKEY_PATHS,
AB_BANKING_REGKEY_IMPORTERDIR);
#if defined(OS_WIN32) || defined(ENABLE_LOCAL_INSTALL)
/* add folder relative to EXE */
GWEN_PluginManager_AddRelPath(pm,
AB_PM_LIBNAME,
AQBANKING_PLUGINS
DIRSEP
AB_IMEXPORTER_FOLDER,
GWEN_PathManager_RelModeExe);
#else
/* add absolute folder */
GWEN_PluginManager_AddPath(pm,
AB_PM_LIBNAME,
AQBANKING_PLUGINS
DIRSEP
AB_IMEXPORTER_FOLDER);
#endif
ab_pluginManagerImExporter=pm;
/* insert DBIO plugin folder */
pm=GWEN_PluginManager_FindPluginManager("dbio");
if (pm) {
#if defined(OS_WIN32) || defined(ENABLE_LOCAL_INSTALL)
/* insert folder relative to EXE */
GWEN_PluginManager_InsertRelPath(pm,
AB_PM_LIBNAME,
AQBANKING_PLUGINS
DIRSEP
AB_DBIO_FOLDER,
GWEN_PathManager_RelModeExe);
#else
/* add absolute folder */
GWEN_PluginManager_InsertPath(pm,
AB_PM_LIBNAME,
AQBANKING_PLUGINS
DIRSEP
AB_DBIO_FOLDER);
#endif
}
else {
DBG_ERROR(AQBANKING_LOGDOMAIN,
"Could not find DBIO plugin manager, maybe GWEN_Init() was not called?");
return GWEN_ERROR_GENERIC;
}
ab_imexporters=AB_ImExporter_List_new();
ab_bankInfoPlugins=AB_BankInfoPlugin_List_new();
}
ab_plugin_init_count++;
return 0;
}
int check1() {
AB_BANKING *ab;
AB_PROVIDER *pro;
int rv;
AH_MEDIUM *medium=0;
GWEN_CRYPTKEY *remotePrivCryptKey=0;
GWEN_CRYPTKEY *remotePubCryptKey=0;
int err;
GWEN_DB_NODE *dbKey;
GWEN_GUI *gui;
gui=GWEN_Gui_CGui_new();
GWEN_Gui_SetGetPasswordFn(gui, _getPin);
unlink("check1.medium");
fprintf(stderr, "Check1:\n");
ab=AB_Banking_new("hbci-check1", 0, 0);
rv=AB_Banking_Init(ab);
if (rv) {
DBG_ERROR(0, "Error on init (%d)", rv);
return 2;
}
pro=AB_Banking_GetProvider(ab, "aqhbci");
assert(pro);
medium=AH_Provider_MediumFactory(pro, "ohbci", 0, "check1.medium");
if (!medium) {
DBG_ERROR(0, "Could not create medium object");
return 3;
}
fprintf(stderr, " Creating medium ...\n");
rv=AH_Medium_Create(medium);
if (rv) {
DBG_ERROR(0, "Could not create medium (%d)", rv);
return 3;
}
fprintf(stderr, " Mounting medium ...\n");
rv=AH_Medium_Mount(medium);
if (rv) {
DBG_ERROR(0, "Could not mount medium (%d)", rv);
return 3;
}
fprintf(stderr, " Selecting context ...\n");
rv=AH_Medium_SelectContext(medium, 0);
if (rv) {
DBG_ERROR(0, "Could not select context (%d)", rv);
return 3;
}
fprintf(stderr, " Creating keys ...\n");
rv=AH_Medium_CreateKeys(medium);
if (rv) {
DBG_ERROR(0, "Could not create keys (%d)", rv);
return 3;
}
remotePrivCryptKey=GWEN_CryptKey_Factory("RSA");
if (!remotePrivCryptKey) {
DBG_ERROR(0, "Could not create key (%d)", rv);
return 3;
}
fprintf(stderr, " Generating remote crypt key ...\n");
err=GWEN_CryptKey_Generate(remotePrivCryptKey, 768);
if (err) {
DBG_ERROR_ERR(0, err);
return 3;
}
fprintf(stderr, " Extracting remote public key ...\n");
dbKey=GWEN_DB_Group_new("key");
err=GWEN_CryptKey_toDb(remotePrivCryptKey, dbKey, 1);
if (err) {
DBG_ERROR_ERR(0, err);
return 3;
}
remotePubCryptKey=GWEN_CryptKey_fromDb(dbKey);
if (!remotePubCryptKey) {
DBG_ERROR(0, "Could not create remote pub crypt key");
return 3;
}
fprintf(stderr, " Storing remote public key ...\n");
rv=AH_Medium_SetPubCryptKey(medium, remotePubCryptKey);
if (rv) {
DBG_ERROR(0, "Could not store remote crypt key (%d)", rv);
return 3;
}
fprintf(stderr, " Unmounting medium ...\n");
rv=AH_Medium_Unmount(medium, 1);
if (rv) {
DBG_ERROR(0, "Could not unmount medium (%d)", rv);
return 3;
}
rv=AB_Banking_Fini(ab);
if (rv) {
DBG_ERROR(0, "Could not deinit banking (%d)", rv);
return 3;
}
unlink("check1.medium");
fprintf(stderr, "Check1: PASSED\n");
return 0;
}
int check2() {
AB_BANKING *ab;
AB_PROVIDER *pro;
int rv;
AH_MEDIUM *medium=0;
GWEN_CRYPTKEY *localCryptKey=0;
GWEN_CRYPTKEY *msgKey=0;
int err;
char keybuffer[16];
unsigned int bsize;
AH_MEDIUM_RESULT res;
GWEN_BUFFER *plainKeyBuf;
GWEN_BUFFER *encKeyBuf;
GWEN_BUFFER *decKeyBuf;
const char *p1, *p2;
int i;
GWEN_GUI *gui;
fprintf(stderr, "Check2:\n");
gui=GWEN_Gui_CGui_new();
GWEN_Gui_SetGetPasswordFn(gui, _getPin);
unlink("check2.medium");
ab=AB_Banking_new("hbci-check1", 0, 0);
rv=AB_Banking_Init(ab);
if (rv) {
DBG_ERROR(0, "Error on init (%d)", rv);
return 2;
}
pro=AB_Banking_GetProvider(ab, "aqhbci");
assert(pro);
medium=AH_Provider_MediumFactory(pro, "ohbci", 0, "check2.medium");
if (!medium) {
DBG_ERROR(0, "Could not create medium object");
AB_Banking_Fini(ab);
return 3;
}
fprintf(stderr, " Creating medium ...\n");
rv=AH_Medium_Create(medium);
if (rv) {
DBG_ERROR(0, "Could not create medium (%d)", rv);
return 3;
}
fprintf(stderr, " Mounting medium ...\n");
rv=AH_Medium_Mount(medium);
if (rv) {
DBG_ERROR(0, "Could not mount medium (%d)", rv);
return 3;
}
fprintf(stderr, " Selecting context ...\n");
rv=AH_Medium_SelectContext(medium, 0);
if (rv) {
DBG_ERROR(0, "Could not select context (%d)", rv);
return 3;
}
fprintf(stderr, " Creating keys ...\n");
rv=AH_Medium_CreateKeys(medium);
if (rv) {
DBG_ERROR(0, "Could not create keys (%d)", rv);
return 3;
}
localCryptKey=AH_Medium_GetLocalPubCryptKey(medium);
if (!localCryptKey) {
DBG_ERROR(0, "No local crypt key.");
return 3;
}
fprintf(stderr, " Storing remote public key ...\n");
rv=AH_Medium_SetPubCryptKey(medium, localCryptKey);
if (rv) {
DBG_ERROR(0, "Could not store remote crypt key (%d)", rv);
return 3;
}
fprintf(stderr, " Creating DES key object ...\n");
msgKey=GWEN_CryptKey_Factory("DES");
if (!msgKey) {
DBG_ERROR(0, "Could not create message key (%d)", rv);
return 3;
}
fprintf(stderr, " Generating DES message key ...\n");
err=GWEN_CryptKey_Generate(msgKey, 16);
if (err) {
DBG_ERROR_ERR(0, err);
return 3;
}
fprintf(stderr, " Getting data of message key ...\n");
bsize=sizeof(keybuffer);
err=GWEN_CryptKey_GetData(msgKey, keybuffer, &bsize);
if (err) {
DBG_ERROR_ERR(0, err);
return 3;
}
fprintf(stderr, " Encrypting message key ...\n");
plainKeyBuf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendBytes(plainKeyBuf, keybuffer, bsize);
encKeyBuf=GWEN_Buffer_new(0, 256, 0, 1);
res=AH_Medium_EncryptKey(medium, plainKeyBuf, encKeyBuf, 1);
if (res!=AH_MediumResultOk) {
DBG_ERROR(0, "Error %d", res);
return 3;
}
fprintf(stderr, " Decrypting message key ...\n");
decKeyBuf=GWEN_Buffer_new(0, 256, 0, 1);
res=AH_Medium_DecryptKey(medium, encKeyBuf, decKeyBuf, 1);
if (res!=AH_MediumResultOk) {
DBG_ERROR(0, "Error %d", res);
return 3;
}
fprintf(stderr, " Comparing message key ...\n");
p1=GWEN_Buffer_GetStart(plainKeyBuf);
p2=GWEN_Buffer_GetStart(decKeyBuf);
rv=0;
for (i=0; i<GWEN_Buffer_GetUsedBytes(plainKeyBuf); i++) {
if (p1[i]!=p2[i]) {
fprintf(stderr, "Buffer1:\n");
GWEN_Buffer_Dump(plainKeyBuf, stderr, 2);
fprintf(stderr, "Buffer2:\n");
GWEN_Buffer_Dump(decKeyBuf, stderr, 2);
fprintf(stderr, "Differ at %d (%04x)\n", i, i);
rv=-1;
break;
}
}
if (rv) {
fprintf(stderr, "Data differs in content\n");
return 3;
}
fprintf(stderr, " Unmounting medium ...\n");
rv=AH_Medium_Unmount(medium, 1);
if (rv) {
DBG_ERROR(0, "Could not unmount medium (%d)", rv);
return 3;
}
rv=AB_Banking_Fini(ab);
if (rv) {
DBG_ERROR(0, "Could not deinit banking (%d)", rv);
return 3;
}
unlink("check2.medium");
fprintf(stderr, "Check2: PASSED\n");
return 0;
}
