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_CB int 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_CB int 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_CB int 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_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; }
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_CB int 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_CB int 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_CB int 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 void fastschedule_stop(void) { FUNC_ENTER(); if (timeEndPeriod(1) != TIMERR_NOERROR) { DBG_WARN((DBG_PREFIX "Unable to restore scheduling period.")); } FUNC_LEAVE(); }
static void fastschedule_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; }