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

static inline int ssl_write_wrapper(irc_session_t *session, irc_dcc_session_t *dcc, void *buf, int num, int *sslError) {#ifdef ENABLE_SSL    int length;        *sslError = SSL_ERROR_NONE;    length = SSL_write(dcc->ssl_ctx, buf, num);    if (unlikely(length == -1)) {        int ssl_err = SSL_get_error(dcc->ssl_ctx, length);        *sslError = ssl_err;        if (ssl_err == SSL_ERROR_WANT_READ) {            DBG_WARN("SSL_ERROR_WANT_READ on ssl_write_wrapper!");        }        else if (ssl_err == SSL_ERROR_WANT_WRITE) {            DBG_WARN("SSL_ERROR_WANT_WRITE on ssl_write_wrapper!");        }        else {            DBG_ERR("fatal ssl-error on ssl_write_wrapper was %s", ERR_error_string(ssl_err, NULL));        }    }    return length;#else    return -1;#endif}

GWEN_MEMCACHE_ENTRY *GWEN_MemCache_CreateEntry(GWEN_MEMCACHE *mc,                                               uint32_t id,                                               void *dataPtr,                                               size_t dataLen){  GWEN_MEMCACHE_ENTRY *me;  assert(mc);  GWEN_MemCache_Lock(mc);  /* invalidate possibly existing entry in any case */  me=GWEN_MemCacheEntry_IdMap_Find(mc->idMap, id);  if (me) {    me->isValid=0;    GWEN_MemCacheEntry_IdMap_Remove(mc->idMap, id);    if (me->useCounter==0)      GWEN_MemCacheEntry_free(me);  }  /* check for limits: entry count */  if (mc->currentCacheEntries>=mc->maxCacheEntries) {    int rv;    /* release unused entries (at least 1 byte) */    rv=GWEN_MemCache__MakeRoom(mc, 1);    if (rv) {      DBG_WARN(GWEN_LOGDOMAIN, "Too many entries in use");      GWEN_MemCache_Unlock(mc);      return NULL;    }  }  /* check for limits: memory in use */  if ((mc->currentCacheMemory+dataLen)>=mc->maxCacheMemory) {    size_t diff;    int rv;    diff=(mc->currentCacheMemory+dataLen)-mc->maxCacheMemory;    /* release unused entries */    rv=GWEN_MemCache__MakeRoom(mc, diff);    if (rv) {      DBG_WARN(GWEN_LOGDOMAIN, "Too much memory in use");      GWEN_MemCache_Unlock(mc);      return NULL;    }  }  /* create new entry */  me=GWEN_MemCacheEntry_new(mc, id, dataPtr, dataLen);  assert(me);  me->useCounter++;  GWEN_MemCacheEntry_IdMap_Insert(mc->idMap, id, me);  GWEN_MemCache_Unlock(mc);  return me;}

static void send_current_file_offset_to_sender (irc_session_t *session, irc_dcc_session_t *dcc) {    int sentBytes, err = 0;    // we convert out irc_dcc_size_t to uint32_t, because it's defined like that in dcc...    uint32_t confirmSizeNetworkOrder = htobe32(dcc->file_confirm_offset);    size_t offset = sizeof(confirmSizeNetworkOrder);#ifdef ENABLE_SSL    if (dcc->ssl == 0)        sentBytes = socket_send(&dcc->sock, &confirmSizeNetworkOrder, offset);    else {        int sslError = 0;        sentBytes = ssl_write_wrapper(session, dcc, &confirmSizeNetworkOrder, offset, &sslError);        if (sslError == SSL_ERROR_WANT_READ) {            dcc->state = LIBIRC_STATE_CONNECTED;            return;        }        else if (sslError == SSL_ERROR_WANT_WRITE) {            return;        }    }#else    sentBytes = socket_send(&dcc->sock, &confirmSizeNetworkOrder, offset);#endif    if (unlikely(sentBytes < 0)) {        DBG_WARN("err send length < 0");        DBG_WARN("error msg: %s/n", strerror(errno));        err = LIBIRC_ERR_WRITE;    } else if (unlikely(sentBytes == 0)) {        err = LIBIRC_ERR_CLOSED;    } else {        if (unlikely(dcc->received_file_size == dcc->file_confirm_offset)) {            DBG_OK("dcc->received_file_size == dcc->file_confirm_offset");            libirc_mutex_unlock(&session->mutex_dcc);            (*dcc->cb)(session, dcc->id, 0, dcc->ctx, 0, 0);			libirc_mutex_lock(&session->mutex_dcc);            libirc_dcc_destroy_nolock(session, dcc->id);        } else {            /* Continue to receive the file */            dcc->state = LIBIRC_STATE_CONNECTED;        }    }    /*     * If error arises somewhere above, we inform the caller      * of failure, and destroy this session.     */    if (unlikely(err)) {        libirc_mutex_unlock(&session->mutex_dcc);        (*dcc->cb)(session, dcc->id, err, dcc->ctx, 0, 0);        libirc_mutex_lock(&session->mutex_dcc);        //libirc_dcc_destroy_nolock (ircsession, dcc->id);    }}

int AB_ImExporter_ImportFile(AB_IMEXPORTER *ie,                             AB_IMEXPORTER_CONTEXT *ctx,                             const char *fname,			     GWEN_DB_NODE *dbProfile){  GWEN_SYNCIO *sio;  int rv;  assert(ie);  assert(ctx);  assert(fname);  assert(dbProfile);  if (fname) {    sio=GWEN_SyncIo_File_new(fname, GWEN_SyncIo_File_CreationMode_OpenExisting);    GWEN_SyncIo_AddFlags(sio, GWEN_SYNCIO_FILE_FLAGS_READ);    rv=GWEN_SyncIo_Connect(sio);    if (rv<0) {      DBG_WARN(AQBANKING_LOGDOMAIN, "Failed to Connect() syncio (%d)", rv);      GWEN_SyncIo_free(sio);      return rv;    }  }  else {    sio=GWEN_SyncIo_File_fromStdin();    GWEN_SyncIo_AddFlags(sio, GWEN_SYNCIO_FLAGS_DONTCLOSE);  }  rv=AB_ImExporter_Import(ie, ctx, sio, dbProfile);  GWEN_SyncIo_Disconnect(sio);  GWEN_SyncIo_free(sio);  return rv;}

static GWENHYWFAR_CBint Gtk3Gui_WGroupBox_SetCharProperty(GWEN_WIDGET *w,                                      GWEN_DIALOG_PROPERTY prop,                                      int index,                                      const char *value,                                      int doSignal){  GtkWidget *g;  g=GTK_WIDGET(GWEN_Widget_GetImplData(w, GTK3_DIALOG_WIDGET_REAL));  assert(g);  switch (prop) {  case GWEN_DialogProperty_Title:    gtk_frame_set_label(GTK_FRAME(g), value);    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)));  return GWEN_ERROR_INVALID;}

