gwenhywfar  4.3.3
gui.c
Go to the documentation of this file.
1 /***************************************************************************
2  begin : Fri Feb 07 2003
3  copyright : (C) 2003-2010 by Martin Preuss
4  email : martin@libchipcard.de
5 
6  ***************************************************************************
7  * *
8  * This library is free software; you can redistribute it and/or *
9  * modify it under the terms of the GNU Lesser General Public *
10  * License as published by the Free Software Foundation; either *
11  * version 2.1 of the License, or (at your option) any later version. *
12  * *
13  * This library is distributed in the hope that it will be useful, *
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
16  * Lesser General Public License for more details. *
17  * *
18  * You should have received a copy of the GNU Lesser General Public *
19  * License along with this library; if not, write to the Free Software *
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21  * MA 02111-1307 USA *
22  * *
23  ***************************************************************************/
24 
25 
26 #ifdef HAVE_CONFIG_H
27 # include <config.h>
28 #endif
29 
30 #define DISABLE_DEBUGLOG
31 
32 
33 #ifndef ICONV_CONST
34 # define ICONV_CONST
35 #endif
36 
37 
38 #include "gui_p.h"
39 #include "dlg_input_l.h"
40 #include "dlg_message_l.h"
41 #include "dlg_progress_l.h"
42 #include "dlg_showbox_l.h"
43 #include "i18n_l.h"
44 
45 #include <gwenhywfar/debug.h>
46 #include <gwenhywfar/dialog_be.h>
47 #include <gwenhywfar/url.h>
48 #include <gwenhywfar/syncio_socket.h>
49 #include <gwenhywfar/syncio_buffered.h>
50 #include <gwenhywfar/syncio_tls.h>
51 #include <gwenhywfar/syncio_http.h>
52 
53 #include <stdarg.h>
54 #include <string.h>
55 #include <errno.h>
56 #include <ctype.h>
57 
58 #ifdef HAVE_ICONV_H
59 # include <iconv.h>
60 #endif
61 
62 
63 
65 
66 
68 
69 
70 
72  GWEN_GUI *gui;
73 
76  gui->refCount=1;
77 
78  gui->checkCertFn=GWEN_Gui_CheckCertBuiltIn;
79  gui->getSyncIoFn=GWEN_Gui_Internal_GetSyncIo;
80 
81  gui->progressDataTree=GWEN_ProgressData_Tree_new();
82  gui->activeDialogs=GWEN_Dialog_List_new();
83 
84  return gui;
85 }
86 
87 
88 
89 void GWEN_Gui_free(GWEN_GUI *gui) {
90  if (gui) {
91  assert(gui->refCount);
92  if ((--gui->refCount)==0) {
94 
95  GWEN_Dialog_List_free(gui->activeDialogs);
96  GWEN_ProgressData_Tree_free(gui->progressDataTree);
97  free(gui->name);
98  free(gui->charSet);
99 
100  GWEN_FREE_OBJECT(gui);
101  }
102  }
103 }
104 
105 
106 
108  assert(gui);
109  DBG_INFO(GWEN_LOGDOMAIN, "Using own callbacks in gui %p", gui);
110  gui->progressStartFn=GWEN_Gui_Internal_ProgressStart;
111  gui->progressAdvanceFn=GWEN_Gui_Internal_ProgressAdvance;
112  gui->progressSetTotalFn=GWEN_Gui_Internal_ProgressSetTotal;
113  gui->progressLogFn=GWEN_Gui_Internal_ProgressLog;
114  gui->progressEndFn=GWEN_Gui_Internal_ProgressEnd;
115  gui->inputBoxFn=GWEN_Gui_Internal_InputBox;
116  gui->messageBoxFn=GWEN_Gui_Internal_MessageBox;
117  gui->showBoxFn=GWEN_Gui_Internal_ShowBox;
118  gui->hideBoxFn=GWEN_Gui_Internal_HideBox;
119 }
120 
121 
122 
124  assert(gui);
125  assert(gui->refCount);
126  gui->refCount++;
127 }
128 
129 
130 
132  if (gui)
133  GWEN_Gui_Attach(gui);
134  if (gwenhywfar_gui)
136  gwenhywfar_gui=gui;
137 }
138 
139 
140 
142  return gwenhywfar_gui;
143 }
144 
145 
146 
147 int GWEN_Gui_ConvertFromUtf8(const GWEN_GUI *gui, const char *text, int len, GWEN_BUFFER *tbuf) {
148  assert(gui);
149  assert(len);
150 
151  if (gui->charSet) {
152  if (strcasecmp(gui->charSet, "utf-8")!=0) {
153 #ifndef HAVE_ICONV
155  "iconv not available, can not convert to \"%s\"",
156  gui->charSet);
157 #else
158  iconv_t ic;
159 
160  ic=iconv_open(gui->charSet, "UTF-8");
161  if (ic==((iconv_t)-1)) {
162  DBG_ERROR(GWEN_LOGDOMAIN, "Charset \"%s\" not available",
163  gui->charSet);
164  }
165  else {
166  char *outbuf;
167  char *pOutbuf;
168  /* Some systems have iconv in libc, some have it in libiconv
169  (OSF/1 and those with the standalone portable GNU libiconv
170  installed). Check which one is available. The define
171  ICONV_CONST will be "" or "const" accordingly. */
172  ICONV_CONST char *pInbuf;
173  size_t inLeft;
174  size_t outLeft;
175  size_t done;
176  size_t space;
177 
178  /* convert */
179  pInbuf=(char*)text;
180 
181  outLeft=len*2;
182  space=outLeft;
183  outbuf=(char*)malloc(outLeft);
184  assert(outbuf);
185 
186  inLeft=len;
187  pInbuf=(char*)text;
188  pOutbuf=outbuf;
189  done=iconv(ic, &pInbuf, &inLeft, &pOutbuf, &outLeft);
190  if (done==(size_t)-1) {
191  DBG_ERROR(GWEN_LOGDOMAIN, "Error in conversion: %s (%d)",
192  strerror(errno), errno);
193  free(outbuf);
194  iconv_close(ic);
195  return GWEN_ERROR_GENERIC;
196  }
197 
198  GWEN_Buffer_AppendBytes(tbuf, outbuf, space-outLeft);
199  free(outbuf);
200  DBG_DEBUG(GWEN_LOGDOMAIN, "Conversion done.");
201  iconv_close(ic);
202  return 0;
203  }
204 #endif
205  }
206  }
207 
208  GWEN_Buffer_AppendBytes(tbuf, text, len);
209  return 0;
210 }
211 
212 
213 
214 void GWEN_Gui_GetRawText(const GWEN_GUI *gui, const char *text, GWEN_BUFFER *tbuf) {
215  const char *p;
216  int rv;
217 
218  assert(text);
219  p=text;
220  while ((p=strchr(p, '<'))) {
221  const char *t;
222 
223  t=p;
224  t++;
225  if (toupper(*t)=='H') {
226  t++;
227  if (toupper(*t)=='T') {
228  t++;
229  if (toupper(*t)=='M') {
230  t++;
231  if (toupper(*t)=='L') {
232  break;
233  }
234  }
235  }
236  }
237  p++;
238  } /* while */
239 
240  if (p)
241  rv=GWEN_Gui_ConvertFromUtf8(gui, text, (p-text), tbuf);
242  else
243  rv=GWEN_Gui_ConvertFromUtf8(gui, text, strlen(text), tbuf);
244  if (rv) {
245  DBG_ERROR(GWEN_LOGDOMAIN, "Error converting text");
246  GWEN_Buffer_Reset(tbuf);
247  if (p)
248  GWEN_Buffer_AppendBytes(tbuf, text, (p-text));
249  else
250  GWEN_Buffer_AppendString(tbuf, text);
251  }
252 }
253 
254 
255 
259 
260  assert(gui);
261  of=gui->messageBoxFn;
262  gui->messageBoxFn=f;
263  return of;
264 }
265 
266 
267 
271 
272  assert(gui);
273  of=gui->inputBoxFn;
274  gui->inputBoxFn=f;
275  return of;
276 }
277 
278 
279 
283 
284  assert(gui);
285  of=gui->showBoxFn;
286  gui->showBoxFn=f;
287  return of;
288 }
289 
290 
291 
295 
296  assert(gui);
297  of=gui->hideBoxFn;
298  gui->hideBoxFn=f;
299  return of;
300 }
301 
302 
303 
307 
308  assert(gui);
309  of=gui->progressStartFn;
310  gui->progressStartFn=f;
311  return of;
312 }
313 
314 
315 
319 
320  assert(gui);
321  of=gui->progressAdvanceFn;
322  gui->progressAdvanceFn=f;
323  return of;
324 }
325 
326 
327 
331 
332  assert(gui);
333  of=gui->progressSetTotalFn;
334  gui->progressSetTotalFn=f;
335  return of;
336 }
337 
338 
339 
343 
344  assert(gui);
345  of=gui->progressLogFn;
346  gui->progressLogFn=f;
347  return of;
348 }
349 
350 
351 
355 
356  assert(gui);
357  of=gui->progressEndFn;
358  gui->progressEndFn=f;
359  return of;
360 }
361 
362 
363 
367 
368  assert(gui);
369  of=gui->printFn;
370  gui->printFn=f;
371  return of;
372 }
373 
374 
375 
379 
380  assert(gui);
381  of=gui->getPasswordFn;
382  gui->getPasswordFn=f;
383  return of;
384 }
385 
386 
387 
392 
393  assert(gui);
394  of=gui->setPasswordStatusFn;
395  gui->setPasswordStatusFn=f;
396  return of;
397 }
398 
399 
400 
404 
405  assert(gui);
406  of=gui->logHookFn;
407  gui->logHookFn=f;
408 
409  return of;
410 }
411 
412 
413 
417 
418  assert(gui);
419  of=gui->waitForSocketsFn;
420  gui->waitForSocketsFn=f;
421 
422  return of;
423 }
424 
425 
426 
429 
430  assert(gui);
431  of=gui->checkCertFn;
432  gui->checkCertFn=f;
433 
434  return of;
435 }
436 
437 
438 
441 
442  assert(gui);
443  of=gui->execDialogFn;
444  gui->execDialogFn=f;
445 
446  return of;
447 }
448 
449 
450 
453 
454  assert(gui);
455  of=gui->openDialogFn;
456  gui->openDialogFn=f;
457 
458  return of;
459 }
460 
461 
462 
465 
466  assert(gui);
467  of=gui->closeDialogFn;
468  gui->closeDialogFn=f;
469 
470  return of;
471 }
472 
473 
474 
477 
478  assert(gui);
479  of=gui->runDialogFn;
480  gui->runDialogFn=f;
481 
482  return of;
483 }
484 
485 
486 
490 
491  assert(gui);
492  of=gui->readDialogPrefsFn;
493  gui->readDialogPrefsFn=f;
494 
495  return of;
496 }
497 
498 
499 
503 
504  assert(gui);
505  of=gui->writeDialogPrefsFn;
506  gui->writeDialogPrefsFn=f;
507 
508  return of;
509 }
510 
511 
512 
515 
516  assert(gui);
517  of=gui->getFileNameFn;
518  gui->getFileNameFn=f;
519 
520  return of;
521 }
522 
523 
524 
527 
528  assert(gui);
529  of=gui->getSyncIoFn;
530  gui->getSyncIoFn=f;
531 
532  return of;
533 }
534 
535 
536 
541 
542  assert(gui);
543  of=gui->keyDataFromTextOpenSslFn;
544  gui->keyDataFromTextOpenSslFn=f;
545 
546  return of;
547 
548 }
549 
550 
551 
552 uint32_t GWEN_Gui_GetFlags(const GWEN_GUI *gui) {
553  assert(gui);
554  return gui->flags;
555 }
556 
557 
558 
559 void GWEN_Gui_SetFlags(GWEN_GUI *gui, uint32_t fl) {
560  assert(gui);
561  gui->flags=fl;
562 }
563 
564 
565 
566 void GWEN_Gui_AddFlags(GWEN_GUI *gui, uint32_t fl) {
567  assert(gui);
568  gui->flags|=fl;
569 }
570 
571 
572 
573 void GWEN_Gui_SubFlags(GWEN_GUI *gui, uint32_t fl) {
574  assert(gui);
575  gui->flags&=~fl;
576 }
577 
578 
579 
580 void GWEN_Gui_SetName(GWEN_GUI *gui, const char *name) {
581  free(gui->name);
582  if (name) gui->name=strdup(name);
583  else gui->name=NULL;
584 }
585 
586 
587 
588 const char *GWEN_Gui_GetName(void) {
589  if (gwenhywfar_gui)
590  return gwenhywfar_gui->name;
591  return NULL;
592 }
593 
594 
595 
596 const char *GWEN_Gui_GetCharSet(const GWEN_GUI *gui) {
597  if (gui)
598  return gui->charSet;
599  return NULL;
600 }
601 
602 
603 
604 void GWEN_Gui_SetCharSet(GWEN_GUI *gui, const char *s) {
605  if (gui) {
606  free(gui->charSet);
607  if (s)
608  gui->charSet=strdup(s);
609  else
610  gui->charSet=NULL;
611  }
612 }
613 
614 
615 
616 
617 
618 
619 
620 
621 
622 
623 int GWEN_Gui_MessageBox(uint32_t flags,
624  const char *title,
625  const char *text,
626  const char *b1,
627  const char *b2,
628  const char *b3,
629  uint32_t guiid) {
630  if (gwenhywfar_gui && gwenhywfar_gui->messageBoxFn)
631  return gwenhywfar_gui->messageBoxFn(gwenhywfar_gui,
632  flags,
633  title,
634  text,
635  b1, b2, b3, guiid);
637 }
638 
639 
640 
641 void GWEN_Gui_ShowError(const char *title, const char *fmt, ...) {
642  va_list list;
643  char msgbuffer[2048];
644  int rv;
645 
646  /* prepare list for va_arg */
647  va_start(list, fmt);
648  rv=vsnprintf(msgbuffer, sizeof(msgbuffer), fmt, list);
649  if (rv<0 || rv>=(int)(sizeof(msgbuffer))) {
650  DBG_WARN(GWEN_LOGDOMAIN, "Internal buffer too small for message, truncating (%d>%d)",
651  rv, (int)(sizeof(msgbuffer)));
652  }
653 
657  title,
658  msgbuffer,
659  I18N("Dismiss"), NULL, NULL, 0);
660 }
661 
662 
663 
664 int GWEN_Gui_InputBox(uint32_t flags,
665  const char *title,
666  const char *text,
667  char *buffer,
668  int minLen,
669  int maxLen,
670  uint32_t guiid) {
671  if (gwenhywfar_gui && gwenhywfar_gui->inputBoxFn)
672  return gwenhywfar_gui->inputBoxFn(gwenhywfar_gui,
673  flags,
674  title,
675  text,
676  buffer,
677  minLen, maxLen, guiid);
679 }
680 
681 
682 
683 uint32_t GWEN_Gui_ShowBox(uint32_t flags,
684  const char *title,
685  const char *text,
686  uint32_t guiid) {
687  if (gwenhywfar_gui && gwenhywfar_gui->showBoxFn)
688  return gwenhywfar_gui->showBoxFn(gwenhywfar_gui,
689  flags,
690  title,
691  text,
692  guiid);
693  return 0;
694 }
695 
696 
697 
698 void GWEN_Gui_HideBox(uint32_t id) {
699  if (gwenhywfar_gui && gwenhywfar_gui->hideBoxFn)
700  return gwenhywfar_gui->hideBoxFn(gwenhywfar_gui, id);
701 }
702 
703 
704 
705 uint32_t GWEN_Gui_ProgressStart(uint32_t progressFlags,
706  const char *title,
707  const char *text,
708  uint64_t total,
709  uint32_t guiid) {
710  if (gwenhywfar_gui && gwenhywfar_gui->progressStartFn)
711  return gwenhywfar_gui->progressStartFn(gwenhywfar_gui,
712  progressFlags,
713  title,
714  text,
715  total,
716  guiid);
717  return 0;
718 }
719 
720 
721 
722 int GWEN_Gui_ProgressAdvance(uint32_t id, uint32_t progress) {
723  if (gwenhywfar_gui && gwenhywfar_gui->progressAdvanceFn)
724  return gwenhywfar_gui->progressAdvanceFn(gwenhywfar_gui,
725  id,
726  progress);
727  return 0;
728 }
729 
730 
731 
732 int GWEN_Gui_ProgressSetTotal(uint32_t id, uint64_t total) {
733  if (gwenhywfar_gui && gwenhywfar_gui->progressSetTotalFn)
734  return gwenhywfar_gui->progressSetTotalFn(gwenhywfar_gui,
735  id,
736  total);
737  return 0;
738 }
739 
740 
741 
742 int GWEN_Gui_ProgressLog(uint32_t id,
743  GWEN_LOGGER_LEVEL level,
744  const char *text) {
745  if (gwenhywfar_gui && gwenhywfar_gui->progressLogFn)
746  return gwenhywfar_gui->progressLogFn(gwenhywfar_gui,
747  id, level, text);
748  return 0;
749 }
750 
751 
752 
753 int GWEN_Gui_ProgressLog2(uint32_t id,
754  GWEN_LOGGER_LEVEL level,
755  const char *fmt, ...) {
756  va_list list;
757  char msgbuffer[2048];
758  int rv;
759 
760  /* prepare list for va_arg */
761  va_start(list, fmt);
762  rv=vsnprintf(msgbuffer, sizeof(msgbuffer), fmt, list);
763  if (rv<0 || rv>=(int)(sizeof(msgbuffer))) {
764  DBG_WARN(GWEN_LOGDOMAIN, "Internal buffer too small for message, truncating (%d>%d)",
765  rv, (int)(sizeof(msgbuffer)));
766  }
767 
768  return GWEN_Gui_ProgressLog(id, level, msgbuffer);
769 }
770 
771 
772 
773 int GWEN_Gui_ProgressEnd(uint32_t id) {
774  if (gwenhywfar_gui && gwenhywfar_gui->progressEndFn)
775  return gwenhywfar_gui->progressEndFn(gwenhywfar_gui, id);
777 }
778 
779 
780 
781 int GWEN_Gui_Print(const char *docTitle,
782  const char *docType,
783  const char *descr,
784  const char *text,
785  uint32_t guiid) {
786  if (gwenhywfar_gui && gwenhywfar_gui->printFn)
787  return gwenhywfar_gui->printFn(gwenhywfar_gui,
788  docTitle,
789  docType,
790  descr,
791  text,
792  guiid);
794 }
795 
796 
797 
798 int GWEN_Gui_GetPassword(uint32_t flags,
799  const char *token,
800  const char *title,
801  const char *text,
802  char *buffer,
803  int minLen,
804  int maxLen,
805  uint32_t guiid) {
806  if (gwenhywfar_gui) {
807  if (gwenhywfar_gui->getPasswordFn)
808  return gwenhywfar_gui->getPasswordFn(gwenhywfar_gui,
809  flags,
810  token,
811  title,
812  text,
813  buffer,
814  minLen,
815  maxLen,
816  guiid);
817  else
818  if (gwenhywfar_gui->inputBoxFn)
819  return gwenhywfar_gui->inputBoxFn(gwenhywfar_gui,
820  flags,
821  title,
822  text,
823  buffer,
824  minLen,
825  maxLen,
826  guiid);
827  }
829 }
830 
831 
832 
833 int GWEN_Gui_SetPasswordStatus(const char *token,
834  const char *pin,
836  uint32_t guiid) {
837  if (gwenhywfar_gui && gwenhywfar_gui->setPasswordStatusFn)
838  return gwenhywfar_gui->setPasswordStatusFn(gwenhywfar_gui,
839  token, pin, status, guiid);
841 }
842 
843 
844 
845 int GWEN_Gui_LogHook(const char *logDomain,
846  GWEN_LOGGER_LEVEL priority, const char *s) {
847  if (gwenhywfar_gui && gwenhywfar_gui->logHookFn) {
848  if (priority>=GWEN_LoggerLevel_Debug &&
849  logDomain &&
850  strcasecmp(logDomain, "gwenhywfar")==0)
851  /* don't send possibly sensitive data to the log function because
852  * some application tend to store the messages indiscriminately.
853  * In some cases sensitive information can be send to this function
854  * which we don't want the application to store */
855  return 0;
856  else {
857  int rv;
858 
859  if (gwenhywfar_gui->inLogHook==0) {
860  /* otherwise the log message seems to be uncritical, convey it */
861  gwenhywfar_gui->inLogHook++;
862  rv=gwenhywfar_gui->logHookFn(gwenhywfar_gui, logDomain, priority, s);
863  gwenhywfar_gui->inLogHook--;
864  return rv;
865  }
866  else
867  /* loghook recursion, don't convey */
868  return 0;
869  }
870  }
871  else
872  /* handle as usual */
873  return 0;
874 }
875 
876 
877 
878 int GWEN_Gui_WaitForSockets(GWEN_SOCKET_LIST2 *readSockets,
879  GWEN_SOCKET_LIST2 *writeSockets,
880  uint32_t guiid,
881  int msecs) {
882  if (gwenhywfar_gui && gwenhywfar_gui->waitForSocketsFn)
883  return gwenhywfar_gui->waitForSocketsFn(gwenhywfar_gui, readSockets, writeSockets, guiid, msecs);
884  else {
885  uint32_t pid;
886  time_t t0;
887  int wt;
888  int dist;
889 
890  t0=time(0);
891  if (msecs==GWEN_TIMEOUT_NONE) {
892  wt=0;
893  dist=0;
894  }
895  else if (msecs==GWEN_TIMEOUT_FOREVER) {
896  wt=0;
897  dist=500;
898  }
899  else {
900  wt=msecs/1000;
901  dist=500;
902  }
903 
908  I18N("Waiting for Data"),
909  "Waiting for data to become available",
910  wt,
911  0);
912  while(1) {
913  GWEN_SOCKETSET *rset;
914  GWEN_SOCKETSET *wset;
915  GWEN_SOCKET_LIST2_ITERATOR *sit;
916 
917  rset=GWEN_SocketSet_new();
918  wset=GWEN_SocketSet_new();
919 
920  /* fill read socket set */
921  if (readSockets) {
922  sit=GWEN_Socket_List2_First(readSockets);
923  if (sit) {
924  GWEN_SOCKET *s;
925 
926  s=GWEN_Socket_List2Iterator_Data(sit);
927  assert(s);
928 
929  while(s) {
930  GWEN_SocketSet_AddSocket(rset, s);
931  s=GWEN_Socket_List2Iterator_Next(sit);
932  }
933  GWEN_Socket_List2Iterator_free(sit);
934  }
935  }
936 
937  /* fill write socket set */
938  if (writeSockets) {
939  sit=GWEN_Socket_List2_First(writeSockets);
940  if (sit) {
941  GWEN_SOCKET *s;
942 
943  s=GWEN_Socket_List2Iterator_Data(sit);
944  assert(s);
945 
946  while(s) {
947  GWEN_SocketSet_AddSocket(wset, s);
948  s=GWEN_Socket_List2Iterator_Next(sit);
949  }
950  GWEN_Socket_List2Iterator_free(sit);
951  }
952  }
953 
954  if (GWEN_SocketSet_GetSocketCount(rset)==0 &&
956  /* no sockets to wait for, sleep for a few ms to keep cpu load down */
957  GWEN_SocketSet_free(wset);
958  GWEN_SocketSet_free(rset);
959 
960  if (msecs) {
961  /* only sleep if a timeout was given */
962  DBG_DEBUG(GWEN_LOGDOMAIN, "Sleeping (no socket)");
964  }
966  return GWEN_ERROR_TIMEOUT;
967  }
968  else {
969  int rv;
970  int v=0;
971 
972  rv=GWEN_Socket_Select(rset, wset, NULL, dist);
973  GWEN_SocketSet_free(wset);
974  GWEN_SocketSet_free(rset);
975 
976  if (rv!=GWEN_ERROR_TIMEOUT) {
978  return rv;
979  }
980 
981  if (wt) {
982  time_t t1;
983 
984  t1=time(0);
985  v=(int) difftime(t1, t0);
986  if (v>wt) {
988  return GWEN_ERROR_TIMEOUT;
989  }
990  }
991  rv=GWEN_Gui_ProgressAdvance(pid, v);
992  if (rv==GWEN_ERROR_USER_ABORTED) {
994  return rv;
995  }
996  }
997  } /* loop */
998  }
999 }
1000 
1001 
1002 
1003 int GWEN_Gui_CheckCert(const GWEN_SSLCERTDESCR *cd, GWEN_SYNCIO *sio, uint32_t guiid) {
1004  if (gwenhywfar_gui && gwenhywfar_gui->checkCertFn)
1005  return gwenhywfar_gui->checkCertFn(gwenhywfar_gui, cd, sio, guiid);
1006  else
1008 }
1009 
1010 
1011 
1013  const GWEN_SSLCERTDESCR *cd,
1014  GWEN_UNUSED GWEN_SYNCIO *sio, uint32_t guiid) {
1015  int rv;
1016  int isError;
1017  const char *hash;
1018  const char *status;
1019  const char *ipAddr;
1020  const char *statusOn;
1021  const char *statusOff;
1022  char varName[128];
1023  char dbuffer1[32];
1024  char dbuffer2[32];
1025  char buffer[8192];
1026  const GWEN_TIME *ti;
1027  const char *unknown;
1028  const char *commonName;
1029  const char *organizationName;
1030  const char *organizationalUnitName;
1031  const char *countryName;
1032  const char *localityName;
1033  const char *stateOrProvinceName;
1034 
1035  char *msg=I18S(
1036  "The following certificate has been received:\n"
1037  "Name : %s\n"
1038  "Organisation: %s\n"
1039  "Department : %s\n"
1040  "Country : %s\n"
1041  "City : %s\n"
1042  "State : %s\n"
1043  "Valid after : %s\n"
1044  "Valid until : %s\n"
1045  "Hash : %s\n"
1046  "Status : %s\n"
1047  "Do you wish to accept this certificate?"
1048 
1049  "<html>"
1050  " <p>"
1051  " The following certificate has been received:"
1052  " </p>"
1053  " <table>"
1054  " <tr><td>Name</td><td>%s</td></tr>"
1055  " <tr><td>Organisation</td><td>%s</td></tr>"
1056  " <tr><td>Department</td><td>%s</td></tr>"
1057  " <tr><td>Country</td><td>%s</td></tr>"
1058  " <tr><td>City</td><td>%s</td></tr>"
1059  " <tr><td>State</td><td>%s</td></tr>"
1060  " <tr><td>Valid after</td><td>%s</td></tr>"
1061  " <tr><td>Valid until</td><td>%s</td></tr>"
1062  " <tr><td>Hash</td><td>%s</td></tr>"
1063  " <tr><td>Status</td><td>%s%s%s</td></tr>"
1064  " </table>"
1065  " <p>"
1066  " Do you wish to accept this certificate?"
1067  " </p>"
1068  "</html>"
1069  );
1070 
1071  memset(dbuffer1, 0, sizeof(dbuffer1));
1072  memset(dbuffer2, 0, sizeof(dbuffer2));
1073  memset(varName, 0, sizeof(varName));
1074 
1075  isError=GWEN_SslCertDescr_GetIsError(cd);
1076 
1079  ipAddr=GWEN_SslCertDescr_GetIpAddress(cd);
1080 
1082  if (ti) {
1083  GWEN_BUFFER *tbuf;
1084 
1085  tbuf=GWEN_Buffer_new(0, 32, 0, 1);
1086  /* TRANSLATORS: This string is used as a template string to
1087  convert a given time into your local translated timeformat. The
1088  following characters are accepted in the template string: Y -
1089  digit of the year, M - digit of the month, D - digit of the day
1090  of month, h - digit of the hour, m - digit of the minute, s-
1091  digit of the second. All other characters are left unchanged. */
1092  if (GWEN_Time_toString(ti, I18N("YYYY/MM/DD hh:mm:ss"), tbuf)) {
1094  "Could not convert beforeDate to string");
1095  abort();
1096  }
1097  strncpy(dbuffer1, GWEN_Buffer_GetStart(tbuf), sizeof(dbuffer1)-1);
1098  GWEN_Buffer_free(tbuf);
1099  }
1100 
1102  if (ti) {
1103  GWEN_BUFFER *tbuf;
1104 
1105  tbuf=GWEN_Buffer_new(0, 32, 0, 1);
1106  if (GWEN_Time_toString(ti, I18N("YYYY/MM/DD hh:mm:ss"), tbuf)) {
1108  "Could not convert untilDate to string");
1109  abort();
1110  }
1111  strncpy(dbuffer2, GWEN_Buffer_GetStart(tbuf), sizeof(dbuffer2)-1);
1112  GWEN_Buffer_free(tbuf);
1113  }
1114 
1115  if (isError) {
1116  statusOn="<font color=red>";
1117  statusOff="</font>";
1118  }
1119  else {
1120  statusOn="<font color=green>";
1121  statusOff="</font>";
1122  }
1123 
1124  unknown=I18N("unknown");
1125  commonName=GWEN_SslCertDescr_GetCommonName(cd);
1126  if (!commonName)
1127  commonName=unknown;
1128  organizationName=GWEN_SslCertDescr_GetOrganizationName(cd);
1129  if (!organizationName)
1130  organizationName=unknown;
1131  organizationalUnitName=GWEN_SslCertDescr_GetOrganizationalUnitName(cd);
1132  if (!organizationalUnitName)
1133  organizationalUnitName=unknown;
1134  countryName=GWEN_SslCertDescr_GetCountryName(cd);
1135  if (!countryName)
1136  countryName=unknown;
1137  localityName=GWEN_SslCertDescr_GetLocalityName(cd);
1138  if (!localityName)
1139  localityName=unknown;
1140  stateOrProvinceName=GWEN_SslCertDescr_GetStateOrProvinceName(cd);
1141  if (!stateOrProvinceName)
1142  stateOrProvinceName=unknown;
1143  if (!status)
1144  status=unknown;
1145 
1146  snprintf(buffer, sizeof(buffer)-1,
1147  I18N(msg),
1148  commonName,
1149  organizationName,
1150  organizationalUnitName,
1151  countryName,
1152  localityName,
1153  stateOrProvinceName,
1154  dbuffer1, dbuffer2,
1155  hash,
1156  status,
1157  /* the same again for HTML */
1158  commonName,
1159  organizationName,
1160  organizationalUnitName,
1161  countryName,
1162  localityName,
1163  stateOrProvinceName,
1164  dbuffer1, dbuffer2,
1165  hash,
1166  statusOn,
1167  status,
1168  statusOff
1169  );
1170 
1174  I18N("Certificate Received"),
1175  buffer,
1176  I18N("Yes"), I18N("No"), 0, guiid);
1177  if (rv==1) {
1178  return 0;
1179  }
1180  else {
1181  DBG_NOTICE(GWEN_LOGDOMAIN, "User rejected certificate");
1182 
1183  return GWEN_ERROR_SSL_SECURITY;
1184  }
1185 }
1186 
1187 
1188 
1190  unsigned char *buffer,
1191  unsigned int bufLength) {
1192  if (gwenhywfar_gui && gwenhywfar_gui->keyDataFromTextOpenSslFn)
1193  return gwenhywfar_gui->keyDataFromTextOpenSslFn(gwenhywfar_gui,
1194  text,
1195  buffer,
1196  bufLength);
1198 }
1199 
1200 
1201 
1202 int GWEN_Gui_ExecDialog(GWEN_DIALOG *dlg, uint32_t guiid) {
1203  if (gwenhywfar_gui && gwenhywfar_gui->execDialogFn)
1204  return gwenhywfar_gui->execDialogFn(gwenhywfar_gui, dlg, guiid);
1206 }
1207 
1208 
1209 
1210 int GWEN_Gui_OpenDialog(GWEN_DIALOG *dlg, uint32_t guiid) {
1211  if (gwenhywfar_gui && gwenhywfar_gui->openDialogFn)
1212  return gwenhywfar_gui->openDialogFn(gwenhywfar_gui, dlg, guiid);
1214 }
1215 
1216 
1217 
1219  if (gwenhywfar_gui && gwenhywfar_gui->closeDialogFn)
1220  return gwenhywfar_gui->closeDialogFn(gwenhywfar_gui, dlg);
1222 }
1223 
1224 
1225 
1226 int GWEN_Gui_RunDialog(GWEN_DIALOG *dlg, int untilEnd) {
1227  if (gwenhywfar_gui && gwenhywfar_gui->runDialogFn)
1228  return gwenhywfar_gui->runDialogFn(gwenhywfar_gui, dlg, untilEnd);
1230 }
1231 
1232 
1233 
1234 
1235 int GWEN_Gui_GetFileName(const char *caption,
1237  uint32_t flags,
1238  const char *patterns,
1239  GWEN_BUFFER *pathBuffer,
1240  uint32_t guiid) {
1241  if (gwenhywfar_gui && gwenhywfar_gui->getFileNameFn)
1242  return gwenhywfar_gui->getFileNameFn(gwenhywfar_gui,
1243  caption,
1244  fnt,
1245  flags,
1246  patterns,
1247  pathBuffer,
1248  guiid);
1250 }
1251 
1252 
1253 
1254 int GWEN_Gui_ReadDialogPrefs(const char *groupName,
1255  const char *altName,
1256  GWEN_DB_NODE **pDb) {
1257  if (gwenhywfar_gui && gwenhywfar_gui->readDialogPrefsFn)
1258  return gwenhywfar_gui->readDialogPrefsFn(gwenhywfar_gui, groupName, altName, pDb);
1260 }
1261 
1262 
1263 
1264 int GWEN_Gui_WriteDialogPrefs(const char *groupName,
1265  GWEN_DB_NODE *db) {
1266  if (gwenhywfar_gui && gwenhywfar_gui->writeDialogPrefsFn)
1267  return gwenhywfar_gui->writeDialogPrefsFn(gwenhywfar_gui, groupName, db);
1269 }
1270 
1271 
1272 
1273 int GWEN_Gui_GetSyncIo(const char *url,
1274  const char *defaultProto,
1275  int defaultPort,
1276  GWEN_SYNCIO **pSio) {
1277  if (gwenhywfar_gui && gwenhywfar_gui->getSyncIoFn)
1278  return gwenhywfar_gui->getSyncIoFn(gwenhywfar_gui, url, defaultProto, defaultPort, pSio);
1280 }
1281 
1282 
1283 
1284 
1285 
1286 
1287 
1288 
1289 
1290 
1292  GWEN_PROGRESS_DATA *highest=NULL;
1293  GWEN_PROGRESS_DATA *t;
1294  GWEN_DIALOG *dlg=NULL;
1295 
1296  assert(gwenhywfar_gui);
1297 
1298  t=pd;
1299  while(t) {
1300  highest=t;
1301  t=GWEN_ProgressData_Tree_GetParent(t);
1302  }
1303 
1304  /* highest must always be visible */
1305  if (GWEN_ProgressData_GetShown(highest)==0)
1306  GWEN_ProgressData_SetShown(highest, 1);
1307 
1308  dlg=GWEN_ProgressData_GetDialog(highest);
1309  if (dlg==NULL) {
1310  int rv;
1311 
1312  /* need to create dialog for it */
1313  dlg=GWEN_DlgProgress_new();
1314  if (dlg==NULL) {
1315  DBG_ERROR(GWEN_LOGDOMAIN, "Unable to create progress dialog, maybe data not installed?");
1316  return GWEN_ERROR_INTERNAL;
1317  }
1320 
1323 
1324  rv=GWEN_Gui_OpenDialog(dlg, 0);
1325  if (rv<0) {
1326  DBG_ERROR(GWEN_LOGDOMAIN, "Unable to openDialog: %d", rv);
1327  GWEN_Dialog_free(dlg);
1328  return rv;
1329  }
1330 
1331  DBG_INFO(GWEN_LOGDOMAIN, "Setting new firstprogress: %08x",
1333  GWEN_DlgProgress_SetFirstProgress(dlg, highest);
1334  GWEN_ProgressData_SetDialog(highest, dlg);
1335  }
1336 
1337  if (pd!=highest) {
1338  DBG_INFO(GWEN_LOGDOMAIN, "Setting new second progress: %08x",
1341  GWEN_ProgressData_SetDialog(pd, dlg);
1343  }
1344 
1345  GWEN_Gui_RunDialog(dlg, 0);
1346 
1347  return 0;
1348 }
1349 
1350 
1351 
1353  if (GWEN_ProgressData_GetShown(pd)==0) {
1355  double dt;
1356  time_t t1;
1357 
1358  t1=time(0);
1359  dt=difftime(t1, GWEN_ProgressData_GetStartTime(pd));
1360  if ((int)dt>=GWEN_GUI_DELAY_SECS) {
1361  DBG_INFO(GWEN_LOGDOMAIN, "Progress %08x open for %d secs, showing",
1362  GWEN_ProgressData_GetId(pd), (int) dt);
1364  }
1365  }
1366  else
1368  }
1369 
1370  if (GWEN_ProgressData_GetShown(pd)==1) {
1371  if (GWEN_ProgressData_GetDialog(pd)==NULL) {
1373  }
1374  }
1375 }
1376 
1377 
1378 
1380  uint32_t progressFlags,
1381  const char *title,
1382  const char *text,
1383  uint64_t total,
1384  uint32_t guiid) {
1385  GWEN_PROGRESS_DATA *pdParent=NULL;
1386  GWEN_PROGRESS_DATA *pd;
1387  uint32_t id;
1388 
1389  id=++(gui->nextProgressId);
1390 
1391  DBG_DEBUG(GWEN_LOGDOMAIN, "ProgressStart: flags=%08x, title=[%s], total=%08x, guiid=%08x",
1392  progressFlags, title?title:"(none)", (uint32_t) total, guiid);
1393 
1394  if (guiid==0) {
1395  guiid=gui->lastProgressId;
1396  }
1397 
1398  if (guiid) {
1399  pdParent=GWEN_ProgressData_Tree_FindProgressById(gui->progressDataTree, guiid);
1400  if (pdParent==NULL) {
1401  DBG_WARN(GWEN_LOGDOMAIN, "Parent progress by id %08x not found", guiid);
1402  DBG_DEBUG(GWEN_LOGDOMAIN, "Title: [%s], Text: [%s]",
1403  title?title:"no title",
1404  text?text:"no text");
1405  }
1406  }
1407 
1408  pd=GWEN_ProgressData_new(gui, id, progressFlags, title, text, total);
1409  assert(pd);
1410  GWEN_ProgressData_SetPreviousId(pd, gui->lastProgressId);
1411  if (pdParent)
1412  GWEN_ProgressData_Tree_AddChild(pdParent, pd);
1413  else
1414  GWEN_ProgressData_Tree_Add(gui->progressDataTree, pd);
1415 
1416  GWEN_Gui_Internal_CheckShow(gui, pd);
1417 
1418  gui->lastProgressId=id;
1419 
1420  return id;
1421 }
1422 
1423 
1424 
1425 int GWEN_Gui_Internal_ProgressEnd(GWEN_GUI *gui, uint32_t pid) {
1426  GWEN_PROGRESS_DATA *pd;
1427  uint32_t parentPid=0;
1428 
1429  DBG_DEBUG(GWEN_LOGDOMAIN, "ProgressEnd: guiid=%08x", pid);
1430 
1431  if (pid==0) {
1432  pid=gui->lastProgressId;
1433  if (pid==0) {
1434  DBG_INFO(GWEN_LOGDOMAIN, "Last active progress not available");
1435  return GWEN_ERROR_INVALID;
1436  }
1437  }
1438 
1439  pd=GWEN_ProgressData_Tree_FindProgressById(gui->progressDataTree, pid);
1440  if (pd==NULL) {
1441  DBG_ERROR(GWEN_LOGDOMAIN, "Progress by id %08x not found", pid);
1442  return GWEN_ERROR_INVALID;
1443  }
1444  else {
1445  GWEN_DIALOG *dlg;
1446  GWEN_PROGRESS_DATA *previousPd;
1447 
1448  /* set previous progress id */
1449  gui->lastProgressId=GWEN_ProgressData_GetPreviousId(pd);
1450 
1451  /* find next highest active progress */
1452  previousPd=GWEN_ProgressData_Tree_GetParent(pd);
1453  if (previousPd)
1454  parentPid=GWEN_ProgressData_GetId(previousPd);
1455  while(previousPd) {
1456  if (GWEN_ProgressData_GetShown(previousPd))
1457  break;
1458  previousPd=GWEN_ProgressData_Tree_GetParent(previousPd);
1459  }
1460 
1462  if (dlg) {
1463  GWEN_PROGRESS_DATA *primary;
1464  GWEN_PROGRESS_DATA *secondary;
1465 
1466  primary=GWEN_DlgProgress_GetFirstProgress(dlg);
1467  secondary=GWEN_DlgProgress_GetSecondProgress(dlg);
1468 
1469  /* force update of progress bar */
1470  GWEN_DlgProgress_Advanced(dlg, pd);
1471  GWEN_Gui_RunDialog(dlg, 0);
1472 
1473  if (primary==pd) {
1474  int rv;
1475 
1476  DBG_DEBUG(GWEN_LOGDOMAIN, "Progress %08x is primary, closing dialog",
1478 
1479  if (secondary) {
1480  DBG_WARN(GWEN_LOGDOMAIN, "There is still a secondary progress!");
1482  GWEN_ProgressData_SetDialog(secondary, NULL);
1483  }
1484 
1485  /* this is the primary progress, with this closed we can also
1486  * close the dialog */
1487  DBG_INFO(GWEN_LOGDOMAIN, "Closing progress dialog");
1488  GWEN_DlgProgress_AddLogText(dlg, GWEN_LoggerLevel_Info, I18N("Operation finished, you can now close this window."));
1489 
1490  // run dialog until end, close then
1492  if (GWEN_DlgProgress_GetStayOpen(dlg)) {
1493  rv=GWEN_Gui_RunDialog(dlg, 1);
1494  if (rv<0) {
1495  DBG_ERROR(GWEN_LOGDOMAIN, "Unable to runDialog: %d", rv);
1496  /*GWEN_Dialog_free(dlg);
1497  return rv;*/
1498  }
1499  }
1500 
1501  rv=GWEN_Gui_CloseDialog(dlg);
1502  if (rv<0) {
1503  DBG_ERROR(GWEN_LOGDOMAIN, "Unable to closeDialog: %d", rv);
1504  GWEN_Dialog_free(dlg);
1505  return rv;
1506  }
1507  GWEN_Dialog_free(dlg);
1508  }
1509  else if (secondary==pd) {
1510  /* t is maybe the next higher progress, it will become the second progress */
1511  if (previousPd && previousPd!=GWEN_DlgProgress_GetFirstProgress(dlg)) {
1512  DBG_DEBUG(GWEN_LOGDOMAIN, "Progress %08x becomes new second progress",
1513  GWEN_ProgressData_GetId(previousPd));
1515  GWEN_ProgressData_SetDialog(pd, dlg);
1516  }
1517  else {
1518  DBG_INFO(GWEN_LOGDOMAIN, "No next secondary progress");
1520  }
1521  }
1522  else {
1523  DBG_ERROR(GWEN_LOGDOMAIN, "Progress %08x is neither primary nor secondary, SNH",
1525  }
1526  }
1527  else {
1528  DBG_DEBUG(GWEN_LOGDOMAIN, "Progress %08x has no dialog", GWEN_ProgressData_GetId(pd));
1529  }
1530 
1532  GWEN_ProgressData_Tree_Del(pd);
1534  }
1535 
1536  return 0;
1537 }
1538 
1539 
1540 
1541 int GWEN_Gui_Internal_ProgressAdvance(GWEN_GUI *gui, uint32_t pid, uint64_t progress) {
1542  GWEN_PROGRESS_DATA *pd;
1543  int aborted=0;
1544 
1545  if (pid==0) {
1546  pid=gui->lastProgressId;
1547  if (pid==0) {
1548  DBG_INFO(GWEN_LOGDOMAIN, "Last active progress not available");
1549  return GWEN_ERROR_INVALID;
1550  }
1551  }
1552 
1553  pd=GWEN_ProgressData_Tree_FindProgressById(gui->progressDataTree, pid);
1554  if (pd==NULL) {
1555  DBG_ERROR(GWEN_LOGDOMAIN, "Progress by id %08x not found", pid);
1556  return GWEN_ERROR_INVALID;
1557  }
1558  else {
1559  GWEN_DIALOG *dlg;
1560 
1561  if (progress==GWEN_GUI_PROGRESS_ONE)
1562  progress=GWEN_ProgressData_GetCurrent(pd)+1;
1563  else if (progress==GWEN_GUI_PROGRESS_NONE)
1564  progress=GWEN_ProgressData_GetCurrent(pd);
1565  GWEN_ProgressData_SetCurrent(pd, progress);
1566  GWEN_Gui_Internal_CheckShow(gui, pd);
1567 
1569  if (dlg) {
1570  time_t t0;
1571  time_t t1;
1572 
1574  t1=time(0);
1575  if (t0!=t1) {
1576  GWEN_DlgProgress_Advanced(dlg, pd);
1577  GWEN_Gui_RunDialog(dlg, 0);
1579  }
1580  }
1581  aborted=GWEN_ProgressData_GetAborted(pd);
1582  }
1583 
1584  if (aborted)
1585  return GWEN_ERROR_USER_ABORTED;
1586  return 0;
1587 }
1588 
1589 
1590 
1591 int GWEN_Gui_Internal_ProgressSetTotal(GWEN_GUI *gui, uint32_t pid, uint64_t total) {
1592  GWEN_PROGRESS_DATA *pd;
1593  int aborted=0;
1594 
1595  if (pid==0) {
1596  pid=gui->lastProgressId;
1597  if (pid==0) {
1598  DBG_INFO(GWEN_LOGDOMAIN, "Last active progress not available");
1599  return GWEN_ERROR_INVALID;
1600  }
1601  }
1602 
1603  pd=GWEN_ProgressData_Tree_FindProgressById(gui->progressDataTree, pid);
1604  if (pd==NULL) {
1605  DBG_ERROR(GWEN_LOGDOMAIN, "Progress by id %08x not found", pid);
1606  return GWEN_ERROR_INVALID;
1607  }
1608  else {
1609  GWEN_DIALOG *dlg;
1610 
1611  GWEN_ProgressData_SetTotal(pd, total);
1612  GWEN_Gui_Internal_CheckShow(gui, pd);
1613 
1615  if (dlg) {
1616  time_t t0;
1617  time_t t1;
1618 
1620  t1=time(0);
1621  if (t0!=t1) {
1623  GWEN_Gui_RunDialog(dlg, 0);
1625  }
1626  }
1627  aborted=GWEN_ProgressData_GetAborted(pd);
1628  }
1629 
1630  if (aborted)
1631  return GWEN_ERROR_USER_ABORTED;
1632  return 0;
1633 }
1634 
1635 
1636 
1638  uint32_t pid,
1639  GWEN_LOGGER_LEVEL level,
1640  const char *text) {
1641  GWEN_PROGRESS_DATA *pd;
1642  int aborted=0;
1643 
1644  if (pid==0) {
1645  pid=gui->lastProgressId;
1646  if (pid==0) {
1647  DBG_INFO(GWEN_LOGDOMAIN, "Last active progress not available");
1648  return GWEN_ERROR_INVALID;
1649  }
1650  }
1651 
1652  pd=GWEN_ProgressData_Tree_FindProgressById(gui->progressDataTree, pid);
1653  if (pd==NULL) {
1654  DBG_ERROR(GWEN_LOGDOMAIN, "Progress by id %08x not found", pid);
1655  return GWEN_ERROR_INVALID;
1656  }
1657  else {
1658  GWEN_DIALOG *dlg;
1659 
1660  if (level<=GWEN_LoggerLevel_Notice)
1662  if (level<=GWEN_LoggerLevel_Warning)
1664  GWEN_Gui_Internal_CheckShow(gui, pd);
1665 
1667  if (dlg) {
1668  if (level<=GWEN_LoggerLevel_Warning) {
1671  }
1672 
1673  GWEN_DlgProgress_AddLogText(dlg, level, text);
1674  GWEN_Gui_RunDialog(dlg, 0);
1675  }
1676  else
1677  GWEN_ProgressData_AddLogText(pd, level, text);
1678 
1679  aborted=GWEN_ProgressData_GetAborted(pd);
1680  }
1681 
1682  if (aborted)
1683  return GWEN_ERROR_USER_ABORTED;
1684  return 0;
1685 }
1686 
1687 
1688 
1690  uint32_t flags,
1691  const char *title,
1692  const char *text,
1693  char *buffer,
1694  int minLen,
1695  int maxLen,
1696  uint32_t guiid) {
1697  GWEN_DIALOG *dlg;
1698  int rv;
1699 
1700  dlg=GWEN_DlgInput_new(flags, title, text, minLen, maxLen);
1701  if (dlg==NULL) {
1702  DBG_ERROR(GWEN_LOGDOMAIN, "Could not create dialog");
1703  return GWEN_ERROR_INTERNAL;
1704  }
1705 
1706  rv=GWEN_Gui_ExecDialog(dlg, 0);
1707  if (rv==1) {
1708  rv=GWEN_DlgInput_CopyInput(dlg, buffer, maxLen);
1709  if (rv<0) {
1710  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
1711  GWEN_Dialog_free(dlg);
1712  return rv;
1713  }
1714  GWEN_Dialog_free(dlg);
1715  return 0;
1716  }
1717  else {
1718  DBG_ERROR(GWEN_LOGDOMAIN, "User aborted");
1719  GWEN_Dialog_free(dlg);
1720  return GWEN_ERROR_USER_ABORTED;
1721  }
1722 }
1723 
1724 
1725 
1727  uint32_t flags,
1728  const char *title,
1729  const char *text,
1730  const char *b1,
1731  const char *b2,
1732  const char *b3,
1733  uint32_t guiid) {
1734  GWEN_DIALOG *dlg;
1735  int rv;
1736 
1737  dlg=GWEN_DlgMessage_new(flags, title, text, b1, b2, b3);
1738  if (dlg==NULL) {
1739  DBG_ERROR(GWEN_LOGDOMAIN, "Could not create dialog");
1740  return GWEN_ERROR_INTERNAL;
1741  }
1742 
1743  GWEN_Gui_ExecDialog(dlg, 0);
1745  GWEN_Dialog_free(dlg);
1746  return rv;
1747 }
1748 
1749 
1750 
1752  uint32_t flags,
1753  const char *title,
1754  const char *text,
1755  uint32_t guiid) {
1756  GWEN_DIALOG *dlg;
1757  int rv;
1758  uint32_t id;
1759 
1760  id=++(gui->nextDialogId);
1761 
1762  dlg=GWEN_DlgShowBox_new(flags, title, text);
1763  if (dlg==NULL) {
1764  DBG_ERROR(GWEN_LOGDOMAIN, "Could not create dialog");
1765  return 0;
1766  }
1767 
1768  GWEN_Dialog_SetGuiId(dlg, id);
1769 
1770  rv=GWEN_Gui_OpenDialog(dlg, guiid);
1771  if (rv<0) {
1772  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
1773  GWEN_Dialog_free(dlg);
1774  return 0;
1775  }
1776 
1777  GWEN_Dialog_List_Add(dlg, gui->activeDialogs);
1778 
1779  return id;
1780 }
1781 
1782 
1783 
1784 void GWEN_Gui_Internal_HideBox(GWEN_GUI *gui, uint32_t id) {
1785  GWEN_DIALOG *dlg;
1786 
1787  if (id) {
1788  dlg=GWEN_Dialog_List_First(gui->activeDialogs);
1789  while(dlg) {
1790  if (GWEN_Dialog_GetGuiId(dlg)==id)
1791  break;
1792  dlg=GWEN_Dialog_List_Next(dlg);
1793  }
1794  }
1795  else
1796  dlg=GWEN_Dialog_List_Last(gui->activeDialogs);
1797 
1798  if (dlg) {
1799  int rv;
1800 
1801  rv=GWEN_Gui_CloseDialog(dlg);
1802  if (rv<0) {
1803  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
1804  }
1805  GWEN_Dialog_List_Del(dlg);
1806  GWEN_Dialog_free(dlg);
1807  }
1808 }
1809 
1810 
1811 
1813  const char *url,
1814  const char *defaultProto,
1815  int defaultPort,
1816  GWEN_SYNCIO **pSio) {
1817  GWEN_URL *u;
1818  const char *s;
1819  int port;
1820  const char *addr;
1821 
1822  if (!(url && *url)) {
1823  DBG_ERROR(GWEN_LOGDOMAIN, "Empty URL");
1824  return GWEN_ERROR_INVALID;
1825  }
1826 
1827  u=GWEN_Url_fromString(url);
1828  if (u==NULL) {
1829  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid URL [%s]", url);
1830  return GWEN_ERROR_INVALID;
1831  }
1832 
1833  /* determine protocol and port */
1834  s=GWEN_Url_GetProtocol(u);
1835  if (!(s && *s))
1836  s=defaultProto;
1837  if (!(s && *s))
1838  s="http";
1839  port=GWEN_Url_GetPort(u);
1840  if (port<1)
1841  port=defaultPort;
1842  if (port<1)
1843  port=80;
1844  addr=GWEN_Url_GetServer(u);
1845  if (!(addr && *addr)) {
1846  DBG_ERROR(GWEN_LOGDOMAIN, "Missing server in URL [%s]", url);
1847  GWEN_Url_free(u);
1848  return GWEN_ERROR_INVALID;
1849  }
1850 
1851  if (strcasecmp(s, "http")==0 ||
1852  strcasecmp(s, "https")==0) {
1853  GWEN_SYNCIO *sio;
1854  GWEN_SYNCIO *baseLayer;
1855  GWEN_DB_NODE *db;
1856  GWEN_BUFFER *tbuf;
1857  int rv;
1858 
1859  /* create base io */
1861  if (sio==NULL) {
1862  DBG_INFO(GWEN_LOGDOMAIN, "here");
1863  GWEN_Url_free(u);
1864  return GWEN_ERROR_GENERIC;
1865  }
1866 
1867  GWEN_SyncIo_Socket_SetAddress(sio, addr);
1868  GWEN_SyncIo_Socket_SetPort(sio, port);
1869  baseLayer=sio;
1870 
1871  if (strcasecmp(s, "https")==0) {
1872  /* create TLS layer */
1873  sio=GWEN_SyncIo_Tls_new(baseLayer);
1874  if (sio==NULL) {
1875  DBG_INFO(GWEN_LOGDOMAIN, "here");
1876  GWEN_SyncIo_free(baseLayer);
1877  GWEN_Url_free(u);
1878  return GWEN_ERROR_GENERIC;
1879  }
1881  baseLayer=sio;
1882  }
1883 
1884  /* create buffered layer as needed for HTTP */
1885  sio=GWEN_SyncIo_Buffered_new(baseLayer);
1886  if (sio==NULL) {
1887  DBG_INFO(GWEN_LOGDOMAIN, "here");
1888  GWEN_SyncIo_free(baseLayer);
1889  GWEN_Url_free(u);
1890  return GWEN_ERROR_GENERIC;
1891  }
1892  baseLayer=sio;
1893 
1894  /* create HTTP layer */
1895  sio=GWEN_SyncIo_Http_new(baseLayer);
1896  if (sio==NULL) {
1897  DBG_INFO(GWEN_LOGDOMAIN, "here");
1898  GWEN_SyncIo_free(baseLayer);
1899  GWEN_Url_free(u);
1900  return GWEN_ERROR_GENERIC;
1901  }
1902 
1903  /* setup default command and header */
1904  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
1906 
1907  /* get command string (e.g. server-relative path plus variables) */
1908  rv=GWEN_Url_toCommandString(u, tbuf);
1909  if (rv<0) {
1910  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid path in URL, ignoring (%d)", rv);
1911  }
1912  else
1914  GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "command", "GET");
1915  GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "protocol", "HTTP/1.0");
1916 
1917  /* preset some headers */
1920  GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "Connection", "close");
1921 
1922  /* done */
1923  GWEN_Url_free(u);
1924  *pSio=sio;
1925  return 0;
1926  }
1927  else {
1928  GWEN_SYNCIO *sio;
1929 
1930  /* create base io */
1932  if (sio==NULL) {
1933  DBG_INFO(GWEN_LOGDOMAIN, "here");
1934  GWEN_Url_free(u);
1935  return GWEN_ERROR_GENERIC;
1936  }
1937  GWEN_SyncIo_Socket_SetAddress(sio, addr);
1938  GWEN_SyncIo_Socket_SetPort(sio, port);
1939 
1940  /* done */
1941  GWEN_Url_free(u);
1942  *pSio=sio;
1943  return 0;
1944  }
1945 
1946 }
1947 
1948 
1949 
1950 
1951