00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029 #ifdef HAVE_CONFIG_H
00030 # include <config.h>
00031 #endif
00032
00033 #ifndef ICONV_CONST
00034 # define ICONV_CONST
00035 #endif
00036
00037
00038 #include "cgui_p.h"
00039 #include "i18n_l.h"
00040
00041 #include <gwenhywfar/gui_be.h>
00042 #include <gwenhywfar/inherit.h>
00043 #include <gwenhywfar/debug.h>
00044 #include <gwenhywfar/misc.h>
00045 #include <gwenhywfar/db.h>
00046 #include <gwenhywfar/gwentime.h>
00047 #include <gwenhywfar/mdigest.h>
00048 #include <gwenhywfar/text.h>
00049
00050
00051 #include <stdlib.h>
00052 #include <string.h>
00053 #include <ctype.h>
00054 #ifdef HAVE_TERMIOS_H
00055 # include <termios.h>
00056 #endif
00057 #include <unistd.h>
00058 #include <fcntl.h>
00059 #include <stdio.h>
00060 #include <errno.h>
00061
00062 #ifdef HAVE_SIGNAL_H
00063 # include <signal.h>
00064 #endif
00065 #ifdef HAVE_ICONV_H
00066 # include <iconv.h>
00067 #endif
00068
00069
00070
00071 GWEN_INHERIT(GWEN_GUI, GWEN_GUI_CGUI)
00072
00073
00074
00075
00076 GWEN_GUI *GWEN_Gui_CGui_new() {
00077 GWEN_GUI *gui;
00078 GWEN_GUI_CGUI *cgui;
00079
00080 gui=GWEN_Gui_new();
00081 GWEN_NEW_OBJECT(GWEN_GUI_CGUI, cgui);
00082 cgui->progressList=GWEN_Gui_CProgress_List_new();
00083 GWEN_INHERIT_SETDATA(GWEN_GUI, GWEN_GUI_CGUI, gui, cgui,
00084 GWEN_Gui_CGui_FreeData);
00085
00086 GWEN_Gui_SetMessageBoxFn(gui, GWEN_Gui_CGui_MessageBox);
00087 GWEN_Gui_SetInputBoxFn(gui, GWEN_Gui_CGui_InputBox);
00088 GWEN_Gui_SetShowBoxFn(gui, GWEN_Gui_CGui_ShowBox);
00089 GWEN_Gui_SetHideBoxFn(gui, GWEN_Gui_CGui_HideBox);
00090 GWEN_Gui_SetProgressStartFn(gui, GWEN_Gui_CGui_ProgressStart);
00091 GWEN_Gui_SetProgressAdvanceFn(gui, GWEN_Gui_CGui_ProgressAdvance);
00092 GWEN_Gui_SetProgressLogFn(gui, GWEN_Gui_CGui_ProgressLog);
00093 GWEN_Gui_SetProgressEndFn(gui, GWEN_Gui_CGui_ProgressEnd);
00094 GWEN_Gui_SetSetPasswordStatusFn(gui, GWEN_Gui_CGui_SetPasswordStatus);
00095 GWEN_Gui_SetGetPasswordFn(gui, GWEN_Gui_CGui_GetPassword);
00096
00097 cgui->checkCertFn=GWEN_Gui_SetCheckCertFn(gui, GWEN_Gui_CGui_CheckCert);
00098
00099 cgui->dbPasswords=GWEN_DB_Group_new("passwords");
00100 cgui->dbCerts=GWEN_DB_Group_new("certs");
00101 cgui->badPasswords=GWEN_StringList_new();
00102
00103 return gui;
00104 }
00105
00106
00107
00108 void GWENHYWFAR_CB GWEN_Gui_CGui_FreeData(GWEN_UNUSED void *bp, void *p) {
00109 GWEN_GUI_CGUI *cgui;
00110
00111 cgui=(GWEN_GUI_CGUI*)p;
00112 GWEN_Gui_CProgress_List_free(cgui->progressList);
00113 free(cgui->charSet);
00114 GWEN_StringList_free(cgui->badPasswords);
00115 GWEN_DB_Group_free(cgui->dbCerts);
00116 GWEN_DB_Group_free(cgui->dbPasswords);
00117 GWEN_FREE_OBJECT(cgui);
00118 }
00119
00120
00121
00122 const char *GWEN_Gui_CGui_GetCharSet(const GWEN_GUI *gui) {
00123 GWEN_GUI_CGUI *cgui;
00124
00125 assert(gui);
00126 cgui=GWEN_INHERIT_GETDATA(GWEN_GUI, GWEN_GUI_CGUI, gui);
00127 assert(cgui);
00128
00129 return cgui->charSet;
00130 }
00131
00132
00133
00134 void GWEN_Gui_CGui_SetCharSet(GWEN_GUI *gui, const char *s) {
00135 GWEN_GUI_CGUI *cgui;
00136
00137 assert(gui);
00138 cgui=GWEN_INHERIT_GETDATA(GWEN_GUI, GWEN_GUI_CGUI, gui);
00139 assert(cgui);
00140
00141 free(cgui->charSet);
00142 if (s)
00143 cgui->charSet=strdup(s);
00144 else
00145 cgui->charSet=NULL;
00146 }
00147
00148
00149
00150 int GWEN_Gui_CGui_GetIsNonInteractive(const GWEN_GUI *gui) {
00151 return GWEN_Gui_GetFlags(gui) & GWEN_GUI_FLAGS_NONINTERACTIVE;
00152 }
00153
00154
00155
00156 void GWEN_Gui_CGui_SetIsNonInteractive(GWEN_GUI *gui, int i) {
00157 if (i)
00158 GWEN_Gui_AddFlags(gui, GWEN_GUI_FLAGS_NONINTERACTIVE);
00159 else
00160 GWEN_Gui_SubFlags(gui, GWEN_GUI_FLAGS_NONINTERACTIVE);
00161 }
00162
00163
00164
00165 int GWEN_Gui_CGui_GetAcceptAllValidCerts(const GWEN_GUI *gui) {
00166 return GWEN_Gui_GetFlags(gui) & GWEN_GUI_FLAGS_ACCEPTVALIDCERTS;
00167 }
00168
00169
00170
00171 void GWEN_Gui_CGui_SetAcceptAllValidCerts(GWEN_GUI *gui, int i) {
00172 if (i)
00173 GWEN_Gui_AddFlags(gui, GWEN_GUI_FLAGS_ACCEPTVALIDCERTS);
00174 else
00175 GWEN_Gui_SubFlags(gui, GWEN_GUI_FLAGS_ACCEPTVALIDCERTS);
00176 }
00177
00178
00179
00180 int GWEN_Gui_CGui__ConvertFromUtf8(GWEN_GUI *gui,
00181 const char *text,
00182 int len,
00183 GWEN_BUFFER *tbuf){
00184 GWEN_GUI_CGUI *cgui;
00185
00186 assert(gui);
00187 cgui=GWEN_INHERIT_GETDATA(GWEN_GUI, GWEN_GUI_CGUI, gui);
00188 assert(cgui);
00189
00190 assert(len);
00191
00192 if (cgui->charSet) {
00193 if (strcasecmp(cgui->charSet, "utf-8")!=0) {
00194 #ifndef HAVE_ICONV
00195 DBG_INFO(GWEN_LOGDOMAIN,
00196 "iconv not available, can not convert to \"%s\"",
00197 cgui->charSet);
00198 #else
00199 iconv_t ic;
00200
00201 ic=iconv_open(cgui->charSet, "UTF-8");
00202 if (ic==((iconv_t)-1)) {
00203 DBG_ERROR(GWEN_LOGDOMAIN, "Charset \"%s\" not available",
00204 cgui->charSet);
00205 }
00206 else {
00207 char *outbuf;
00208 char *pOutbuf;
00209
00210
00211
00212
00213 ICONV_CONST char *pInbuf;
00214 size_t inLeft;
00215 size_t outLeft;
00216 size_t done;
00217 size_t space;
00218
00219
00220 pInbuf=(char*)text;
00221
00222 outLeft=len*2;
00223 space=outLeft;
00224 outbuf=(char*)malloc(outLeft);
00225 assert(outbuf);
00226
00227 inLeft=len;
00228 pInbuf=(char*)text;
00229 pOutbuf=outbuf;
00230 done=iconv(ic, &pInbuf, &inLeft, &pOutbuf, &outLeft);
00231 if (done==(size_t)-1) {
00232 DBG_ERROR(GWEN_LOGDOMAIN, "Error in conversion: %s (%d)",
00233 strerror(errno), errno);
00234 free(outbuf);
00235 iconv_close(ic);
00236 return GWEN_ERROR_GENERIC;
00237 }
00238
00239 GWEN_Buffer_AppendBytes(tbuf, outbuf, space-outLeft);
00240 free(outbuf);
00241 DBG_DEBUG(GWEN_LOGDOMAIN, "Conversion done.");
00242 iconv_close(ic);
00243 return 0;
00244 }
00245 #endif
00246 }
00247 }
00248
00249 GWEN_Buffer_AppendBytes(tbuf, text, len);
00250 return 0;
00251 }
00252
00253
00254
00255 void GWEN_Gui_CGui_GetRawText(GWEN_GUI *gui,
00256 const char *text,
00257 GWEN_BUFFER *tbuf) {
00258 const char *p;
00259 int rv;
00260
00261 assert(text);
00262 p=text;
00263 while ((p=strchr(p, '<'))) {
00264 const char *t;
00265
00266 t=p;
00267 t++;
00268 if (toupper(*t)=='H') {
00269 t++;
00270 if (toupper(*t)=='T') {
00271 t++;
00272 if (toupper(*t)=='M') {
00273 t++;
00274 if (toupper(*t)=='L') {
00275 break;
00276 }
00277 }
00278 }
00279 }
00280 p++;
00281 }
00282
00283 if (p)
00284 rv=GWEN_Gui_CGui__ConvertFromUtf8(gui, text, (p-text), tbuf);
00285 else
00286 rv=GWEN_Gui_CGui__ConvertFromUtf8(gui, text, strlen(text), tbuf);
00287 if (rv) {
00288 DBG_ERROR(GWEN_LOGDOMAIN, "Error converting text");
00289 GWEN_Buffer_Reset(tbuf);
00290 if (p)
00291 GWEN_Buffer_AppendBytes(tbuf, text, (p-text));
00292 else
00293 GWEN_Buffer_AppendString(tbuf, text);
00294 }
00295 }
00296
00297
00298
00299 char GWEN_Gui_CGui__readCharFromStdin(int waitFor) {
00300 int chr;
00301 #ifdef HAVE_TERMIOS_H
00302 struct termios OldAttr, NewAttr;
00303 int AttrChanged = 0;
00304 #endif
00305 #if HAVE_DECL_SIGPROCMASK
00306 sigset_t snew, sold;
00307 #endif
00308
00309
00310 #if HAVE_DECL_SIGPROCMASK
00311 sigemptyset(&snew);
00312 sigaddset(&snew, SIGINT);
00313 sigaddset(&snew, SIGSTOP);
00314 sigprocmask(SIG_BLOCK, &snew, &sold);
00315 #endif
00316 #ifdef HAVE_TERMIOS_H
00317 if (0 == tcgetattr (fileno (stdin), &OldAttr)){
00318 NewAttr = OldAttr;
00319 NewAttr.c_lflag &= ~ICANON;
00320 NewAttr.c_lflag &= ~ECHO;
00321 tcsetattr (fileno (stdin), TCSAFLUSH, &NewAttr);
00322 AttrChanged = !0;
00323 }
00324 #endif
00325
00326 for (;;) {
00327 chr=getchar();
00328 if (waitFor) {
00329 if (chr==-1 ||
00330 chr==GWEN_GUI_CGUI_CHAR_ABORT ||
00331 chr==GWEN_GUI_CGUI_CHAR_ENTER ||
00332 chr==waitFor)
00333 break;
00334 }
00335 else
00336 break;
00337 }
00338
00339 #ifdef HAVE_TERMIOS_H
00340
00341 if (AttrChanged)
00342 tcsetattr (fileno (stdin), TCSADRAIN, &OldAttr);
00343 #endif
00344
00345 #if HAVE_DECL_SIGPROCMASK
00346 sigprocmask(SIG_BLOCK, &sold, 0);
00347 #endif
00348
00349 return chr;
00350 }
00351
00352
00353
00354 int GWEN_Gui_CGui__input(GWEN_UNUSED GWEN_GUI *gui,
00355 uint32_t flags,
00356 char *buffer,
00357 int minLen,
00358 int maxLen,
00359 uint32_t guiid){
00360 #ifdef HAVE_TERMIOS_H
00361 struct termios OldInAttr, NewInAttr;
00362 struct termios OldOutAttr, NewOutAttr;
00363 int AttrInChanged = 0;
00364 int AttrOutChanged = 0;
00365 #endif
00366 int chr;
00367 unsigned int pos;
00368 int rv;
00369 #if HAVE_DECL_SIGPROCMASK
00370 sigset_t snew, sold;
00371 #endif
00372
00373
00374
00375 #if HAVE_DECL_SIGPROCMASK
00376 sigemptyset(&snew);
00377 sigaddset(&snew, SIGINT);
00378 sigaddset(&snew, SIGSTOP);
00379 sigprocmask(SIG_BLOCK, &snew, &sold);
00380 #endif
00381
00382 #ifdef HAVE_TERMIOS_H
00383 if (0 == tcgetattr (fileno (stdin), &OldInAttr)){
00384 NewInAttr = OldInAttr;
00385 NewInAttr.c_lflag &= ~ECHO;
00386 NewInAttr.c_lflag &= ~ICANON;
00387 tcsetattr (fileno (stdin), TCSAFLUSH, &NewInAttr);
00388 AttrInChanged = !0;
00389 }
00390 if (0 == tcgetattr (fileno (stderr), &OldOutAttr)){
00391 NewOutAttr = OldOutAttr;
00392 NewOutAttr.c_lflag &= ~ICANON;
00393 tcsetattr (fileno (stderr), TCSAFLUSH, &NewOutAttr);
00394 AttrOutChanged = !0;
00395 }
00396 #endif
00397
00398 pos=0;
00399 rv=0;
00400 for (;;) {
00401 chr=getchar();
00402 if (chr==GWEN_GUI_CGUI_CHAR_DELETE) {
00403 if (pos) {
00404 pos--;
00405 fprintf(stderr, "%c %c", 8, 8);
00406 }
00407 }
00408 else if (chr==GWEN_GUI_CGUI_CHAR_ENTER) {
00409 if (minLen && pos<minLen) {
00410 if (pos==0 && (flags & GWEN_GUI_INPUT_FLAGS_ALLOW_DEFAULT)) {
00411 rv=GWEN_Gui_MessageBox(GWEN_GUI_MSG_FLAGS_TYPE_INFO |
00412 GWEN_GUI_MSG_FLAGS_CONFIRM_B1 |
00413 GWEN_GUI_MSG_FLAGS_SEVERITY_DANGEROUS,
00414 I18N("Empty Input"),
00415 I18N("Your input was empty.\n"
00416 "Do you want to use the default?"),
00417 I18N("Yes"),
00418 I18N("No"),
00419 I18N("Abort"), guiid);
00420 if (rv==1) {
00421 rv=GWEN_ERROR_DEFAULT_VALUE;
00422 break;
00423 }
00424 else {
00425 rv=GWEN_ERROR_USER_ABORTED;
00426 break;
00427 }
00428 }
00429 else {
00430
00431 fprintf(stderr, "\007");
00432 }
00433 }
00434 else {
00435 fprintf(stderr, "\n");
00436 buffer[pos]=0;
00437 rv=0;
00438 break;
00439 }
00440 }
00441 else {
00442 if (pos<maxLen) {
00443 if (chr==GWEN_GUI_CGUI_CHAR_ABORT) {
00444 DBG_INFO(GWEN_LOGDOMAIN, "User aborted");
00445 rv=GWEN_ERROR_USER_ABORTED;
00446 break;
00447 }
00448 else {
00449 if ((flags & GWEN_GUI_INPUT_FLAGS_NUMERIC) &&
00450 !isdigit(chr)) {
00451
00452 fprintf(stderr, "\007");
00453 }
00454 else {
00455 if (flags & GWEN_GUI_INPUT_FLAGS_SHOW)
00456 fprintf(stderr, "%c", chr);
00457 else
00458 fprintf(stderr, "*");
00459 buffer[pos++]=chr;
00460 buffer[pos]=0;
00461 }
00462 }
00463 }
00464 else {
00465
00466 fprintf(stderr, "\007");
00467 }
00468 }
00469 }
00470
00471 #ifdef HAVE_TERMIOS_H
00472
00473 if (AttrOutChanged)
00474 tcsetattr (fileno (stderr), TCSADRAIN, &OldOutAttr);
00475 if (AttrInChanged)
00476 tcsetattr (fileno (stdin), TCSADRAIN, &OldInAttr);
00477 #endif
00478
00479 #if HAVE_DECL_SIGPROCMASK
00480 sigprocmask(SIG_BLOCK, &sold, 0);
00481 #endif
00482 return rv;
00483 }
00484
00485
00486
00487 int GWEN_Gui_CGui_MessageBox(GWEN_GUI *gui,
00488 uint32_t flags,
00489 const char *title,
00490 const char *text,
00491 const char *b1,
00492 const char *b2,
00493 const char *b3,
00494 GWEN_UNUSED uint32_t guiid) {
00495 GWEN_GUI_CGUI *cgui;
00496 GWEN_BUFFER *tbuf;
00497 int c;
00498
00499 assert(gui);
00500 cgui=GWEN_INHERIT_GETDATA(GWEN_GUI, GWEN_GUI_CGUI, gui);
00501 assert(cgui);
00502
00503 tbuf=GWEN_Buffer_new(0, 256, 0, 1);
00504 GWEN_Gui_CGui_GetRawText(gui, text, tbuf);
00505
00506 if (GWEN_Gui_GetFlags(gui) & GWEN_GUI_FLAGS_NONINTERACTIVE) {
00507 if (GWEN_GUI_MSG_FLAGS_SEVERITY_IS_DANGEROUS(flags)) {
00508 fprintf(stderr,
00509 "Got the following dangerous message:\n%s\n",
00510 GWEN_Buffer_GetStart(tbuf));
00511 GWEN_Buffer_free(tbuf);
00512 return 0;
00513 }
00514 else {
00515 DBG_INFO(GWEN_LOGDOMAIN,
00516 "Auto-answering the following message with %d:\n%s",
00517 GWEN_GUI_MSG_FLAGS_CONFIRM_BUTTON(flags),
00518 GWEN_Buffer_GetStart(tbuf));
00519 GWEN_Buffer_free(tbuf);
00520 return GWEN_GUI_MSG_FLAGS_CONFIRM_BUTTON(flags);
00521 }
00522 }
00523
00524 fprintf(stderr, "===== %s =====\n", title);
00525 fprintf(stderr, "%s\n", GWEN_Buffer_GetStart(tbuf));
00526 GWEN_Buffer_free(tbuf);
00527 tbuf=0;
00528
00529 if (b1) {
00530 fprintf(stderr, "(1) %s", b1);
00531 if (b2) {
00532 fprintf(stderr, " (2) %s", b2);
00533 if (b3) {
00534 fprintf(stderr, " (3) %s", b3);
00535 }
00536 }
00537 fprintf(stderr, "\n");
00538 }
00539 fprintf(stderr, "Please enter your choice: ");
00540 for(;;) {
00541 c=GWEN_Gui_CGui__readCharFromStdin(0);
00542 if (c==EOF) {
00543 fprintf(stderr, "Aborted.\n");
00544 return GWEN_ERROR_USER_ABORTED;
00545 }
00546 if (!b1 && c==13)
00547 return 0;
00548 if (c=='1' && b1) {
00549 fprintf(stderr, "1\n");
00550 return 1;
00551 }
00552 else if (c=='2' && b2) {
00553 fprintf(stderr, "2\n");
00554 return 2;
00555 }
00556 else if (c=='3' && b3) {
00557 fprintf(stderr, "3\n");
00558 return 3;
00559 }
00560 else {
00561 fprintf(stderr, "%c", 7);
00562 }
00563 }
00564
00565 }
00566
00567
00568
00569 int GWEN_Gui_CGui_InputBox(GWEN_GUI *gui,
00570 uint32_t flags,
00571 const char *title,
00572 const char *text,
00573 char *buffer,
00574 int minLen,
00575 int maxLen,
00576 uint32_t guiid) {
00577 int rv;
00578 GWEN_BUFFER *tbuf;
00579
00580 assert(gui);
00581 tbuf=GWEN_Buffer_new(0, 256, 0, 1);
00582 GWEN_Gui_CGui_GetRawText(gui, text, tbuf);
00583
00584 fprintf(stderr, "===== %s =====\n", title);
00585 fprintf(stderr, "%s\n", GWEN_Buffer_GetStart(tbuf));
00586 GWEN_Buffer_free(tbuf);
00587 tbuf=0;
00588
00589 if (flags & GWEN_GUI_INPUT_FLAGS_CONFIRM) {
00590 for (;;) {
00591 char *lbuffer=0;
00592
00593 lbuffer=(char*)malloc(maxLen);
00594 if (!lbuffer) {
00595 DBG_ERROR(GWEN_LOGDOMAIN, "Not enough memory for %d bytes", maxLen);
00596 return GWEN_ERROR_INVALID;
00597 }
00598 fprintf(stderr, "Input: ");
00599 rv=GWEN_Gui_CGui__input(gui, flags, lbuffer, minLen, maxLen, guiid);
00600 if (rv) {
00601 free(lbuffer);
00602 return rv;
00603 }
00604
00605 fprintf(stderr, "Again: ");
00606 rv=GWEN_Gui_CGui__input(gui, flags, buffer, minLen, maxLen, guiid);
00607 if (rv) {
00608 free(lbuffer);
00609 return rv;
00610 }
00611 if (strcmp(lbuffer, buffer)!=0) {
00612 fprintf(stderr,
00613 "ERROR: Entries do not match, please try (again or abort)\n");
00614 }
00615 else {
00616 rv=0;
00617 break;
00618 }
00619
00620 }
00621 }
00622 else {
00623 fprintf(stderr, "Input: ");
00624 rv=GWEN_Gui_CGui__input(gui, flags, buffer, minLen, maxLen, guiid);
00625 }
00626
00627 return rv;
00628 }
00629
00630
00631
00632 uint32_t GWEN_Gui_CGui_ShowBox(GWEN_GUI *gui,
00633 GWEN_UNUSED uint32_t flags,
00634 const char *title,
00635 const char *text,
00636 GWEN_UNUSED uint32_t guiid) {
00637 GWEN_GUI_CGUI *cgui;
00638 GWEN_BUFFER *tbuf;
00639
00640 assert(gui);
00641 cgui=GWEN_INHERIT_GETDATA(GWEN_GUI, GWEN_GUI_CGUI, gui);
00642 assert(cgui);
00643
00644 tbuf=GWEN_Buffer_new(0, 256, 0, 1);
00645 GWEN_Gui_CGui_GetRawText(gui, text, tbuf);
00646
00647 fprintf(stderr, "----- %s -----\n", title);
00648 fprintf(stderr, "%s\n", GWEN_Buffer_GetStart(tbuf));
00649 GWEN_Buffer_free(tbuf);
00650 tbuf=0;
00651
00652 return ++(cgui->nextBoxId);
00653 }
00654
00655
00656
00657 void GWEN_Gui_CGui_HideBox(GWEN_GUI *gui, GWEN_UNUSED uint32_t id) {
00658 GWEN_GUI_CGUI *cgui;
00659
00660 assert(gui);
00661 cgui=GWEN_INHERIT_GETDATA(GWEN_GUI, GWEN_GUI_CGUI, gui);
00662 assert(cgui);
00663
00664
00665 }
00666
00667
00668
00669 uint32_t GWEN_Gui_CGui_ProgressStart(GWEN_GUI *gui,
00670 uint32_t progressFlags,
00671 const char *title,
00672 const char *text,
00673 uint64_t total,
00674 GWEN_UNUSED uint32_t guiid) {
00675 GWEN_GUI_CGUI *cgui;
00676 GWEN_GUI_CPROGRESS *cp;
00677
00678 assert(gui);
00679 cgui=GWEN_INHERIT_GETDATA(GWEN_GUI, GWEN_GUI_CGUI, gui);
00680 assert(cgui);
00681
00682 cp=GWEN_Gui_CProgress_new(gui,
00683 ++(cgui->nextProgressId),
00684 progressFlags,
00685 title,
00686 text,
00687 total);
00688 GWEN_Gui_CProgress_List_Insert(cp, cgui->progressList);
00689 return GWEN_Gui_CProgress_GetId(cp);
00690 }
00691
00692
00693
00694 GWEN_GUI_CPROGRESS *GWEN_Gui_CGui__findProgress(GWEN_GUI *gui, uint32_t id) {
00695 GWEN_GUI_CGUI *cgui;
00696 GWEN_GUI_CPROGRESS *cp;
00697
00698 assert(gui);
00699 cgui=GWEN_INHERIT_GETDATA(GWEN_GUI, GWEN_GUI_CGUI, gui);
00700 assert(cgui);
00701
00702 cp=GWEN_Gui_CProgress_List_First(cgui->progressList);
00703 if (id==0)
00704 return cp;
00705 while(cp) {
00706 if (GWEN_Gui_CProgress_GetId(cp)==id)
00707 break;
00708 cp=GWEN_Gui_CProgress_List_Next(cp);
00709 }
00710
00711 return cp;
00712 }
00713
00714
00715
00716 int GWEN_Gui_CGui_ProgressAdvance(GWEN_GUI *gui,
00717 uint32_t id,
00718 uint64_t progress) {
00719 GWEN_GUI_CGUI *cgui;
00720 GWEN_GUI_CPROGRESS *cp;
00721
00722 assert(gui);
00723 cgui=GWEN_INHERIT_GETDATA(GWEN_GUI, GWEN_GUI_CGUI, gui);
00724 assert(cgui);
00725
00726 cp=GWEN_Gui_CGui__findProgress(gui, id);
00727 if (!cp) {
00728 DBG_DEBUG(GWEN_LOGDOMAIN, "Progress object %u not found", id);
00729 return 0;
00730 }
00731 else {
00732 return GWEN_Gui_CProgress_Advance(cp, progress);
00733 }
00734 }
00735
00736
00737
00738 int GWEN_Gui_CGui_ProgressLog(GWEN_GUI *gui,
00739 uint32_t id,
00740 GWEN_LOGGER_LEVEL level,
00741 const char *text) {
00742 GWEN_GUI_CGUI *cgui;
00743 GWEN_GUI_CPROGRESS *cp;
00744
00745 assert(gui);
00746 cgui=GWEN_INHERIT_GETDATA(GWEN_GUI, GWEN_GUI_CGUI, gui);
00747 assert(cgui);
00748
00749 cp=GWEN_Gui_CGui__findProgress(gui, id);
00750 if (!cp) {
00751 DBG_DEBUG(GWEN_LOGDOMAIN, "Progress object %u not found", id);
00752 return 0;
00753 }
00754 else {
00755 return GWEN_Gui_CProgress_Log(cp, level, text);
00756 }
00757 }
00758
00759
00760
00761 int GWEN_Gui_CGui_ProgressEnd(GWEN_GUI *gui,uint32_t id) {
00762 GWEN_GUI_CGUI *cgui;
00763 GWEN_GUI_CPROGRESS *cp;
00764
00765 assert(gui);
00766 cgui=GWEN_INHERIT_GETDATA(GWEN_GUI, GWEN_GUI_CGUI, gui);
00767 assert(cgui);
00768
00769 cp=GWEN_Gui_CGui__findProgress(gui, id);
00770 if (!cp) {
00771 DBG_DEBUG(GWEN_LOGDOMAIN, "Progress object %u not found", id);
00772 return 0;
00773 }
00774 else {
00775 int rv;
00776
00777 rv=GWEN_Gui_CProgress_End(cp);
00778 GWEN_Gui_CProgress_List_Del(cp);
00779 GWEN_Gui_CProgress_free(cp);
00780 return rv;
00781 }
00782 }
00783
00784
00785
00786 int GWEN_Gui_CGui_Print(GWEN_UNUSED GWEN_GUI *gui,
00787 GWEN_UNUSED const char *docTitle,
00788 GWEN_UNUSED const char *docType,
00789 GWEN_UNUSED const char *descr,
00790 GWEN_UNUSED const char *text,
00791 GWEN_UNUSED uint32_t guiid) {
00792 return GWEN_ERROR_NOT_SUPPORTED;
00793 }
00794
00795
00796
00797 int GWEN_Gui_CGui__HashPair(const char *token,
00798 const char *pin,
00799 GWEN_BUFFER *buf) {
00800 GWEN_MDIGEST *md;
00801 int rv;
00802
00803
00804 md=GWEN_MDigest_Md5_new();
00805 rv=GWEN_MDigest_Begin(md);
00806 if (rv==0)
00807 rv=GWEN_MDigest_Update(md, (const uint8_t*)token, strlen(token));
00808 if (rv==0)
00809 rv=GWEN_MDigest_Update(md, (const uint8_t*)pin, strlen(pin));
00810 if (rv==0)
00811 rv=GWEN_MDigest_End(md);
00812 if (rv<0) {
00813 DBG_ERROR(GWEN_LOGDOMAIN, "Hash error (%d)", rv);
00814 GWEN_MDigest_free(md);
00815 return rv;
00816 }
00817
00818 GWEN_Text_ToHexBuffer((const char*)GWEN_MDigest_GetDigestPtr(md),
00819 GWEN_MDigest_GetDigestSize(md),
00820 buf,
00821 0, 0, 0);
00822 GWEN_MDigest_free(md);
00823 return 0;
00824 }
00825
00826
00827
00828 int GWEN_Gui_CGui_CheckCert(GWEN_GUI *gui,
00829 const GWEN_SSLCERTDESCR *cd,
00830 GWEN_IO_LAYER *io, uint32_t guiid) {
00831 GWEN_GUI_CGUI *cgui;
00832 const char *hash;
00833 const char *status;
00834 GWEN_BUFFER *hbuf;
00835 int i;
00836
00837 assert(gui);
00838 cgui=GWEN_INHERIT_GETDATA(GWEN_GUI, GWEN_GUI_CGUI, gui);
00839 assert(cgui);
00840
00841 hash=GWEN_SslCertDescr_GetFingerPrint(cd);
00842 status=GWEN_SslCertDescr_GetStatusText(cd);
00843
00844 hbuf=GWEN_Buffer_new(0, 64, 0, 1);
00845 GWEN_Gui_CGui__HashPair(hash, status, hbuf);
00846
00847 i=GWEN_DB_GetIntValue(cgui->dbCerts, GWEN_Buffer_GetStart(hbuf), 0, 1);
00848 if (i==0) {
00849 DBG_NOTICE(GWEN_LOGDOMAIN,
00850 "Automatically accepting certificate [%s]",
00851 hash);
00852 GWEN_Buffer_free(hbuf);
00853 return 0;
00854 }
00855
00856 if (GWEN_Gui_GetFlags(gui) & GWEN_GUI_FLAGS_NONINTERACTIVE) {
00857 uint32_t fl;
00858
00859 fl=GWEN_SslCertDescr_GetStatusFlags(cd);
00860 if (fl==GWEN_SSL_CERT_FLAGS_OK && (GWEN_Gui_GetFlags(gui) & GWEN_GUI_FLAGS_ACCEPTVALIDCERTS)) {
00861 DBG_NOTICE(GWEN_LOGDOMAIN,
00862 "Automatically accepting valid new certificate [%s]",
00863 hash);
00864 GWEN_Buffer_free(hbuf);
00865 return 0;
00866 }
00867 else {
00868 DBG_ERROR(GWEN_LOGDOMAIN,
00869 "Automatically rejecting certificate [%s] (noninteractive)",
00870 hash);
00871 GWEN_Buffer_free(hbuf);
00872 return GWEN_ERROR_USER_ABORTED;
00873 }
00874 }
00875
00876 if (cgui->checkCertFn) {
00877 i=cgui->checkCertFn(gui, cd, io, guiid);
00878 if (i==0) {
00879 GWEN_DB_SetIntValue(cgui->dbCerts, GWEN_DB_FLAGS_OVERWRITE_VARS,
00880 GWEN_Buffer_GetStart(hbuf), i);
00881 }
00882 GWEN_Buffer_free(hbuf);
00883
00884 return i;
00885 }
00886 else {
00887 GWEN_Buffer_free(hbuf);
00888 return GWEN_ERROR_NOT_SUPPORTED;
00889 }
00890 }
00891
00892
00893
00894 int GWEN_Gui_CGui_SetPasswordStatus(GWEN_GUI *gui,
00895 const char *token,
00896 const char *pin,
00897 GWEN_GUI_PASSWORD_STATUS status,
00898 GWEN_UNUSED uint32_t guiid) {
00899 GWEN_GUI_CGUI *cgui;
00900
00901 assert(gui);
00902 cgui=GWEN_INHERIT_GETDATA(GWEN_GUI, GWEN_GUI_CGUI, gui);
00903 assert(cgui);
00904
00905 if (token==NULL && pin==NULL && status==GWEN_Gui_PasswordStatus_Remove) {
00906 if (cgui->persistentPasswords==0)
00907 GWEN_DB_ClearGroup(cgui->dbPasswords, NULL);
00908 }
00909 else {
00910 GWEN_BUFFER *hbuf;
00911
00912 hbuf=GWEN_Buffer_new(0, 64, 0, 1);
00913 GWEN_Gui_CGui__HashPair(token, pin, hbuf);
00914 if (status==GWEN_Gui_PasswordStatus_Bad)
00915 GWEN_StringList_AppendString(cgui->badPasswords,
00916 GWEN_Buffer_GetStart(hbuf),
00917 0, 1);
00918 else if (status==GWEN_Gui_PasswordStatus_Ok ||
00919 status==GWEN_Gui_PasswordStatus_Remove) {
00920 if (cgui->persistentPasswords==0)
00921 GWEN_StringList_RemoveString(cgui->badPasswords,
00922 GWEN_Buffer_GetStart(hbuf));
00923 }
00924 GWEN_Buffer_free(hbuf);
00925 }
00926
00927 return 0;
00928 }
00929
00930
00931
00932 int GWEN_Gui_CGui_GetPassword(GWEN_GUI *gui,
00933 uint32_t flags,
00934 const char *token,
00935 const char *title,
00936 const char *text,
00937 char *buffer,
00938 int minLen,
00939 int maxLen,
00940 uint32_t guiid) {
00941 GWEN_GUI_CGUI *cgui;
00942
00943 assert(gui);
00944 cgui=GWEN_INHERIT_GETDATA(GWEN_GUI, GWEN_GUI_CGUI, gui);
00945 assert(cgui);
00946
00947 if (flags & GWEN_GUI_INPUT_FLAGS_TAN) {
00948 return GWEN_Gui_InputBox(flags,
00949 title,
00950 text,
00951 buffer,
00952 minLen,
00953 maxLen,
00954 guiid);
00955 }
00956 else {
00957 GWEN_BUFFER *buf;
00958 int rv;
00959 const char *s;
00960
00961 buf=GWEN_Buffer_new(0, 256, 0, 1);
00962 GWEN_Text_EscapeToBufferTolerant(token, buf);
00963
00964 if (!(flags & GWEN_GUI_INPUT_FLAGS_CONFIRM)) {
00965 s=GWEN_DB_GetCharValue(cgui->dbPasswords,
00966 GWEN_Buffer_GetStart(buf),
00967 0, NULL);
00968 if (s) {
00969 int i;
00970
00971 i=strlen(s);
00972 if (i>=minLen && i<=maxLen) {
00973 memmove(buffer, s, i+1);
00974 GWEN_Buffer_free(buf);
00975 return 0;
00976 }
00977 else {
00978 DBG_ERROR(GWEN_LOGDOMAIN, "Stored password [%s] is not within size limits (%d), rejecting.",
00979 GWEN_Buffer_GetStart(buf), i);
00980 }
00981 }
00982 }
00983
00984 if (GWEN_Gui_GetFlags(gui) & GWEN_GUI_FLAGS_NONINTERACTIVE) {
00985 DBG_ERROR(GWEN_LOGDOMAIN,
00986 "Password for [%s] missing in noninteractive mode, "
00987 "aborting", GWEN_Buffer_GetStart(buf));
00988 GWEN_Buffer_free(buf);
00989 return GWEN_ERROR_USER_ABORTED;
00990 }
00991
00992 for (;;) {
00993 rv=GWEN_Gui_InputBox(flags,
00994 title,
00995 text,
00996 buffer,
00997 minLen,
00998 maxLen,
00999 guiid);
01000 if (rv) {
01001 GWEN_Buffer_free(buf);
01002 return rv;
01003 }
01004 else {
01005 GWEN_BUFFER *hbuf;
01006 int isBad=0;
01007
01008 hbuf=GWEN_Buffer_new(0, 64, 0, 1);
01009 GWEN_Gui_CGui__HashPair(token, buffer, hbuf);
01010 isBad=GWEN_StringList_HasString(cgui->badPasswords,
01011 GWEN_Buffer_GetStart(hbuf));
01012 if (!isBad) {
01013 GWEN_Buffer_free(hbuf);
01014 break;
01015 }
01016 rv=GWEN_Gui_MessageBox(GWEN_GUI_MSG_FLAGS_TYPE_ERROR |
01017 GWEN_GUI_MSG_FLAGS_CONFIRM_B1 |
01018 GWEN_GUI_MSG_FLAGS_SEVERITY_DANGEROUS,
01019 I18N("Enforce PIN"),
01020 I18N(
01021 "You entered the same PIN twice.\n"
01022 "The PIN is marked as bad, do you want\n"
01023 "to use it anyway?"
01024 "<html>"
01025 "<p>"
01026 "You entered the same PIN twice."
01027 "</p>"
01028 "<p>"
01029 "The PIN is marked as <b>bad</b>, "
01030 "do you want to use it anyway?"
01031 "</p>"
01032 "</html>"),
01033 I18N("Use my input"),
01034 I18N("Re-enter"),
01035 0,
01036 guiid);
01037 if (rv==1) {
01038
01039 GWEN_StringList_RemoveString(cgui->badPasswords,
01040 GWEN_Buffer_GetStart(hbuf));
01041 GWEN_Buffer_free(hbuf);
01042 break;
01043 }
01044 GWEN_Buffer_free(hbuf);
01045 }
01046 }
01047
01048 GWEN_DB_SetCharValue(cgui->dbPasswords, GWEN_DB_FLAGS_OVERWRITE_VARS,
01049 GWEN_Buffer_GetStart(buf), buffer);
01050 GWEN_Buffer_free(buf);
01051 return 0;
01052 }
01053 }
01054
01055
01056
01057 void GWEN_Gui_CGui_SetPasswordDb(GWEN_GUI *gui,
01058 GWEN_DB_NODE *dbPasswords,
01059 int persistent) {
01060 GWEN_GUI_CGUI *cgui;
01061
01062 assert(gui);
01063 cgui=GWEN_INHERIT_GETDATA(GWEN_GUI, GWEN_GUI_CGUI, gui);
01064 assert(cgui);
01065
01066 GWEN_DB_Group_free(cgui->dbPasswords);
01067 cgui->dbPasswords=dbPasswords;
01068 cgui->persistentPasswords=persistent;
01069 }
01070
01071
01072
01073 GWEN_DB_NODE *GWEN_Gui_CGui_GetPasswordDb(const GWEN_GUI *gui) {
01074 GWEN_GUI_CGUI *cgui;
01075
01076 assert(gui);
01077 cgui=GWEN_INHERIT_GETDATA(GWEN_GUI, GWEN_GUI_CGUI, gui);
01078 assert(cgui);
01079
01080 return cgui->dbPasswords;
01081 }
01082
01083
01084
01085 void GWEN_Gui_CGui_SetCertDb(GWEN_GUI *gui, GWEN_DB_NODE *dbCerts) {
01086 GWEN_GUI_CGUI *cgui;
01087
01088 assert(gui);
01089 cgui=GWEN_INHERIT_GETDATA(GWEN_GUI, GWEN_GUI_CGUI, gui);
01090 assert(cgui);
01091
01092 GWEN_DB_Group_free(cgui->dbCerts);
01093 cgui->dbCerts=dbCerts;
01094 }
01095
01096
01097
01098 GWEN_DB_NODE *GWEN_Gui_CGui_GetCertDb(const GWEN_GUI *gui) {
01099 GWEN_GUI_CGUI *cgui;
01100
01101 assert(gui);
01102 cgui=GWEN_INHERIT_GETDATA(GWEN_GUI, GWEN_GUI_CGUI, gui);
01103 assert(cgui);
01104
01105 return cgui->dbCerts;
01106 }
01107
01108