net_http_handle *net_http_open(char *host, char *request) {	struct net_http_handle *h = malloc(sizeof(struct net_http_handle));	h->socket = net_connect(host, 80);	if (!h->socket) {		free(h);		return NULL;	}	int len = snprintf(h->buf, BUF_SIZE,	  "GET %s HTTP/1.1/r/n"	  "Host: %s/r/n"	  "Accept-Encoding:/r/n"	  "Connection: close/r/n/r/n",	  request, host);	if (len >= BUF_SIZE || net_write(h->socket, h->buf, len) < len) {		DBG_WARN("failed to send /"%s/" to %s", request, host);		net_close(h->socket);		free(h);		return NULL;	}	h->data = NULL;	h->len = 0;	h->complete = 0;	memset(&h->settings, 0, sizeof(http_parser_settings));	h->settings.on_body = on_body_cb;	h->settings.on_message_complete = on_message_complete_cb;	h->parser = malloc(sizeof(http_parser));	h->parser->data = h;	http_parser_init(h->parser, HTTP_RESPONSE);	return h;}

static void libirc_dcc_process_descriptors(irc_session_t * ircsession) {    irc_dcc_session_t * dcc;    /*     * We need to use such a complex scheme here, because on every callback     * a number of DCC sessions could be destroyed.     */    libirc_mutex_lock(&ircsession->mutex_dcc);    for (dcc = ircsession->dcc_sessions; dcc; dcc = dcc->next) {        switch (dcc->state) {            case LIBIRC_STATE_CONNECTING:                //printf("LIBIRC_STATE_CONNECTING/n");                handleConnectingState(ircsession, dcc);            break;            case LIBIRC_STATE_CONNECTED:                //printf("LIBIRC_STATE_CONNECTED/n");                handleConnectedState(ircsession, dcc);            break;            case LIBIRC_STATE_CONFIRM_SIZE:                //printf("LIBIRC_STATE_CONFIRM_SIZE/n");                handleConfirmSizeState(ircsession, dcc);            break;            case LIBIRC_STATE_WAITING_FOR_RESUME_ACK:            break;            default:                DBG_WARN("unknown state %d at libirc_dcc_process_descriptors!", dcc->state);            break;        }    }    libirc_mutex_unlock(&ircsession->mutex_dcc);}

uint32_t LC_DriverFlags_fromDb(GWEN_DB_NODE *db, const char *name) {  const char *p;  int i;  uint32_t flags=0;  for (i=0; ; i++) {    p=GWEN_DB_GetCharValue(db, name, i, 0);    if (!p)      break;    if (strcasecmp(p, "auto")==0)      flags|=LC_DRIVER_FLAGS_AUTO;    else if (strcasecmp(p, "remote")==0)      flags|=LC_DRIVER_FLAGS_REMOTE;    else if (strcasecmp(p, "has_verify_fn")==0)      flags|=LC_DRIVER_FLAGS_HAS_VERIFY_FN;    else if (strcasecmp(p, "has_modify_fn")==0)      flags|=LC_DRIVER_FLAGS_HAS_MODIFY_FN;    else if (strcasecmp(p, "config")==0)      flags|=LC_DRIVER_FLAGS_CONFIG;    else {      DBG_WARN(0, "Unknown driver flag /"%s/"", p);    }  }  return flags;}

int AIO_OfxGroup_BUYMF_StartTag(AIO_OFX_GROUP *g,				 const char *tagName) {  AIO_OFX_GROUP_BUYMF *xg;  GWEN_XML_CONTEXT *ctx;  AIO_OFX_GROUP *gNew=NULL;  assert(g);  xg=GWEN_INHERIT_GETDATA(AIO_OFX_GROUP, AIO_OFX_GROUP_BUYMF, g);  assert(xg);  ctx=AIO_OfxGroup_GetXmlContext(g);  if (strcasecmp(tagName, "BUYTYPE")==0 ||      strcasecmp(tagName, "SELLTYPE")==0) {        /* TODO */  }  else if (strcasecmp(tagName, "INVBUY")==0 ||           strcasecmp(tagName, "INVSELL")==0) {    gNew=AIO_OfxGroup_INVBUY_new(tagName, g, ctx);      }  else {    DBG_WARN(AQBANKING_LOGDOMAIN,	     "Ignoring tag [%s]", tagName);    free(xg->currentElement);    xg->currentElement=strdup(tagName);  }  if (gNew) {    AIO_OfxXmlCtx_SetCurrentGroup(ctx, gNew);    GWEN_XmlCtx_IncDepth(ctx);  }  return 0;}

/* --------------------------------------------------------------- FUNCTION */int AH_Job_SepaStandingOrdersGet_Process(AH_JOB *j, AB_IMEXPORTER_CONTEXT *ctx){  GWEN_DB_NODE *dbResponses;  GWEN_DB_NODE *dbCurr;  const char *responseName;  int rv;  DBG_INFO(AQHBCI_LOGDOMAIN, "Processing JobSepaStandingOrdersGet");  assert(j);  responseName=AH_Job_GetResponseName(j);  dbResponses=AH_Job_GetResponses(j);  assert(dbResponses);  /* search for "Transactions" */  dbCurr=GWEN_DB_GetFirstGroup(dbResponses);  while(dbCurr) {    rv=AH_Job_CheckEncryption(j, dbCurr);    if (rv) {      DBG_INFO(AQHBCI_LOGDOMAIN, "Compromised security (encryption)");      AH_Job_SetStatus(j, AH_JobStatusError);      return rv;    }    rv=AH_Job_CheckSignature(j, dbCurr);    if (rv) {      DBG_INFO(AQHBCI_LOGDOMAIN, "Compromised security (signature)");      AH_Job_SetStatus(j, AH_JobStatusError);      return rv;    }    if (responseName && *responseName) {      GWEN_DB_NODE *dbXA;      dbXA=GWEN_DB_GetGroup(dbCurr, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "data");      if (dbXA)        dbXA=GWEN_DB_GetGroup(dbXA, GWEN_PATH_FLAGS_NAMEMUSTEXIST, responseName);      if (dbXA) {	const void *p;	unsigned int bs;	const char *fiId;	fiId=GWEN_DB_GetCharValue(dbXA, "fiId", 0, NULL);	p=GWEN_DB_GetBinValue(dbXA, "transfer", 0, 0, 0, &bs);	if (p && bs) {	  rv=AH_Job_SepaStandingOrdersGet__ReadSto(j, ctx, p, bs, fiId);	  if (rv<0) {	    DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);	    DBG_WARN(AQHBCI_LOGDOMAIN, "Error reading standing order from data, ignoring (%d)", rv);	  }	}      }    }    dbCurr=GWEN_DB_GetNextGroup(dbCurr);  }  return 0;}

static GWENHYWFAR_CBint Gtk3Gui_WStack_GetIntProperty(GWEN_WIDGET *w,                                  GWEN_DIALOG_PROPERTY prop,                                  int index,                                  int defaultValue) {  GtkWidget *g;  g=GTK_WIDGET(GWEN_Widget_GetImplData(w, GTK3_DIALOG_WIDGET_REAL));  assert(g);  switch(prop) {  case GWEN_DialogProperty_Enabled:    return (gtk_widget_get_sensitive(GTK_WIDGET(g))==TRUE)?1:0;  case GWEN_DialogProperty_Focus:    return (gtk_widget_has_focus(GTK_WIDGET(g))==TRUE)?1:0;    return 0;  case GWEN_DialogProperty_Value:    return gtk_notebook_get_current_page(GTK_NOTEBOOK(g));  default:    break;  }  DBG_WARN(GWEN_LOGDOMAIN,           "Function is not appropriate for this type of widget (%s)",           GWEN_Widget_Type_toString(GWEN_Widget_GetType(w)));  return defaultValue;}

int AIO_OfxGroup_STATUS_StartTag(AIO_OFX_GROUP *g,                                 const char *tagName){  AIO_OFX_GROUP_STATUS *xg;  //GWEN_XML_CONTEXT *ctx;  assert(g);  xg=GWEN_INHERIT_GETDATA(AIO_OFX_GROUP, AIO_OFX_GROUP_STATUS, g);  assert(xg);  //ctx=AIO_OfxGroup_GetXmlContext(g);  free(xg->currentElement);  xg->currentElement=NULL;  if (strcasecmp(tagName, "CODE")==0) {    xg->currentElement=strdup(tagName);  }  else if (strcasecmp(tagName, "SEVERITY")==0) {    xg->currentElement=strdup(tagName);  }  else if (strcasecmp(tagName, "MESSAGE")==0) {    xg->currentElement=strdup(tagName);  }  else {    DBG_WARN(AQBANKING_LOGDOMAIN,             "Ignoring tag [%s]", tagName);  }  return 0;}

static GWENHYWFAR_CBint Gtk2Gui_WTextEdit_SetIntProperty(GWEN_WIDGET *w,                                     GWEN_DIALOG_PROPERTY prop,                                     int index,                                     int value,                                     int doSignal){  GtkWidget *g;  g=GTK_WIDGET(GWEN_Widget_GetImplData(w, GTK2_DIALOG_WIDGET_REAL));  assert(g);  switch (prop) {  case GWEN_DialogProperty_Enabled:    gtk_widget_set_sensitive(GTK_WIDGET(g), (value==0)?FALSE:TRUE);    return 0;  case GWEN_DialogProperty_Focus:    gtk_widget_grab_focus(GTK_WIDGET(g));    return 0;  case GWEN_DialogProperty_Width:  case GWEN_DialogProperty_Height:    /* just ignore these for now */    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)));  return GWEN_ERROR_INVALID;}

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

int AIO_OfxGroup_Document_StartTag(AIO_OFX_GROUP *g, const char *tagName) {  AIO_OFX_GROUP *gNew=NULL;  GWEN_XML_CONTEXT *ctx;  assert(g);  ctx=AIO_OfxGroup_GetXmlContext(g);  if (strcasecmp(tagName, "OFX")==0)    gNew=AIO_OfxGroup_OFX_new(tagName, g, ctx);  else if (strcasecmp(tagName, "OFC")==0) {    gNew=AIO_OfxGroup_OFX_new(tagName, g, ctx);  }  else {    DBG_WARN(AQBANKING_LOGDOMAIN,	     "Ignoring group [%s]", tagName);    gNew=AIO_OfxGroup_Ignore_new(tagName, g, ctx);  }  if (gNew) {    AIO_OfxXmlCtx_SetCurrentGroup(ctx, gNew);    GWEN_XmlCtx_IncDepth(ctx);  }  return 0;}

static GWENHYWFAR_CBint Gtk3Gui_WLineEdit_GetIntProperty(GWEN_WIDGET *w,                                     GWEN_DIALOG_PROPERTY prop,                                     int index,                                     int defaultValue) {  GtkWidget *g;  g=GTK_WIDGET(GWEN_Widget_GetImplData(w, GTK3_DIALOG_WIDGET_REAL));  assert(g);  switch(prop) {  case GWEN_DialogProperty_Enabled:    return (gtk_widget_get_sensitive(GTK_WIDGET(g))==TRUE)?1:0;  case GWEN_DialogProperty_Focus:    return (gtk_widget_has_focus(GTK_WIDGET(g))==TRUE)?1:0;    return 0;  case GWEN_DialogProperty_Width:  case GWEN_DialogProperty_Height:    /* just ignore these for now */    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)));  return defaultValue;}

  int setCharProperty(GWEN_DIALOG_PROPERTY prop,                      int index,                      const char *value,                      int doSignal) {    QTextEdit *qw;    QString text;    qw=(QTextEdit*) GWEN_Widget_GetImplData(_widget, QT4_DIALOG_WIDGET_REAL);    assert(qw);    if (value)      text=QString::fromUtf8(value);    switch(prop) {    case GWEN_DialogProperty_Value:      qw->setText(text);      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(_widget)));    return GWEN_ERROR_INVALID;  };

