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