GWEN_DIALOG *Dlg_Test1_new() {
GWEN_DIALOG *dlg;
int rv;
const char *s;
GWEN_BUFFER *tbuf;
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
s=getenv("DIALOG_DIR");
if (s && *s)
GWEN_Buffer_AppendString(tbuf, s);
else
GWEN_Buffer_AppendString(tbuf, MEDIAPATH);
dlg=GWEN_Dialog_new("dlg_test");
GWEN_Dialog_SetSignalHandler(dlg, _gwenGuiSignalHandler);
GWEN_Dialog_AddMediaPath(dlg, GWEN_Buffer_GetStart(tbuf));
/* read dialog from dialog description file */
GWEN_Buffer_AppendString(tbuf, GWEN_DIR_SEPARATOR_S "dlg_test.dlg");
rv=GWEN_Dialog_ReadXmlFile(dlg, GWEN_Buffer_GetStart(tbuf));
GWEN_Buffer_free(tbuf);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d).", rv);
GWEN_Dialog_free(dlg);
return NULL;
}
/* done */
return dlg;
}
int GWEN_Directory_FindPathForFile(const GWEN_STRINGLIST *paths,
const char *filePath,
GWEN_BUFFER *fbuf) {
GWEN_STRINGLISTENTRY *se;
se=GWEN_StringList_FirstEntry(paths);
while(se) {
GWEN_BUFFER *tbuf;
FILE *f;
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendString(tbuf, GWEN_StringListEntry_Data(se));
GWEN_Buffer_AppendString(tbuf, DIRSEP);
GWEN_Buffer_AppendString(tbuf, filePath);
DBG_VERBOUS(GWEN_LOGDOMAIN, "Trying \"%s\"",
GWEN_Buffer_GetStart(tbuf));
f=fopen(GWEN_Buffer_GetStart(tbuf), "r");
if (f) {
fclose(f);
DBG_INFO(GWEN_LOGDOMAIN,
"File \"%s\" found in folder \"%s\"",
filePath,
GWEN_StringListEntry_Data(se));
GWEN_Buffer_AppendString(fbuf, GWEN_StringListEntry_Data(se));
GWEN_Buffer_free(tbuf);
return 0;
}
GWEN_Buffer_free(tbuf);
se=GWEN_StringListEntry_Next(se);
}
DBG_INFO(GWEN_LOGDOMAIN, "File \"%s\" not found", filePath);
return GWEN_ERROR_NOT_FOUND;
}
int GWEN_Gui_CProgress_Log(GWEN_GUI_CPROGRESS *cp,
GWEN_UNUSED GWEN_LOGGER_LEVEL level,
const char *text)
{
assert(cp);
assert(text);
if (!(GWEN_Gui_GetFlags(cp->gui) & GWEN_GUI_FLAGS_NONINTERACTIVE)) {
GWEN_BUFFER *tbuf;
const char *t;
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Gui_GetRawText(cp->gui, text, tbuf);
t=GWEN_Buffer_GetStart(tbuf);
if (t[GWEN_Buffer_GetUsedBytes(tbuf)-1]!='\n') {
GWEN_Buffer_AppendByte(tbuf, '\n');
/* Just in case the buffer has been reallocated */
t=GWEN_Buffer_GetStart(tbuf);
}
GWEN_Gui_StdPrintf(cp->gui, stderr, "%s", t);
GWEN_Buffer_AppendString(cp->logBuf, t);
GWEN_Buffer_free(tbuf);
tbuf=0;
if (cp->aborted)
return GWEN_ERROR_USER_ABORTED;
}
return 0;
}
GWEN_TIME *AB_ImExporter_DateFromString(const char *p, const char *tmpl,
int inUtc) {
GWEN_TIME *ti;
if (strchr(tmpl, 'h')==0) {
GWEN_BUFFER *dbuf;
GWEN_BUFFER *tbuf;
dbuf=GWEN_Buffer_new(0, 32, 0, 1);
GWEN_Buffer_AppendString(dbuf, p);
GWEN_Buffer_AppendString(dbuf, "-12:00");
tbuf=GWEN_Buffer_new(0, 32, 0, 1);
GWEN_Buffer_AppendString(tbuf, tmpl);
GWEN_Buffer_AppendString(tbuf, "-hh:mm");
ti=GWEN_Time_fromUtcString(GWEN_Buffer_GetStart(dbuf),
GWEN_Buffer_GetStart(tbuf));
GWEN_Buffer_free(tbuf);
GWEN_Buffer_free(dbuf);
}
else {
if (inUtc)
ti=GWEN_Time_fromUtcString(p, tmpl);
else
ti=GWEN_Time_fromString(p, tmpl);
}
return ti;
}
void AB_Value_toHbciString(const AB_VALUE *v, GWEN_BUFFER *buf) {
GWEN_BUFFER *tbuf;
char *p;
int l;
tbuf=GWEN_Buffer_new(0, 32, 0, 1);
AB_Value_toHumanReadableString2(v, tbuf, 2, 0);
/* convert decimal komma */
p=GWEN_Buffer_GetStart(tbuf);
while(*p) {
if (*p=='.') {
*p=',';
break;
}
p++;
}
/* remove trailing zeroes */
p=GWEN_Buffer_GetStart(tbuf);
l=strlen(GWEN_Buffer_GetStart(tbuf));
if (l>0 && strchr(p, ',')!=NULL) {
l--;
while(l>0 && p[l]=='0') {
p[l]=0;
l--;
}
}
GWEN_Buffer_AppendString(buf, GWEN_Buffer_GetStart(tbuf));
GWEN_Buffer_free(tbuf);
}
int GWEN_PathManager_FindFile(const char *destLib,
const char *pathName,
const char *fileName,
GWEN_BUFFER *fbuf) {
GWEN_DB_NODE *dbT;
assert(gwen__paths);
dbT=GWEN_DB_GetGroup(gwen__paths, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
destLib);
if (dbT) {
dbT=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
pathName);
if (dbT) {
int i;
const char *s;
GWEN_DB_NODE *dbN;
GWEN_BUFFER *tbuf;
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
/* check all paths */
dbN=GWEN_DB_FindFirstGroup(dbT, "pair");
while(dbN) {
for (i=0; ; i++) {
s=GWEN_DB_GetCharValue(dbN, "path", i, 0);
if (!s)
break;
else {
FILE *f;
GWEN_Buffer_AppendString(tbuf, s);
GWEN_Buffer_AppendString(tbuf, GWEN_DIR_SEPARATOR_S);
GWEN_Buffer_AppendString(tbuf, fileName);
DBG_DEBUG(GWEN_LOGDOMAIN, "Trying \"%s\"",
GWEN_Buffer_GetStart(tbuf));
f=fopen(GWEN_Buffer_GetStart(tbuf), "r");
if (f) {
fclose(f);
DBG_DEBUG(GWEN_LOGDOMAIN,
"File \"%s\" found in folder \"%s\"",
fileName,
s);
GWEN_Buffer_AppendBuffer(fbuf, tbuf);
GWEN_Buffer_free(tbuf);
return 0;
}
GWEN_Buffer_Reset(tbuf);
}
}
dbN=GWEN_DB_FindNextGroup(dbN, "pair");
}
GWEN_Buffer_free(tbuf);
}
}
DBG_INFO(GWEN_LOGDOMAIN, "File \"%s\" not found", fileName);
return GWEN_ERROR_NOT_FOUND;
}
LC_CLIENT_RESULT LC_EgkCard_ReadRawPd(LC_CARD *card, GWEN_BUFFER *buf){
LC_EGKCARD *egk;
LC_CLIENT_RESULT res;
GWEN_BUFFER *lbuf;
int size;
const unsigned char *p;
assert(card);
egk=GWEN_INHERIT_GETDATA(LC_CARD, LC_EGKCARD, card);
assert(egk);
res=LC_Card_SelectEf(card, "EF_PD");
if (res!=LC_Client_ResultOk)
return res;
lbuf=GWEN_Buffer_new(0, 2, 0, 1);
res=LC_Card_IsoReadBinary(card, 0, 0, 2, lbuf);
if (res!=LC_Client_ResultOk) {
GWEN_Buffer_free(lbuf);
return res;
}
if (GWEN_Buffer_GetUsedBytes(lbuf)<2) {
DBG_ERROR(LC_LOGDOMAIN, "Invalid response size (%d)",
GWEN_Buffer_GetUsedBytes(lbuf));
GWEN_Buffer_free(lbuf);
return LC_Client_ResultDataError;
}
p=(const unsigned char*)GWEN_Buffer_GetStart(lbuf);
assert(p);
size=(*(p++))<<8;
size+=*p;
if (size<2) {
DBG_ERROR(LC_LOGDOMAIN, "Invalid size spec in data (%d)", size);
GWEN_Buffer_free(lbuf);
return LC_Client_ResultDataError;
}
size-=2;
GWEN_Buffer_Reset(lbuf);
if (size) {
res=LC_Card_ReadBinary(card, 2, size, lbuf);
if (res!=LC_Client_ResultOk) {
DBG_INFO(LC_LOGDOMAIN, "here (%d)", res);
GWEN_Buffer_free(lbuf);
return res;
}
}
res=LC_EgkCard_Unzip(GWEN_Buffer_GetStart(lbuf),
GWEN_Buffer_GetUsedBytes(lbuf),
buf);
GWEN_Buffer_free(lbuf);
return res;
}
static
void _dumpBal(const AB_BALANCE *bal,
const GWEN_TIME *ti,
FILE *fd) {
if (bal) {
const GWEN_TIME *bti;
const AB_VALUE *val;
bti=AB_Balance_GetTime(bal);
if (bti==0)
bti=ti;
if (bti) {
GWEN_BUFFER *tbuf;
tbuf=GWEN_Buffer_new(0, 24, 0, 1);
GWEN_Time_toString(bti, "DD.MM.YYYY\thh:mm", tbuf);
fprintf(fd, "%s\t", GWEN_Buffer_GetStart(tbuf));
GWEN_Buffer_free(tbuf);
}
else {
fprintf(fd, "\t\t");
}
val=AB_Balance_GetValue(bal);
if (val) {
AB_VALUE *vNew;
GWEN_BUFFER *vbuf;
const char *cur;
vNew=AB_Value_dup(val);
AB_Value_SetCurrency(vNew, NULL);
vbuf=GWEN_Buffer_new(0, 32, 0, 1);
AB_Value_toHumanReadableString(vNew, vbuf, 2);
fprintf(fd, "%s\t", GWEN_Buffer_GetStart(vbuf));
GWEN_Buffer_free(vbuf);
AB_Value_free(vNew);
cur=AB_Value_GetCurrency(val);
if (cur)
fprintf(fd, "%s\t", cur);
else
fprintf(fd, "\t");
}
else {
fprintf(fd, "\t\t");
}
}
else {
fprintf(fd, "\t\t\t\t");
}
}
int GWEN_PathManager_GetMatchingFilesRecursively(const char *destLib,
const char *pathName,
const char *subFolderName,
GWEN_STRINGLIST *sl,
const char *mask) {
GWEN_DB_NODE *dbT;
assert(gwen__paths);
dbT=GWEN_DB_GetGroup(gwen__paths, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
destLib);
if (dbT) {
dbT=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
pathName);
if (dbT) {
int i;
const char *s;
GWEN_DB_NODE *dbN;
GWEN_BUFFER *tbuf;
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
/* check all paths */
dbN=GWEN_DB_FindFirstGroup(dbT, "pair");
while(dbN) {
for (i=0; ; i++) {
s=GWEN_DB_GetCharValue(dbN, "path", i, 0);
if (!s)
break;
else {
GWEN_Buffer_AppendString(tbuf, s);
if (subFolderName && *subFolderName) {
GWEN_Buffer_AppendString(tbuf, GWEN_DIR_SEPARATOR_S);
GWEN_Buffer_AppendString(tbuf, subFolderName);
}
DBG_DEBUG(GWEN_LOGDOMAIN, "Trying \"%s\"",
GWEN_Buffer_GetStart(tbuf));
GWEN_Directory_GetMatchingFilesRecursively(GWEN_Buffer_GetStart(tbuf), sl, mask);
GWEN_Buffer_Reset(tbuf);
}
}
dbN=GWEN_DB_FindNextGroup(dbN, "pair");
}
GWEN_Buffer_free(tbuf);
}
}
return 0;
}
int AIO_OfxGroup_STATUS_AddData(AIO_OFX_GROUP *g, const char *data)
{
AIO_OFX_GROUP_STATUS *xg;
assert(g);
xg=GWEN_INHERIT_GETDATA(AIO_OFX_GROUP, AIO_OFX_GROUP_STATUS, g);
assert(xg);
if (xg->currentElement) {
GWEN_BUFFER *buf;
int rv;
const char *s;
buf=GWEN_Buffer_new(0, strlen(data), 0, 1);
rv=AIO_OfxXmlCtx_SanitizeData(AIO_OfxGroup_GetXmlContext(g), data, buf);
if (rv<0) {
DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(buf);
return rv;
}
s=GWEN_Buffer_GetStart(buf);
if (*s) {
DBG_INFO(AQBANKING_LOGDOMAIN,
"AddData: %s=[%s]", xg->currentElement, s);
if (strcasecmp(xg->currentElement, "CODE")==0) {
if (1!=sscanf(s, "%d", &xg->code)) {
DBG_ERROR(AQBANKING_LOGDOMAIN,
"Bad data for element [%s]",
xg->currentElement);
GWEN_Buffer_free(buf);
return GWEN_ERROR_BAD_DATA;
}
}
else if (strcasecmp(xg->currentElement, "SEVERITY")==0) {
free(xg->severity);
xg->severity=strdup(GWEN_Buffer_GetStart(buf));
}
else {
DBG_INFO(AQBANKING_LOGDOMAIN,
"Ignoring data for unknown element [%s]",
xg->currentElement);
}
}
GWEN_Buffer_free(buf);
}
return 0;
}
int GWEN_Padd_UnpaddWithIso9796_2(GWEN_BUFFER *buf) {
uint32_t l;
uint32_t realSize;
const uint8_t *p;
l=GWEN_Buffer_GetUsedBytes(buf);
if (l<11) {
DBG_ERROR(GWEN_LOGDOMAIN, "Buffer contains too few bytes");
return GWEN_ERROR_INVALID;
}
p=(const uint8_t*)GWEN_Buffer_GetStart(buf);
if (*p!=0x60) {
DBG_ERROR(GWEN_LOGDOMAIN, "First byte is not a 0x60");
return GWEN_ERROR_BAD_DATA;
}
p++;
l=0;
while(*p==0x00) {
l++;
p++;
}
if (*p!=0x01) {
/*DBG_ERROR(GWEN_LOGDOMAIN, "First byte after padding is not a 0x01");*/
return GWEN_ERROR_BAD_DATA;
}
realSize=GWEN_Buffer_GetUsedBytes(buf)-11-l;
GWEN_Buffer_Crop(buf, 10+l, realSize);
return 0;
}
static GWENHYWFAR_CB
int Gtk3Gui_WLabel_SetCharProperty(GWEN_WIDGET *w,
GWEN_DIALOG_PROPERTY prop,
int index,
const char *value,
int doSignal) {
GtkLabel *g;
GWEN_BUFFER *tbuf;
g=GTK_LABEL(GWEN_Widget_GetImplData(w, GTK3_DIALOG_WIDGET_REAL));
assert(g);
tbuf=GWEN_Buffer_new(0, 128, 0, 1);
if (value && *value)
Gtk3Gui_GetRawText(value, tbuf);
switch(prop) {
case GWEN_DialogProperty_Title:
gtk_label_set_text(g, GWEN_Buffer_GetStart(tbuf));
GWEN_Buffer_free(tbuf);
return 0;
default:
break;
}
DBG_WARN(GWEN_LOGDOMAIN,
"Function is not appropriate for this type of widget (%s)",
GWEN_Widget_Type_toString(GWEN_Widget_GetType(w)));
GWEN_Buffer_free(tbuf);
return GWEN_ERROR_INVALID;
}
static int Gtk3Gui_WLabel_Setup(GWEN_WIDGET *w) {
GtkWidget *g;
const char *s;
GWEN_WIDGET *wParent;
GWEN_BUFFER *tbuf;
wParent=GWEN_Widget_Tree_GetParent(w);
s=GWEN_Widget_GetText(w, 0);
tbuf=GWEN_Buffer_new(0, 128, 0, 1);
if (s && *s)
Gtk3Gui_GetRawText(s, tbuf);
g=gtk_label_new(GWEN_Buffer_GetStart(tbuf));
GWEN_Buffer_free(tbuf);
GWEN_Widget_SetImplData(w, GTK3_DIALOG_WIDGET_REAL, (void*) g);
GWEN_Widget_SetImplData(w, GTK3_DIALOG_WIDGET_CONTENT, (void*) g);
GWEN_Widget_SetSetIntPropertyFn(w, Gtk3Gui_WLabel_SetIntProperty);
GWEN_Widget_SetGetIntPropertyFn(w, Gtk3Gui_WLabel_GetIntProperty);
GWEN_Widget_SetSetCharPropertyFn(w, Gtk3Gui_WLabel_SetCharProperty);
GWEN_Widget_SetGetCharPropertyFn(w, Gtk3Gui_WLabel_GetCharProperty);
if (wParent)
GWEN_Widget_AddChildGuiWidget(wParent, w);
return 0;
}
int AB_Banking_GetSharedDataDir(const AB_BANKING *ab,
const char *name,
GWEN_BUFFER *buf){
assert(ab);
if (ab->dataDir) {
GWEN_Buffer_AppendString(buf, ab->dataDir);
GWEN_Buffer_AppendString(buf, DIRSEP "shared" DIRSEP);
if (GWEN_Text_EscapeToBufferTolerant(name, buf)) {
DBG_ERROR(AQBANKING_LOGDOMAIN,
"Bad share name, aborting.");
abort();
}
else {
char *s;
s=GWEN_Buffer_GetStart(buf);
while(*s) {
*s=tolower(*s);
s++;
}
}
return 0;
}
else {
DBG_ERROR(AQBANKING_LOGDOMAIN, "No data dir (not init?)");
return GWEN_ERROR_GENERIC;
}
}
LC_CLIENT_RESULT LC_EgkCard_ReadInsuranceData(LC_CARD *card,
LC_HI_INSURANCE_DATA **pData) {
GWEN_BUFFER *dbuf;
LC_CLIENT_RESULT res;
dbuf=GWEN_Buffer_new(0, 256, 0, 1);
res=LC_EgkCard_ReadVd(card, dbuf);
if (res!=LC_Client_ResultOk) {
DBG_INFO(LC_LOGDOMAIN, "here (%d)", res);
GWEN_Buffer_free(dbuf);
return res;
}
else {
GWEN_XMLNODE *root;
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);
res=LC_EgkCard_ParseInsuranceData(root, pData);
GWEN_XMLNode_free(root);
return res;
}
}
const char *AB_ImExporterContext_GetLog(const AB_IMEXPORTER_CONTEXT *iec) {
assert(iec);
if (GWEN_Buffer_GetUsedBytes(iec->logs))
return GWEN_Buffer_GetStart(iec->logs);
else
return NULL;
}
int GWEN_Padd_PaddWithPkcs1Bt1(GWEN_BUFFER *buf, int dstSize) {
unsigned int diff;
char *p;
if ((unsigned int)dstSize<GWEN_Buffer_GetUsedBytes(buf)) {
DBG_ERROR(GWEN_LOGDOMAIN, "Buffer contains too much data");
return GWEN_ERROR_INVALID;
}
diff=dstSize-GWEN_Buffer_GetUsedBytes(buf);
if (diff<11) {
/* honour minimum padding length for BT 1 of 8 bytes, plus the
* leading and the trailing zero and the block type identifier */
DBG_ERROR(GWEN_LOGDOMAIN,
"Buffer contains too many bytes (diff is <11)");
return GWEN_ERROR_INVALID;
}
/* reset position to 0 */
GWEN_Buffer_Rewind(buf);
if (GWEN_Buffer_InsertRoom(buf, diff)) {
DBG_ERROR(GWEN_LOGDOMAIN, "Could not insert room for %d bytes", diff);
return GWEN_ERROR_GENERIC;
}
p=GWEN_Buffer_GetStart(buf);
*(p++)=0x00;
*(p++)=0x01; /* block type 01 */
if (diff>3) {
memset(p, 0xff, diff-3);
p+=diff-3;
}
*(p++)=0x00;
return 0;
}
int GWEN_CryptMgr_Decode(GWEN_CRYPTMGR *cm, const uint8_t *pData, uint32_t lData, GWEN_BUFFER *dbuf) {
GWEN_BUFFER *tbuf;
int rv;
tbuf=GWEN_Buffer_new(0, lData, 0, 1);
/* decrypt encrypted object */
DBG_INFO(GWEN_LOGDOMAIN, "Decrypting data");
rv=GWEN_CryptMgr_Decrypt(cm, pData, lData, tbuf);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
return rv;
}
/* verify signature, copy signed data to dbuf in the process */
DBG_INFO(GWEN_LOGDOMAIN, "Verifying data");
rv=GWEN_CryptMgr_Verify(cm,
(const uint8_t*)GWEN_Buffer_GetStart(tbuf),
GWEN_Buffer_GetUsedBytes(tbuf),
dbuf);
GWEN_Buffer_free(tbuf);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
return rv;
}
return 0;
}
int EB_Msg_WriteSignature(EB_MSG *m, const unsigned char *hash, int hsize) {
int rv;
GWEN_BUFFER *hbuf;
assert(m);
assert(m->usage);
if (hsize!=128) {
DBG_ERROR(AQEBICS_LOGDOMAIN,
"Bad signature size (expected 128, was %d)",
hsize);
return -1;
}
hbuf=GWEN_Buffer_new(0, 256, 0, 1);
rv=GWEN_Base64_Encode(hash, (uint32_t) hsize, hbuf, 0);
if (rv) {
DBG_ERROR(AQEBICS_LOGDOMAIN,
"Could not base64-encode signature (%d)", rv);
GWEN_Buffer_free(hbuf);
return -1;
}
EB_Xml_SetCharValue(xmlDocGetRootElement(m->doc),
"AuthSignature/"
"ds:SignatureValue",
GWEN_Buffer_GetStart(hbuf));
GWEN_Buffer_free(hbuf);
return 0;
}
static int AH_NewKeyFileDialog_HandleActivatedIniLetter(GWEN_DIALOG *dlg) {
AH_NEWKEYFILE_DIALOG *xdlg;
int rv;
GWEN_BUFFER *tbuf;
assert(dlg);
xdlg=GWEN_INHERIT_GETDATA(GWEN_DIALOG, AH_NEWKEYFILE_DIALOG, dlg);
assert(xdlg);
tbuf=GWEN_Buffer_new(0, 1024, 0, 1);
/* add HTML version of the INI letter */
GWEN_Buffer_AppendString(tbuf, "<html>");
rv=AH_Provider_GetIniLetterHtml(AB_User_GetProvider(xdlg->user),
xdlg->user,
0,
0,
tbuf,
1);
if (rv<0) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
// TODO: show error message
AB_Banking_ClearCryptTokenList(xdlg->banking);
GWEN_Buffer_free(tbuf);
return GWEN_DialogEvent_ResultHandled;
}
GWEN_Buffer_AppendString(tbuf, "</html>");
/* add ASCII version of the INI letter for frontends which don't support HTML */
rv=AH_Provider_GetIniLetterTxt(AB_User_GetProvider(xdlg->user),
xdlg->user,
0,
0,
tbuf,
0);
if (rv<0) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
// TODO: show error message
AB_Banking_ClearCryptTokenList(xdlg->banking);
GWEN_Buffer_free(tbuf);
return GWEN_DialogEvent_ResultHandled;
}
rv=GWEN_Gui_Print(I18N("INI Letter"),
"HBCI-INILETTER",
I18N("INI Letter for HBCI"),
GWEN_Buffer_GetStart(tbuf),
0);
if (rv<0) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
// TODO: show error message
GWEN_Buffer_free(tbuf);
return GWEN_DialogEvent_ResultHandled;
}
GWEN_Buffer_free(tbuf);
return GWEN_DialogEvent_ResultHandled;
}
int GWEN_CryptMgr_Encode(GWEN_CRYPTMGR *cm, const uint8_t *pData, uint32_t lData, GWEN_BUFFER *dbuf) {
GWEN_BUFFER *tbuf;
int rv;
tbuf=GWEN_Buffer_new(0, lData, 0, 1);
/* create signed object */
DBG_INFO(GWEN_LOGDOMAIN, "Signing data");
rv=GWEN_CryptMgr_Sign(cm, pData, lData, tbuf);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
return rv;
}
/* create encrypted object (containing a signed object in this case) */
DBG_INFO(GWEN_LOGDOMAIN, "Encrypting data");
rv=GWEN_CryptMgr_Encrypt(cm,
(const uint8_t*)GWEN_Buffer_GetStart(tbuf),
GWEN_Buffer_GetUsedBytes(tbuf),
dbuf);
GWEN_Buffer_free(tbuf);
if (rv<0) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
return rv;
}
return 0;
}
LC_CLIENT_RESULT LC_DDVCard_CryptBlock(LC_CARD *card,
GWEN_BUFFER *ibuf,
GWEN_BUFFER *obuf){
return LC_DDVCard_CryptCharBlock(card,
GWEN_Buffer_GetStart(ibuf),
GWEN_Buffer_GetUsedBytes(ibuf),
obuf);
}
GWEN_DIALOG *AH_NewKeyFileDialog_new(AB_BANKING *ab) {
GWEN_DIALOG *dlg;
AH_NEWKEYFILE_DIALOG *xdlg;
GWEN_BUFFER *fbuf;
int rv;
dlg=GWEN_Dialog_new("ah_setup_newkeyfile");
GWEN_NEW_OBJECT(AH_NEWKEYFILE_DIALOG, xdlg);
GWEN_INHERIT_SETDATA(GWEN_DIALOG, AH_NEWKEYFILE_DIALOG, dlg, xdlg,
AH_NewKeyFileDialog_FreeData);
GWEN_Dialog_SetSignalHandler(dlg, AH_NewKeyFileDialog_SignalHandler);
/* 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/backends/aqhbci/dialogs/dlg_newkeyfile.dlg",
fbuf);
if (rv<0) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Dialog description file not found (%d).", rv);
GWEN_Buffer_free(fbuf);
GWEN_Dialog_free(dlg);
return NULL;
}
/* read dialog from dialog description file */
rv=GWEN_Dialog_ReadXmlFile(dlg, GWEN_Buffer_GetStart(fbuf));
if (rv<0) {
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d).", rv);
GWEN_Gui_ShowError(I18N("Error"),
I18N("Could not read dialog description file [%s], maybe an installation error (%d)?"),
GWEN_Buffer_GetStart(fbuf), rv);
GWEN_Buffer_free(fbuf);
GWEN_Dialog_free(dlg);
return NULL;
}
GWEN_Buffer_free(fbuf);
xdlg->banking=ab;
/* preset */
xdlg->hbciVersion=210;
xdlg->rdhVersion=0;
/* done */
return dlg;
}
HTML_IMAGE *FOX16_HtmlCtx::getImage(const char *fileName) {
GWEN_STRINGLIST *sl;
sl=HtmlCtx_GetMediaPaths(_context);
if (sl) {
GWEN_BUFFER *tbuf;
int rv;
FXImage *ximg;
HTML_IMAGE *img;
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
rv=GWEN_Directory_FindFileInPaths(sl, fileName, tbuf);
if (rv<0) {
DBG_ERROR(GWEN_LOGDOMAIN, "here (%d)", rv);
GWEN_Buffer_free(tbuf);
return NULL;
}
if (m_iconSource==NULL)
m_iconSource=new FXIconSource(FXApp::instance());
ximg=m_iconSource->loadIconFile(GWEN_Buffer_GetStart(tbuf));
if (ximg==NULL) {
DBG_ERROR(GWEN_LOGDOMAIN, "Could not load icon [%s]", GWEN_Buffer_GetStart(tbuf));
GWEN_Buffer_free(tbuf);
return NULL;
}
ximg->create();
img=HtmlImage_new();
HtmlImage_SetImageName(img, GWEN_Buffer_GetStart(tbuf));
HtmlImage_SetWidth(img, ximg->getWidth());
HtmlImage_SetHeight(img, ximg->getHeight());
GWEN_INHERIT_SETDATA(HTML_IMAGE, FXImage, img, ximg,
FOX16_HtmlCtxLinker::freeImageData);
GWEN_Buffer_free(tbuf);
return img;
}
else {
DBG_ERROR(GWEN_LOGDOMAIN, "No media paths in dialog");
return NULL;
}
}
GWEN_DATE *GWEN_Date_fromTime(const GWEN_TIME *ti) {
GWEN_BUFFER *tbuf;
GWEN_DATE *gd;
tbuf=GWEN_Buffer_new(0, 32, 0, 1);
GWEN_Time_toString(ti, "YYYYMMDD", tbuf);
gd=GWEN_Date_fromString(GWEN_Buffer_GetStart(tbuf));
GWEN_Buffer_free(tbuf);
return gd;
}
GWEN_DB_NODE *AH_User_GetUpdForAccountIdAndSuffix(const AB_USER *u,
const char *sAccountNumber,
const char *sAccountSuffix) {
AH_USER *ue;
GWEN_DB_NODE *db;
GWEN_BUFFER *tbuf;
assert(u);
ue=GWEN_INHERIT_GETDATA(AB_USER, AH_USER, u);
assert(ue);
db=AH_User_GetUpd(u);
if (db==NULL) {
DBG_INFO(AQHBCI_LOGDOMAIN, "No upd");
return NULL;
}
tbuf=GWEN_Buffer_new(0, 64, 0, 1);
GWEN_Buffer_AppendString(tbuf, sAccountNumber);
GWEN_Buffer_AppendString(tbuf, "-");
/* take into account the "Unterkontomerkmal", don't rely solely on account id */
if (sAccountSuffix && *sAccountSuffix)
GWEN_Buffer_AppendString(tbuf, sAccountSuffix);
else
GWEN_Buffer_AppendString(tbuf, "none");
DBG_INFO(AQHBCI_LOGDOMAIN, "Checking upd for account \"%s\"", GWEN_Buffer_GetStart(tbuf));
db=GWEN_DB_GetGroup(db,
GWEN_PATH_FLAGS_NAMEMUSTEXIST,
GWEN_Buffer_GetStart(tbuf));
GWEN_Buffer_free(tbuf);
if (db==NULL) {
DBG_INFO(AQHBCI_LOGDOMAIN, "Falling back to old storage of UPD for account \"%s\"", sAccountNumber);
db=AH_User_GetUpd(u);
db=GWEN_DB_GetGroup(db,
GWEN_PATH_FLAGS_NAMEMUSTEXIST,
sAccountNumber);
}
return db;
}
int AH_User_InputTan(AB_USER *u,
char *pwbuffer,
int minLen,
int maxLen){
int rv;
char buffer[512];
const char *un;
const char *bn=NULL;
GWEN_BUFFER *nbuf;
AB_BANKINFO *bi;
assert(u);
un=AB_User_GetUserId(u);
/* find bank name */
bi=AB_Banking_GetBankInfo(AB_User_GetBanking(u),
"de",
"*",
AB_User_GetBankCode(u));
if (bi)
bn=AB_BankInfo_GetBankName(bi);
if (!bn)
AB_User_GetBankCode(u);
buffer[0]=0;
buffer[sizeof(buffer)-1]=0;
snprintf(buffer, sizeof(buffer)-1,
I18N("Please enter the next TAN\n"
"for user %s at %s."
"<html>"
"Please enter the next TAN for user <i>%s</i> at "
"<i>%s</i>."
"</html>"),
un, bn,
un, bn);
buffer[sizeof(buffer)-1]=0;
nbuf=GWEN_Buffer_new(0, 256 ,0 ,1);
AH_User_MkTanName(u, NULL, nbuf);
rv=GWEN_Gui_GetPassword(GWEN_GUI_INPUT_FLAGS_TAN |
/*GWEN_GUI_INPUT_FLAGS_NUMERIC |*/
GWEN_GUI_INPUT_FLAGS_SHOW,
GWEN_Buffer_GetStart(nbuf),
I18N("Enter TAN"),
buffer,
pwbuffer,
minLen,
maxLen,
0);
GWEN_Buffer_free(nbuf);
AB_BankInfo_free(bi);
return rv;
}
void OH_GetInstituteDialog_UpdateList(GWEN_DIALOG *dlg)
{
OH_GETINST_DIALOG *xdlg;
const OH_INSTITUTE_SPEC_LIST *sl;
assert(dlg);
xdlg=GWEN_INHERIT_GETDATA(GWEN_DIALOG, OH_GETINST_DIALOG, dlg);
assert(xdlg);
/* clear bank info list */
GWEN_Dialog_SetIntProperty(dlg, "listBox", GWEN_DialogProperty_ClearValues, 0, 0, 0);
OH_InstituteSpec_List_Clear(xdlg->matchingSpecList);
OH_InstituteData_free(xdlg->selectedData);
xdlg->selectedData=NULL;
sl=OfxHome_GetSpecs(xdlg->ofxHome);
if (sl) {
GWEN_BUFFER *tbuf;
const OH_INSTITUTE_SPEC *os;
const char *s;
s=GWEN_Dialog_GetCharProperty(dlg, "nameEdit", GWEN_DialogProperty_Value, 0, NULL);
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
os=OH_InstituteSpec_List_First(sl);
while (os) {
const char *bname;
bname=OH_InstituteSpec_GetName(os);
/* only add matching entries */
if ((s && bname && GWEN_Text_StrCaseStr(bname, s)!=NULL) ||
!(s && *s)) {
OH_InstituteSpec_List_Add(OH_InstituteSpec_dup(os), xdlg->matchingSpecList);
createListBoxString(os, tbuf);
GWEN_Dialog_SetCharProperty(dlg,
"listBox",
GWEN_DialogProperty_AddValue,
0,
GWEN_Buffer_GetStart(tbuf),
0);
GWEN_Buffer_Reset(tbuf);
}
os=OH_InstituteSpec_List_Next(os);
}
GWEN_Buffer_free(tbuf);
}
if (GWEN_Dialog_GetIntProperty(dlg, "listBox", GWEN_DialogProperty_Value, 0, -1)>=0)
GWEN_Dialog_SetIntProperty(dlg, "okButton", GWEN_DialogProperty_Enabled, 0, 1, 0);
else
GWEN_Dialog_SetIntProperty(dlg, "okButton", GWEN_DialogProperty_Enabled, 0, 0, 0);
}
AB_VALUE *AB_Value_fromDouble(double i) {
GWEN_BUFFER *nbuf;
AB_VALUE *v;
int rv;
nbuf=GWEN_Buffer_new(0, 256, 0, 1);
rv=GWEN_Text_DoubleToBuffer(i, nbuf);
assert(rv==0);
v=AB_Value_fromString(GWEN_Buffer_GetStart(nbuf));
GWEN_Buffer_free(nbuf);
return v;
}
GWEN_DIALOG *AB_SelectBankInfoDialog_new(AB_BANKING *ab,
const char *country,
const char *bankCode)
{
GWEN_DIALOG *dlg;
AB_SELECTBANKINFO_DIALOG *xdlg;
GWEN_BUFFER *fbuf;
int rv;
dlg=GWEN_Dialog_new("ab_selectbankinfo");
GWEN_NEW_OBJECT(AB_SELECTBANKINFO_DIALOG, xdlg);
GWEN_INHERIT_SETDATA(GWEN_DIALOG, AB_SELECTBANKINFO_DIALOG, dlg, xdlg,
AB_SelectBankInfoDialog_FreeData);
GWEN_Dialog_SetSignalHandler(dlg, AB_SelectBankInfoDialog_SignalHandler);
/* 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_selectbankinfo.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 dialog from dialog description file */
rv=GWEN_Dialog_ReadXmlFile(dlg, GWEN_Buffer_GetStart(fbuf));
if (rv<0) {
DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d).", rv);
GWEN_Buffer_free(fbuf);
GWEN_Dialog_free(dlg);
return NULL;
}
GWEN_Buffer_free(fbuf);
xdlg->banking=ab;
if (country)
xdlg->country=strdup(country);
else
xdlg->country=strdup("de");
if (bankCode)
xdlg->bankCode=strdup(bankCode);
else
xdlg->bankCode=NULL;
/* done */
return dlg;
}