static GWENHYWFAR_CBint Gtk3Gui_WLineEdit_SetCharProperty(GWEN_WIDGET *w,                                      GWEN_DIALOG_PROPERTY prop,                                      int index,                                      const char *value,                                      int doSignal) {  GtkWidget *g;  g=GTK_WIDGET(GWEN_Widget_GetImplData(w, GTK3_DIALOG_WIDGET_REAL));  assert(g);  switch(prop) {  case GWEN_DialogProperty_Value:    if (value && *value)        gtk_entry_set_text(GTK_ENTRY(g), value);    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)));  return GWEN_ERROR_INVALID;}

int AB_Banking_UnloadConfig(AB_BANKING *ab) {  AB_PROVIDER *pro;  int rv;  assert(ab);  /* clear all active crypt token */  AB_Banking_ClearCryptTokenList(ab);  AB_Account_List_Clear(ab->accounts);  AB_User_List_Clear(ab->users);  /* deinit all providers */  pro=AB_Provider_List_First(ab->providers);  while(pro) {    while (AB_Provider_IsInit(pro)) {      rv=AB_Banking_FiniProvider(ab, pro);      if (rv) {	DBG_WARN(AQBANKING_LOGDOMAIN,		 "Error deinitializing backend /"%s/"",		 AB_Provider_GetName(pro));	break;      }    }    pro=AB_Provider_List_Next(pro);  } /* while */  AB_Provider_List_Clear(ab->providers);  return 0;}

  const char *getCharProperty(GWEN_DIALOG_PROPERTY prop,                              int index,                              const char *defaultValue) {    QWidget *qw;    QString str;    qw=(QWidget*) GWEN_Widget_GetImplData(_widget, QT4_DIALOG_WIDGET_REAL);    assert(qw);    switch(prop) {    case GWEN_DialogProperty_Title:      str=qw->windowTitle();      if (str.isEmpty())        return defaultValue;      else {        GWEN_Widget_SetText(_widget, QT4_DIALOG_STRING_TITLE, str.toUtf8());        return GWEN_Widget_GetText(_widget, QT4_DIALOG_STRING_TITLE);      }      break;    default:      break;    }    DBG_WARN(GWEN_LOGDOMAIN,             "Function is not appropriate for this type of widget (%s)",             GWEN_Widget_Type_toString(GWEN_Widget_GetType(_widget)));    return defaultValue;  };

