GWEN_DATE *GWEN_Date_fromString(const char *s) {
int y, m, d;
if (3==sscanf(s, "%04d%02d%02d", &y, &m, &d)) {
GWEN_DATE *result = GWEN_Date_fromGregorian(y, m, d);
if (!result)
DBG_ERROR(GWEN_LOGDOMAIN, "Bad date string [%s]", s);
return result;
}
else {
DBG_ERROR(GWEN_LOGDOMAIN, "Bad date string [%s]", s);
return NULL;
}
}
int AB_SetupDialog_EditAccount(GWEN_DIALOG *dlg)
{
AB_SETUP_DIALOG *xdlg;
assert(dlg);
xdlg=GWEN_INHERIT_GETDATA(GWEN_DIALOG, AB_SETUP_DIALOG, dlg);
assert(xdlg);
if (xdlg->currentAccountList) {
uint32_t aid;
aid=AB_SetupDialog_GetCurrentAccountId(dlg);
if (aid) {
AB_ACCOUNT *a;
a=AB_Account_List_GetByUniqueId(xdlg->currentAccountList, aid);
if (a) {
AB_PROVIDER *pro;
uint32_t flags=0;
GWEN_DIALOG *dlg2;
int rv;
pro=AB_Account_GetProvider(a);
assert(pro);
flags=AB_Provider_GetFlags(pro);
if (flags & AB_PROVIDER_FLAGS_HAS_EDITACCOUNT_DIALOG)
dlg2=AB_Provider_GetEditAccountDialog(pro, a);
else
dlg2=AB_EditAccountDialog_new(pro, a, 1);
if (dlg2==NULL) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not create dialog");
return GWEN_DialogEvent_ResultHandled;
}
rv=GWEN_Gui_ExecDialog(dlg2, 0);
if (rv==0) {
/* rejected */
GWEN_Dialog_free(dlg2);
return GWEN_DialogEvent_ResultHandled;
}
GWEN_Dialog_free(dlg2);
AB_SetupDialog_Reload(dlg);
} /* if a */
} /* if aid */
else {
DBG_ERROR(AQBANKING_LOGDOMAIN, "No current account");
}
} /* if xdlg->currentAccountList */
return GWEN_DialogEvent_ResultHandled;
}
static int
upload(CBM_FILE fd, unsigned char drive)
{
enum cbm_device_type_e driveType;
const unsigned char *pp_drive_prog = 0;
unsigned int pp_drive_prog_length = 0;
unsigned int bytesWritten;
if (cbm_identify(fd, drive, &driveType, NULL))
return 1;
switch (driveType)
{
case cbm_dt_cbm1581:
DBG_ERROR((DBG_PREFIX "1581 not supported!"));
return 1;
case cbm_dt_cbm1541:
DBG_PRINT((DBG_PREFIX "recognized 1541."));
pp_drive_prog = pp1541_drive_prog;
pp_drive_prog_length = sizeof(pp1541_drive_prog);
break;
case cbm_dt_cbm1570:
case cbm_dt_cbm1571:
DBG_PRINT((DBG_PREFIX "recognized 1571."));
pp_drive_prog = pp1571_drive_prog;
pp_drive_prog_length = sizeof(pp1571_drive_prog);
break;
case cbm_dt_unknown:
/* FALL THROUGH */
default:
DBG_ERROR((DBG_PREFIX "unknown device type!"));
return 1;
}
bytesWritten = cbm_upload(fd, drive, 0x700, pp_drive_prog, pp_drive_prog_length);
if (bytesWritten != pp_drive_prog_length)
{
DBG_ERROR((DBG_PREFIX "wanted to write %u bytes, but only %u "
"bytes could be written", pp_drive_prog_length, bytesWritten));
return 1;
}
return 0;
}
int OH_GetInstituteDialog_HandleActivated(GWEN_DIALOG *dlg, const char *sender)
{
OH_GETINST_DIALOG *xdlg;
assert(dlg);
xdlg=GWEN_INHERIT_GETDATA(GWEN_DIALOG, OH_GETINST_DIALOG, dlg);
assert(xdlg);
DBG_ERROR(0, "Activated: %s", sender);
if (strcasecmp(sender, "listBox")==0) {
OH_INSTITUTE_SPEC *os;
os=OH_GetInstituteDialog_DetermineSelectedBankInfo(dlg);
GWEN_Dialog_SetIntProperty(dlg, "okButton", GWEN_DialogProperty_Enabled, 0, os?1:0, 0);
return GWEN_DialogEvent_ResultHandled;
}
else if (strcasecmp(sender, "nameEdit")==0) {
OH_GetInstituteDialog_UpdateList(dlg);
return GWEN_DialogEvent_ResultHandled;
}
else if (strcasecmp(sender, "okButton")==0) {
OH_INSTITUTE_SPEC *os;
os=OH_GetInstituteDialog_DetermineSelectedBankInfo(dlg);
if (os) {
const OH_INSTITUTE_DATA *od;
od=OfxHome_GetData(xdlg->ofxHome, OH_InstituteSpec_GetId(os));
if (od) {
OH_InstituteData_free(xdlg->selectedData);
xdlg->selectedData=OH_InstituteData_dup(od);
return GWEN_DialogEvent_ResultAccept;
}
else {
DBG_ERROR(AQOFXCONNECT_LOGDOMAIN, "No institute data for id=%d",
OH_InstituteSpec_GetId(os));
}
}
return GWEN_DialogEvent_ResultHandled;
}
else if (strcasecmp(sender, "abortButton")==0)
return GWEN_DialogEvent_ResultReject;
else if (strcasecmp(sender, "wiz_help_button")==0) {
/* TODO: open a help dialog */
}
return GWEN_DialogEvent_ResultNotHandled;
}
char *getHomeDir(char *buffer, unsigned int size) {
struct passwd *pw;
pw=getpwuid(getuid());
if (!pw) {
DBG_ERROR("No pwent for this user");
return 0;
}
if (size<strlen(pw->pw_dir)) {
DBG_ERROR("Buffer too small");
return 0;
}
strcpy(buffer, pw->pw_dir);
return buffer;
}
int LC_DDVCard_GetSignKeyVersion0(LC_CARD *card){
LC_DDVCARD *ddv;
LC_CLIENT_RESULT res;
GWEN_DB_NODE *dbRecord;
GWEN_BUFFER *mbuf;
int keyVer;
assert(card);
ddv=GWEN_INHERIT_GETDATA(LC_CARD, LC_DDVCARD, card);
assert(ddv);
res=LC_Card_SelectEf(card, "EF_KEYD");
if (res!=LC_Client_ResultOk) {
DBG_INFO(LC_LOGDOMAIN, "here");
return -1;
}
mbuf=GWEN_Buffer_new(0, 4, 0, 1);
res=LC_Card_IsoReadRecord(card,
LC_CARD_ISO_FLAGS_RECSEL_GIVEN,
1 /* should be 2 */,
mbuf);
if (res!=LC_Client_ResultOk) {
DBG_INFO(LC_LOGDOMAIN, "here");
GWEN_Buffer_free(mbuf);
return -1;
}
GWEN_Buffer_Rewind(mbuf);
dbRecord=GWEN_DB_Group_new("autd");
if (LC_Card_ParseRecord(card,
1 /* should be 2, but that doesn't work */,
mbuf, dbRecord)) {
DBG_ERROR(LC_LOGDOMAIN, "Error parsing record");
GWEN_DB_Group_free(dbRecord);
GWEN_Buffer_free(mbuf);
return -1;
}
GWEN_Buffer_free(mbuf);
keyVer=GWEN_DB_GetIntValue(dbRecord, "keyVersion", 0, -1);
GWEN_DB_Group_free(dbRecord);
if (keyVer==-1) {
DBG_ERROR(LC_LOGDOMAIN, "No keyVersion in record 2 of EF_KEYD");
}
return keyVer;
}
static int setColumnValueFromCombo(GWEN_DIALOG *dlg,
GWEN_DB_NODE *db,
const char *varName,
const char *comboBoxName,
const char **strings)
{
int i;
int j;
/* count number of string entries */
for (j=0; ; j+=2) {
if (strings[j]==NULL)
break;
}
j>>=1;
i=GWEN_Dialog_GetIntProperty(dlg, comboBoxName, GWEN_DialogProperty_Value, 0, -1);
if (i<0 || i>=j) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Index %d of %s out of range (%d)", i, comboBoxName, j);
return GWEN_ERROR_INVALID;
}
if (i!=0)
GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, varName, strings[i*2]);
return 0;
}
int AB_Banking_SaveUser(AB_BANKING *ab, AB_USER *u) {
GWEN_DB_NODE *db;
GWEN_DB_NODE *dbP;
int rv;
db=GWEN_DB_Group_new("user");
AB_User_toDb(u, db);
dbP=GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_DEFAULT,
"data/backend");
rv=AB_Provider_ExtendUser(AB_User_GetProvider(u), u,
AB_ProviderExtendMode_Save,
dbP);
if (rv) {
DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d)", rv);
GWEN_DB_Group_free(db);
return rv;
}
/* save group (still locked) */
rv=GWEN_ConfigMgr_SetGroup(ab->configMgr,
AB_CFG_GROUP_USERS,
AB_User_GetDbId(u),
db);
if (rv<0) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not save user group (%d)", rv);
GWEN_DB_Group_free(db);
return rv;
}
GWEN_DB_Group_free(db);
return 0;
}
/**
* et131x_device_alloc
*
* Returns pointer to the allocated and initialized net_device struct for
* this device.
*
* Create instances of net_device and wl_private for the new adapter and
* register the device's entry points in the net_device structure.
*/
struct net_device *et131x_device_alloc(void)
{
struct net_device *netdev;
DBG_ENTER(et131x_dbginfo);
/* Alloc net_device and adapter structs */
netdev = alloc_etherdev(sizeof(struct et131x_adapter));
if (netdev == NULL) {
DBG_ERROR(et131x_dbginfo,
"Alloc of net_device struct failed\n");
DBG_LEAVE(et131x_dbginfo);
return NULL;
}
/* Setup the function registration table (and other data) for a
* net_device
*/
//netdev->init = &et131x_init;
//netdev->set_config = &et131x_config;
netdev->watchdog_timeo = ET131X_TX_TIMEOUT;
netdev->netdev_ops = &et131x_netdev_ops;
//netdev->ethtool_ops = &et131x_ethtool_ops;
// Poll?
//netdev->poll = &et131x_poll;
//netdev->poll_controller = &et131x_poll_controller;
DBG_LEAVE(et131x_dbginfo);
return netdev;
}
int LC_DDVCard_GetKeyVersion1(LC_CARD *card, int keyNumber){
LC_DDVCARD *ddv;
GWEN_DB_NODE *dbReq;
GWEN_DB_NODE *dbResp;
LC_CLIENT_RESULT res;
int keyVersion;
assert(card);
ddv=GWEN_INHERIT_GETDATA(LC_CARD, LC_DDVCARD, card);
assert(ddv);
dbReq=GWEN_DB_Group_new("GetKeyInfo");
dbResp=GWEN_DB_Group_new("response");
GWEN_DB_SetIntValue(dbReq, GWEN_DB_FLAGS_DEFAULT,
"keyNumber", keyNumber);
res=LC_Card_ExecCommand(card, "GetKeyInfo", dbReq, dbResp);
if (res!=LC_Client_ResultOk) {
GWEN_DB_Group_free(dbReq);
GWEN_DB_Group_free(dbResp);
return -1;
}
keyVersion=GWEN_DB_GetIntValue(dbResp,
"response/keyVersion", 0, -1);
if (keyVersion==-1) {
DBG_ERROR(LC_LOGDOMAIN, "No keyversion returned by command");
}
GWEN_DB_Group_free(dbReq);
GWEN_DB_Group_free(dbResp);
return keyVersion;
}
int AH_Msg_DecryptRdh(AH_MSG *hmsg, GWEN_DB_NODE *gr){
AB_USER *u;
int rv;
assert(hmsg);
u=AH_Dialog_GetDialogOwner(hmsg->dialog);
switch(AH_User_GetRdhType(u)) {
case 0:
case 1:
rv=AH_Msg_DecryptRdh1(hmsg, gr);
break;
case 2:
rv=AH_Msg_DecryptRdh2(hmsg, gr);
break;
case 3:
rv=AH_Msg_DecryptRdh3(hmsg, gr);
break;
case 5:
rv=AH_Msg_DecryptRdh5(hmsg, gr);
break;
case 9:
rv=AH_Msg_DecryptRdh9(hmsg, gr);
break;
case 10:
rv=AH_Msg_DecryptRdh10(hmsg, gr);
break;
default:
DBG_ERROR(AQHBCI_LOGDOMAIN, "RDH %d not supported", AH_User_GetRdhType(u));
rv=GWEN_ERROR_INVALID;
}
return rv;
}
/*******************************************************************************
* wl_adapter_attach()
*******************************************************************************
*
* DESCRIPTION:
*
* Creates an instance of the driver, allocating local data structures for
* one device. The device is registered with Card Services.
*
* PARAMETERS:
*
* none
*
* RETURNS:
*
* pointer to an allocated dev_link_t structure
* NULL on failure
*
******************************************************************************/
static int wl_adapter_attach(struct pcmcia_device *link)
{
struct net_device *dev;
struct wl_private *lp;
/*--------------------------------------------------------------------*/
DBG_FUNC("wl_adapter_attach");
DBG_ENTER(DbgInfo);
dev = wl_device_alloc();
if (dev == NULL) {
DBG_ERROR(DbgInfo, "wl_device_alloc returned NULL\n");
return -ENOMEM;
}
link->resource[0]->end = HCF_NUM_IO_PORTS;
link->resource[0]->flags= IO_DATA_PATH_WIDTH_16;
link->config_flags |= CONF_ENABLE_IRQ;
link->config_index = 5;
link->config_regs = PRESENT_OPTION;
link->priv = dev;
lp = wl_priv(dev);
lp->link = link;
wl_adapter_insert(link);
DBG_LEAVE(DbgInfo);
return 0;
} /* wl_adapter_attach */
GWEN_DATE *GWEN_Date_GetThisMonthEnd(const GWEN_DATE *dt) {
int day;
switch(GWEN_Date_GetMonth(dt)) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
day=31;
break;
case 2:
if (GWEN_Date_IsLeapYear(GWEN_Date_GetYear(dt)))
day=29;
else
day=28;
break;
case 4:
case 6:
case 9:
case 11:
day=30;
break;
default:
DBG_ERROR(GWEN_LOGDOMAIN, "Invalid month (%d)", GWEN_Date_GetMonth(dt));
abort();
break;
}
return GWEN_Date_fromGregorian(GWEN_Date_GetYear(dt), GWEN_Date_GetMonth(dt), day);
}
static int wl_adapter_attach(struct pcmcia_device *link)
{
struct net_device *dev;
struct wl_private *lp;
/*------------------------------------------------------------------------*/
DBG_FUNC( "wl_adapter_attach" );
DBG_ENTER( DbgInfo );
dev = wl_device_alloc();
if(dev == NULL) {
DBG_ERROR( DbgInfo, "wl_device_alloc returned NULL\n");
return -ENOMEM;
}
link->io.NumPorts1 = HCF_NUM_IO_PORTS;
link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
link->io.IOAddrLines = 6;
link->conf.Attributes = CONF_ENABLE_IRQ;
link->conf.IntType = INT_MEMORY_AND_IO;
link->conf.ConfigIndex = 5;
link->conf.Present = PRESENT_OPTION;
link->priv = dev;
lp = wl_priv(dev);
lp->link = link;
wl_adapter_insert(link);
DBG_LEAVE( DbgInfo );
return 0;
} // wl_adapter_attach
/* --------------------------------------------------------------- FUNCTION */
int AH_Job_SepaStandingOrdersGet_Exchange(AH_JOB *j, AB_JOB *bj,
AH_JOB_EXCHANGE_MODE m,
AB_IMEXPORTER_CONTEXT *ctx){
DBG_INFO(AQHBCI_LOGDOMAIN, "Exchanging (%d)", m);
assert(j);
if (AB_Job_GetType(bj)!=AB_Job_TypeSepaGetStandingOrders) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Not a GetStandingOrders job");
return GWEN_ERROR_INVALID;
}
switch(m) {
case AH_Job_ExchangeModeParams:
return 0;
case AH_Job_ExchangeModeArgs:
return 0;
case AH_Job_ExchangeModeResults:
return 0;
default:
DBG_NOTICE(AQHBCI_LOGDOMAIN, "Unsupported exchange mode");
return GWEN_ERROR_NOT_SUPPORTED;
} /* switch */
}
xmlNodeSetPtr EB_Xml_GetNodes(EB_MSG *m, const char *xpathExpr) {
xmlNodeSetPtr nodes;
xmlXPathObjectPtr xpathObj;
assert(m);
assert(m->usage);
xpathObj=xmlXPathEvalExpression(BAD_CAST xpathExpr, m->xpathCtx);
if(xpathObj == NULL) {
DBG_ERROR(AQEBICS_LOGDOMAIN,
"Unable to evaluate xpath expression \"%s\"",
xpathExpr);
return 0;
}
nodes=xpathObj->nodesetval;
if (!nodes) {
DBG_INFO(AQEBICS_LOGDOMAIN, "No matching nodes");
xmlXPathFreeObject(xpathObj);
return 0;
}
xpathObj->nodesetval=NULL;
xmlXPathFreeObject(xpathObj);
return nodes;
}
static void find_music_packs(void) {
char *cur_dir = getcwd(NULL, 0);
if (!cur_dir)
DBG_ERROR("Could not determine current directory");
HANDLE hFind;
WIN32_FIND_DATA ffd;
hFind = FindFirstFile("music\\*", &ffd);
if (hFind == INVALID_HANDLE_VALUE)
return;
do {
if ((ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && ffd.cFileName[0] != '.') {
char *dirname = malloc(strlen(cur_dir) + 7 + strlen(ffd.cFileName) + 1);
strcpy(dirname, cur_dir);
strcat(dirname, "\\music\\");
strcat(dirname, ffd.cFileName);
add_music_pack(dirname);
free(dirname);
}
} while (FindNextFile(hFind, &ffd) != 0);
FindClose(hFind);
free(cur_dir);
}
unsigned char* L2capGetSendBuffer (void)
{
if(l2capSendBufferCheckedOut == TRUE_)
{DBG_ERROR("buff error!\n");}
l2capSendBufferCheckedOut = TRUE_;
return HciGetAclBuffer() + L2CAP_HEADER_LEN; // Leave room for L2CAP header - added later
}
int AHB_DTAUS__AddDtaWord(GWEN_BUFFER *dst,
unsigned int size,
const char *s) {
unsigned int i;
unsigned int ssize;
assert(dst);
assert(size);
assert(s);
DBG_DEBUG(AQBANKING_LOGDOMAIN, "Adding DTA word: %s", s);
ssize=strlen(s);
if (ssize>size) {
/* Error out here because e.g. truncated accountid will lead to failed jobs. */
DBG_ERROR(AQBANKING_LOGDOMAIN, "Word \"%s\" too long: Has length %d but must not be longer than %d characters",
s, ssize, size);
return -1;
}
for (i=0; i<size; i++) {
char c;
if (i>=ssize)
c=0;
else
c=s[i];
if (c)
GWEN_Buffer_AppendByte(dst, c);
else
GWEN_Buffer_AppendByte(dst, ' ');
} /* for */
return 0;
}
int AHB_DTAUS__AddNum(GWEN_BUFFER *dst,
unsigned int size,
const char *s) {
unsigned int i, j;
assert(dst);
assert(s);
DBG_DEBUG(AQBANKING_LOGDOMAIN, "Adding num : %s", s);
i=strlen(s);
if (i>size) {
/* Error out here because e.g. truncated BLZ will lead to failed jobs. */
DBG_ERROR(AQBANKING_LOGDOMAIN, "Number \"%s\" too long: Has length %d but must not be longer than %d characters",
s, i, size);
return -1;
}
j=size-i;
if (j) {
unsigned int k;
for (k=0; k<j; k++)
GWEN_Buffer_AppendByte(dst, '0');
}
GWEN_Buffer_AppendString(dst, s);
return 0;
}
int AO_NewUserDialog_HandleActivated(GWEN_DIALOG *dlg, const char *sender)
{
DBG_ERROR(0, "Activated: %s", sender);
if (strcasecmp(sender, "wiz_prev_button")==0)
return AO_NewUserDialog_Previous(dlg);
else if (strcasecmp(sender, "wiz_next_button")==0)
return AO_NewUserDialog_Next(dlg);
else if (strcasecmp(sender, "wiz_abort_button")==0) {
AO_NewUserDialog_UndoIt(dlg);
return GWEN_DialogEvent_ResultReject;
}
else if (strcasecmp(sender, "wiz_bank_button")==0)
return AO_NewUserDialog_HandleActivatedBankSelect(dlg);
else if (strcasecmp(sender, "wiz_app_combo")==0)
return AO_NewUserDialog_HandleActivatedApp(dlg);
else if (strcasecmp(sender, "wiz_special_button")==0)
return AO_NewUserDialog_HandleActivatedSpecial(dlg);
else if (strcasecmp(sender, "wiz_getaccounts_button")==0)
return AO_NewUserDialog_HandleActivatedGetAccounts(dlg);
else if (strcasecmp(sender, "wiz_help_button")==0) {
/* TODO: open a help dialog */
}
return GWEN_DialogEvent_ResultNotHandled;
}
int CMpeg2DecoderDXVA2::FindRenderTarget(const GUID &guid, const D3DFORMAT *pFormatList, int FormatCount)
{
if (!m_pDecoderService)
return -1;
UINT Count;
D3DFORMAT *pFormats;
HRESULT hr = m_pDecoderService->GetDecoderRenderTargets(guid, &Count, &pFormats);
if (FAILED(hr)) {
DBG_ERROR(TEXT("GetDecoderRenderTargets() failed (%x)"), hr);
return -1;
}
int Found = -1;
for (UINT i = 0; i < Count && Found < 0; i++) {
for (int j = 0; j < FormatCount; j++) {
if (pFormats[i] == pFormatList[j]) {
Found = j;
break;
}
}
}
::CoTaskMemFree(pFormats);
return Found;
}
/* --------------------------------------------------------------- FUNCTION */
int AH_Job_GetBalance_Exchange(AH_JOB *j, AB_JOB *bj,
AH_JOB_EXCHANGE_MODE m,
AB_IMEXPORTER_CONTEXT *ctx){
AH_JOB_GETBALANCE *aj;
DBG_INFO(AQHBCI_LOGDOMAIN, "Exchanging (%d)", m);
assert(j);
aj=GWEN_INHERIT_GETDATA(AH_JOB, AH_JOB_GETBALANCE, j);
assert(aj);
if (AB_Job_GetType(bj)!=AB_Job_TypeGetBalance) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Not a GetBalance job");
return GWEN_ERROR_INVALID;
}
switch(m) {
case AH_Job_ExchangeModeParams:
DBG_NOTICE(AQHBCI_LOGDOMAIN, "No params to exchange");
return 0;
case AH_Job_ExchangeModeArgs:
DBG_NOTICE(AQHBCI_LOGDOMAIN, "No arguments to exchange");
return 0;
case AH_Job_ExchangeModeResults:
return 0;
default:
DBG_NOTICE(AQHBCI_LOGDOMAIN, "Unsupported exchange mode");
return GWEN_ERROR_NOT_SUPPORTED;
} /* switch */
}
CTSERVICEREQUEST *CTService_Request_Create(int serviceid,
int msgCode,
int msgVersion,
int msgId,
int msgReply,
int msgSize) {
CTSERVICEREQUEST *req;
DBG_ENTER;
req=CTService_Request_new();
req->requestId=msgId;
req->serviceId=serviceid;
req->message=CTService_Message_Create(msgCode,
msgVersion,
msgId,
msgReply,
msgSize);
if (!req->message) {
DBG_ERROR("Could not create message");
CTService_Request_free(req);
return 0;
}
DBG_LEAVE;
return req;
}
void GWEN_MemCacheEntry_EndUse(GWEN_MEMCACHE_ENTRY *me) {
int rv;
assert(me);
rv=GWEN_MemCache_Lock(me->memCache);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
assert(0);
}
if (me->useCounter>0) {
me->useCounter--;
if (me->useCounter==0) {
if (!(me->isValid)) {
GWEN_MemCacheEntry_free(me);
}
else
me->unusedSince=time(0);
}
}
else {
DBG_ERROR(GWEN_LOGDOMAIN, "Use counter < 1, aborting");
GWEN_MemCache_Unlock(me->memCache);
assert(me->useCounter>0);
}
GWEN_MemCache_Unlock(me->memCache);
}
int addChildGuiWidget(GWEN_WIDGET *wChild) {
QTabWidget *qw;
QWidget *qChild;
const char *s;
QString text;
qw=(QTabWidget*) GWEN_Widget_GetImplData(_widget, QT4_DIALOG_WIDGET_REAL);
assert(qw);
if (GWEN_Widget_GetType(wChild)!=GWEN_Widget_TypeTabPage) {
DBG_ERROR(GWEN_LOGDOMAIN, "You can only add TabPages to a TabBook");
return GWEN_ERROR_INVALID;
}
qChild=getQWidget(wChild);
assert(qChild);
s=GWEN_Widget_GetText(wChild, 0);
if (s)
text=QString::fromUtf8(s);
qw->addTab(qChild, text);
return 0;
}
int AB_Banking_EndExclUseAccount(AB_BANKING *ab,
AB_ACCOUNT *a,
int abandon) {
int rv;
if (!abandon) {
GWEN_DB_NODE *db=GWEN_DB_Group_new("account");
GWEN_DB_NODE *dbP;
AB_Account_toDb(a, db);
dbP=GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_DEFAULT, "data/backend");
rv=AB_Provider_ExtendAccount(AB_Account_GetProvider(a), a,
AB_ProviderExtendMode_Save,
dbP);
if (rv) {
DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d)", rv);
GWEN_DB_Group_free(db);
return rv;
}
/* save group (still locked) */
rv=GWEN_ConfigMgr_SetGroup(ab->configMgr,
AB_CFG_GROUP_ACCOUNTS,
AB_Account_GetDbId(a),
db);
if (rv<0) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not save account group (%d)", rv);
GWEN_ConfigMgr_UnlockGroup(ab->configMgr,
AB_CFG_GROUP_ACCOUNTS,
AB_Account_GetDbId(a));
GWEN_DB_Group_free(db);
return rv;
}
GWEN_DB_Group_free(db);
}
/* unlock group */
rv=GWEN_ConfigMgr_UnlockGroup(ab->configMgr,
AB_CFG_GROUP_ACCOUNTS,
AB_Account_GetDbId(a));
if (rv<0) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not unlock account group (%d)", rv);
return rv;
}
return 0;
}
int AB_Banking_DeleteUser(AB_BANKING *ab, AB_USER *u) {
int rv;
AB_ACCOUNT *acc_rv;
const char *groupName;
assert(ab);
assert(u);
acc_rv=AB_Banking_FindFirstAccountOfUser(ab, u);
if (acc_rv) {
DBG_ERROR(AQBANKING_LOGDOMAIN,
"Error on removing user: Still belongs to an account (bankcode %s, accountnumber %s). Delete the account first.",
AB_Account_GetBankCode(acc_rv),
AB_Account_GetAccountNumber(acc_rv));
return GWEN_ERROR_INVALID;
}
rv=AB_User_List_Del(u);
if (rv) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error on removing user from list (%d)", rv);
return rv;
}
rv=AB_Provider_ExtendUser(AB_User_GetProvider(u), u,
AB_ProviderExtendMode_Remove,
NULL);
if (rv) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Error on remove extension of user (%d)", rv);
return rv;
}
groupName=AB_User_GetDbId(u);
if (groupName) {
rv=GWEN_ConfigMgr_DeleteGroup(ab->configMgr,
AB_CFG_GROUP_USERS,
groupName);
if (rv<0) {
DBG_ERROR(AQBANKING_LOGDOMAIN,
"Unable to delete user config [%08x] (%d)",
AB_User_GetUniqueId(u), rv);
return rv;
}
}
AB_User_free(u);
return 0;
}
char *makeAbsolutePath(const char *path, char *buffer, int size) {
/* try to chdir to that directory */
if (chdir(path)) {
DBG_ERROR("Error on chdir(%s): %s",
path,
strerror(errno));
return 0;
}
/* get the absolute path */
if (getcwd(buffer, size)==0) {
DBG_ERROR("Error on getcwd(): %s", strerror(errno));
return 0;
}
return buffer;
}
int AH_Msg_SignRdh(AH_MSG *hmsg,
GWEN_BUFFER *rawBuf,
const char *signer) {
AB_USER *su;
int rv;
assert(hmsg);
su=AB_Banking_FindUser(AH_HBCI_GetBankingApi(AH_Dialog_GetHbci(hmsg->dialog)),
AH_PROVIDER_NAME,
"de", "*",
signer, "*");
if (!su) {
DBG_ERROR(AQHBCI_LOGDOMAIN,
"Unknown user \"%s\"",
signer);
return GWEN_ERROR_NOT_FOUND;
}
switch(AH_User_GetRdhType(su)) {
case 0:
case 1:
rv=AH_Msg_SignRdh1(hmsg, su, rawBuf, signer);
break;
case 2:
rv=AH_Msg_SignRdh2(hmsg, su, rawBuf, signer);
break;
case 3:
rv=AH_Msg_SignRdh3(hmsg, su, rawBuf, signer);
break;
case 5:
rv=AH_Msg_SignRdh5(hmsg, su, rawBuf, signer);
break;
case 9:
rv=AH_Msg_SignRdh9(hmsg, su, rawBuf, signer);
break;
case 10:
rv=AH_Msg_SignRdh10(hmsg, su, rawBuf, signer);
break;
default:
DBG_ERROR(AQHBCI_LOGDOMAIN, "RDH %d not supported", AH_User_GetRdhType(su));
rv=GWEN_ERROR_INVALID;
}
return rv;
}
