cgui.c

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

Generated on Wed Sep 3 15:21:57 2008 for gwenhywfar by  doxygen 1.5.6