自学教程：C++ DBG_ERROR函数代码示例

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 intupload(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;}

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;}