static void createListBoxString(const AB_BANKINFO *bi, GWEN_BUFFER *tbuf)
{
const char *s;
AB_BANKINFO_SERVICE *sv;
uint32_t pos;
int svsAdded=0;
s=AB_BankInfo_GetBankId(bi);
if (s && *s)
GWEN_Buffer_AppendString(tbuf, s);
GWEN_Buffer_AppendString(tbuf, "\t");
s=AB_BankInfo_GetBic(bi);
if (s && *s)
GWEN_Buffer_AppendString(tbuf, s);
GWEN_Buffer_AppendString(tbuf, "\t");
s=AB_BankInfo_GetBankName(bi);
if (s && *s)
GWEN_Buffer_AppendString(tbuf, s);
GWEN_Buffer_AppendString(tbuf, "\t");
s=AB_BankInfo_GetLocation(bi);
if (s && *s)
GWEN_Buffer_AppendString(tbuf, s);
GWEN_Buffer_AppendString(tbuf, "\t");
pos=GWEN_Buffer_GetPos(tbuf);
sv=AB_BankInfoService_List_First(AB_BankInfo_GetServices(bi));
while (sv) {
const char *s;
s=AB_BankInfoService_GetType(sv);
if (s && *s) {
const char *p;
p=GWEN_Buffer_GetStart(tbuf)+pos;
if (strstr(p, s)==NULL) {
if (svsAdded)
GWEN_Buffer_AppendString(tbuf, ", ");
GWEN_Buffer_AppendString(tbuf, s);
svsAdded++;
}
}
sv=AB_BankInfoService_List_Next(sv);
}
}
int GWEN_Directory_GetFileEntriesWithType(const char *folder,
GWEN_STRINGLIST *sl,
const char *mask) {
GWEN_DIRECTORY *d;
int rv;
char buffer[256];
GWEN_BUFFER *pbuf;
uint32_t pos;
d=GWEN_Directory_new();
rv=GWEN_Directory_Open(d, folder);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Directory_free(d);
return rv;
}
pbuf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendString(pbuf, folder);
GWEN_Buffer_AppendString(pbuf, GWEN_DIR_SEPARATOR_S);
pos=GWEN_Buffer_GetPos(pbuf);
while(0==GWEN_Directory_Read(d, buffer+1, sizeof(buffer)-2)) {
if (strcmp(buffer, ".")!=0 &&
strcmp(buffer, "..")!=0 &&
(mask==NULL ||
GWEN_Text_ComparePattern(buffer+1, mask, 0)!=-1)) {
struct stat st;
GWEN_Buffer_AppendString(pbuf, buffer+1);
if (stat(GWEN_Buffer_GetStart(pbuf), &st)==0) {
if (S_ISREG(st.st_mode))
buffer[0]='f';
else if (S_ISDIR(st.st_mode))
buffer[0]='d';
else
buffer[0]='?';
GWEN_StringList_AppendString(sl, buffer, 0, 1);
}
GWEN_Buffer_Crop(pbuf, 0, pos);
}
}
GWEN_Directory_Close(d);
GWEN_Directory_free(d);
return 0;
}
static int addToList(const char *fname, int recursive, GWEN_STRINGLIST *sl) {
struct stat st;
int rv;
/* stat file to be added */
#if _BSD_SOURCE || _XOPEN_SOURCE >= 500 || _XOPEN_SOURCE && _XOPEN_SOURCE_EXTENDED
rv=lstat(fname, &st);
#else
rv=stat(fname, &st);
#endif
if (rv) {
DBG_ERROR(GSA_LOGDOMAIN, "stat(%s): %d (%s)",
fname, errno, strerror(errno));
fprintf(stderr, "Ignoring file \"%s\"\n", fname);
}
else {
/* always append this entry */
GWEN_StringList_AppendString(sl, fname, 0, 1);
if (recursive && S_ISDIR(st.st_mode)) {
GWEN_STRINGLIST *sll;
GWEN_STRINGLISTENTRY *se;
GWEN_DIRECTORY *d;
int rv;
char buffer[256];
GWEN_BUFFER *tbuf;
uint32_t pos;
/* add entries */
sll=GWEN_StringList_new();
d=GWEN_Directory_new();
rv=GWEN_Directory_Open(d, fname);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Directory_free(d);
GWEN_StringList_free(sll);
return rv;
}
while(0==GWEN_Directory_Read(d, buffer, sizeof(buffer))) {
if (strcmp(buffer, ".")!=0 &&
strcmp(buffer, "..")!=0)
GWEN_StringList_AppendString(sll, buffer, 0, 1);
}
GWEN_Directory_Close(d);
GWEN_Directory_free(d);
/* recurse */
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendString(tbuf, fname);
GWEN_Buffer_AppendString(tbuf, GWEN_DIR_SEPARATOR_S);
pos=GWEN_Buffer_GetPos(tbuf);
se=GWEN_StringList_FirstEntry(sll);
while(se) {
const char *s;
s=GWEN_StringListEntry_Data(se);
if (s && *s) {
GWEN_Buffer_AppendString(tbuf, s);
rv=addToList(GWEN_Buffer_GetStart(tbuf), recursive, sl);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
GWEN_StringList_free(sll);
return rv;
}
}
GWEN_Buffer_Crop(tbuf, 0, pos);
se=GWEN_StringListEntry_Next(se);
} /* while se */
GWEN_Buffer_free(tbuf);
GWEN_StringList_free(sll);
} /* if dir and recursive */
} /* if stat was ok */
return 0;
}
GWEN_TLV *GWEN_TLV_fromBuffer(GWEN_BUFFER *mbuf, int isBerTlv) {
const char *p;
unsigned int tagMode;
unsigned int tagType;
unsigned int tagLength;
const char *tagData;
unsigned int size;
unsigned int pos;
unsigned int j;
GWEN_TLV *tlv;
uint32_t startPos;
if (!GWEN_Buffer_GetBytesLeft(mbuf)) {
DBG_ERROR(GWEN_LOGDOMAIN, "Buffer empty");
return 0;
}
startPos=GWEN_Buffer_GetPos(mbuf);
tagMode=tagType=tagLength=0;
p=GWEN_Buffer_GetPosPointer(mbuf);
pos=0;
size=GWEN_Buffer_GetBytesLeft(mbuf);
/* get tag type */
if (size<2) {
DBG_ERROR(GWEN_LOGDOMAIN, "Too few bytes for BER-TLV");
return 0;
}
j=(unsigned char)(p[pos]);
tagMode=(j & 0xe0);
if (isBerTlv) {
if ((j & 0x1f)==0x1f) {
pos++;
if (pos>=size) {
DBG_ERROR(GWEN_LOGDOMAIN, "Too few bytes");
return 0;
}
j=(unsigned char)(p[pos]);
}
else
j&=0x1f;
}
DBG_DEBUG(GWEN_LOGDOMAIN, "Tag type %02x%s", j,
isBerTlv?" (BER-TLV)":"");
tagType=j;
/* get length */
pos++;
if (pos>=size) {
DBG_ERROR(GWEN_LOGDOMAIN, "Too few bytes");
return 0;
}
j=(unsigned char)(p[pos]);
if (isBerTlv) {
if (j & 0x80) {
if (j==0x81) {
pos++;
if (pos>=size) {
DBG_ERROR(GWEN_LOGDOMAIN, "Too few bytes");
return 0;
}
j=(unsigned char)(p[pos]);
} /* 0x81 */
else if (j==0x82) {
if (pos+1>=size) {
DBG_ERROR(GWEN_LOGDOMAIN, "Too few bytes");
return 0;
}
pos++;
j=((unsigned char)(p[pos]))<<8;
pos++;
j+=(unsigned char)(p[pos]);
} /* 0x82 */
else {
DBG_ERROR(GWEN_LOGDOMAIN, "Unexpected tag length modifier %02x at %d", j, pos);
return 0;
}
} /* if tag length modifier */
}
else {
if (j==255) {
if (pos+2>=size) {
DBG_ERROR(GWEN_LOGDOMAIN, "Too few bytes");
return 0;
}
pos++;
j=((unsigned char)(p[pos]))<<8;
pos++;
j+=(unsigned char)(p[pos]);
}
}
pos++;
tagLength=j;
tagData=p+pos;
GWEN_Buffer_IncrementPos(mbuf, pos);
DBG_DEBUG(GWEN_LOGDOMAIN, "Tag: %02x (%d bytes)", tagType, tagLength);
if (pos+j>size) {
DBG_ERROR(GWEN_LOGDOMAIN, "Too few bytes");
return 0;
}
tlv=GWEN_TLV_new();
assert(tlv);
tlv->isBerTlv=isBerTlv;
tlv->tagMode=tagMode;
tlv->tagType=tagType;
tlv->tagLength=tagLength;
if (tagLength) {
tlv->tagData=(void*)malloc(tagLength);
memmove(tlv->tagData, tagData, tagLength);
}
GWEN_Buffer_IncrementPos(mbuf, tagLength);
tlv->tagSize=GWEN_Buffer_GetPos(mbuf)-startPos;
return tlv;
}
int GWEN_CryptMgr_Encrypt(GWEN_CRYPTMGR *cm, const uint8_t *pData, uint32_t lData, GWEN_BUFFER *dbuf) {
GWEN_CRYPTHEAD *ch;
uint32_t pos;
uint8_t *p;
uint32_t l;
int rv;
GWEN_BUFFER *cryptbuf;
GWEN_BUFFER *tbuf;
GWEN_CRYPT_KEY *mkey;
assert(cm);
/* generate a message key */
mkey=GWEN_Crypt_KeyBlowFish_Generate(GWEN_Crypt_CryptMode_Cbc, 256/8, 2);
if (mkey==NULL) {
DBG_ERROR(GWEN_LOGDOMAIN, "Unable to generate BLOWFISH key");
return GWEN_ERROR_GENERIC;
}
GWEN_Buffer_AppendByte(dbuf, GWEN_CRYPTMGR_TLV_ENCRYPTEDOBJECT);
pos=GWEN_Buffer_GetPos(dbuf);
GWEN_Buffer_AppendByte(dbuf, 0);
GWEN_Buffer_AppendByte(dbuf, 0);
/* prepare signature head */
ch=GWEN_CryptHead_new();
GWEN_CryptHead_SetKeyName(ch, cm->peerKeyName);
GWEN_CryptHead_SetKeyNumber(ch, cm->peerKeyNumber);
GWEN_CryptHead_SetKeyVersion(ch, cm->peerKeyVersion);
GWEN_CryptHead_SetCryptProfile(ch, cm->signatureProfile);
/* encrypt key */
cryptbuf=GWEN_Buffer_new(0, lData+256, 0, 1);
rv=GWEN_CryptMgr_EncryptKey(cm,
GWEN_Crypt_KeyBlowFish_GetKeyDataPtr(mkey),
GWEN_Crypt_KeyBlowFish_GetKeyDataLen(mkey),
cryptbuf);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(cryptbuf);
GWEN_CryptHead_free(ch);
GWEN_Crypt_Key_free(mkey);
return rv;
}
GWEN_CryptHead_SetKey(ch,
(const uint8_t*)GWEN_Buffer_GetStart(cryptbuf),
GWEN_Buffer_GetUsedBytes(cryptbuf));
GWEN_Buffer_free(cryptbuf);
/* write crypt head to buffer */
rv=GWEN_CryptHead_toBuffer(ch, dbuf, GWEN_CRYPTMGR_TLV_CRYPTHEAD);
GWEN_CryptHead_free(ch);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Crypt_Key_free(mkey);
return rv;
}
/* padd plain text data */
tbuf=GWEN_Buffer_new(0, lData+256, 0, 1);
GWEN_Buffer_AppendBytes(tbuf, (const char*)pData, lData);
GWEN_Padd_PaddWithAnsiX9_23(tbuf);
/* encrypt with message key */
cryptbuf=GWEN_Buffer_new(0, lData+256, 0, 1);
l=GWEN_Buffer_GetMaxUnsegmentedWrite(cryptbuf);
rv=GWEN_Crypt_Key_Encipher(mkey,
(const uint8_t*)GWEN_Buffer_GetStart(tbuf),
GWEN_Buffer_GetUsedBytes(tbuf),
(uint8_t*)GWEN_Buffer_GetStart(cryptbuf),
&l);
GWEN_Buffer_free(tbuf);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(cryptbuf);
GWEN_Crypt_Key_free(mkey);
return rv;
}
GWEN_Buffer_IncrementPos(cryptbuf, l);
GWEN_Buffer_AdjustUsedBytes(cryptbuf);
/* write encrypted data */
GWEN_Tag16_DirectlyToBuffer(GWEN_CRYPTMGR_TLV_CRYPTDATA,
GWEN_Buffer_GetStart(cryptbuf),
GWEN_Buffer_GetUsedBytes(cryptbuf),
dbuf);
GWEN_Buffer_free(cryptbuf);
GWEN_Crypt_Key_free(mkey);
/* write complete size */
l=GWEN_Buffer_GetPos(dbuf)-pos-2;
p=(uint8_t*)GWEN_Buffer_GetStart(dbuf)+pos;
*(p++)=l & 0xff;
*p=(l>>8) & 0xff;
return 0;
}
int GWEN_CryptMgr_Sign(GWEN_CRYPTMGR *cm, const uint8_t *pData, uint32_t lData, GWEN_BUFFER *dbuf) {
GWEN_SIGHEAD *sh;
GWEN_SIGTAIL *st;
GWEN_TIME *ti;
uint32_t pos;
uint32_t shPos;
uint8_t *p;
uint32_t l;
int rv;
GWEN_BUFFER *sigbuf;
assert(cm);
GWEN_Buffer_AppendByte(dbuf, GWEN_CRYPTMGR_TLV_SIGNEDOBJECT);
pos=GWEN_Buffer_GetPos(dbuf);
GWEN_Buffer_AppendByte(dbuf, 0);
GWEN_Buffer_AppendByte(dbuf, 0);
/* prepare signature head */
sh=GWEN_SigHead_new();
GWEN_SigHead_SetKeyName(sh, cm->localKeyName);
GWEN_SigHead_SetKeyNumber(sh, cm->localKeyNumber);
GWEN_SigHead_SetKeyVersion(sh, cm->localKeyVersion);
ti=GWEN_CurrentTime();
GWEN_SigHead_SetDateTime(sh, ti);
GWEN_Time_free(ti);
GWEN_SigHead_SetSignatureProfile(sh, cm->signatureProfile);
GWEN_SigHead_SetSignatureNumber(sh, 1);
/* write signature head to buffer */
shPos=GWEN_Buffer_GetPos(dbuf);
rv=GWEN_SigHead_toBuffer(sh, dbuf, GWEN_CRYPTMGR_TLV_SIGHEAD);
GWEN_SigHead_free(sh);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
return rv;
}
/* write data to buffer */
if (pData && lData)
GWEN_Tag16_DirectlyToBuffer(GWEN_CRYPTMGR_TLV_SIGDATA,
(const char*)pData,
lData,
dbuf);
/* sign data: signature head TLV + data TLV */
sigbuf=GWEN_Buffer_new(0, 300, 0, 1);
p=((uint8_t*)GWEN_Buffer_GetStart(dbuf))+shPos;
l=GWEN_Buffer_GetPos(dbuf)-shPos;
rv=GWEN_CryptMgr_SignData(cm, p, l, sigbuf);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(sigbuf);
return rv;
}
/* create signature tail */
st=GWEN_SigTail_new();
GWEN_SigTail_SetSignature(st,
(const uint8_t*)GWEN_Buffer_GetStart(sigbuf),
GWEN_Buffer_GetUsedBytes(sigbuf));
GWEN_Buffer_free(sigbuf);
GWEN_SigTail_SetSignatureNumber(st, 1);
/* write signature tail */
rv=GWEN_SigTail_toBuffer(st, dbuf, GWEN_CRYPTMGR_TLV_SIGTAIL);
GWEN_SigTail_free(st);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
return rv;
}
/* write complete size */
l=GWEN_Buffer_GetPos(dbuf)-pos-2;
p=(uint8_t*)GWEN_Buffer_GetStart(dbuf)+pos;
*(p++)=l & 0xff;
*p=(l>>8) & 0xff;
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 GWEN_LibLoader_OpenLibraryWithPath(GWEN_LIBLOADER *h,
const char *path,
const char *name)
{
GWEN_BUFFER *buffer;
unsigned int pos;
unsigned int pos2;
unsigned int i;
int missingSoExt;
int missingLibPrefix;
int err;
assert(h);
assert(name);
missingSoExt=0;
missingLibPrefix=0;
buffer=GWEN_Buffer_new(0, 256, 0, 1);
if (path) {
GWEN_Buffer_AppendString(buffer, path);
GWEN_Buffer_AppendByte(buffer, '/');
}
/* remember current position */
pos=GWEN_Buffer_GetPos(buffer);
/* append name of the library to load */
GWEN_Buffer_AppendString(buffer, name);
i=strlen(name);
/* check whether we have the ".so" extension */
if ((i<=3) || (strcmp(name+i-3, ".so")!=0)) {
/* no SO-extension, add it myself */
missingSoExt=1;
}
/* check whether we have the "lib" prefix */
if ((i<=3) || (strncmp(name, "lib", 3)!=0)) {
/* no SO-extension, add it myself */
missingLibPrefix=1;
}
/* try to load the library */
err=GWEN_LibLoader_LoadLibrary(h, GWEN_Buffer_GetStart(buffer));
if (!err) {
DBG_INFO(GWEN_LOGDOMAIN, "Library \"%s\" loaded",
GWEN_Buffer_GetStart(buffer));
GWEN_Buffer_free(buffer);
return 0;
}
/* could not load, check why */
/*if (GWEN_Error_GetType(err)!=
GWEN_Error_FindType(GWEN_LIBLOADER_ERROR_TYPE) ||
GWEN_Error_GetCode(err)!=GWEN_LIBLOADER_ERROR_NOT_FOUND) {
DBG_ERROR_ERR(GWEN_LOGDOMAIN, err);
DBG_INFO(GWEN_LOGDOMAIN, "Could not load library \"%s\"",
GWEN_Buffer_GetStart(buffer));
GWEN_Buffer_free(buffer);
return err;
}
*/
/* hmm, not found, try some variants */
if (missingSoExt) {
/* try again, this time with ".so" appended */
pos2=GWEN_Buffer_GetPos(buffer);
GWEN_Buffer_AppendString(buffer, ".so");
err=GWEN_LibLoader_LoadLibrary(h, GWEN_Buffer_GetStart(buffer));
if (!err) {
DBG_INFO(GWEN_LOGDOMAIN, "Library \"%s\" loaded",
GWEN_Buffer_GetStart(buffer));
GWEN_Buffer_free(buffer);
return 0;
}
GWEN_Buffer_Crop(buffer, 0, pos2);
GWEN_Buffer_SetPos(buffer, pos2);
/* could not load, check why */
if (err!=GWEN_ERROR_NOT_FOUND) {
DBG_INFO(GWEN_LOGDOMAIN, "Could not load library \"%s\"",
GWEN_Buffer_GetStart(buffer));
GWEN_Buffer_free(buffer);
return err;
}
}
if (missingLibPrefix) {
GWEN_Buffer_SetPos(buffer, pos);
/* insert "lib" */
GWEN_Buffer_InsertString(buffer, "lib");
/* try again */
err=GWEN_LibLoader_LoadLibrary(h, GWEN_Buffer_GetStart(buffer));
if (!err) {
DBG_INFO(GWEN_LOGDOMAIN, "Library \"%s\" loaded",
GWEN_Buffer_GetStart(buffer));
GWEN_Buffer_free(buffer);
return 0;
}
/* could not load, check why */
if (err!=GWEN_ERROR_NOT_FOUND) {
DBG_INFO(GWEN_LOGDOMAIN, "Could not load library \"%s\"",
GWEN_Buffer_GetStart(buffer));
GWEN_Buffer_free(buffer);
return err;
}
/* try again, this time with ".so" AND "lib" */
if (missingSoExt) {
GWEN_Buffer_AppendString(buffer, ".so");
err=GWEN_LibLoader_LoadLibrary(h, GWEN_Buffer_GetStart(buffer));
if (!err) {
DBG_INFO(GWEN_LOGDOMAIN, "Library \"%s\" loaded",
GWEN_Buffer_GetStart(buffer));
GWEN_Buffer_free(buffer);
return 0;
}
}
}
DBG_INFO(GWEN_LOGDOMAIN, "Library \"%s\" name (or variants) not found, giving up",
name);
GWEN_Buffer_free(buffer);
return err;
}
int AB_Banking__GetConfigManager(AB_BANKING *ab, const char *dname) {
GWEN_BUFFER *buf;
char home[256];
if (GWEN_Directory_GetHomeDirectory(home, sizeof(home))) {
DBG_ERROR(AQBANKING_LOGDOMAIN,
"Could not determine home directory, aborting.");
abort();
}
buf=GWEN_Buffer_new(0, 256, 0, 1);
if (dname) {
/* setup data dir */
ab->dataDir=strdup(dname);
/* determine config manager URL */
GWEN_Buffer_AppendString(buf, "dir://");
GWEN_Buffer_AppendString(buf, dname);
GWEN_Buffer_AppendString(buf, DIRSEP);
GWEN_Buffer_AppendString(buf, "settings");
}
else {
const char *s;
uint32_t pos;
GWEN_Buffer_AppendString(buf, "dir://");
pos=GWEN_Buffer_GetPos(buf);
/* determine config directory */
s=getenv("AQBANKING_HOME");
if (s && !*s)
s=0;
if (s)
GWEN_Buffer_AppendString(buf, s);
else {
/* use default */
GWEN_Buffer_AppendString(buf, home);
GWEN_Buffer_AppendString(buf, DIRSEP);
GWEN_Buffer_AppendString(buf, AB_BANKING_USERDATADIR);
}
/* as we are at it: store default data dir */
ab->dataDir=strdup(GWEN_Buffer_GetStart(buf)+pos);
/* continue with settings folder */
GWEN_Buffer_AppendString(buf, DIRSEP);
GWEN_Buffer_AppendString(buf, "settings");
}
DBG_INFO(AQBANKING_LOGDOMAIN,
"Using data folder [%s]",
ab->dataDir);
DBG_INFO(AQBANKING_LOGDOMAIN,
"Using ConfigManager [%s]",
GWEN_Buffer_GetStart(buf));
ab->configMgr=GWEN_ConfigMgr_Factory(GWEN_Buffer_GetStart(buf));
if (ab->configMgr==NULL) {
DBG_ERROR(AQBANKING_LOGDOMAIN,
"Could not create ConfigMgr[%s]. "
"Maybe the gwenhywfar plugins are not installed?",
GWEN_Buffer_GetStart(buf));
GWEN_Buffer_free(buf);
return GWEN_ERROR_GENERIC;
}
/* done */
GWEN_Buffer_free(buf);
return 0;
}
int GWEN_Directory_GetMatchingFilesRecursively(const char *folder,
GWEN_STRINGLIST *sl,
const char *mask) {
GWEN_DIRECTORY *d;
int rv;
char buffer[256];
GWEN_BUFFER *pbuf;
uint32_t pos;
GWEN_STRINGLIST *folderList;
folderList=GWEN_StringList_new();
d=GWEN_Directory_new();
rv=GWEN_Directory_Open(d, folder);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Directory_free(d);
GWEN_StringList_free(folderList);
return rv;
}
pbuf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendString(pbuf, folder);
GWEN_Buffer_AppendString(pbuf, GWEN_DIR_SEPARATOR_S);
pos=GWEN_Buffer_GetPos(pbuf);
while(0==GWEN_Directory_Read(d, buffer, sizeof(buffer)-2)) {
if (strcmp(buffer, ".")!=0 &&
strcmp(buffer, "..")!=0) {
struct stat st;
GWEN_Buffer_AppendString(pbuf, buffer);
if (stat(GWEN_Buffer_GetStart(pbuf), &st)==0) {
if (S_ISDIR(st.st_mode))
/* add folders to the folder list */
GWEN_StringList_AppendString(folderList, GWEN_Buffer_GetStart(pbuf), 0, 0);
else {
if (mask==NULL || GWEN_Text_ComparePattern(buffer, mask, 0)!=-1)
/* don't check for duplicates here (i.e. last param =0) */
GWEN_StringList_AppendString(sl, GWEN_Buffer_GetStart(pbuf), 0, 0);
}
}
GWEN_Buffer_Crop(pbuf, 0, pos);
}
}
GWEN_Directory_Close(d);
GWEN_Directory_free(d);
if (GWEN_StringList_Count(folderList)) {
GWEN_STRINGLISTENTRY *se;
se=GWEN_StringList_FirstEntry(folderList);
while(se) {
const char *s;
s=GWEN_StringListEntry_Data(se);
if (s && *s)
GWEN_Directory_GetMatchingFilesRecursively(s, sl, mask);
se=GWEN_StringListEntry_Next(se);
}
}
GWEN_StringList_free(folderList);
GWEN_Buffer_free(pbuf);
return 0;
}