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 #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         /* Some systems have iconv in libc, some have it in libiconv
00210            (OSF/1 and those with the standalone portable GNU libiconv
00211            installed). Check which one is available. The define
00212            ICONV_CONST will be "" or "const" accordingly. */
00213         ICONV_CONST char *pInbuf;
00214         size_t inLeft;
00215         size_t outLeft;
00216         size_t done;
00217         size_t space;
00218 
00219         /* convert */
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   } /* while */
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   // disable canonical mode to receive a single character
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   /* re-enable canonical mode (if previously disabled) */
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   /* if possible, disable echo from stdin to stderr during password
00374    * entry */
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           /* too few characters */
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             /* bad character */
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         /* buffer full */
00466         fprintf(stderr, "\007");
00467       }
00468     }
00469   } /* for */
00470 
00471 #ifdef HAVE_TERMIOS_H
00472   /* re-enable echo (if previously disabled) */
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   } /* for */
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     } /* for */
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   /* nothing to do right now */
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   } /* while */
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   /* hash token and pin */
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           /* accept this input */
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     } /* for */
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 

Generated on Sat Jan 2 09:32:35 2010 for gwenhywfar by  doxygen 1.6.1