int test2(int argc, char **argv) {
int rv;
uint32_t id1;
uint32_t id2;
uint64_t i1;
uint64_t i2;
GWEN_GUI *gui;
gtk_set_locale ();
gtk_init (&argc, &argv);
gui=Gtk2_Gui_new();
GWEN_Gui_SetGui(gui);
id1=GWEN_Gui_ProgressStart(GWEN_GUI_PROGRESS_SHOW_LOG |
GWEN_GUI_PROGRESS_SHOW_ABORT |
GWEN_GUI_PROGRESS_KEEP_OPEN,
"Progress-Title",
"<html>"
"<p><b>This</b> is an example <i>text</i>..</p>"
"<p>As you can see <font color=red>colors</font> can "
"be used.</p>"
"</html>",
10,
0);
for (i1=1; i1<=10; i1++) {
char numbuf[128];
snprintf(numbuf, sizeof(numbuf)-1, "Step %d\n", (int)i1);
GWEN_Gui_ProgressLog(id1, GWEN_LoggerLevel_Notice, numbuf);
id2=GWEN_Gui_ProgressStart(GWEN_GUI_PROGRESS_SHOW_LOG |
GWEN_GUI_PROGRESS_DELAY |
GWEN_GUI_PROGRESS_SHOW_ABORT,
"2nd progress",
"Starting 2nd progress...",
10,
id1);
for (i2=1; i2<=10; i2++) {
sleep(1);
fprintf(stderr, "Advancing %d/%d\n", (int)i1, (int)i2);
rv=GWEN_Gui_ProgressAdvance(id2, i2);
if (rv==GWEN_ERROR_USER_ABORTED) {
fprintf(stderr, "Aborted by user (2)\n");
break;
}
}
GWEN_Gui_ProgressEnd(id2);
rv=GWEN_Gui_ProgressAdvance(id1, i1);
if (rv==GWEN_ERROR_USER_ABORTED) {
fprintf(stderr, "Aborted by user (1)\n");
break;
}
}
GWEN_Gui_ProgressEnd(id1);
return 0;
}
int AH_NewKeyFileDialog_DoIt(GWEN_DIALOG *dlg) {
AH_NEWKEYFILE_DIALOG *xdlg;
AB_USER *u;
GWEN_URL *url;
int rv;
uint32_t pid;
AB_IMEXPORTER_CONTEXT *ctx;
AB_PROVIDER *pro;
GWEN_PLUGIN_MANAGER *pm;
GWEN_PLUGIN *pl;
GWEN_CRYPT_TOKEN *ct;
assert(dlg);
xdlg=GWEN_INHERIT_GETDATA(GWEN_DIALOG, AH_NEWKEYFILE_DIALOG, dlg);
assert(xdlg);
rv=AH_NewKeyFileDialog_GetFilePageData(dlg);
if (rv<0) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "No file?");
// TODO: show error message
return GWEN_DialogEvent_ResultHandled;
}
pro=AB_Banking_GetProvider(xdlg->banking, "aqhbci");
if (pro==NULL) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not find backend, maybe some plugins are not installed?");
GWEN_Gui_ShowError(I18N("Error"),
"%s",
I18N("Could not find HBCI backend, maybe some plugins are not installed?"));
return GWEN_DialogEvent_ResultHandled;
}
u=AB_Banking_CreateUser(xdlg->banking, "aqhbci");
if (u==NULL) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not create user, maybe backend missing?");
GWEN_Gui_ShowError(I18N("Error"), "%s", I18N("Could not find HBCI backend, maybe some plugins are not installed?"));
return GWEN_DialogEvent_ResultHandled;
}
/* generic setup */
AB_User_SetUserName(u, xdlg->userName);
AB_User_SetUserId(u, xdlg->userId);
if (xdlg->customerId && *(xdlg->customerId))
AB_User_SetCustomerId(u, xdlg->customerId);
else
AB_User_SetCustomerId(u, xdlg->userId);
AB_User_SetCountry(u, "de");
AB_User_SetBankCode(u, xdlg->bankCode);
/* HBCI setup */
AH_User_SetTokenType(u, "ohbci");
AH_User_SetTokenName(u, AH_NewKeyFileDialog_GetFileName(dlg));
AH_User_SetTokenContextId(u, 1);
AH_User_SetCryptMode(u, AH_CryptMode_Rdh);
AH_User_SetStatus(u, AH_UserStatusPending);
AH_User_SetHbciVersion(u, xdlg->hbciVersion);
AH_User_SetRdhType(u, xdlg->rdhVersion);
AH_User_SetFlags(u, xdlg->flags);
/* create CryptToken */
pm=GWEN_PluginManager_FindPluginManager(GWEN_CRYPT_TOKEN_PLUGIN_TYPENAME);
if (pm==0) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Plugin manager not found");
GWEN_Gui_ShowError(I18N("Error"),
I18N("CryptToken plugin for type %s is not available. Did you install all necessary packages?"),
GWEN_CRYPT_TOKEN_PLUGIN_TYPENAME);
return 3;
}
pl=GWEN_PluginManager_GetPlugin(pm, AH_User_GetTokenType(u));
if (pl==0) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Plugin not found");
GWEN_Gui_ShowError(I18N("Error"),
I18N("CryptToken plugin for type %s is not available. Did you install all necessary packages?"),
AH_User_GetTokenType(u));
AB_User_free(u);
return GWEN_DialogEvent_ResultHandled;
}
ct=GWEN_Crypt_Token_Plugin_CreateToken(pl, AH_User_GetTokenName(u));
if (ct==0) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not create crypt token");
AB_User_free(u);
return GWEN_DialogEvent_ResultHandled;
}
/* create crypt token */
rv=GWEN_Crypt_Token_Create(ct, 0);
if (rv<0) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not create token");
GWEN_Gui_ShowError(I18N("Error"),
I18N("The keyfile %s could not be created. Maybe there already is a file of that name (%d)."),
GWEN_Crypt_Token_GetTokenName(ct),
rv);
AB_User_free(u);
return GWEN_DialogEvent_ResultHandled;
}
/* close crypt token */
rv=GWEN_Crypt_Token_Close(ct, 0, 0);
if (rv) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not close token");
GWEN_Gui_ShowError(I18N("Error"),
I18N("The keyfile %s could not be closed. Please check disc space."),
GWEN_Crypt_Token_GetTokenName(ct),
rv);
AB_User_free(u);
unlink(AH_User_GetTokenName(u));
return GWEN_DialogEvent_ResultHandled;
}
url=GWEN_Url_fromString(xdlg->url);
assert(url);
GWEN_Url_SetProtocol(url, "hbci");
if (GWEN_Url_GetPort(url)==0)
GWEN_Url_SetPort(url, 3000);
AH_User_SetServerUrl(u, url);
GWEN_Url_free(url);
rv=AB_Banking_AddUser(xdlg->banking, u);
if (rv<0) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not add user (%d)", rv);
GWEN_Gui_ShowError(I18N("Error"),
I18N("Could not add HBCI user, maybe there already is a user of that id (%d)"),
rv);
AB_User_free(u);
DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not add user, maybe there already is a user of the same id (%d)?", rv);
return GWEN_DialogEvent_ResultHandled;
}
pid=GWEN_Gui_ProgressStart(GWEN_GUI_PROGRESS_DELAY |
GWEN_GUI_PROGRESS_ALLOW_EMBED |
GWEN_GUI_PROGRESS_SHOW_PROGRESS |
GWEN_GUI_PROGRESS_SHOW_ABORT,
I18N("Setting Up Keyfile User"),
I18N("The server keys will now be retrieved, keys created and sent to the bank."),
3, /* getkeys, mkKeys, sendKeys */
0);
/* lock new user */
rv=AB_Banking_BeginExclUseUser(xdlg->banking, u);
if (rv<0) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Could not lock user (%d)", rv);
GWEN_Gui_ProgressLog2(pid,
GWEN_LoggerLevel_Error,
I18N("Unable to lock users (%d)"), rv);
AB_Banking_DeleteUser(xdlg->banking, u);
unlink(AH_NewKeyFileDialog_GetFileName(dlg));
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
/* get server keys id */
GWEN_Gui_ProgressLog(pid,
GWEN_LoggerLevel_Notice,
I18N("Retrieving server keys"));
ctx=AB_ImExporterContext_new();
rv=AH_Provider_GetServerKeys(pro, u, ctx, 0, 1, 0);
if (rv<0) {
AB_Banking_EndExclUseUser(xdlg->banking, u, 1);
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
AB_Banking_DeleteUser(xdlg->banking, u);
unlink(AH_NewKeyFileDialog_GetFileName(dlg));
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
rv=AH_NewKeyFileDialog_CheckBankIniLetter(dlg, u);
if (rv<0) {
AB_Banking_EndExclUseUser(xdlg->banking, u, 1);
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
AB_Banking_DeleteUser(xdlg->banking, u);
unlink(AH_NewKeyFileDialog_GetFileName(dlg));
GWEN_Gui_ProgressLog(pid,
GWEN_LoggerLevel_Error,
I18N("Bad bank keys, you should contact your bank."));
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
rv=GWEN_Gui_ProgressAdvance(pid, GWEN_GUI_PROGRESS_ONE);
if (rv==GWEN_ERROR_USER_ABORTED) {
AB_Banking_EndExclUseUser(xdlg->banking, u, 1);
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
AB_Banking_DeleteUser(xdlg->banking, u);
unlink(AH_NewKeyFileDialog_GetFileName(dlg));
GWEN_Gui_ProgressLog(pid,
GWEN_LoggerLevel_Error,
I18N("Aborted by user."));
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
/* generate keys */
rv=AH_Provider_CreateKeys(pro, u, 0);
if (rv<0) {
AB_Banking_EndExclUseUser(xdlg->banking, u, 1);
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
AB_Banking_DeleteUser(xdlg->banking, u);
unlink(AH_NewKeyFileDialog_GetFileName(dlg));
GWEN_Gui_ProgressLog2(pid,
GWEN_LoggerLevel_Error,
I18N("Error generating keys: %d"), rv);
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
rv=GWEN_Gui_ProgressAdvance(pid, GWEN_GUI_PROGRESS_ONE);
if (rv==GWEN_ERROR_USER_ABORTED) {
AB_Banking_EndExclUseUser(xdlg->banking, u, 1);
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
AB_Banking_DeleteUser(xdlg->banking, u);
unlink(AH_NewKeyFileDialog_GetFileName(dlg));
GWEN_Gui_ProgressLog(pid,
GWEN_LoggerLevel_Error,
I18N("Aborted by user."));
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
/* send user keys */
GWEN_Gui_ProgressLog(pid,
GWEN_LoggerLevel_Notice,
I18N("Sending user keys"));
ctx=AB_ImExporterContext_new();
rv=AH_Provider_SendUserKeys2(pro, u, ctx, 0, 0, 1, 0); /* withAuthKey, withProgress, nounmount, doLock */
if (rv<0) {
AB_Banking_EndExclUseUser(xdlg->banking, u, 1);
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
AB_Banking_DeleteUser(xdlg->banking, u);
unlink(AH_NewKeyFileDialog_GetFileName(dlg));
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
rv=GWEN_Gui_ProgressAdvance(pid, GWEN_GUI_PROGRESS_ONE);
if (rv==GWEN_ERROR_USER_ABORTED) {
AB_Banking_EndExclUseUser(xdlg->banking, u, 1);
DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);
AB_Banking_DeleteUser(xdlg->banking, u);
//unlink(AH_NewKeyFileDialog_GetFileName(dlg));
GWEN_Gui_ProgressLog(pid,
GWEN_LoggerLevel_Error,
I18N("Aborted by user."));
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
/* unlock user */
rv=AB_Banking_EndExclUseUser(xdlg->banking, u, 0);
if (rv<0) {
DBG_INFO(AQHBCI_LOGDOMAIN,
"Could not unlock customer [%s] (%d)",
AB_User_GetCustomerId(u), rv);
GWEN_Gui_ProgressLog2(pid,
GWEN_LoggerLevel_Error,
I18N("Could not unlock user %s (%d)"),
AB_User_GetUserId(u), rv);
AB_Banking_EndExclUseUser(xdlg->banking, u, 1);
AB_Banking_DeleteUser(xdlg->banking, u);
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
GWEN_Gui_ProgressEnd(pid);
AH_NewKeyFileDialog_EnterPage(dlg, PAGE_END, 1);
xdlg->user=u;
return GWEN_DialogEvent_ResultHandled;
}
GWEN_FSLOCK_RESULT GWEN_FSLock_Lock(GWEN_FSLOCK *fl, int timeout, uint32_t gid) {
GWEN_TIME *t0;
int distance;
int count;
GWEN_FSLOCK_RESULT rv;
uint32_t progressId;
t0=GWEN_CurrentTime();
assert(t0);
progressId=GWEN_Gui_ProgressStart(GWEN_GUI_PROGRESS_DELAY |
GWEN_GUI_PROGRESS_ALLOW_EMBED |
GWEN_GUI_PROGRESS_SHOW_PROGRESS |
GWEN_GUI_PROGRESS_SHOW_ABORT,
I18N("Accquiring lock"),
NULL,
(timeout==GWEN_TIMEOUT_FOREVER)
?0:timeout, gid);
if (timeout==GWEN_TIMEOUT_NONE)
distance=GWEN_TIMEOUT_NONE;
else if (timeout==GWEN_TIMEOUT_FOREVER)
distance=GWEN_TIMEOUT_FOREVER;
else {
distance=GWEN_GUI_CHECK_PERIOD;
if (distance>timeout)
distance=timeout;
}
for (count=0;; count++) {
int err;
err=GWEN_Gui_ProgressAdvance(progressId, GWEN_GUI_PROGRESS_NONE);
if (err==GWEN_ERROR_USER_ABORTED) {
DBG_ERROR(GWEN_LOGDOMAIN, "User aborted.");
GWEN_Gui_ProgressEnd(progressId);
return GWEN_FSLock_ResultUserAbort;
}
rv=GWEN_FSLock__Lock(fl);
if (rv==GWEN_FSLock_ResultError) {
DBG_INFO(GWEN_LOGDOMAIN, "here");
GWEN_Time_free(t0);
GWEN_Gui_ProgressEnd(progressId);
return rv;
}
else if (rv==GWEN_FSLock_ResultOk) {
GWEN_Time_free(t0);
GWEN_Gui_ProgressEnd(progressId);
return rv;
}
else {
/* check timeout */
if (timeout!=GWEN_TIMEOUT_FOREVER) {
GWEN_TIME *t1;
double d;
if (timeout==GWEN_TIMEOUT_NONE) {
GWEN_Gui_ProgressEnd(progressId);
return GWEN_FSLock_ResultTimeout;
}
t1=GWEN_CurrentTime();
assert(t1);
d=GWEN_Time_Diff(t1, t0);
GWEN_Time_free(t1);
if (d>=timeout) {
DBG_DEBUG(GWEN_LOGDOMAIN,
"Could not lock within %d milliseconds, giving up",
timeout);
GWEN_Time_free(t0);
GWEN_Gui_ProgressEnd(progressId);
return GWEN_FSLock_ResultTimeout;
}
err=GWEN_Gui_ProgressAdvance(progressId, (uint64_t)d);
if (err) {
DBG_ERROR(GWEN_LOGDOMAIN, "User aborted.");
GWEN_Gui_ProgressEnd(progressId);
return GWEN_FSLock_ResultUserAbort;
}
}
/* sleep for the distance of the WaitCallback */
GWEN_Socket_Select(0, 0, 0, distance);
}
} /* for */
GWEN_Gui_ProgressEnd(progressId);
DBG_WARN(GWEN_LOGDOMAIN, "We should never reach this point");
GWEN_Time_free(t0);
return GWEN_FSLock_ResultError;
}
int APY_NewUserDialog_DoIt(GWEN_DIALOG *dlg) {
APY_NEWUSER_DIALOG *xdlg;
AB_USER *u;
int rv;
uint32_t pid;
AB_PROVIDER *pro;
DBG_INFO(0, "Doit");
assert(dlg);
xdlg=GWEN_INHERIT_GETDATA(GWEN_DIALOG, APY_NEWUSER_DIALOG, dlg);
assert(xdlg);
pro=AB_Banking_GetProvider(xdlg->banking, "aqpaypal");
if (pro==NULL) {
DBG_ERROR(AQPAYPAL_LOGDOMAIN, "Could not find backend, maybe some plugins are not installed?");
// TODO: show error message
return GWEN_DialogEvent_ResultHandled;
}
DBG_INFO(0, "Creating user");
u=AB_Banking_CreateUser(xdlg->banking, "aqpaypal");
if (u==NULL) {
DBG_ERROR(AQPAYPAL_LOGDOMAIN, "Could not create user, maybe backend missing?");
// TODO: show error message
return GWEN_DialogEvent_ResultHandled;
}
/* generic setup */
AB_User_SetUserName(u, xdlg->userName);
AB_User_SetUserId(u, xdlg->userId);
AB_User_SetCustomerId(u, xdlg->userId);
AB_User_SetCountry(u, "de");
AB_User_SetBankCode(u, "PAYPAL");
APY_User_SetServerUrl(u, xdlg->url);
APY_User_SetHttpVMajor(u, xdlg->httpVMajor);
APY_User_SetHttpVMinor(u, xdlg->httpVMinor);
DBG_INFO(0, "Adding user");
rv=AB_Banking_AddUser(xdlg->banking, u);
if (rv<0) {
DBG_ERROR(AQPAYPAL_LOGDOMAIN, "Could not add user (%d)", rv);
AB_User_free(u);
return GWEN_DialogEvent_ResultHandled;
}
pid=GWEN_Gui_ProgressStart(GWEN_GUI_PROGRESS_DELAY |
GWEN_GUI_PROGRESS_ALLOW_EMBED |
GWEN_GUI_PROGRESS_SHOW_PROGRESS |
GWEN_GUI_PROGRESS_SHOW_ABORT,
I18N("Setting Up Paypal User"),
I18N("The user will be created."),
3,
0);
/* lock new user */
DBG_INFO(0, "Locking user");
rv=AB_Banking_BeginExclUseUser(xdlg->banking, u);
if (rv<0) {
DBG_ERROR(AQPAYPAL_LOGDOMAIN, "Could not lock user (%d)", rv);
GWEN_Gui_ProgressLog(pid,
GWEN_LoggerLevel_Error,
I18N("Unable to lock users"));
AB_Banking_DeleteUser(xdlg->banking, u);
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
#if 0
DBG_INFO(0, "Getting certs (%08x)", AH_User_GetFlags(u));
GWEN_Gui_ProgressLog(pid,
GWEN_LoggerLevel_Notice,
I18N("Retrieving SSL certificate"));
rv=APY_Provider_GetCert(pro, u, 0, 1, 0);
if (rv<0) {
// TODO: retry with SSLv3 if necessary
AB_Banking_EndExclUseUser(xdlg->banking, u, 1);
DBG_ERROR(AQPAYPAL_LOGDOMAIN, "here (%d)", rv);
AB_Banking_DeleteUser(xdlg->banking, u);
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
rv=GWEN_Gui_ProgressAdvance(pid, GWEN_GUI_PROGRESS_ONE);
if (rv==GWEN_ERROR_USER_ABORTED) {
AB_Banking_EndExclUseUser(xdlg->banking, u, 1);
DBG_INFO(AQPAYPAL_LOGDOMAIN, "here (%d)", rv);
AB_Banking_DeleteUser(xdlg->banking, u);
GWEN_Gui_ProgressLog(pid,
GWEN_LoggerLevel_Error,
I18N("Aborted by user."));
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
#endif
GWEN_Gui_ProgressLog(pid,
GWEN_LoggerLevel_Notice,
I18N("Creating API credentials file"));
rv=APY_User_SetApiSecrets(u, xdlg->apiPassword, xdlg->apiSignature, xdlg->apiUserId);
if (rv<0) {
AB_Banking_EndExclUseUser(xdlg->banking, u, 1);
DBG_INFO(AQPAYPAL_LOGDOMAIN, "here (%d)", rv);
AB_Banking_DeleteUser(xdlg->banking, u);
GWEN_Gui_ProgressLog(pid,
GWEN_LoggerLevel_Error,
I18N("Aborted by user."));
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
/* unlock user */
DBG_INFO(0, "Unlocking user");
rv=AB_Banking_EndExclUseUser(xdlg->banking, u, 0);
if (rv<0) {
DBG_INFO(AQPAYPAL_LOGDOMAIN,
"Could not unlock user [%s] (%d)",
AB_User_GetUserId(u), rv);
GWEN_Gui_ProgressLog2(pid,
GWEN_LoggerLevel_Error,
I18N("Could not unlock user %s (%d)"),
AB_User_GetUserId(u), rv);
AB_Banking_EndExclUseUser(xdlg->banking, u, 1);
AB_Banking_DeleteUser(xdlg->banking, u);
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
if (1) {
AB_ACCOUNT *account;
int rv;
static char accountname[256];
account=AB_Banking_CreateAccount(xdlg->banking, APY_PROVIDER_NAME);
assert(account);
#if 0
AB_User_SetUserName(u, xdlg->userName);
AB_User_SetUserId(u, xdlg->userId);
#endif
AB_Account_SetOwnerName(account, AB_User_GetUserName(u));
AB_Account_SetAccountNumber(account, AB_User_GetUserId(u));
AB_Account_SetBankCode(account, "PAYPAL");
AB_Account_SetBankName(account, "PAYPAL");
strcpy(accountname, "PP ");
strcat(accountname, AB_User_GetUserName(u));
AB_Account_SetAccountName(account, accountname);
AB_Account_SetUser(account, u);
AB_Account_SetSelectedUser(account, u);
rv=AB_Banking_AddAccount(xdlg->banking, account);
if (rv<0) {
DBG_INFO(AQPAYPAL_LOGDOMAIN, "Error adding account (%d)", rv);
AB_Account_free(account);
AB_Banking_DeleteUser(xdlg->banking, u);
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
}
GWEN_Dialog_SetCharProperty(dlg,
"wiz_end_label",
GWEN_DialogProperty_Title,
0,
I18N("The user has been successfully setup."),
0);
GWEN_Gui_ProgressEnd(pid);
APY_NewUserDialog_EnterPage(dlg, PAGE_END, 1);
xdlg->user=u;
return GWEN_DialogEvent_ResultHandled;
}
LC_CLIENT_RESULT LC_Client_GetNextCard(LC_CLIENT *cl, LC_CARD **pCard, int timeout) {
LONG rv;
int i;
uint32_t progressId;
time_t startt;
uint64_t to;
int distance;
assert(cl);
startt=time(0);
if (timeout==GWEN_TIMEOUT_NONE ||
timeout==GWEN_TIMEOUT_FOREVER)
to=0;
else
to=timeout;
progressId=GWEN_Gui_ProgressStart(GWEN_GUI_PROGRESS_DELAY |
GWEN_GUI_PROGRESS_ALLOW_EMBED |
GWEN_GUI_PROGRESS_SHOW_PROGRESS |
GWEN_GUI_PROGRESS_SHOW_ABORT,
I18N("Waiting for card to be inserted"),
NULL,
to,
0);
distance=GWEN_GUI_CHECK_PERIOD;
if (distance>timeout)
distance=timeout;
for (;;) {
double d;
int err;
/* continue checking */
for (i=cl->lastUsedReader+1; i<cl->readerCount; i++) {
/* we have a change here */
if (cl->readerStates[i].dwEventState & SCARD_STATE_CHANGED)
cl->readerStates[i].dwCurrentState=cl->readerStates[i].dwEventState;
else
continue;
DBG_DEBUG(LC_LOGDOMAIN, "Status changed on reader [%s] (%08x, %08x)",
cl->readerStates[i].szReader,
(unsigned int)(cl->readerStates[i].dwCurrentState),
(unsigned int)(cl->readerStates[i].dwEventState));
if (cl->pnpAvailable && i==cl->readerCount-1) {
/* pnp pseudo reader: a reader has been added or removed */
DBG_DEBUG(LC_LOGDOMAIN, "Pseudo reader, updating reader list (%08x, %08x)",
(unsigned int)(cl->readerStates[i].dwCurrentState),
(unsigned int)(cl->readerStates[i].dwEventState));
LC_Client_UpdateReaderStates(cl);
cl->lastUsedReader=-1;
break;
}
else {
if ((cl->readerStates[i].dwEventState & SCARD_STATE_PRESENT) &&
!(cl->readerStates[i].dwEventState & SCARD_STATE_EXCLUSIVE) &&
!(cl->readerStates[i].dwEventState & SCARD_STATE_INUSE)) {
LC_CLIENT_RESULT res;
LC_CARD *card=NULL;
/* card inserted and not used by another application */
DBG_DEBUG(LC_LOGDOMAIN, "Found usable card in reader [%s]", cl->readerStates[i].szReader);
res=LC_Client_ConnectCard(cl, cl->readerStates[i].szReader, &card);
if (res==LC_Client_ResultOk) {
/* card csuccessfully connected, return */
*pCard=card;
cl->lastUsedReader=i;
GWEN_Gui_ProgressEnd(progressId);
return LC_Client_ResultOk;
}
else {
DBG_ERROR(LC_LOGDOMAIN,
"Error connecting to card in reader [%s]",
cl->readerStates[i].szReader);
}
}
else {
DBG_INFO(LC_LOGDOMAIN, "Either no card in reader or card unavailable in reader [%s]",
cl->readerStates[i].szReader);
}
}
}
if (i>=cl->readerCount) {
/* there was no relevant change in a reader, wait for status change */
cl->lastUsedReader=-1;
rv=SCardGetStatusChange(cl->scardContext, distance, cl->readerStates, cl->readerCount);
if (rv==SCARD_E_TIMEOUT) {
/* timeout, just repeat next loop */
if (timeout==GWEN_TIMEOUT_NONE) {
GWEN_Gui_ProgressEnd(progressId);
return LC_Client_ResultWait;
}
}
else if (rv!=SCARD_S_SUCCESS) {
DBG_ERROR(LC_LOGDOMAIN, "SCardGetStatusChange: %d", (int) rv);
GWEN_Gui_ProgressEnd(progressId);
return LC_Client_ResultIoError;
}
}
/* check timeout */
d=difftime(time(0), startt);
if (timeout!=GWEN_TIMEOUT_FOREVER) {
if (timeout==GWEN_TIMEOUT_NONE ||
d>timeout) {
DBG_INFO(GWEN_LOGDOMAIN,
"Timeout (%d) while waiting, giving up",
timeout);
GWEN_Gui_ProgressEnd(progressId);
return LC_Client_ResultWait;
}
}
/* check for user abort */
err=GWEN_Gui_ProgressAdvance(progressId, (uint64_t)(d*1000));
if (err==GWEN_ERROR_USER_ABORTED) {
DBG_ERROR(GWEN_LOGDOMAIN, "User aborted");
GWEN_Gui_ProgressEnd(progressId);
return LC_Client_ResultAborted;
}
}
}
int upload(AB_BANKING *ab,
GWEN_DB_NODE *dbArgs,
int argc,
char **argv) {
GWEN_DB_NODE *db;
AB_PROVIDER *pro;
AB_USER_LIST2 *ul;
AB_USER *u=0;
int rv;
const char *bankId;
const char *userId;
const char *customerId;
const char *requestType;
const char *inFile;
uint32_t guiid;
const GWEN_ARGS args[]={
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"bankId", /* name */
0, /* minnum */
1, /* maxnum */
"b", /* short option */
"bank", /* long option */
"Specify the bank code", /* short description */
"Specify the bank code" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"userId", /* name */
0, /* minnum */
1, /* maxnum */
"u", /* short option */
"user", /* long option */
"Specify the user id", /* short description */
"Specify the user id" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"customerId", /* name */
0, /* minnum */
1, /* maxnum */
"c", /* short option */
"customer", /* long option */
"Specify the customer id (Kundennummer)", /* short description */
"Specify the customer id (Kundennummer)" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Char, /* type */
"requestType", /* name */
1, /* minnum */
1, /* maxnum */
"r", /* short option */
"request", /* long option */
"Specify the request type", /* short description */
"Specify the request type" /* long description */
},
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT,
GWEN_ArgsType_Char,
"inFile",
1,
1,
"f",
"infile",
"Specify the file to upload",
"Specify the file to upload"
},
{
GWEN_ARGS_FLAGS_HELP | GWEN_ARGS_FLAGS_LAST, /* flags */
GWEN_ArgsType_Int, /* type */
"help", /* name */
0, /* minnum */
0, /* maxnum */
"h", /* short option */
"help", /* long option */
"Show this help screen", /* short description */
"Show this help screen" /* long description */
}
};
db=GWEN_DB_GetGroup(dbArgs, GWEN_DB_FLAGS_DEFAULT, "local");
rv=GWEN_Args_Check(argc, argv, 1,
0 /*GWEN_ARGS_MODE_ALLOW_FREEPARAM*/,
args,
db);
if (rv==GWEN_ARGS_RESULT_ERROR) {
fprintf(stderr, "ERROR: Could not parse arguments\n");
return 1;
}
else if (rv==GWEN_ARGS_RESULT_HELP) {
GWEN_BUFFER *ubuf;
ubuf=GWEN_Buffer_new(0, 1024, 0, 1);
if (GWEN_Args_Usage(args, ubuf, GWEN_ArgsOutType_Txt)) {
fprintf(stderr, "ERROR: Could not create help string\n");
return 1;
}
fprintf(stdout, "%s\n", GWEN_Buffer_GetStart(ubuf));
GWEN_Buffer_free(ubuf);
return 0;
}
rv=AB_Banking_Init(ab);
if (rv) {
DBG_ERROR(0, "Error on init (%d)", rv);
return 2;
}
rv=AB_Banking_OnlineInit(ab);
if (rv) {
DBG_ERROR(0, "Error on onlineInit (%d)", rv);
return 2;
}
pro=AB_Banking_GetProvider(ab, EBC_PROVIDER_NAME);
assert(pro);
bankId=GWEN_DB_GetCharValue(db, "bankId", 0, "*");
userId=GWEN_DB_GetCharValue(db, "userId", 0, "*");
customerId=GWEN_DB_GetCharValue(db, "customerId", 0, "*");
requestType=GWEN_DB_GetCharValue(db, "requestType", 0, NULL);
inFile=GWEN_DB_GetCharValue(db, "inFile", 0, NULL);
ul=AB_Banking_FindUsers(ab, EBC_PROVIDER_NAME,
"de", bankId, userId, customerId);
if (ul) {
if (AB_User_List2_GetSize(ul)!=1) {
DBG_ERROR(0, "Ambiguous customer specification");
AB_Banking_OnlineFini(ab);
AB_Banking_Fini(ab);
return 3;
}
else {
AB_USER_LIST2_ITERATOR *cit;
cit=AB_User_List2_First(ul);
assert(cit);
u=AB_User_List2Iterator_Data(cit);
AB_User_List2Iterator_free(cit);
}
AB_User_List2_free(ul);
}
if (!u) {
DBG_ERROR(0, "No matching customer");
AB_Banking_OnlineFini(ab);
AB_Banking_Fini(ab);
return 3;
}
else {
GWEN_BUFFER *inBuffer;
inBuffer=GWEN_Buffer_new(0, 1024, 0, 1);
rv=readFile(inFile, inBuffer);
if (rv<0) {
DBG_ERROR(0, "Error reading data file (%d)", rv);
GWEN_Buffer_free(inBuffer);
AB_Banking_OnlineFini(ab);
AB_Banking_Fini(ab);
return 1;
}
guiid=GWEN_Gui_ProgressStart(GWEN_GUI_PROGRESS_ALLOW_SUBLEVELS |
GWEN_GUI_PROGRESS_SHOW_PROGRESS |
GWEN_GUI_PROGRESS_SHOW_LOG |
GWEN_GUI_PROGRESS_ALWAYS_SHOW_LOG |
GWEN_GUI_PROGRESS_KEEP_OPEN |
GWEN_GUI_PROGRESS_SHOW_ABORT,
I18N("Executing Request"),
I18N("Now the request is send "
"to the credit institute."),
GWEN_GUI_PROGRESS_NONE,
0);
rv=EBC_Provider_Upload(pro, u,
requestType,
(const uint8_t*)GWEN_Buffer_GetStart(inBuffer),
GWEN_Buffer_GetUsedBytes(inBuffer),
1);
GWEN_Gui_ProgressEnd(guiid);
if (rv) {
DBG_ERROR(0, "Error sending upload request (%d)", rv);
AB_Banking_OnlineFini(ab);
AB_Banking_Fini(ab);
return 4;
}
else {
fprintf(stderr, "Upload request sent.\n");
}
GWEN_Buffer_free(inBuffer);
}
rv=AB_Banking_OnlineFini(ab);
if (rv) {
fprintf(stderr, "ERROR: Error on online deinit (%d)\n", rv);
AB_Banking_Fini(ab);
return 5;
}
rv=AB_Banking_Fini(ab);
if (rv) {
fprintf(stderr, "ERROR: Error on deinit (%d)\n", rv);
return 5;
}
fprintf(stderr, "Upload request ok.\n");
return 0;
}
int AO_NewUserDialog_DoIt(GWEN_DIALOG *dlg)
{
AO_NEWUSER_DIALOG *xdlg;
AB_USER *u;
int rv;
uint32_t pid;
DBG_ERROR(0, "Doit");
assert(dlg);
xdlg=GWEN_INHERIT_GETDATA(GWEN_DIALOG, AO_NEWUSER_DIALOG, dlg);
assert(xdlg);
DBG_ERROR(0, "Creating user");
u=AB_Provider_CreateUserObject(xdlg->provider);
if (u==NULL) {
DBG_ERROR(AQOFXCONNECT_LOGDOMAIN, "Could not create user, maybe backend missing?");
// TODO: show error message
return GWEN_DialogEvent_ResultHandled;
}
/* generic setup */
AB_User_SetUserName(u, xdlg->userName);
AB_User_SetUserId(u, xdlg->userId);
AB_User_SetCustomerId(u, xdlg->userId);
AB_User_SetCountry(u, "us");
AO_User_SetBankName(u, xdlg->bankName);
AB_User_SetBankCode(u, "0000000000");
AO_User_SetFlags(u, xdlg->flags);
AO_User_SetBrokerId(u, xdlg->brokerId);
AO_User_SetOrg(u, xdlg->org);
AO_User_SetFid(u, xdlg->fid);
AO_User_SetAppId(u, xdlg->appId);
AO_User_SetAppVer(u, xdlg->appVer);
AO_User_SetHeaderVer(u, xdlg->headerVer);
AO_User_SetClientUid(u, xdlg->clientUid);
AO_User_SetSecurityType(u, xdlg->securityType);
AO_User_SetServerAddr(u, xdlg->url);
AO_User_SetHttpVMajor(u, xdlg->httpVMajor);
AO_User_SetHttpVMinor(u, xdlg->httpVMinor);
DBG_ERROR(0, "Adding user");
rv=AB_Provider_AddUser(xdlg->provider, u);
if (rv<0) {
DBG_ERROR(AQOFXCONNECT_LOGDOMAIN, "Could not add user (%d)", rv);
AB_User_free(u);
return GWEN_DialogEvent_ResultHandled;
}
pid=GWEN_Gui_ProgressStart(GWEN_GUI_PROGRESS_DELAY |
GWEN_GUI_PROGRESS_ALLOW_EMBED |
GWEN_GUI_PROGRESS_SHOW_PROGRESS |
GWEN_GUI_PROGRESS_SHOW_ABORT,
I18N("Setting Up OFX DirectConnect User"),
I18N("The user will be created and the certificate retrieved."),
1,
0);
/* lock new user */
DBG_ERROR(0, "Locking user");
rv=AB_Provider_BeginExclUseUser(xdlg->provider, u);
if (rv<0) {
DBG_ERROR(AQOFXCONNECT_LOGDOMAIN, "Could not lock user (%d)", rv);
GWEN_Gui_ProgressLog(pid,
GWEN_LoggerLevel_Error,
I18N("Unable to lock users"));
AB_Provider_DeleteUser(xdlg->provider, AB_User_GetUniqueId(u));
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
GWEN_Gui_ProgressLog(pid,
GWEN_LoggerLevel_Notice,
I18N("Retrieving SSL certificate"));
rv=AO_Provider_GetCert(xdlg->provider, u);
if (rv<0) {
AB_Provider_EndExclUseUser(xdlg->provider, u, 1);
DBG_ERROR(AQOFXCONNECT_LOGDOMAIN, "here (%d)", rv);
AB_Provider_DeleteUser(xdlg->provider, AB_User_GetUniqueId(u));
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
rv=GWEN_Gui_ProgressAdvance(pid, GWEN_GUI_PROGRESS_ONE);
if (rv==GWEN_ERROR_USER_ABORTED) {
AB_Provider_EndExclUseUser(xdlg->provider, u, 1);
DBG_INFO(AQOFXCONNECT_LOGDOMAIN, "here (%d)", rv);
AB_Provider_DeleteUser(xdlg->provider, AB_User_GetUniqueId(u));
GWEN_Gui_ProgressLog(pid,
GWEN_LoggerLevel_Error,
I18N("Aborted by user."));
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
/* unlock user */
DBG_ERROR(0, "Unlocking user");
rv=AB_Provider_EndExclUseUser(xdlg->provider, u, 0);
if (rv<0) {
DBG_INFO(AQOFXCONNECT_LOGDOMAIN,
"Could not unlock user [%s] (%d)",
AB_User_GetUserId(u), rv);
GWEN_Gui_ProgressLog2(pid,
GWEN_LoggerLevel_Error,
I18N("Could not unlock user %s (%d)"),
AB_User_GetUserId(u), rv);
AB_Provider_EndExclUseUser(xdlg->provider, u, 1);
AB_Provider_DeleteUser(xdlg->provider, AB_User_GetUniqueId(u));
GWEN_Gui_ProgressEnd(pid);
return GWEN_DialogEvent_ResultHandled;
}
GWEN_Gui_ProgressEnd(pid);
AO_NewUserDialog_EnterPage(dlg, PAGE_END, 1);
xdlg->user=u;
return GWEN_DialogEvent_ResultHandled;
}
int GWEN_Crypt_Token_PluginManager_CheckToken(GWEN_PLUGIN_MANAGER *pm,
GWEN_CRYPT_TOKEN_DEVICE devt,
GWEN_BUFFER *typeName,
GWEN_BUFFER *tokenName,
uint32_t guiid)
{
GWEN_PLUGIN_DESCRIPTION_LIST2 *pdl;
assert(pm);
pdl=GWEN_Crypt_Token_PluginManager_GetPluginDescrs(pm, devt);
if (pdl==NULL) {
DBG_ERROR(GWEN_LOGDOMAIN, "No plugin descriptions found for this device type");
GWEN_Gui_ProgressLog(guiid,
GWEN_LoggerLevel_Error,
I18N("No plugin found for this device type"));
GWEN_Gui_ProgressLog(guiid,
GWEN_LoggerLevel_Error,
I18N("If you're using a Debian/Ubuntu based system "
"please consider to install package "
LIBCHIPCARD_GWENHYWFAR_PLUGIN_PACKAGE));
return GWEN_ERROR_NOT_FOUND;
}
else {
GWEN_PLUGIN_DESCRIPTION_LIST2_ITERATOR *pit;
pit=GWEN_PluginDescription_List2_First(pdl);
if (pit) {
GWEN_PLUGIN_DESCRIPTION *pd;
uint32_t progressId;
unsigned int pdcount;
unsigned int cnt=0;
pdcount=GWEN_PluginDescription_List2_GetSize(pdl);
progressId=GWEN_Gui_ProgressStart(GWEN_GUI_PROGRESS_DELAY |
GWEN_GUI_PROGRESS_ALLOW_EMBED |
GWEN_GUI_PROGRESS_SHOW_PROGRESS |
GWEN_GUI_PROGRESS_SHOW_LOG |
GWEN_GUI_PROGRESS_ALWAYS_SHOW_LOG |
GWEN_GUI_PROGRESS_SHOW_ABORT,
I18N("Determining plugin module..."),
NULL,
pdcount,
guiid);
pd=GWEN_PluginDescription_List2Iterator_Data(pit);
assert(pd);
while (pd) {
GWEN_XMLNODE *n;
int err;
GWEN_PLUGIN *pl;
char logbuffer[256];
n=GWEN_PluginDescription_GetXmlNode(pd);
assert(n);
snprintf(logbuffer, sizeof(logbuffer)-1,
I18N("Loading plugin \"%s\""),
GWEN_PluginDescription_GetName(pd));
logbuffer[sizeof(logbuffer)-1]=0;
GWEN_Gui_ProgressLog(progressId,
GWEN_LoggerLevel_Notice,
logbuffer);
/* device type matches, check this plugin */
pl=GWEN_PluginManager_GetPlugin(pm, GWEN_PluginDescription_GetName(pd));
if (pl) {
GWEN_BUFFER *lTokenName;
int rv;
lTokenName=GWEN_Buffer_dup(tokenName);
snprintf(logbuffer, sizeof(logbuffer)-1,
I18N("Checking plugin \"%s\""),
GWEN_Plugin_GetName(pl));
logbuffer[sizeof(logbuffer)-1]=0;
GWEN_Gui_ProgressLog(progressId,
GWEN_LoggerLevel_Notice,
logbuffer);
DBG_INFO(GWEN_LOGDOMAIN,
"Checking plugin \"%s\" for [%s]",
GWEN_Plugin_GetName(pl),
GWEN_Buffer_GetStart(lTokenName));
rv=GWEN_Crypt_Token_Plugin_CheckToken(pl, lTokenName);
switch (rv) {
case 0:
/* responsive plugin found */
snprintf(logbuffer, sizeof(logbuffer)-1,
I18N("Plugin \"%s\" supports this token"),
GWEN_Plugin_GetName(pl));
logbuffer[sizeof(logbuffer)-1]=0;
err=GWEN_Gui_ProgressLog(progressId,
GWEN_LoggerLevel_Notice,
logbuffer);
if (err==GWEN_ERROR_USER_ABORTED) {
GWEN_Gui_ProgressEnd(progressId);
GWEN_Buffer_free(lTokenName);
GWEN_PluginDescription_List2Iterator_free(pit);
GWEN_PluginDescription_List2_freeAll(pdl);
return err;
}
GWEN_Buffer_Reset(typeName);
GWEN_Buffer_AppendString(typeName, GWEN_Plugin_GetName(pl));
GWEN_Buffer_Reset(tokenName);
GWEN_Buffer_AppendBuffer(tokenName, lTokenName);
GWEN_Buffer_free(lTokenName);
GWEN_PluginDescription_List2Iterator_free(pit);
GWEN_PluginDescription_List2_freeAll(pdl);
GWEN_Gui_ProgressEnd(progressId);
return 0;
case GWEN_ERROR_NOT_IMPLEMENTED:
snprintf(logbuffer, sizeof(logbuffer)-1,
I18N("Plugin \"%s\": Function not implemented"),
GWEN_Plugin_GetName(pl));
logbuffer[sizeof(logbuffer)-1]=0;
GWEN_Gui_ProgressLog(progressId,
GWEN_LoggerLevel_Notice,
logbuffer);
break;
case GWEN_ERROR_NOT_SUPPORTED:
snprintf(logbuffer, sizeof(logbuffer)-1,
I18N("Plugin \"%s\" does not support this token"),
GWEN_Plugin_GetName(pl));
logbuffer[sizeof(logbuffer)-1]=0;
GWEN_Gui_ProgressLog(progressId,
GWEN_LoggerLevel_Info,
logbuffer);
break;
case GWEN_ERROR_BAD_NAME:
snprintf(logbuffer, sizeof(logbuffer)-1,
I18N("Plugin \"%s\" supports this token, but the name "
"did not match"),
GWEN_Plugin_GetName(pl));
logbuffer[sizeof(logbuffer)-1]=0;
GWEN_Gui_ProgressLog(progressId,
GWEN_LoggerLevel_Info,
logbuffer);
break;
default:
snprintf(logbuffer, sizeof(logbuffer)-1,
I18N("Plugin \"%s\": Unexpected error (%d)"),
GWEN_Plugin_GetName(pl), rv);
logbuffer[sizeof(logbuffer)-1]=0;
GWEN_Gui_ProgressLog(progressId,
GWEN_LoggerLevel_Info,
logbuffer);
break;
} /* switch */
} /* if plugin loaded */
else {
snprintf(logbuffer, sizeof(logbuffer)-1,
I18N("Could not load plugin \"%s\""),
GWEN_PluginDescription_GetName(pd));
logbuffer[sizeof(logbuffer)-1]=0;
GWEN_Gui_ProgressLog(progressId,
GWEN_LoggerLevel_Warning,
logbuffer);
}
cnt++;
err=GWEN_Gui_ProgressAdvance(progressId, cnt);
if (err) {
DBG_INFO(GWEN_LOGDOMAIN, "User aborted");
GWEN_Gui_ProgressEnd(progressId);
GWEN_PluginDescription_List2Iterator_free(pit);
GWEN_PluginDescription_List2_freeAll(pdl);
GWEN_Gui_ProgressEnd(progressId);
return err;
}
pd=GWEN_PluginDescription_List2Iterator_Next(pit);
}
GWEN_Gui_ProgressEnd(progressId);
GWEN_PluginDescription_List2Iterator_free(pit);
}
GWEN_PluginDescription_List2_freeAll(pdl);
}
return GWEN_ERROR_NOT_SUPPORTED;
}
int sendHPD(AB_PROVIDER *pro,
GWEN_DB_NODE *dbArgs,
int argc,
char **argv)
{
GWEN_DB_NODE *db;
uint32_t uid;
AB_USER *u=NULL;
int rv;
const GWEN_ARGS args[]= {
{
GWEN_ARGS_FLAGS_HAS_ARGUMENT, /* flags */
GWEN_ArgsType_Int, /* type */
"userId", /* name */
0, /* minnum */
1, /* maxnum */
"u", /* short option */
"user", /* long option */
"Specify the unique user id", /* short description */
"Specify the unique user id" /* long description */
},
{
GWEN_ARGS_FLAGS_HELP | GWEN_ARGS_FLAGS_LAST, /* flags */
GWEN_ArgsType_Int, /* type */
"help", /* name */
0, /* minnum */
0, /* maxnum */
"h", /* short option */
"help", /* long option */
"Show this help screen", /* short description */
"Show this help screen" /* long description */
}
};
db=GWEN_DB_GetGroup(dbArgs, GWEN_DB_FLAGS_DEFAULT, "local");
rv=GWEN_Args_Check(argc, argv, 1,
0 /*GWEN_ARGS_MODE_ALLOW_FREEPARAM*/,
args,
db);
if (rv==GWEN_ARGS_RESULT_ERROR) {
fprintf(stderr, "ERROR: Could not parse arguments\n");
return 1;
}
else if (rv==GWEN_ARGS_RESULT_HELP) {
GWEN_BUFFER *ubuf;
ubuf=GWEN_Buffer_new(0, 1024, 0, 1);
if (GWEN_Args_Usage(args, ubuf, GWEN_ArgsOutType_Txt)) {
fprintf(stderr, "ERROR: Could not create help string\n");
return 1;
}
fprintf(stdout, "%s\n", GWEN_Buffer_GetStart(ubuf));
GWEN_Buffer_free(ubuf);
return 0;
}
/* doit */
uid=(uint32_t) GWEN_DB_GetIntValue(db, "userId", 0, 0);
if (uid==0) {
fprintf(stderr, "ERROR: Invalid or missing unique user id\n");
return 1;
}
rv=AB_Provider_GetUser(pro, uid, 1, 1, &u);
if (rv<0) {
fprintf(stderr, "ERROR: User with id %lu not found\n", (unsigned long int) uid);
return 2;
}
else {
if ((EBC_User_GetStatus(u)==EBC_UserStatus_Enabled)) {
uint32_t guiid;
guiid=GWEN_Gui_ProgressStart(GWEN_GUI_PROGRESS_ALLOW_SUBLEVELS |
GWEN_GUI_PROGRESS_SHOW_PROGRESS |
GWEN_GUI_PROGRESS_SHOW_LOG |
GWEN_GUI_PROGRESS_ALWAYS_SHOW_LOG |
GWEN_GUI_PROGRESS_KEEP_OPEN |
GWEN_GUI_PROGRESS_SHOW_ABORT,
I18N("Executing Request"),
I18N("Now the request is send to the credit institute."),
GWEN_GUI_PROGRESS_NONE,
0);
rv=EBC_Provider_Send_HPD(pro, u, 1);
GWEN_Gui_ProgressEnd(guiid);
if (rv) {
DBG_ERROR(0, "Error sending HPD request (%d)", rv);
return 4;
}
else {
fprintf(stderr, "HPD request sent.\n");
}
}
}
fprintf(stderr, "HPD request ok.\n");
return 0;
}
/* --------------------------------------------------------------- FUNCTION */
int AH_Job_GetTransactions__ReadTransactions(AH_JOB *j,
AB_IMEXPORTER_ACCOUNTINFO *ai,
const char *docType,
int noted,
GWEN_BUFFER *buf){
GWEN_DBIO *dbio;
GWEN_SYNCIO *sio;
int rv;
GWEN_DB_NODE *db;
GWEN_DB_NODE *dbDay;
GWEN_DB_NODE *dbParams;
AB_ACCOUNT *a;
AB_USER *u;
uint32_t progressId;
uint64_t cnt=0;
a=AH_AccountJob_GetAccount(j);
assert(a);
u=AH_Job_GetUser(j);
assert(u);
dbio=GWEN_DBIO_GetPlugin("swift");
if (!dbio) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Plugin SWIFT is not found");
GWEN_Gui_ProgressLog(0,
GWEN_LoggerLevel_Error,
I18N("Plugin \"SWIFT\" not found."));
return AB_ERROR_PLUGIN_MISSING;
}
GWEN_Buffer_Rewind(buf);
sio=GWEN_SyncIo_Memory_new(buf, 0);
db=GWEN_DB_Group_new("transactions");
dbParams=GWEN_DB_Group_new("params");
GWEN_DB_SetCharValue(dbParams, GWEN_DB_FLAGS_OVERWRITE_VARS,
"type", docType);
if (AH_User_GetFlags(u) & AH_USER_FLAGS_KEEP_MULTIPLE_BLANKS)
GWEN_DB_SetIntValue(dbParams, GWEN_DB_FLAGS_OVERWRITE_VARS,
"keepMultipleBlanks", 1);
else
GWEN_DB_SetIntValue(dbParams, GWEN_DB_FLAGS_OVERWRITE_VARS,
"keepMultipleBlanks", 0);
rv=GWEN_DBIO_Import(dbio, sio,
db, dbParams,
GWEN_PATH_FLAGS_CREATE_GROUP);
if (rv<0) {
DBG_ERROR(AQHBCI_LOGDOMAIN,
"Error parsing SWIFT %s (%d)",
docType, rv);
GWEN_DB_Group_free(dbParams);
GWEN_DB_Group_free(db);
GWEN_SyncIo_free(sio);
GWEN_DBIO_free(dbio);
return rv;
}
GWEN_DB_Group_free(dbParams);
GWEN_SyncIo_free(sio);
GWEN_DBIO_free(dbio);
/* first count the groups */
dbDay=GWEN_DB_FindFirstGroup(db, "day");
while(dbDay) {
GWEN_DB_NODE *dbT;
dbT=GWEN_DB_FindFirstGroup(dbDay, "transaction");
while(dbT) {
cnt++;
dbT=GWEN_DB_FindNextGroup(dbT, "transaction");
} /* while */
dbDay=GWEN_DB_FindNextGroup(dbDay, "day");
} /* while */
progressId=GWEN_Gui_ProgressStart(GWEN_GUI_PROGRESS_DELAY |
GWEN_GUI_PROGRESS_ALLOW_EMBED |
GWEN_GUI_PROGRESS_SHOW_PROGRESS |
GWEN_GUI_PROGRESS_SHOW_ABORT,
I18N("Importing transactions..."),
NULL,
cnt,
0);
/* add transactions to list */
dbDay=GWEN_DB_FindFirstGroup(db, "day");
while(dbDay) {
GWEN_DB_NODE *dbT;
dbT=GWEN_DB_FindFirstGroup(dbDay, "transaction");
while(dbT) {
AB_TRANSACTION *t;
t=AB_Transaction_fromDb(dbT);
if (!t) {
DBG_ERROR(AQHBCI_LOGDOMAIN, "Bad transaction data:");
GWEN_DB_Dump(dbT, 2);
}
else {
const char *s;
AB_Transaction_SetLocalBankCode(t, AB_User_GetBankCode(u));
AB_Transaction_SetLocalAccountNumber(t,
AB_Account_GetAccountNumber(a));
/* some translations */
s=AB_Transaction_GetRemoteIban(t);
if (!(s && *s)) {
const char *sAid;
/* no remote IBAN set, check whether the bank sends this info in the
* fields for national account specifications (instead of the SWIFT
* field "?38" which was specified for this case) */
sAid=AB_Transaction_GetRemoteAccountNumber(t);
if (sAid && *sAid && AB_Banking_CheckIban(sAid)==0) {
/* there is a remote account number specification, and that is an IBAN,
* so we set that accordingly */
DBG_INFO(AQBANKING_LOGDOMAIN, "Setting remote IBAN from account number");
AB_Transaction_SetRemoteIban(t, sAid);
/* set remote BIC if it not already is */
s=AB_Transaction_GetRemoteBic(t);
if (!(s && *s)) {
const char *sBid;
sBid=AB_Transaction_GetRemoteBankCode(t);
if (sBid && *sBid) {
DBG_INFO(AQBANKING_LOGDOMAIN, "Setting remote BIC from bank code");
AB_Transaction_SetRemoteBic(t, sBid);
}
}
}
}
DBG_INFO(AQHBCI_LOGDOMAIN, "Adding transaction");
if (noted)
AB_ImExporterAccountInfo_AddNotedTransaction(ai, t);
else
AB_ImExporterAccountInfo_AddTransaction(ai, t);
}
if (GWEN_ERROR_USER_ABORTED==
GWEN_Gui_ProgressAdvance(progressId, GWEN_GUI_PROGRESS_ONE)) {
GWEN_Gui_ProgressEnd(progressId);
return GWEN_ERROR_USER_ABORTED;
}
dbT=GWEN_DB_FindNextGroup(dbT, "transaction");
} /* while */
/* read all endsaldos */
if (!noted) {
dbT=GWEN_DB_FindFirstGroup(dbDay, "endSaldo");
while (dbT) {
GWEN_DB_NODE *dbX;
GWEN_TIME *ti=0;
dbX=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "date");
if (dbX)
ti=GWEN_Time_fromDb(dbX);
dbX=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "value");
if (dbX) {
AB_VALUE *v;
v=AB_Value_fromDb(dbX);
if (v) {
AB_BALANCE *bal;
AB_ACCOUNT_STATUS *as;
bal=AB_Balance_new(v, ti);
AB_Value_free(v);
as=AB_AccountStatus_new();
if (ti)
AB_AccountStatus_SetTime(as, ti);
AB_AccountStatus_SetNotedBalance(as, bal);
AB_Balance_free(bal);
AB_ImExporterAccountInfo_AddAccountStatus(ai, as);
}
}
GWEN_Time_free(ti);
dbT=GWEN_DB_FindNextGroup(dbT, "endSaldo");
} /* while */
}
dbDay=GWEN_DB_FindNextGroup(dbDay, "day");
} /* while */
GWEN_Gui_ProgressEnd(progressId);
GWEN_DB_Group_free(db);
return 0;
}
