GWEN_XMLNODE *GWEN_XMLNode_fromString(const char *s, int len, uint32_t flags) {
#if 0
GWEN_XML_CONTEXT *ctx;
GWEN_SYNCIO *sio;
GWEN_XMLNODE *n;
int rv;
if (len==0)
len=strlen(s);
sio=GWEN_SyncIo_Memory_fromBuffer((const uint8_t*)s, len);
n=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "doc");
ctx=GWEN_XmlCtxStore_new(n, flags);
rv=GWEN_XML__ReadAllFromIo(ctx, sio);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_SyncIo_free(sio);
GWEN_XmlCtx_free(ctx);
GWEN_XMLNode_free(n);
return NULL;
}
GWEN_SyncIo_free(sio);
GWEN_XmlCtx_free(ctx);
return n;
#else
GWEN_XML_CONTEXT *ctx;
GWEN_SYNCIO *sio;
GWEN_XMLNODE *n;
int rv;
GWEN_BUFFER *tbuf;
tbuf=GWEN_Buffer_new((char*)s, len, len, 0);
/* static buffer, don't resize */
GWEN_Buffer_SubMode(tbuf, GWEN_BUFFER_MODE_DYNAMIC);
GWEN_Buffer_AddMode(tbuf, GWEN_BUFFER_MODE_READONLY);
sio=GWEN_SyncIo_Memory_new(tbuf, 0);
n=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "doc");
ctx=GWEN_XmlCtxStore_new(n, flags);
rv=GWEN_XML__ReadAllFromIo(ctx, sio);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_XmlCtx_free(ctx);
GWEN_XMLNode_free(n);
GWEN_SyncIo_free(sio);
GWEN_Buffer_free(tbuf);
return NULL;
}
GWEN_XmlCtx_free(ctx);
GWEN_SyncIo_free(sio);
GWEN_Buffer_free(tbuf);
return n;
#endif
}
int AB_ImExporterYN_Import(AB_IMEXPORTER *ie,
AB_IMEXPORTER_CONTEXT *ctx,
GWEN_SYNCIO *sio,
GWEN_DB_NODE *params){
AB_IMEXPORTER_YELLOWNET *ieh;
//GWEN_DB_NODE *dbSubParams;
GWEN_XMLNODE *doc;
GWEN_XMLNODE *node;
int rv;
GWEN_XML_CONTEXT *ctxml;
assert(ie);
ieh=GWEN_INHERIT_GETDATA(AB_IMEXPORTER, AB_IMEXPORTER_YELLOWNET, ie);
assert(ieh);
// dbSubParams=GWEN_DB_GetGroup(params, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
// "params");
doc=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "root");
ctxml=GWEN_XmlCtxStore_new(doc, GWEN_XML_FLAGS_HANDLE_HEADERS);
rv=GWEN_XMLContext_ReadFromIo(ctxml, sio);
GWEN_XmlCtx_free(ctxml);
if (rv) {
DBG_ERROR(AQBANKING_LOGDOMAIN,
"Could not parse XML stream (%d)", rv);
GWEN_XMLNode_free(doc);
return GWEN_ERROR_BAD_DATA;
}
node=GWEN_XMLNode_FindFirstTag(doc, "IC", 0, 0);
if (node==NULL) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Document does not contain element \"IC\"");
GWEN_XMLNode_Dump(doc, 2);
GWEN_XMLNode_free(doc);
return GWEN_ERROR_BAD_DATA;
}
node=GWEN_XMLNode_FindFirstTag(node, "KONAUS", 0, 0);
while(node) {
AB_IMEXPORTER_ACCOUNTINFO *ai;
ai=AB_ImExporterYN__ReadAccountInfo(ie, ctx, node);
assert(ai);
rv=AB_ImExporterYN__ReadAccountStatus(ie, ai, node);
if (rv==0)
rv=AB_ImExporterYN__ReadTransactions(ie, ai, node);
if (rv) {
AB_ImExporterAccountInfo_free(ai);
GWEN_XMLNode_free(doc);
return rv;
}
AB_ImExporterContext_AddAccountInfo(ctx, ai);
node=GWEN_XMLNode_FindNextTag(node, "KONAUS", 0, 0);
}
GWEN_XMLNode_free(doc);
return 0;
}
int GWEN_DBIO_XmlDb_Import(GWEN_DBIO *dbio,
GWEN_SYNCIO *sio,
GWEN_DB_NODE *data,
GWEN_DB_NODE *cfg,
uint32_t flags) {
int rv;
GWEN_XMLNODE *root;
GWEN_XMLNODE *n;
const char *rootName=0;
GWEN_XML_CONTEXT *ctx;
assert(data);
if (cfg)
rootName=GWEN_DB_GetCharValue(cfg, "rootElement", 0, 0);
root=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "root");
ctx=GWEN_XmlCtxStore_new(root,
GWEN_XML_FLAGS_DEFAULT |
GWEN_XML_FLAGS_HANDLE_HEADERS);
rv=GWEN_XMLContext_ReadFromIo(ctx, sio);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_XmlCtx_free(ctx);
GWEN_XMLNode_free(root);
return rv;
}
GWEN_XmlCtx_free(ctx);
if (rootName) {
n=GWEN_XMLNode_FindFirstTag(root, rootName, 0, 0);
if (!n) {
DBG_ERROR(GWEN_LOGDOMAIN,
"Root node in XML file is not \"%s\"", rootName);
GWEN_XMLNode_free(root);
return GWEN_ERROR_BAD_DATA;
}
}
else {
n=GWEN_XMLNode_GetFirstTag(root);
if (!n) {
DBG_ERROR(GWEN_LOGDOMAIN,
"No root node in XML file");
GWEN_XMLNode_free(root);
return GWEN_ERROR_BAD_DATA;
}
}
rv=GWEN_DBIO__XmlDb_ImportGroup(dbio, flags, data, cfg, n);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_XMLNode_free(root);
return rv;
}
GWEN_XMLNode_free(root);
return 0;
}
int GWEN_DBIO_XmlDb_Export(GWEN_DBIO *dbio,
GWEN_SYNCIO *sio,
GWEN_DB_NODE *data,
GWEN_DB_NODE *cfg,
uint32_t flags) {
GWEN_XMLNODE *root;
GWEN_XMLNODE *nh;
int rv;
const char *rootName=0;
GWEN_XML_CONTEXT *ctx;
if (cfg)
rootName=GWEN_DB_GetCharValue(cfg, "rootElement", 0, 0);
root=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "root");
nh=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "?xml");
GWEN_XMLNode_SetProperty(nh, "version", "1.0");
GWEN_XMLNode_SetProperty(nh, "encoding", "utf-8");
GWEN_XMLNode_AddHeader(root, nh);
rv=GWEN_DBIO_XmlDb__ExportGroup(dbio, data, root, rootName);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_XMLNode_free(root);
return rv;
}
ctx=GWEN_XmlCtxStore_new(root,
GWEN_XML_FLAGS_DEFAULT |
GWEN_XML_FLAGS_SIMPLE |
GWEN_XML_FLAGS_HANDLE_HEADERS);
rv=GWEN_XMLNode_WriteToStream(root, ctx, sio);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_XmlCtx_free(ctx);
GWEN_XMLNode_free(root);
return rv;
}
GWEN_XmlCtx_free(ctx);
GWEN_XMLNode_free(root);
return 0;
}
void GWEN_XMLNode_SetCharValue(GWEN_XMLNODE *n,
const char *name,
const char *value) {
if (name && *name) {
GWEN_XMLNODE *nn;
nn=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, name);
if (value) {
GWEN_XMLNODE *nnn;
nnn=GWEN_XMLNode_new(GWEN_XMLNodeTypeData, value);
GWEN_XMLNode_AddChild(nn, nnn);
}
GWEN_XMLNode_AddChild(n, nn);
}
else {
GWEN_XMLNODE *nn;
nn=GWEN_XMLNode_new(GWEN_XMLNodeTypeData, value);
GWEN_XMLNode_AddChild(n, nn);
}
}
GWEN_XMLNODE *GWEN_XMLNode_dup(const GWEN_XMLNODE *n) {
GWEN_XMLNODE *nn, *cn, *ncn;
const GWEN_XMLPROPERTY *p;
const GWEN_XMLNODE_NAMESPACE *nns;
/* duplicate node itself */
nn=GWEN_XMLNode_new(n->type, n->data);
if (n->nameSpace)
nn->nameSpace=strdup(n->nameSpace);
/* duplicate properties */
p=n->properties;
while(p) {
GWEN_XMLPROPERTY *np;
np=GWEN_XMLProperty_dup(p);
GWEN_XMLProperty_add(np, &(nn->properties));
p=p->next;
} /* while */
/* duplicate children */
cn=GWEN_XMLNode_List_First(n->children);
while(cn) {
ncn=GWEN_XMLNode_dup(cn);
GWEN_XMLNode_AddChild(nn, ncn);
cn=GWEN_XMLNode_Next(cn);
} /* while */
/* duplicate headers */
cn=GWEN_XMLNode_List_First(n->headers);
while(cn) {
ncn=GWEN_XMLNode_dup(cn);
GWEN_XMLNode_AddHeader(nn, ncn);
cn=GWEN_XMLNode_Next(cn);
} /* while */
/* duplicate namespaces */
nns=GWEN_XMLNode_NameSpace_List_First(n->nameSpaces);
while(nns) {
GWEN_XMLNODE_NAMESPACE *nnns;
nnns=GWEN_XMLNode_NameSpace_dup(nns);
GWEN_XMLNode_NameSpace_List_Add(nnns, nn->nameSpaces);
nns=GWEN_XMLNode_NameSpace_List_Next(nns);
}
return nn;
}
int GWEN_DBIO_XmlDb__ExportGroup(GWEN_DBIO *dbio,
GWEN_DB_NODE *data,
GWEN_XMLNODE *node,
const char *newName) {
const char *s;
GWEN_XMLNODE *n;
GWEN_DB_NODE *dbT;
int rv;
if (newName)
s=newName;
else
s=GWEN_DB_GroupName(data);
assert(s && *s);
n=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, s);
GWEN_XMLNode_SetProperty(n, "type", "group");
GWEN_XMLNode_AddChild(node, n);
/* store variables */
dbT=GWEN_DB_GetFirstVar(data);
while(dbT) {
if (!(GWEN_DB_GetNodeFlags(dbT) & GWEN_DB_NODE_FLAGS_VOLATILE)) {
rv=GWEN_DBIO_XmlDb__ExportVar(dbio, dbT, n);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
return rv;
}
}
dbT=GWEN_DB_GetNextVar(dbT);
}
/* store groups */
dbT=GWEN_DB_GetFirstGroup(data);
while(dbT) {
if (!(GWEN_DB_GetNodeFlags(dbT) & GWEN_DB_NODE_FLAGS_VOLATILE)) {
rv=GWEN_DBIO_XmlDb__ExportGroup(dbio, dbT, n, 0);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
return rv;
}
}
dbT=GWEN_DB_GetNextGroup(dbT);
}
return 0;
}
void GWEN_Param_WriteXml(const GWEN_PARAM *p_struct, GWEN_XMLNODE *p_db)
{
assert(p_struct);
/* member "name" */
GWEN_XMLNode_SetCharValue(p_db, "name", p_struct->name);
/* member "flags" */
GWEN_XMLNode_SetIntValue(p_db, "flags", p_struct->flags);
/* member "type" */
GWEN_XMLNode_SetCharValue(p_db, "type", GWEN_Param_Type_toString(p_struct->type));
/* member "dataType" */
GWEN_XMLNode_SetCharValue(p_db, "dataType", GWEN_Param_DataType_toString(p_struct->dataType));
/* member "shortDescription" */
GWEN_XMLNode_SetCharValue(p_db, "shortDescription", p_struct->shortDescription);
/* member "longDescription" */
GWEN_XMLNode_SetCharValue(p_db, "longDescription", p_struct->longDescription);
/* member "currentValue" */
GWEN_XMLNode_SetCharValue(p_db, "currentValue", p_struct->currentValue);
/* member "defaultValue" */
GWEN_XMLNode_SetCharValue(p_db, "defaultValue", p_struct->defaultValue);
/* member "choices" */
if (p_struct->choices) {
GWEN_XMLNODE *n;
n=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "choices");
GWEN_StringList2_toXml(p_struct->choices, n);
GWEN_XMLNode_AddChild(p_db, n);
}
/* member "internalIntValue" is volatile, not writing to xml */
/* member "internalFloatValue" is volatile, not writing to xml */
/* member "runtimeFlags" is volatile, not writing to xml */
}
int GWEN_XMLNode_SetCharValueByPath(GWEN_XMLNODE *n, uint32_t flags,
const char *name,
const char *value) {
GWEN_XMLNODE *nn;
nn=GWEN_XMLNode_GetNodeByXPath(n, name, 0);
if (nn) {
GWEN_XMLNODE *nnn;
/* clear current entries */
if (flags & GWEN_XML_PATH_FLAGS_OVERWRITE_VALUES)
GWEN_XMLNode_List_Clear(nn->children);
/* create value node */
nnn=GWEN_XMLNode_new(GWEN_XMLNodeTypeData, value);
GWEN_XMLNode_AddChild(nn, nnn);
return 0;
}
else {
DBG_ERROR(GWEN_LOGDOMAIN, "Unable to create node [%s]", name);
return GWEN_ERROR_INVALID;
}
}
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 Typemaker2_TypeManager_LoadTypeFileNoLookup(TYPEMAKER2_TYPEMANAGER *tym, const char *fileName,
TYPEMAKER2_TYPE_LIST2 *tlist2) {
int rv;
TYPEMAKER2_TYPE *ty=NULL;
GWEN_XMLNODE *root;
GWEN_XMLNODE *node;
/* read XML file */
root=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "xml");
rv=GWEN_XML_ReadFile(root, fileName,
GWEN_XML_FLAGS_DEFAULT |
GWEN_XML_FLAGS_HANDLE_HEADERS |
GWEN_XML_FLAGS_HANDLE_OPEN_HTMLTAGS);
if (rv<0) {
DBG_ERROR(GWEN_LOGDOMAIN, "Could not load typefile [%s] (%d)", fileName, rv);
GWEN_XMLNode_free(root);
return rv;
}
/* get <tm2> element */
node=GWEN_XMLNode_FindFirstTag(root, "tm2", NULL, NULL);
if (node==NULL) {
DBG_ERROR(GWEN_LOGDOMAIN,
"File [%s] does not contain a tm2 element",
fileName);
GWEN_XMLNode_free(root);
return GWEN_ERROR_NO_DATA;
}
/* get <type> element with id==typeName and wanted language */
node=GWEN_XMLNode_FindFirstTag(node, "type", NULL, NULL);
if (node==NULL) {
DBG_ERROR(GWEN_LOGDOMAIN,
"File [%s] does not contain a type element",
fileName);
GWEN_XMLNode_free(root);
return GWEN_ERROR_NO_DATA;
}
/* read all types from the file */
while(node) {
/* load type from XML element */
ty=Typemaker2_Type_new();
rv=Typemaker2_Type_readXml(ty, node, tym->lang);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "Error reading type from file [%s] (%d)",
fileName,
rv);
Typemaker2_Type_free(ty);
GWEN_XMLNode_free(root);
return rv;
}
/* preset some stuff */
if (1) {
const char *x;
x=Typemaker2_Type_GetExtends(ty);
if (!x || !(*x))
Typemaker2_Type_SetExtends(ty, "struct_base");
}
/* add first, because other types might want to refer to this one */
Typemaker2_Type_List_Add(ty, tym->typeList);
Typemaker2_Type_List2_PushBack(tlist2, ty);
if (Typemaker2_Type_GetFlags(ty) & TYPEMAKER2_FLAGS_WITH_LIST1)
Typemaker2_TypeManager_MakeTypeList1(tym, ty);
if (Typemaker2_Type_GetFlags(ty) & TYPEMAKER2_FLAGS_WITH_LIST2)
Typemaker2_TypeManager_MakeTypeList2(tym, ty);
if (Typemaker2_Type_GetFlags(ty) & TYPEMAKER2_FLAGS_WITH_TREE)
Typemaker2_TypeManager_MakeTypeTree(tym, ty);
node=GWEN_XMLNode_FindNextTag(node, "type", NULL, NULL);
}
GWEN_XMLNode_free(root);
//Typemaker2_TypeManager_Dump(tym, stderr, 2);
return 0;
}
TYPEMAKER2_TYPE *Typemaker2_TypeManager_LoadType(TYPEMAKER2_TYPEMANAGER *tym, const char *typeName) {
GWEN_BUFFER *tbuf;
GWEN_BUFFER *nbuf;
char *p;
int rv;
TYPEMAKER2_TYPE *ty=NULL;
GWEN_XMLNODE *root;
GWEN_XMLNODE *node;
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendString(tbuf, typeName);
p=GWEN_Buffer_GetStart(tbuf);
while(*p) {
*p=tolower(*p);
p++;
}
GWEN_Buffer_AppendString(tbuf, ".tm2");
nbuf=GWEN_Buffer_new(0, 256, 0, 1);
rv=GWEN_Directory_FindFileInPaths(tym->folders, GWEN_Buffer_GetStart(tbuf), nbuf);
if (rv<0) {
DBG_ERROR(GWEN_LOGDOMAIN, "Typefile [%s] not found (%d)", GWEN_Buffer_GetStart(tbuf), rv);
GWEN_Buffer_free(nbuf);
GWEN_Buffer_free(tbuf);
return NULL;
}
/* read XML file */
root=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "xml");
rv=GWEN_XML_ReadFile(root, GWEN_Buffer_GetStart(nbuf),
GWEN_XML_FLAGS_DEFAULT |
GWEN_XML_FLAGS_HANDLE_HEADERS |
GWEN_XML_FLAGS_HANDLE_OPEN_HTMLTAGS);
if (rv<0) {
DBG_ERROR(GWEN_LOGDOMAIN, "Could not load typefile [%s] (%d)", GWEN_Buffer_GetStart(nbuf), rv);
GWEN_XMLNode_free(root);
GWEN_Buffer_free(nbuf);
GWEN_Buffer_free(tbuf);
return NULL;
}
/* get <tm2> element */
node=GWEN_XMLNode_FindFirstTag(root, "tm2", NULL, NULL);
if (node==NULL) {
DBG_ERROR(GWEN_LOGDOMAIN,
"File [%s] does not contain a tm2 element",
GWEN_Buffer_GetStart(nbuf));
GWEN_XMLNode_free(root);
GWEN_Buffer_free(nbuf);
GWEN_Buffer_free(tbuf);
return NULL;
}
/* get <typedef> element with id==typeName and wanted language */
node=GWEN_XMLNode_FindFirstTag(node, "typedef", "id", typeName);
while(node) {
const char *s=GWEN_XMLNode_GetProperty(node, "lang", NULL);
if (s && *s && strcasecmp(s, tym->lang)==0)
break;
node=GWEN_XMLNode_FindNextTag(node, "typedef", "id", typeName);
}
if (node==NULL) {
DBG_ERROR(GWEN_LOGDOMAIN,
"File [%s] does not contain a <typedef> element for type [%s] and language [%s]",
GWEN_Buffer_GetStart(nbuf), typeName, tym->lang);
GWEN_XMLNode_free(root);
GWEN_Buffer_free(nbuf);
GWEN_Buffer_free(tbuf);
return NULL;
}
/* load typedef from XML element */
ty=Typemaker2_Type_new();
rv=Typemaker2_Type_readXml(ty, node, NULL);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "Error reading type [%s] from file [%s] (%d)",
typeName,
GWEN_Buffer_GetStart(nbuf),
rv);
Typemaker2_Type_free(ty);
GWEN_XMLNode_free(root);
GWEN_Buffer_free(nbuf);
GWEN_Buffer_free(tbuf);
return NULL;
}
GWEN_XMLNode_free(root);
GWEN_Buffer_free(nbuf);
GWEN_Buffer_free(tbuf);
return ty;
}
int GWEN_DBIO_XmlDb__ExportVar(GWEN_DBIO *dbio,
GWEN_DB_NODE *data,
GWEN_XMLNODE *node) {
const char *s;
GWEN_XMLNODE *n;
GWEN_DB_NODE *dbT;
int rv;
s=GWEN_DB_VariableName(data);
assert(s && *s);
n=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, s);
GWEN_XMLNode_SetProperty(n, "type", "var");
GWEN_XMLNode_AddChild(node, n);
/* store variables */
dbT=GWEN_DB_GetFirstValue(data);
while(dbT) {
if (!(GWEN_DB_GetNodeFlags(dbT) & GWEN_DB_NODE_FLAGS_VOLATILE)) {
GWEN_DB_NODE_TYPE vt;
GWEN_XMLNODE *vn;
vt=GWEN_DB_GetValueType(dbT);
switch(vt) {
case GWEN_DB_NodeType_ValueChar:
s=GWEN_DB_GetCharValueFromNode(dbT);
if (s && *s) {
GWEN_XMLNODE *dn;
GWEN_BUFFER *tbuf;
vn=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "value");
GWEN_XMLNode_SetProperty(vn, "type", "char");
GWEN_XMLNode_AddChild(n, vn);
tbuf=GWEN_Buffer_new(0, 64, 0, 1);
rv=GWEN_Text_EscapeXmlToBuffer(s, tbuf);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
return rv;
}
dn=GWEN_XMLNode_new(GWEN_XMLNodeTypeData, GWEN_Buffer_GetStart(tbuf));
GWEN_Buffer_free(tbuf);
GWEN_XMLNode_AddChild(vn, dn);
}
break;
case GWEN_DB_NodeType_ValueInt: {
char nbuf[32];
GWEN_XMLNODE *dn;
snprintf(nbuf, sizeof(nbuf), "%i", GWEN_DB_GetIntValueFromNode(dbT));
vn=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "value");
GWEN_XMLNode_SetProperty(vn, "type", "int");
GWEN_XMLNode_AddChild(n, vn);
dn=GWEN_XMLNode_new(GWEN_XMLNodeTypeData, nbuf);
GWEN_XMLNode_AddChild(vn, dn);
break;
}
case GWEN_DB_NodeType_ValueBin: {
const void *vp;
unsigned int vsize;
vp=GWEN_DB_GetBinValueFromNode(dbT, &vsize);
if (vp && vsize) {
GWEN_BUFFER *bbuf;
GWEN_XMLNODE *dn;
bbuf=GWEN_Buffer_new(0, vsize*2, 0, 1);
rv=GWEN_Text_ToHexBuffer((const char*)vp,
vsize,
bbuf,
0, 0, 0);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(bbuf);
return rv;
}
vn=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "value");
GWEN_XMLNode_SetProperty(vn, "type", "bin");
GWEN_XMLNode_AddChild(n, vn);
dn=GWEN_XMLNode_new(GWEN_XMLNodeTypeData,
GWEN_Buffer_GetStart(bbuf));
GWEN_Buffer_free(bbuf);
GWEN_XMLNode_AddChild(vn, dn);
}
break;
}
case GWEN_DB_NodeType_ValuePtr:
DBG_DEBUG(GWEN_LOGDOMAIN, "Not storing pointer value");
break;
default:
DBG_ERROR(GWEN_LOGDOMAIN,
"Unsupported variable type %d",
vt);
return GWEN_ERROR_INVALID;
}
} /* if non-volatile */
dbT=GWEN_DB_GetNextValue(dbT);
}
return 0;
}
int logFile(AB_BANKING *ab,
GWEN_DB_NODE *dbArgs,
int argc,
char **argv) {
int rv;
GWEN_DB_NODE *db;
GWEN_DB_NODE *dbMessages;
const char *s;
GWEN_MSGENGINE *e;
GWEN_SYNCIO *sioOut=NULL;
GWEN_SYNCIO *sioDb=NULL;
const char *inFile;
const char *outFile;
const char *dbOutFile;
int i;
GWEN_DB_NODE *dbT;
int trustLevel;
const GWEN_ARGS args[]={
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"xmlfile", /* name */
0, /* minnum */
99, /* maxnum */
"x", /* short option */
"xmlfile", /* long option */
"Specify XML files to load", /* short description */
"Specify XML files to load" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"infile", /* name */
1, /* minnum */
1, /* maxnum */
"i", /* short option */
"infile", /* long option */
"Specify input file", /* short description */
"Specify input file" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"outfile", /* name */
0, /* minnum */
1, /* maxnum */
"o", /* short option */
"outfile", /* long option */
"Specify output file", /* short description */
"Specify output file" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"dboutfile", /* name */
0, /* minnum */
1, /* maxnum */
"d", /* short option */
"dbfile", /* long option */
"Specify DB output file", /* short description */
"Specify DB output file" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Int, /* type */
"trustLevel", /* name */
0, /* minnum */
1, /* maxnum */
"L", /* short option */
"trustlevel", /* long option */
"Specify the trust level", /* short description */
"Specify the trust level" /* 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;
}
trustLevel=GWEN_DB_GetIntValue(db, "trustLevel", 0, 0);
outFile=GWEN_DB_GetCharValue(db, "outFile", 0, NULL);
dbOutFile=GWEN_DB_GetCharValue(db, "dbOutFile", 0, NULL);
inFile=GWEN_DB_GetCharValue(db, "inFile", 0, NULL);
assert(inFile);
/* do it */
dbMessages=GWEN_DB_Group_new("Messages");
rv=_readLogFile(inFile, dbMessages);
if (rv<0) {
DBG_ERROR(0, "Error reading message (%d)", rv);
return 2;
}
/* create message engine, read XML definitions */
e=AH_MsgEngine_new();
for (i=0; i<99; i++) {
s=GWEN_DB_GetCharValue(dbArgs, "xmlfile", i, NULL);
if (s && *s) {
GWEN_XMLNODE *defs;
defs=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "defs");
if (GWEN_XML_ReadFile(defs, s, GWEN_XML_FLAGS_DEFAULT)){
fprintf(stderr, "Error parsing.\n");
GWEN_MsgEngine_free(e);
return 2;
}
GWEN_MsgEngine_AddDefinitions(e, defs);
GWEN_XMLNode_free(defs);
}
else {
if (i==0) {
GWEN_XMLNODE *defs;
defs=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "defs");
if (GWEN_XML_ReadFile(defs, XMLDATA_DIR "/hbci.xml", GWEN_XML_FLAGS_DEFAULT)){
fprintf(stderr, "Error parsing.\n");
GWEN_MsgEngine_free(e);
return 2;
}
GWEN_MsgEngine_AddDefinitions(e, defs);
GWEN_XMLNode_free(defs);
}
break;
}
}
if (outFile) {
sioOut=GWEN_SyncIo_File_new(outFile, GWEN_SyncIo_File_CreationMode_CreateAlways);
GWEN_SyncIo_AddFlags(sioOut,
GWEN_SYNCIO_FILE_FLAGS_READ |
GWEN_SYNCIO_FILE_FLAGS_WRITE |
GWEN_SYNCIO_FILE_FLAGS_UREAD |
GWEN_SYNCIO_FILE_FLAGS_UWRITE |
GWEN_SYNCIO_FILE_FLAGS_APPEND);
rv=GWEN_SyncIo_Connect(sioOut);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_SyncIo_free(sioOut);
return 2;
}
}
if (dbOutFile) {
sioDb=GWEN_SyncIo_File_new(dbOutFile, GWEN_SyncIo_File_CreationMode_CreateAlways);
GWEN_SyncIo_AddFlags(sioDb,
GWEN_SYNCIO_FILE_FLAGS_READ |
GWEN_SYNCIO_FILE_FLAGS_WRITE |
GWEN_SYNCIO_FILE_FLAGS_UREAD |
GWEN_SYNCIO_FILE_FLAGS_UWRITE |
GWEN_SYNCIO_FILE_FLAGS_APPEND);
rv=GWEN_SyncIo_Connect(sioDb);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_SyncIo_free(sioDb);
return 2;
}
}
dbT=GWEN_DB_GetFirstGroup(dbMessages);
while(dbT) {
const uint8_t *p;
uint32_t len;
GWEN_DB_NODE *dbHeader;
dbHeader=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "header");
assert(dbHeader);
s=GWEN_DB_GetCharValue(dbHeader, "mode", 0, "PINTAN");
GWEN_MsgEngine_SetMode(e, s);
i=GWEN_DB_GetIntValue(dbHeader, "hbciVersion", 0, 220);
GWEN_MsgEngine_SetProtocolVersion(e, i);
p=GWEN_DB_GetBinValue(dbT, "body", 0, NULL, 0, &len);
if (p && len) {
GWEN_BUFFER *tbuf;
GWEN_DB_NODE *gr;
GWEN_MSGENGINE_TRUSTEDDATA *trustedData;
GWEN_MSGENGINE_TRUSTEDDATA *ntd;
GWEN_DB_NODE *repl;
gr=GWEN_DB_Group_new("message");
tbuf=GWEN_Buffer_new((char*) p, len, len, 0);
rv=GWEN_MsgEngine_ReadMessage(e, "SEG", tbuf, gr,
GWEN_MSGENGINE_READ_FLAGS_TRUSTINFO);
if (rv) {
fprintf(stderr, "ERROR.\n");
GWEN_Buffer_Dump(tbuf, 2);
return 2;
}
/* work on trust data */
trustedData=GWEN_MsgEngine_TakeTrustInfo(e);
if (trustedData) {
if (GWEN_MsgEngine_TrustedData_CreateReplacements(trustedData)) {
fprintf(stderr, "Could not anonymize log (createReplacements)\n");
GWEN_MsgEngine_TrustedData_free(trustedData);
GWEN_MsgEngine_free(e);
return 2;
}
}
/* anonymize file */
ntd=trustedData;
repl=GWEN_DB_GetGroup(dbHeader, GWEN_DB_FLAGS_OVERWRITE_GROUPS, "replacements");
assert(repl);
while(ntd) {
if (GWEN_MsgEngine_TrustedData_GetTrustLevel(ntd)>trustLevel) {
int pos;
unsigned int size;
char rbuffer[3];
const char *rpstr;
rpstr=GWEN_MsgEngine_TrustedData_GetReplacement(ntd);
assert(rpstr);
assert(*rpstr);
size=strlen(rpstr);
if (size==1) {
rbuffer[0]=rpstr[0];
rbuffer[1]=0;
}
else {
rbuffer[0]=rpstr[0];
rbuffer[1]=rpstr[1];
rbuffer[2]=0;
}
GWEN_DB_SetCharValue(repl,
GWEN_DB_FLAGS_DEFAULT |
GWEN_PATH_FLAGS_CREATE_VAR,
rbuffer,
GWEN_MsgEngine_TrustedData_GetDescription(ntd));
size=GWEN_MsgEngine_TrustedData_GetSize(ntd);
pos=GWEN_MsgEngine_TrustedData_GetFirstPos(ntd);
while(pos>=0) {
DBG_INFO(0, "Replacing %d bytes at %d", size, pos);
GWEN_Buffer_SetPos(tbuf, pos);
GWEN_Buffer_ReplaceBytes(tbuf,
size,
GWEN_MsgEngine_TrustedData_GetReplacement(ntd),
size);
pos=GWEN_MsgEngine_TrustedData_GetNextPos(ntd);
} // while pos
}
ntd=GWEN_MsgEngine_TrustedData_GetNext(ntd);
} // while ntd
GWEN_DB_SetIntValue(dbHeader, GWEN_DB_FLAGS_OVERWRITE_VARS, "size", GWEN_Buffer_GetUsedBytes(tbuf));
if (outFile) {
rv=dumpMsg(sioOut,
dbHeader,
(const uint8_t*)GWEN_Buffer_GetStart(tbuf),
GWEN_Buffer_GetUsedBytes(tbuf));
if (rv<0) {
fprintf(stderr, "Could not anonymize log (dumpMsg)\n");
GWEN_MsgEngine_TrustedData_free(trustedData);
GWEN_MsgEngine_free(e);
return 2;
}
}
if (dbOutFile) {
GWEN_BUFFER *xbuf;
GWEN_DB_NODE *dbOut;
xbuf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendString(xbuf, "# ========== Message ( ");
s=GWEN_DB_GetCharValue(dbHeader, "sender", 0, "UNK");
if (s && *s) {
GWEN_Buffer_AppendString(xbuf, "sender=");
GWEN_Buffer_AppendString(xbuf, s);
GWEN_Buffer_AppendString(xbuf, " ");
}
s=GWEN_DB_GetCharValue(dbHeader, "crypt", 0, "UNK");
if (s && *s) {
GWEN_Buffer_AppendString(xbuf, "crypt=");
GWEN_Buffer_AppendString(xbuf, s);
GWEN_Buffer_AppendString(xbuf, " ");
}
GWEN_Buffer_AppendString(xbuf, ") ==========\n");
dbOut=GWEN_DB_Group_new("Message");
GWEN_Buffer_Rewind(tbuf);
rv=GWEN_MsgEngine_ReadMessage(e, "SEG", tbuf, dbOut, 0);
if (rv) {
fprintf(stderr, "ERROR.\n");
GWEN_Buffer_Dump(tbuf, 2);
return 2;
}
rv=GWEN_SyncIo_WriteForced(sioDb,
(const uint8_t*) GWEN_Buffer_GetStart(xbuf),
GWEN_Buffer_GetUsedBytes(xbuf));
GWEN_Buffer_free(xbuf);
if (rv<0) {
DBG_INFO(0, "here (%d)", rv);
return rv;
}
rv=GWEN_DB_WriteToIo(dbOut, sioDb, GWEN_DB_FLAGS_DEFAULT);
if (rv<0) {
DBG_INFO(0, "here (%d)", rv);
return 2;
}
/* append empty line to separate header from data */
rv=GWEN_SyncIo_WriteForced(sioDb, (const uint8_t*) "\n", 1);
if (rv<0) {
DBG_INFO(0, "here (%d)", rv);
return rv;
}
}
GWEN_Buffer_free(tbuf);
}
dbT=GWEN_DB_GetNextGroup(dbT);
}
/* close output layer */
if (outFile) {
rv=GWEN_SyncIo_Disconnect(sioOut);
if (rv<0) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
GWEN_SyncIo_free(sioOut);
return 2;
}
GWEN_SyncIo_free(sioOut);
}
if (dbOutFile) {
rv=GWEN_SyncIo_Disconnect(sioDb);
if (rv<0) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
GWEN_SyncIo_free(sioDb);
return 2;
}
GWEN_SyncIo_free(sioDb);
}
return 0;
}
void* GWEN_XMLNode_HandlePath(const char *entry,
void *data,
int idx,
uint32_t flags) {
GWEN_XMLNODE *n;
GWEN_XMLNODE *nn;
int i;
n=(GWEN_XMLNODE*)data;
if (flags & GWEN_PATH_FLAGS_VARIABLE) {
DBG_ERROR(GWEN_LOGDOMAIN,
"GWEN_PATH_FLAGS_VARIABLE not allowed for XPATH");
return 0;
}
if (flags & GWEN_PATH_FLAGS_ROOT) {
while(n->parent)
n=n->parent;
if (*entry=='/')
entry++;
}
if (strcasecmp(entry, "..")==0) {
return n->parent;
}
else if (strcasecmp(entry, ".")==0 ||
strcasecmp(entry, "here()")==0) {
return n;
}
/* check whether we are allowed to simply create the node */
if (
((flags & GWEN_PATH_FLAGS_LAST) &&
(((flags & GWEN_PATH_FLAGS_VARIABLE) &&
(flags & GWEN_PATH_FLAGS_CREATE_VAR)) ||
(!(flags & GWEN_PATH_FLAGS_VARIABLE) &&
(flags & GWEN_PATH_FLAGS_CREATE_GROUP)))
) ||
(
!(flags & GWEN_PATH_FLAGS_LAST) &&
(flags & GWEN_PATH_FLAGS_PATHCREATE))
) {
/* simply create the new variable/group */
if (flags & GWEN_PATH_FLAGS_VARIABLE) {
/* not allowed for now */
return 0;
}
else {
if (idx!=0) {
DBG_ERROR(GWEN_LOGDOMAIN,
"Can not create tag with index!=1 (%s)", entry);
return 0;
}
DBG_VERBOUS(GWEN_LOGDOMAIN,
"Unconditionally creating tag \"%s\"", entry);
nn=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, entry);
GWEN_XMLNode_AddChild(n, nn);
return nn;
}
}
/* find the node */
i=idx;
nn=GWEN_XMLNode_FindFirstTag(n, entry, 0, 0);
while(nn && i--) {
nn=GWEN_XMLNode_FindNextTag(nn, entry, 0, 0);
}
if (!nn) {
/* node not found, check, if we are allowed to create it */
if (
(!(flags & GWEN_PATH_FLAGS_LAST) &&
(flags & GWEN_PATH_FLAGS_PATHMUSTEXIST)) ||
(flags & GWEN_PATH_FLAGS_NAMEMUSTEXIST)
) {
DBG_VERBOUS(GWEN_LOGDOMAIN,
"Tag \"%s\" does not exist", entry);
return 0;
}
/* create the new variable/group */
if (idx!=0) {
DBG_ERROR(GWEN_LOGDOMAIN,
"Can not create tag with index!=1 (%s)", entry);
return 0;
}
DBG_VERBOUS(GWEN_LOGDOMAIN,
"Tag \"%s\" not found, creating", entry);
nn=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, entry);
GWEN_XMLNode_AddChild(n, nn);
} /* if node not found */
else {
/* node does exist, check whether this is ok */
if (
((flags & GWEN_PATH_FLAGS_LAST) &&
(flags & GWEN_PATH_FLAGS_NAMEMUSTNOTEXIST)) ||
(!(flags & GWEN_PATH_FLAGS_LAST) &&
(flags & GWEN_PATH_FLAGS_PATHMUSTNOTEXIST))
) {
DBG_VERBOUS(GWEN_LOGDOMAIN, "Entry \"%s\" already exists", entry);
return 0;
}
}
return nn;
}
GWEN_DIALOG *AB_SetupNewUserDialog_new(AB_BANKING *ab) {
GWEN_DIALOG *dlg;
AB_SETUP_NEWUSER_DIALOG *xdlg;
GWEN_BUFFER *fbuf;
int rv;
GWEN_XMLNODE *n;
GWEN_XMLNODE *nDialog;
GWEN_PLUGIN_DESCRIPTION_LIST2 *providers;
GWEN_DIALOG_LIST *subDialogs=NULL;
dlg=GWEN_Dialog_new("ab_setup_newuser");
GWEN_NEW_OBJECT(AB_SETUP_NEWUSER_DIALOG, xdlg);
GWEN_INHERIT_SETDATA(GWEN_DIALOG, AB_SETUP_NEWUSER_DIALOG, dlg, xdlg,
AB_SetupNewUserDialog_FreeData);
GWEN_Dialog_SetSignalHandler(dlg, AB_SetupNewUserDialog_SignalHandler);
xdlg->backendDialogs=GWEN_Dialog_List2_new();
xdlg->backendRadioNames=GWEN_StringList_new();
xdlg->backendNames=GWEN_StringList_new();
/* get path of dialog description file */
fbuf=GWEN_Buffer_new(0, 256, 0, 1);
rv=GWEN_PathManager_FindFile(AB_PM_LIBNAME, AB_PM_DATADIR,
"aqbanking/dialogs/dlg_setup_newuser.dlg",
fbuf);
if (rv<0) {
DBG_INFO(AQBANKING_LOGDOMAIN, "Dialog description file not found (%d).", rv);
GWEN_Buffer_free(fbuf);
GWEN_Dialog_free(dlg);
return NULL;
}
/* read XML file, extend it */
n=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "root");
rv=GWEN_XML_ReadFile(n, GWEN_Buffer_GetStart(fbuf),
GWEN_XML_FLAGS_DEFAULT |
GWEN_XML_FLAGS_HANDLE_HEADERS);
if (rv<0) {
DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d)", rv);
GWEN_XMLNode_free(n);
GWEN_Buffer_free(fbuf);
GWEN_Dialog_free(dlg);
return NULL;
}
nDialog=GWEN_XMLNode_FindFirstTag(n, "dialog", NULL, NULL);
if (nDialog==NULL) {
DBG_INFO(AQBANKING_LOGDOMAIN, "Dialog element not found in XML file [%s]", GWEN_Buffer_GetStart(fbuf));
GWEN_XMLNode_free(n);
GWEN_Buffer_free(fbuf);
GWEN_Dialog_free(dlg);
return NULL;
}
providers=AB_Banking_GetProviderDescrs(ab);
if (providers) {
GWEN_XMLNODE *nBackendRadioWidget;
nBackendRadioWidget=GWEN_XMLNode_FindFirstTag(nDialog, "widget", "name", "dialogVLayout");
if (nBackendRadioWidget)
nBackendRadioWidget=GWEN_XMLNode_FindFirstTag(nBackendRadioWidget, "widget", "name", "wiz_stack");
if (nBackendRadioWidget)
nBackendRadioWidget=GWEN_XMLNode_FindFirstTag(nBackendRadioWidget, "widget", "name", "backendRadioWidget");
subDialogs=GWEN_Dialog_List_new();
if (nBackendRadioWidget) {
GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *pit;
pit=GWEN_PluginDescription_List2_First(providers);
if (pit) {
GWEN_PLUGIN_DESCRIPTION *pd;
pd=GWEN_PluginDescription_List2Iterator_Data(pit);
while(pd) {
const char *name;
name=GWEN_PluginDescription_GetName(pd);
if (name && *name) {
AB_PROVIDER *pro;
pro=AB_Banking_GetProvider(ab, name);
if (pro) {
GWEN_DIALOG *cdlg;
GWEN_BUFFER *tbuf;
GWEN_XMLNODE *wn;
const char *s;
if (AB_Provider_GetFlags(pro) & AB_PROVIDER_FLAGS_HAS_USERTYPE_DIALOG) {
cdlg=AB_ProviderGetUserTypeDialog(pro);
if (cdlg==NULL) {
DBG_WARN(AQBANKING_LOGDOMAIN, "Backend [%s] does not return a userType dialog, using default", name);
cdlg=AB_UserTypePageDefaultDialog_new(ab);
}
}
else
cdlg=AB_UserTypePageDefaultDialog_new(ab);
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendString(tbuf, "backend_");
GWEN_Buffer_AppendString(tbuf, name);
GWEN_Buffer_AppendString(tbuf, "_radio");
wn=GWEN_XMLNode_new(GWEN_XMLNodeTypeTag, "widget");
GWEN_XMLNode_SetProperty(wn, "type", "radioButton");
GWEN_XMLNode_SetProperty(wn, "name", GWEN_Buffer_GetStart(tbuf));
GWEN_StringList_AppendString(xdlg->backendRadioNames, GWEN_Buffer_GetStart(tbuf), 0, 0);
GWEN_StringList_AppendString(xdlg->backendNames, name, 0, 0);
s=GWEN_PluginDescription_GetShortDescr(pd);
if (!(s && *s))
s=name;
GWEN_XMLNode_SetProperty(wn, "text", I18N(s));
GWEN_XMLNode_SetProperty(wn, "groupId", "999999");
GWEN_XMLNode_SetProperty(wn, "flags", "fillX justifyLeft");
GWEN_XMLNode_AddChild(nBackendRadioWidget, wn);
GWEN_Dialog_List_Add(cdlg, subDialogs);
}
else {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not activate backend [%s]", name);
}
}
pd=GWEN_PluginDescription_List2Iterator_Next(pit);
}
GWEN_PluginDescription_List2Iterator_free(pit);
}
}
else {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Dialog description does not contain path [dialogVLayout/wiz_stack/backendRadioWidget]");
GWEN_XMLNode_Dump(nDialog, 2);
GWEN_XMLNode_free(n);
GWEN_Buffer_free(fbuf);
GWEN_Dialog_free(dlg);
return NULL;
}
}
/* read dialog from dialog description file */
rv=GWEN_Dialog_ReadXml(dlg, nDialog);
if (rv<0) {
DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d).", rv);
GWEN_Dialog_List_free(subDialogs);
GWEN_XMLNode_free(n);
GWEN_Buffer_free(fbuf);
GWEN_Dialog_free(dlg);
return NULL;
}
GWEN_XMLNode_free(n);
GWEN_Buffer_free(fbuf);
/* insert pages for each backend */
if (GWEN_Dialog_List_GetCount(subDialogs)) {
GWEN_DIALOG *cdlg;
while ( (cdlg=GWEN_Dialog_List_First(subDialogs)) ) {
GWEN_Dialog_List_Del(cdlg);
DBG_NOTICE(AQBANKING_LOGDOMAIN, "Adding dialog %s", GWEN_Dialog_GetId(cdlg));
rv=GWEN_Dialog_AddSubDialog(dlg, "wiz_stack", cdlg);
if (rv<0) {
DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d)", rv);
GWEN_Dialog_List_free(subDialogs);
GWEN_Dialog_free(cdlg);
GWEN_Dialog_free(dlg);
return NULL;
}
GWEN_Dialog_List2_PushBack(xdlg->backendDialogs, cdlg);
}
}
GWEN_Dialog_List_free(subDialogs);
xdlg->banking=ab;
/* done */
return dlg;
}