static GWENHYWFAR_CBint Gtk3Gui_WStack_SetIntProperty(GWEN_WIDGET *w,                                  GWEN_DIALOG_PROPERTY prop,                                  int index,                                  int value,                                  int doSignal) {  GtkWidget *g;  g=GTK_WIDGET(GWEN_Widget_GetImplData(w, GTK3_DIALOG_WIDGET_REAL));  assert(g);  switch(prop) {  case GWEN_DialogProperty_Enabled:    gtk_widget_set_sensitive(GTK_WIDGET(g), (value==0)?FALSE:TRUE);    return 0;  case GWEN_DialogProperty_Focus:    gtk_widget_grab_focus(GTK_WIDGET(g));    return 0;  case GWEN_DialogProperty_Value:    gtk_notebook_set_current_page(GTK_NOTEBOOK(g), value);    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)));  return GWEN_ERROR_INVALID;}

void GWEN_XMLNode_DecUsage(GWEN_XMLNODE *n) {  assert(n);  if (n->usage==0) {    DBG_WARN(GWEN_LOGDOMAIN, "Node usage already is zero");  }  else    n->usage--;}

int AB_Banking_PluginSystemFini(void) {    if (ab_plugin_init_count) {        if (--ab_plugin_init_count==0) {            AB_BankInfoPlugin_List_free(ab_bankInfoPlugins);            ab_bankInfoPlugins=NULL;            AB_ImExporter_List_free(ab_imexporters);            ab_imexporters=NULL;            /* unregister and unload provider plugin manager */            if (ab_pluginManagerProvider) {                if (GWEN_PluginManager_Unregister(ab_pluginManagerProvider)) {                    DBG_ERROR(AQBANKING_LOGDOMAIN,                              "Could not unregister provider plugin manager");                }                GWEN_PluginManager_free(ab_pluginManagerProvider);                ab_pluginManagerProvider=NULL;            }            /* unregister and unload bankinfo plugin manager */            if (ab_pluginManagerBankInfo) {                if (GWEN_PluginManager_Unregister(ab_pluginManagerBankInfo)) {                    DBG_ERROR(AQBANKING_LOGDOMAIN,                              "Could not unregister bankinfo plugin manager");                }                GWEN_PluginManager_free(ab_pluginManagerBankInfo);                ab_pluginManagerBankInfo=NULL;            }            /* unregister and unload imexporters plugin manager */            if (ab_pluginManagerImExporter) {                if (GWEN_PluginManager_Unregister(ab_pluginManagerImExporter)) {                    DBG_ERROR(AQBANKING_LOGDOMAIN,                              "Could not unregister imexporter plugin manager");                }                GWEN_PluginManager_free(ab_pluginManagerImExporter);                ab_pluginManagerImExporter=NULL;            }            /* undefine our own paths */            GWEN_PathManager_UndefinePath(AB_PM_LIBNAME, AB_PM_LOCALEDIR);            GWEN_PathManager_UndefinePath(AB_PM_LIBNAME, AB_PM_DATADIR);            GWEN_PathManager_UndefinePath(AB_PM_LIBNAME, AB_PM_SYSCONFDIR);            GWEN_PathManager_UndefinePath(AB_PM_LIBNAME, AB_PM_WIZARDDIR);            /* remove AqBanking additions to all pathmanagers */            GWEN_PathManager_RemovePaths(AB_PM_LIBNAME);            GWEN_Logger_Close(AQBANKING_LOGDOMAIN);            GWEN_Fini();        }    }    else {        DBG_WARN(AQBANKING_LOGDOMAIN,                 "AB_Banking_PluginSystemFini() called too often!");    }    return 0;}

