const char *GWEN_XMLNode_GetCharValue(const GWEN_XMLNODE *n,
const char *name,
const char *defValue) {
GWEN_XMLNODE *nn;
if (name && *name) {
nn=GWEN_XMLNode_FindFirstTag(n, name, 0, 0);
while(nn) {
GWEN_XMLNODE *dn;
dn=GWEN_XMLNode_GetFirstData(nn);
if (dn) {
if (dn->data)
return dn->data;
}
nn=GWEN_XMLNode_FindNextTag(nn, name, 0, 0);
}
}
else {
GWEN_XMLNODE *dn;
dn=GWEN_XMLNode_GetFirstData(n);
if (dn) {
if (dn->data)
return dn->data;
}
}
return defValue;
}
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;
}
const char *GWEN_XMLNode_GetLocalizedCharValue(const GWEN_XMLNODE *n,
const char *name,
const char *defValue) {
GWEN_XMLNODE *nn=0;
GWEN_STRINGLIST *langl;
langl=GWEN_I18N_GetCurrentLocaleList();
if (langl) {
GWEN_STRINGLISTENTRY *se;
se=GWEN_StringList_FirstEntry(langl);
while(se) {
const char *l;
l=GWEN_StringListEntry_Data(se);
DBG_DEBUG(GWEN_LOGDOMAIN, "Trying locale \"%s\"", l);
assert(l);
nn=GWEN_XMLNode_FindFirstTag(n, name, "lang", l);
while(nn) {
GWEN_XMLNODE *dn;
dn=GWEN_XMLNode_GetFirstData(nn);
if (dn) {
if (dn->data && *(dn->data))
return dn->data;
}
nn=GWEN_XMLNode_FindNextTag(nn, name, "lang", l);
} /* while nn */
se=GWEN_StringListEntry_Next(se);
} /* while */
} /* if language list available */
/* otherwise try without locale */
nn=GWEN_XMLNode_FindFirstTag(n, name, 0, 0);
while(nn) {
GWEN_XMLNODE *dn;
dn=GWEN_XMLNode_GetFirstData(nn);
if (dn) {
if (dn->data)
return dn->data;
}
nn=GWEN_XMLNode_FindNextTag(nn, name, 0, 0);
}
return defValue;
}
int AB_ImExporterYN__ReadAccountStatus(AB_IMEXPORTER *ie,
AB_IMEXPORTER_ACCOUNTINFO *ai,
GWEN_XMLNODE *doc) {
GWEN_XMLNODE *n;
n=GWEN_XMLNode_FindFirstTag(doc, "SG4", 0, 0);
while(n) {
GWEN_XMLNODE *nn;
nn=GWEN_XMLNode_GetNodeByXPath(n, "LIN/PF:D_0805",
GWEN_PATH_FLAGS_NAMEMUSTEXIST);
if (nn) {
const char *s;
s=GWEN_XMLNode_GetProperty(nn, "Value", 0);
if (s && strcasecmp(s, "LEN")==0) {
GWEN_XMLNODE *nnn;
GWEN_TIME *ti=0;
AB_VALUE *val=0;
/* read time */
nnn=GWEN_XMLNode_GetNodeByXPath(n, "SG5/DTM",
GWEN_PATH_FLAGS_NAMEMUSTEXIST);
if (nnn)
ti=AB_ImExporterYN__ReadTime(ie, nnn, 202);
/* read value */
nnn=GWEN_XMLNode_GetNodeByXPath(n, "SG5/MOA",
GWEN_PATH_FLAGS_NAMEMUSTEXIST);
if (nnn)
val=AB_ImExporterYN__ReadValue(ie, nnn, 343);
if (val) {
AB_ACCOUNT_STATUS *ast;
AB_BALANCE *bal;
AB_Value_SetCurrency(val, AB_ImExporterAccountInfo_GetCurrency(ai));
ast=AB_AccountStatus_new();
bal=AB_Balance_new(val, ti);
AB_AccountStatus_SetBookedBalance(ast, bal);
AB_Balance_free(bal);
AB_ImExporterAccountInfo_AddAccountStatus(ai, ast);
}
AB_Value_free(val);
GWEN_Time_free(ti);
}
}
n=GWEN_XMLNode_FindNextTag(n, "SG4", 0, 0);
}
return 0;
}
int AB_ImExporterYN__ReadTransactions(AB_IMEXPORTER *ie,
AB_IMEXPORTER_ACCOUNTINFO *ai,
GWEN_XMLNODE *doc)
{
GWEN_XMLNODE *n;
n=GWEN_XMLNode_FindFirstTag(doc, "SG4", 0, 0);
while (n) {
GWEN_XMLNODE *nn;
nn=GWEN_XMLNode_GetNodeByXPath(n, "LIN/PF:D_0805",
GWEN_PATH_FLAGS_NAMEMUSTEXIST);
if (nn) {
const char *s;
s=GWEN_XMLNode_GetProperty(nn, "Value", 0);
if (s &&
(strcasecmp(s, "LNE")==0 ||
strcasecmp(s, "LNS")==0)
) {
nn = GWEN_XMLNode_FindFirstTag(n, "SG6", 0, 0);
while (nn) {
AB_TRANSACTION *t;
const char *s;
t=AB_ImExporterYN__ReadLNE_LNS(ie, ai, nn);
s=AB_ImExporterAccountInfo_GetAccountNumber(ai);
AB_Transaction_SetLocalAccountNumber(t, s);
s=AB_ImExporterAccountInfo_GetIban(ai);
AB_Transaction_SetLocalIban(t, s);
AB_ImExporterAccountInfo_AddTransaction(ai, t);
nn=GWEN_XMLNode_FindNextTag(nn, "SG6", 0, 0);
}
}
}
n=GWEN_XMLNode_FindNextTag(n, "SG4", 0, 0);
}
return 0;
}
int write_hp_files_c(ARGUMENTS *args, GWEN_XMLNODE *node)
{
GWEN_XMLNODE *n;
int rv;
n=GWEN_XMLNode_FindFirstTag(node, "type", 0, 0);
while (n) {
rv=write_hp_file_c(args, n);
if (rv)
return rv;
n=GWEN_XMLNode_FindNextTag(n, "type", 0, 0);
}
return 0;
}
uint32_t LC_ReaderFlags_fromXml(GWEN_XMLNODE *node, const char *name){
const char *p;
uint32_t flags=0;
GWEN_XMLNODE *n;
n=GWEN_XMLNode_FindFirstTag(node, name, 0, 0);
while(n) {
GWEN_XMLNODE *nn;
nn=GWEN_XMLNode_GetFirstData(n);
if (nn) {
p=GWEN_XMLNode_GetData(nn);
assert(p);
if (strcasecmp(p, "keypad")==0)
flags|=LC_READER_FLAGS_KEYPAD;
else if (strcasecmp(p, "display")==0)
flags|=LC_READER_FLAGS_DISPLAY;
else if (strcasecmp(p, "noinfo")==0)
flags|=LC_READER_FLAGS_NOINFO;
else if (strcasecmp(p, "remote")==0)
flags|=LC_READER_FLAGS_REMOTE;
else if (strcasecmp(p, "auto")==0)
flags|=LC_READER_FLAGS_AUTO;
else if (strcasecmp(p, "suspended_checks")==0)
flags|=LC_READER_FLAGS_SUSPENDED_CHECKS;
else if (strcasecmp(p, "driverHasVerify")==0)
flags|=LC_READER_FLAGS_DRIVER_HAS_VERIFY;
else if (strcasecmp(p, "keepRunning")==0)
flags|=LC_READER_FLAGS_KEEP_RUNNING;
else if (strcasecmp(p, "lowWriteBoundary")==0)
flags|=LC_READER_FLAGS_LOW_WRITE_BOUNDARY;
else if (strcasecmp(p, "noMemorySw")==0)
flags|=LC_READER_FLAGS_NO_MEMORY_SW;
else {
DBG_WARN(0, "Unknown flag \"%s\", ignoring", p);
}
}
n=GWEN_XMLNode_FindNextTag(n, name, 0, 0);
} /* while */
return flags;
}
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 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_ImportVar(GWEN_DBIO *dbio,
uint32_t flags,
GWEN_DB_NODE *data,
GWEN_DB_NODE *cfg,
GWEN_XMLNODE *node) {
GWEN_XMLNODE *n;
const char *vname;
GWEN_BUFFER *tbuf;
assert(node);
vname=GWEN_XMLNode_GetData(node);
assert(vname && *vname);
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
n=GWEN_XMLNode_FindFirstTag(node, "value", 0, 0);
while(n) {
const char *s;
const char *d;
int rv;
GWEN_DBIO__XmlDb_ReadDataTags(n, tbuf);
d=GWEN_Buffer_GetStart(tbuf);
if (*d) {
s=GWEN_XMLNode_GetData(n);
assert(s && *s);
s=GWEN_XMLNode_GetProperty(n, "type", 0);
if (s) {
if (strcasecmp(s, "char")==0) {
rv=GWEN_DB_SetCharValue(data, flags, vname, d);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
return rv;
}
}
else if (strcasecmp(s, "int")==0) {
int val;
if (1!=sscanf(d, "%i", &val)) {
DBG_INFO(GWEN_LOGDOMAIN, "Non-integer value [%s]", d);
GWEN_Buffer_free(tbuf);
return GWEN_ERROR_INVALID;
}
rv=GWEN_DB_SetIntValue(data, flags, vname, val);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
return rv;
}
}
else if (strcasecmp(s, "bin")==0) {
GWEN_BUFFER *xbuf;
xbuf=GWEN_Buffer_new(0, 256, 0, 1);
rv=GWEN_Text_FromHexBuffer(d, xbuf);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(xbuf);
GWEN_Buffer_free(tbuf);
return rv;
}
rv=GWEN_DB_SetBinValue(data, flags, vname,
GWEN_Buffer_GetStart(xbuf),
GWEN_Buffer_GetUsedBytes(xbuf));
GWEN_Buffer_free(xbuf);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
return rv;
}
}
else {
DBG_ERROR(GWEN_LOGDOMAIN,
"Unhandled value type \"%s\"", s);
GWEN_Buffer_free(tbuf);
return GWEN_ERROR_INVALID;
}
}
}
else {
DBG_DEBUG(GWEN_LOGDOMAIN, "Empty value");
}
GWEN_Buffer_Reset(tbuf);
n=GWEN_XMLNode_FindNextTag(n, "value", 0, 0);
}
GWEN_Buffer_free(tbuf);
return 0;
}
int GWEN_XMLNode_GetXPath(const GWEN_XMLNODE *n1,
const GWEN_XMLNODE *n2,
GWEN_BUFFER *nbuf) {
GWEN_BUFFER *lbuf;
const GWEN_XMLNODE *ln1;
const GWEN_XMLNODE *ln2;
if (!n1 && !n2) {
DBG_ERROR(GWEN_LOGDOMAIN, "Both nodes are NULL");
return -1;
}
if (!n1) {
n1=n2;
while(n1->parent)
n1=n1->parent;
}
if (!n2) {
n2=n1;
while(n2->parent)
n2=n2->parent;
}
if (n2==n1) {
GWEN_Buffer_AppendString(nbuf, "here()");
return 0;
}
lbuf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_ReserveBytes(lbuf, 128);
ln1=n1->parent;
if (ln1) {
GWEN_Buffer_AppendString(lbuf, "../");
while(ln1) {
if (ln1==n2) {
/* found n2 */
GWEN_Buffer_AppendBuffer(nbuf, lbuf);
GWEN_Buffer_free(lbuf);
return 0;
}
if (GWEN_XMLNode_IsChildOf(ln1, n2))
break;
ln1=ln1->parent;
GWEN_Buffer_AppendString(lbuf, "../");
}
if (!ln1) {
DBG_ERROR(GWEN_LOGDOMAIN, "Nodes do not share root node");
GWEN_Buffer_free(lbuf);
return -1;
}
/* append path to n1 */
GWEN_Buffer_AppendBuffer(nbuf, lbuf);
}
DBG_ERROR(GWEN_LOGDOMAIN, "Path so far: %s", GWEN_Buffer_GetStart(lbuf));
/* get path to n2 */
GWEN_Buffer_Reset(lbuf);
ln2=n2;
while(ln2) {
GWEN_XMLNODE *tn;
int idx;
char idxbuf[32];
if (ln2->parent==ln1)
break;
/* count occurences of this tag in this level */
idx=1;
tn=ln2->parent;
if (tn) {
tn=GWEN_XMLNode_FindFirstTag(tn, ln2->data, 0, 0);
while(tn) {
if (tn==ln2)
break;
idx++;
tn=GWEN_XMLNode_FindNextTag(tn, ln2->data, 0, 0);
}
}
snprintf(idxbuf, sizeof(idxbuf), "[%d]", idx);
idxbuf[sizeof(idxbuf)-1]=0;
GWEN_Buffer_InsertString(lbuf, idxbuf);
GWEN_Buffer_InsertString(lbuf, GWEN_XMLNode_GetData(ln2));
GWEN_Buffer_InsertByte(lbuf, '/');
ln2=ln2->parent;
}
DBG_ERROR(GWEN_LOGDOMAIN, "Path so far: %s", GWEN_Buffer_GetStart(lbuf));
assert(ln2);
/* append path to n2 */
GWEN_Buffer_AppendBuffer(nbuf, lbuf);
GWEN_Buffer_free(lbuf);
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;
}
