TYPEMAKER2_INLINE *Typemaker2_Inline_fromXml(GWEN_XMLNODE *node) {
TYPEMAKER2_INLINE *th;
const char *s;
th=Typemaker2_Inline_new();
s=GWEN_XMLNode_GetCharValue(node, "content", NULL);
Typemaker2_Inline_SetContent(th, s);
s=GWEN_XMLNode_GetCharValue(node, "typeFlagsMask", NULL);
if (s && *s)
th->typeFlagsMask=Typemaker2_FlagsFromString(s);
s=GWEN_XMLNode_GetCharValue(node, "typeFlagsValue", NULL);
if (s && *s)
th->typeFlagsValue=Typemaker2_FlagsFromString(s);
/* read header location */
s=GWEN_XMLNode_GetProperty(node, "loc", "post");
if (strcasecmp(s, "header")==0)
Typemaker2_Inline_SetLocation(th, Typemaker2_InlineLocation_Header);
else if (strcasecmp(s, "code")==0)
Typemaker2_Inline_SetLocation(th, Typemaker2_InlineLocation_Code);
/* read access */
s=GWEN_XMLNode_GetProperty(node, "access", "public");
Typemaker2_Inline_SetAccess(th, Typemaker2_AccessFromString(s));
return th;
}
void Test_ReadXml(TEST *p_struct, GWEN_XMLNODE *p_db)
{
assert(p_struct);
/* member "id" */
if (p_struct->id) {
free(p_struct->id);
}
p_struct->id=NULL;
{
const char *s;
s=GWEN_XMLNode_GetProperty(p_db, "id", NULL);
if (s)
p_struct->id=strdup(s);
}
/* member "prefix" */
if (p_struct->prefix) {
free(p_struct->prefix);
}
p_struct->prefix=NULL;
{
const char *s;
s=GWEN_XMLNode_GetProperty(p_db, "prefix", NULL);
if (s)
p_struct->prefix=strdup(s);
}
/* member "type" */
if (p_struct->type) {
free(p_struct->type);
}
p_struct->type=NULL;
{
const char *s;
s=GWEN_XMLNode_GetProperty(p_db, "type", NULL);
if (s)
p_struct->type=strdup(s);
}
/* member "items" */
if (p_struct->items) {
}
/* member "items" is volatile, not reading from xml */
/* member "mode" */
}
GWEN_XMLNODE *GWEN_XMLNode_FindTag(const GWEN_XMLNODE *n,
const char *tname,
const char *pname,
const char *pvalue) {
while(n) {
if (-1!=GWEN_Text_ComparePattern(n->data, tname, 0)) {
if (pname) {
const char *p;
p=GWEN_XMLNode_GetProperty(n, pname, 0);
if (p) {
if (!pvalue)
return (GWEN_XMLNODE*)n;
if (-1!=GWEN_Text_ComparePattern(pvalue, p, 0))
return (GWEN_XMLNODE*)n;
}
else {
/* return this node if pvalue is 0 an the property does not exist */
if (!pvalue)
return (GWEN_XMLNODE*)n;
}
} /* if pname */
else
return (GWEN_XMLNODE*)n;
}
n=GWEN_XMLNode_GetNextTag(n);
} /* while */
return 0;
}
AB_VALUE *AB_ImExporterYN__ReadValue(AB_IMEXPORTER *ie,
GWEN_XMLNODE *node,
int value)
{
GWEN_XMLNODE *n;
AB_VALUE *val=0;
n=GWEN_XMLNode_FindFirstTag(node, "C516", 0, 0);
if (n) {
GWEN_XMLNODE *nn;
int v=0;
nn=GWEN_XMLNode_FindFirstTag(n, "D_5025", 0, 0);
if (nn)
v=atoi(GWEN_XMLNode_GetProperty(nn, "Value", "0"));
if (value==0 || v==value) {
const char *sValue;
const char *sSign;
sValue=GWEN_XMLNode_GetCharValue(n, "D_5004", 0);
sSign=GWEN_XMLNode_GetCharValue(node, "PF:D_5003", 0);
if (sValue) {
val=AB_Value_fromString(sValue);
if (val && sSign && strcmp(sSign, "-")==0)
AB_Value_Negate(val);
}
}
}
return val;
}
GWEN_TIME *AB_ImExporterYN__ReadTime(AB_IMEXPORTER *ie,
GWEN_XMLNODE *node,
int value) {
GWEN_XMLNODE *n;
GWEN_TIME *ti=0;
n=GWEN_XMLNode_GetNodeByXPath(node, "C507",
GWEN_PATH_FLAGS_NAMEMUSTEXIST);
if (n) {
GWEN_XMLNODE *nn;
int v=0;
nn=GWEN_XMLNode_FindFirstTag(n, "D_2005", 0, 0);
if (nn)
v=atoi(GWEN_XMLNode_GetProperty(nn, "Value", "0"));
if (value==0 || v==value) {
const char *s;
s=GWEN_XMLNode_GetCharValue(n, "D_2380", 0);
if (s)
ti=AB_ImExporter_DateFromString(s, "YYYYMMDD", 0);
}
}
return ti;
}
GWEN_DATE *AB_ImExporterYN__ReadDate(AB_IMEXPORTER *ie, GWEN_XMLNODE *node, int value)
{
GWEN_XMLNODE *n;
GWEN_DATE *da=NULL;
n=GWEN_XMLNode_GetNodeByXPath(node, "C507", GWEN_PATH_FLAGS_NAMEMUSTEXIST);
if (n) {
GWEN_XMLNODE *nn;
int v=0;
nn=GWEN_XMLNode_FindFirstTag(n, "D_2005", 0, 0);
if (nn)
v=atoi(GWEN_XMLNode_GetProperty(nn, "Value", "0"));
if (value==0 || v==value) {
const char *s;
s=GWEN_XMLNode_GetCharValue(n, "D_2380", 0);
if (s)
da=GWEN_Date_fromStringWithTemplate(s, "YYYYMMDD");
}
}
return da;
}
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;
}
LC_CLIENT_RESULT LC_EgkCard_ParseInsuranceData(GWEN_XMLNODE *root,
LC_HI_INSURANCE_DATA **pData) {
LC_CLIENT_RESULT res;
GWEN_XMLNODE *n;
LC_HI_INSURANCE_DATA *d=NULL;
n=GWEN_XMLNode_FindFirstTag(root,
"UC_allgemeineVersicherungsdatenXML",
NULL, NULL);
if (n) {
const char *s;
d=LC_HIInsuranceData_new();
s=GWEN_XMLNode_GetProperty(n, "CDM_VERSION", NULL);
if (s) {
DBG_INFO(LC_LOGDOMAIN, "CDM_VERSION is [%s]", s);
if (GWEN_Text_ComparePattern(s, "5.*", 0)!=-1) {
DBG_INFO(LC_LOGDOMAIN, "Reading as 5.1.0");
res=LC_EgkCard_ReadInsuranceData_5_1_0(n, d);
}
else if (GWEN_Text_ComparePattern(s, "3.*", 0)!=-1) {
DBG_INFO(LC_LOGDOMAIN, "Reading as 3.0.0");
res=LC_EgkCard_ReadInsuranceData_3_0_0(n, d);
}
else {
DBG_WARN(LC_LOGDOMAIN,
"Unhandled CDM_VERSION [%s], trying 5.1.0", s);
res=LC_EgkCard_ReadInsuranceData_5_1_0(n, d);
}
}
else {
DBG_INFO(LC_LOGDOMAIN,
"Missing CDM_VERSION, trying old data type");
/*GWEN_XMLNode_Dump(n, stderr, 2);*/
res=LC_EgkCard_ReadInsuranceData_old(n, d);
}
if (res!=LC_Client_ResultOk) {
DBG_INFO(LC_LOGDOMAIN, "here (%d)", res);
LC_HIInsuranceData_free(d);
return res;
}
}
else {
DBG_ERROR(LC_LOGDOMAIN, "UC_allgemeineVersicherungsdatenXML not found, data follows:");
GWEN_XMLNode_Dump(root, 2);
return LC_Client_ResultNotFound;
}
*pData=d;
return LC_Client_ResultOk;
}
int GWEN_DBIO__XmlDb_ImportGroup(GWEN_DBIO *dbio,
uint32_t flags,
GWEN_DB_NODE *data,
GWEN_DB_NODE *cfg,
GWEN_XMLNODE *node) {
GWEN_XMLNODE *n;
assert(node);
n=GWEN_XMLNode_GetFirstTag(node);
while(n) {
const char *tname;
const char *s;
tname=GWEN_XMLNode_GetData(n);
assert(tname && *tname);
s=GWEN_XMLNode_GetProperty(n, "type", 0);
if (s) {
if (strcasecmp(s, "group")==0) {
GWEN_DB_NODE *db;
int rv;
db=GWEN_DB_GetGroup(data, flags, tname);
if (db==0) {
DBG_INFO(GWEN_LOGDOMAIN, "here");
return GWEN_ERROR_INVALID;
}
rv=GWEN_DBIO__XmlDb_ImportGroup(dbio, flags, db, cfg, n);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
return rv;
}
}
else if (strcasecmp(s, "var")==0) {
int rv;
rv=GWEN_DBIO__XmlDb_ImportVar(dbio, flags, data, cfg, n);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
return rv;
}
}
else {
DBG_ERROR(GWEN_LOGDOMAIN, "Unexpected type \"%s\"", s);
return GWEN_ERROR_INVALID;
}
}
n=GWEN_XMLNode_GetNextTag(n);
}
return 0;
}
int write_h_func_c(ARGUMENTS *args, GWEN_XMLNODE *node,
GWEN_SYNCIO *sio)
{
const char *name;
const char *typ;
const char *styp;
styp=get_struct_property(node, "id", 0);
if (!styp) {
DBG_ERROR(0, "No id in struct");
return -1;
}
name=GWEN_XMLNode_GetProperty(node, "name", 0);
if (!name) {
DBG_ERROR(0, "No name for function");
return -1;
}
typ=GWEN_XMLNode_GetProperty(node, "type", 0);
if (!typ) {
DBG_ERROR(0, "No type for function");
return -1;
}
GWEN_SyncIo_WriteString(sio, " ");
/* rettype name; */
GWEN_SyncIo_WriteString(sio, styp);
GWEN_SyncIo_WriteString(sio, "_");
GWEN_SyncIo_WriteString(sio, typ);
GWEN_SyncIo_WriteString(sio, " ");
GWEN_SyncIo_WriteChar(sio, tolower(*name));
GWEN_SyncIo_WriteString(sio, name+1);
GWEN_SyncIo_WriteLine(sio, ";");
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 GWEN_XMLNode_NormalizeNameSpaces(GWEN_XMLNODE *n) {
const char *ns;
int rv;
GWEN_STRINGLIST2 *sl;
ns=GWEN_XMLNode_GetProperty(n, "xmlns", 0);
sl=GWEN_StringList2_new();
rv=GWEN_XMLNode__CheckNameSpaceDecls1(n, sl, ns);
GWEN_StringList2_free(sl);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here");
return rv;
}
//rv=GWEN_XMLNode__CheckNameSpaceDecls2(n, ns);
rv=GWEN_XMLNode__CheckNameSpaceDecls3(n);
if (rv==-1)
return rv;
return 0;
}
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__CheckAndSetNameSpace(GWEN_XMLNODE *n,
const char *prefix,
const char *nspace) {
GWEN_XMLPROPERTY *pr;
const char *p;
int inUse;
inUse=0;
/* check current tag for prefix */
if (prefix) {
p=strchr(n->data, ':');
if (p) {
if (strncasecmp(n->data, prefix, p-n->data)==0) {
DBG_DEBUG(GWEN_LOGDOMAIN, "Prefix \"%s\" used in tag \"%s\"",
prefix, n->data);
inUse=1;
}
}
if (!inUse) {
/* check all attributes for prefixes */
pr=n->properties;
while(pr) {
p=strchr(pr->name, ':');
if (p) {
if (strncasecmp(pr->name, prefix, p-pr->name)==0) {
DBG_DEBUG(GWEN_LOGDOMAIN,
"Prefix \"%s\" used in attribute \"%s\" of tag \"%s\"",
prefix, pr->name, n->data);
inUse=1;
break;
}
else {
DBG_DEBUG(GWEN_LOGDOMAIN,
"Prefix \"%s\" not used in attribute \"%s\" of tag \"%s\"",
prefix, pr->name, n->data);
}
}
pr=pr->next;
} /* while */
}
} /* if prefix */
else {
/* no prefix, check whether the current element hasn't any */
p=strchr(n->data, ':');
if (!p) {
/* current tag has no prefix, check whether we have a namespace
* declaration here */
if (GWEN_XMLNode_GetProperty(n, "xmlns", 0)==0) {
/* no, so the current namespace from above is used */
DBG_DEBUG(GWEN_LOGDOMAIN,
"No prefix, current namespace is used");
inUse=1;
}
}
} /* if no prefix */
if (inUse) {
GWEN_BUFFER *nbuf;
nbuf=GWEN_Buffer_new(0, 32, 0, 1);
GWEN_Buffer_AppendString(nbuf, "xmlns");
if (prefix) {
GWEN_Buffer_AppendByte(nbuf, ':');
GWEN_Buffer_AppendString(nbuf, prefix);
}
GWEN_XMLNode__SetProperty(n, GWEN_Buffer_GetStart(nbuf), nspace, 1);
GWEN_Buffer_free(nbuf);
return 1;
}
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;
}
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;
}
GWEN_PLUGIN_DESCRIPTION_LIST2 *GWEN_Crypt_Token_PluginManager_GetPluginDescrs(GWEN_PLUGIN_MANAGER *pm,
GWEN_CRYPT_TOKEN_DEVICE devt)
{
GWEN_PLUGIN_DESCRIPTION_LIST2 *pl1;
pl1=GWEN_PluginManager_GetPluginDescrs(pm);
if (pl1) {
GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *pit;
GWEN_PLUGIN_DESCRIPTION_LIST2 *pl2;
pl2=GWEN_PluginDescription_List2_new();
pit=GWEN_PluginDescription_List2_First(pl1);
if (pit) {
GWEN_PLUGIN_DESCRIPTION *pd;
const char *ts;
if (devt==GWEN_Crypt_Token_Device_Any)
ts=NULL;
else
ts=GWEN_Crypt_Token_Device_toString(devt);
pd=GWEN_PluginDescription_List2Iterator_Data(pit);
while (pd) {
GWEN_XMLNODE *node;
const char *nts;
int match=0;
node=GWEN_PluginDescription_GetXmlNode(pd);
assert(node);
nts=GWEN_XMLNode_GetProperty(node, "device", 0);
if (nts) {
if (!ts || (ts && strcasecmp(ts, nts)==0))
match=1;
}
else if (!ts)
match=1;
if (match) {
GWEN_PLUGIN_DESCRIPTION *pd2;
pd2=GWEN_PluginDescription_dup(pd);
GWEN_PluginDescription_List2_PushBack(pl2, pd2);
}
pd=GWEN_PluginDescription_List2Iterator_Next(pit);
}
GWEN_PluginDescription_List2Iterator_free(pit);
}
GWEN_PluginDescription_List2_freeAll(pl1);
if (GWEN_PluginDescription_List2_GetSize(pl2)==0) {
GWEN_PluginDescription_List2_freeAll(pl2);
DBG_ERROR(GWEN_LOGDOMAIN,
"No matching plugin descriptions for the given device type");
return NULL;
}
return pl2;
}
else {
DBG_ERROR(GWEN_LOGDOMAIN, "No plugin descriptions at all");
}
return NULL;
}
AB_IMEXPORTER_ACCOUNTINFO *AB_ImExporterYN__ReadAccountInfo(AB_IMEXPORTER *ie,
AB_IMEXPORTER_CONTEXT *ctx,
GWEN_XMLNODE *doc)
{
GWEN_XMLNODE *n;
AB_IMEXPORTER_ACCOUNTINFO *ai;
ai=AB_ImExporterAccountInfo_new();
n=GWEN_XMLNode_FindFirstTag(doc, "SG2", 0, 0);
if (n)
n=GWEN_XMLNode_FindFirstTag(n, "FII", 0, 0);
if (n) {
GWEN_XMLNODE *nn;
const char *s;
nn=GWEN_XMLNode_FindFirstTag(n, "C078", 0, 0);
if (nn) {
GWEN_XMLNODE *nnn;
/* account number */
s=GWEN_XMLNode_GetCharValue(nn, "D_3194", 0);
if (s)
AB_ImExporterAccountInfo_SetAccountNumber(ai, s);
/* IBAN */
s=GWEN_XMLNode_GetCharValue(nn, "D_3192", 0);
if (s)
AB_ImExporterAccountInfo_SetIban(ai, s);
/* currency */
nnn=GWEN_XMLNode_FindFirstTag(nn, "D_6345", 0, 0);
if (nnn) {
s=GWEN_XMLNode_GetProperty(nnn, "value", 0);
if (s)
AB_ImExporterAccountInfo_SetCurrency(ai, s);
}
}
/* account number */
s=GWEN_XMLNode_GetCharValue(n, "PF:D_5388", 0);
if (s)
AB_ImExporterAccountInfo_SetAccountName(ai, s);
}
/* owner name */
n=GWEN_XMLNode_GetNodeByXPath(doc, "SG3[1]/NAD",
GWEN_PATH_FLAGS_NAMEMUSTEXIST);
if (n) {
GWEN_XMLNODE *nn;
nn=GWEN_XMLNode_FindFirstTag(n, "D_3035", 0, 0);
if (nn) {
const char *s;
s=GWEN_XMLNode_GetProperty(nn, "Value", 0);
if (s && strcasecmp(s, "HQ")==0) {
nn=GWEN_XMLNode_FindFirstTag(n, "C058", 0, 0);
if (nn) {
s=GWEN_XMLNode_GetCharValue(nn, "D_3124", 0);
if (s && *s) {
GWEN_BUFFER *xbuf;
xbuf=GWEN_Buffer_new(0, 256, 0, 1);
AB_ImExporter_Iso8859_1ToUtf8(s, strlen(s), xbuf);
AB_ImExporterAccountInfo_SetOwner(ai, GWEN_Buffer_GetStart(xbuf));
GWEN_Buffer_free(xbuf);
}
}
}
}
}
return ai;
}
LC_CLIENT_RESULT LC_EgkCard_ReadPersonalData(LC_CARD *card,
LC_HI_PERSONAL_DATA **pData) {
GWEN_BUFFER *dbuf;
LC_CLIENT_RESULT res;
dbuf=GWEN_Buffer_new(0, 256, 0, 1);
res=LC_EgkCard_ReadPd(card, dbuf);
if (res!=LC_Client_ResultOk) {
DBG_INFO(LC_LOGDOMAIN, "here (%d)", res);
GWEN_Buffer_free(dbuf);
return res;
}
else {
GWEN_XMLNODE *root;
GWEN_XMLNODE *n;
root=GWEN_XMLNode_fromString(GWEN_Buffer_GetStart(dbuf),
GWEN_Buffer_GetUsedBytes(dbuf),
GWEN_XML_FLAGS_HANDLE_HEADERS |
GWEN_XML_FLAGS_HANDLE_NAMESPACES);
if (root==NULL) {
DBG_INFO(LC_LOGDOMAIN, "Invalid XML string");
GWEN_Buffer_free(dbuf);
return LC_Client_ResultDataError;
}
GWEN_Buffer_free(dbuf);
GWEN_XMLNode_StripNamespaces(root);
/*GWEN_XMLNode_Dump(root, stderr, 2);*/
n=GWEN_XMLNode_FindFirstTag(root,
"UC_PersoenlicheVersichertendatenXML",
NULL, NULL);
if (n) {
const char *s;
LC_HI_PERSONAL_DATA *d;
d=LC_HIPersonalData_new();
s=GWEN_XMLNode_GetProperty(n, "CDM_VERSION", NULL);
if (s) {
if (GWEN_Text_ComparePattern(s, "5.*", 0)!=-1)
res=LC_EgkCard_ReadPersonalData_5_1_0(n, d);
else if (GWEN_Text_ComparePattern(s, "3.*", 0)!=-1)
res=LC_EgkCard_ReadPersonalData_3_0_0(n, d);
else {
DBG_WARN(LC_LOGDOMAIN,
"Unhandled CDM_VERSION [%s], trying 5.1.0", s);
res=LC_EgkCard_ReadPersonalData_5_1_0(n, d);
}
}
else
res=LC_EgkCard_ReadPersonalData_old(n, d);
if (res!=LC_Client_ResultOk) {
DBG_INFO(LC_LOGDOMAIN, "here (%d)", res);
LC_HIPersonalData_free(d);
GWEN_XMLNode_free(root);
return res;
}
*pData=d;
}
GWEN_XMLNode_free(root);
}
return LC_Client_ResultOk;
}