void game_make_move(move_t *move, int ui_update) {	if (do_move(move, ui_update)) {		comm_send("%s/n", fullalg_list.move[fullalg_list.entries - 1]);	} else {		char *move_str = move_to_fullalg(history->last->board, move);		DBG_WARN("Ignoring illegal move %s", move_str);		free(move_str);	}}

int AB_Banking_BeginExclUseAccount(AB_BANKING *ab,				   AB_ACCOUNT *a) {  GWEN_DB_NODE *db=NULL;  GWEN_DB_NODE *dbP;  int rv;  assert(ab);  /* check for config manager (created by AB_Banking_Init) */  if (ab->configMgr==NULL) {    DBG_ERROR(AQBANKING_LOGDOMAIN,	      "No config manager (maybe the gwenhywfar plugins are not installed?");    return GWEN_ERROR_GENERIC;  }  /* lock group */  rv=GWEN_ConfigMgr_LockGroup(ab->configMgr,			      AB_CFG_GROUP_ACCOUNTS,			      AB_Account_GetDbId(a));  if (rv<0) {    DBG_ERROR(AQBANKING_LOGDOMAIN, "Unable to lock account config group (%d)", rv);    return rv;  }  /* load group (is locked now) */  rv=GWEN_ConfigMgr_GetGroup(ab->configMgr,			     AB_CFG_GROUP_ACCOUNTS,			     AB_Account_GetDbId(a),			     &db);  if (rv<0) {    DBG_ERROR(AQBANKING_LOGDOMAIN, "Could not load account group (%d)", rv);    GWEN_ConfigMgr_UnlockGroup(ab->configMgr,			       AB_CFG_GROUP_ACCOUNTS,			       AB_Account_GetDbId(a));    return rv;  }  AB_Account_ReadDb(a, db);  /* let provider also reload account data */  dbP=GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_DEFAULT, "data/backend");  rv=AB_Provider_ExtendAccount(AB_Account_GetProvider(a), a, AB_ProviderExtendMode_Reload, dbP);  if (rv<0) {    DBG_WARN(AQBANKING_LOGDOMAIN, "Could not extend account [%s/%s] (%d)",	     AB_Account_GetBankCode(a), AB_Account_GetAccountNumber(a), 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);  return 0;}

void UDP_Recv(sint32 fd, MSG_Q_ID id){    sint32 recvNum;    uint32 rst;    recvNum = UDP_ReadData(fd);        // if receive enougth data, then unpack    if (recvNum >= UDP_RECV_BUF_LEN_MIN)    {        rst = UDP_UnpackRecvData();        SIM_ASSERT(rst == UDP_MSG_HEAD_LEN);        // todo only for test        //show_udp_recv_head_data();                switch (udpRecvMsgHead.msgId)        {        case SIM_RECV_SPD_MSG_ID:            rst = UDP_UnpackRecvSpdInfoData();            SIM_ASSERT(rst == UDP_MSG_SPD_PACKAGE_LEN);            // todo only for test            //show_udp_recv_spd_data();            break;                    case SIM_RECV_INIT_MSG_ID:            rst = UDP_UnpackRecvInitInfoData(id);            SIM_ASSERT(rst == UDP_MSG_INIT_PACKAGE_LEN);            // todo only for test            //show_udp_recv_velocity_data();            break;                    case SIM_RECV_BTM_MSG_ID:            rst = UDP_UnpackRecvBtmInfoData(id);            SIM_ASSERT(rst >= UDP_MSG_BTM_PACKAGE_LEN_MIN);            // todo only for test            //show_udp_recv_btm_data();            break;                    case SIM_RECV_TMS_MSG_ID:            rst = UDP_UnpackRecvTmsInfoData();            //SIM_ASSERT(rst >= UDP_MSG_TMS_PACKAGE_LEN_MIN);            semGive(udpSendTmsSemID);            // todo only for test            //show_udp_recv_tms_data();            break;                    default:            DBG_ERRO("[UDP] receive msg head id ERROR %x!/n", udpRecvMsgHead.msgId);            break;        }    }    else    {        DBG_WARN("[UDP] receive udp data less or timeout!/n");    }}

LC_CLIENT_RESULT LC_EgkCard_ParseInsuranceData(GWEN_XMLNODE *root,					       LC_HI_INSURANCE_DATA **pData) {  LC_CLIENT_RESULT res;  GWEN_XMLNODE *n;  LC_HI_INSURANCE_DATA *d=NULL;  n=GWEN_XMLNode_FindFirstTag(root,			      "UC_allgemeineVersicherungsdatenXML",			      NULL, NULL);  if (n) {    const char *s;    d=LC_HIInsuranceData_new();    s=GWEN_XMLNode_GetProperty(n, "CDM_VERSION", NULL);    if (s) {      DBG_INFO(LC_LOGDOMAIN, "CDM_VERSION is [%s]", s);      if (GWEN_Text_ComparePattern(s, "5.*", 0)!=-1) {	DBG_INFO(LC_LOGDOMAIN, "Reading as 5.1.0");	res=LC_EgkCard_ReadInsuranceData_5_1_0(n, d);      }      else if (GWEN_Text_ComparePattern(s, "3.*", 0)!=-1) {	DBG_INFO(LC_LOGDOMAIN, "Reading as 3.0.0");	res=LC_EgkCard_ReadInsuranceData_3_0_0(n, d);      }      else {	DBG_WARN(LC_LOGDOMAIN,		 "Unhandled CDM_VERSION [%s], trying 5.1.0", s);	res=LC_EgkCard_ReadInsuranceData_5_1_0(n, d);      }    }    else {      DBG_INFO(LC_LOGDOMAIN,	       "Missing CDM_VERSION, trying old data type");      /*GWEN_XMLNode_Dump(n, stderr, 2);*/      res=LC_EgkCard_ReadInsuranceData_old(n, d);    }    if (res!=LC_Client_ResultOk) {      DBG_INFO(LC_LOGDOMAIN, "here (%d)", res);      LC_HIInsuranceData_free(d);      return res;    }  }  else {    DBG_ERROR(LC_LOGDOMAIN, "UC_allgemeineVersicherungsdatenXML not found, data follows:");    GWEN_XMLNode_Dump(root, 2);    return LC_Client_ResultNotFound;  }  *pData=d;  return LC_Client_ResultOk;}

static voidfastschedule_stop(void){    FUNC_ENTER();    if (timeEndPeriod(1) != TIMERR_NOERROR)    {        DBG_WARN((DBG_PREFIX "Unable to restore scheduling period."));    }    FUNC_LEAVE();}

static voidfastschedule_start(void){    FUNC_ENTER();    if (timeBeginPeriod(1) != TIMERR_NOERROR)    {        DBG_WARN((DBG_PREFIX "Unable to decrease scheduling period."));    }    FUNC_LEAVE();}

LC_CLIENT_RESULT LC_EgkCard_ReadPersonalData_old(GWEN_XMLNODE *n,						 LC_HI_PERSONAL_DATA *d) {  const char *s;  GWEN_XMLNODE *nn;    s=GWEN_XMLNode_GetCharValue(n, "Versicherten_ID", NULL);  LC_HIPersonalData_SetInsuranceId(d, s);    s=GWEN_XMLNode_GetCharValue(n, "Geburtsdatum", NULL);  if (s) {    GWEN_TIME *ti=GWEN_Time_fromUtcString(s, "YYYYMMDD");    LC_HIPersonalData_SetDateOfBirth(d, ti);    GWEN_Time_free(ti);  }  s=GWEN_XMLNode_GetCharValue(n, "Vorname", NULL);  LC_HIPersonalData_SetPrename(d, s);  s=GWEN_XMLNode_GetCharValue(n, "Nachname", NULL);  LC_HIPersonalData_SetName(d, s);  s=GWEN_XMLNode_GetCharValue(n, "Sex", "1");  if (s) {    if (strcasecmp(s, "1")==0)      LC_HIPersonalData_SetSex(d, LC_HIPersonalData_SexMale);    else if (strcasecmp(s, "2")==0)      LC_HIPersonalData_SetSex(d, LC_HIPersonalData_SexFemale);    else {      DBG_WARN(LC_LOGDOMAIN, "Unknown sex /"%s/"", s);    }  }    nn=GWEN_XMLNode_FindFirstTag(n,			       "Anschrift",			       NULL, NULL);  if (nn) {    s=GWEN_XMLNode_GetCharValue(nn, "Postleitzahl", NULL);    LC_HIPersonalData_SetAddrZipCode(d, s);    s=GWEN_XMLNode_GetCharValue(nn, "Ort", NULL);    LC_HIPersonalData_SetAddrCity(d, s);    s=GWEN_XMLNode_GetCharValue(nn, "Wohnsitzlaendercode", NULL);    LC_HIPersonalData_SetAddrCountry(d, s);    nn=GWEN_XMLNode_FindFirstTag(nn,				 "Adresse",				 NULL, NULL);    if (nn) {      s=GWEN_XMLNode_GetCharValue(nn, "Strasse", NULL);      LC_HIPersonalData_SetAddrStreet(d, s);      s=GWEN_XMLNode_GetCharValue(nn, "Hausnummer", NULL);      LC_HIPersonalData_SetAddrHouseNum(d, s);    }  }  return LC_Client_ResultOk;}