LCOV - code coverage report
Current view: top level - tests/gpg - t-gpgconf.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 2 95 2.1 %
Date: 2015-11-05 17:14:26 Functions: 1 6 16.7 %

          Line data    Source code
       1             : /* t-gpgconf.c - Regression test.
       2             :    Copyright (C) 2001, 2004, 2007 g10 Code GmbH
       3             : 
       4             :    This file is part of GPGME.
       5             : 
       6             :    GPGME is free software; you can redistribute it and/or modify it
       7             :    under the terms of the GNU Lesser General Public License as
       8             :    published by the Free Software Foundation; either version 2.1 of
       9             :    the License, or (at your option) any later version.
      10             :    
      11             :    GPGME is distributed in the hope that it will be useful, but
      12             :    WITHOUT ANY WARRANTY; without even the implied warranty of
      13             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14             :    Lesser General Public License for more details.
      15             :    
      16             :    You should have received a copy of the GNU Lesser General Public
      17             :    License along with this program; if not, write to the Free Software
      18             :    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
      19             :    02111-1307, USA.  */
      20             : 
      21             : #ifdef HAVE_CONFIG_H
      22             : #include <config.h>
      23             : #endif
      24             : 
      25             : #include <unistd.h>
      26             : #include <errno.h>
      27             : #include <stdlib.h>
      28             : #include <locale.h>
      29             : #include <string.h>
      30             : 
      31             : #ifdef HAVE_W32_SYSTEM
      32             : #include <windows.h>
      33             : #endif
      34             : 
      35             : #include <gpgme.h>
      36             : 
      37             : 
      38             : #define fail_if_err(err)                                        \
      39             :   do                                                            \
      40             :     {                                                           \
      41             :       if (err)                                                  \
      42             :         {                                                       \
      43             :           fprintf (stderr, "%s:%d: %s: %s\n",                 \
      44             :                    __FILE__, __LINE__, gpgme_strsource (err),   \
      45             :                    gpgme_strerror (err));                       \
      46             :           exit (1);                                             \
      47             :         }                                                       \
      48             :     }                                                           \
      49             :   while (0)
      50             : 
      51             : 
      52             : void
      53           0 : init_gpgme (gpgme_protocol_t proto)
      54             : {
      55             :   gpgme_error_t err;
      56             : 
      57           0 :   gpgme_check_version (NULL);
      58           0 :   setlocale (LC_ALL, "");
      59           0 :   gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
      60             : #ifndef HAVE_W32_SYSTEM
      61           0 :   gpgme_set_locale (NULL, LC_MESSAGES, setlocale (LC_MESSAGES, NULL));
      62             : #endif
      63             : 
      64           0 :   err = gpgme_engine_check_version (proto);
      65           0 :   fail_if_err (err);
      66           0 : }
      67             : 
      68             : 
      69             : static char *
      70           0 : spaces (char *str, int extra)
      71             : {
      72             :   static char buf[80];
      73           0 :   int len = str ? strlen (str) : 0;
      74             :   int n;
      75             : 
      76             : #define TABSTOP 30
      77           0 :   n = TABSTOP - len - extra;
      78             : 
      79           0 :   memset (buf, ' ', sizeof (buf));
      80           0 :   if (n < 1 || n > (sizeof (buf) - 1))
      81             :     {
      82           0 :       buf[0] = '\n';
      83           0 :       n = TABSTOP + 1;
      84             :     }
      85             : 
      86           0 :   buf[n] = '\0';
      87           0 :   return buf;
      88             : }
      89             : 
      90             : 
      91             : void
      92           0 : dump_arg (int type, gpgme_conf_arg_t arg)
      93             : {
      94           0 :   if (!arg)
      95             :     {
      96           0 :       printf ("(none)");
      97           0 :       return;
      98             :     }
      99             : 
     100           0 :   while (arg)
     101             :     {
     102           0 :       switch (type)
     103             :         {
     104             :         case GPGME_CONF_STRING:
     105             :         case GPGME_CONF_PATHNAME:
     106             :         case GPGME_CONF_LDAP_SERVER:
     107             :         case GPGME_CONF_KEY_FPR:
     108             :         case GPGME_CONF_PUB_KEY:
     109             :         case GPGME_CONF_SEC_KEY:
     110             :         case GPGME_CONF_ALIAS_LIST:
     111           0 :           printf ("`%s'", arg->value.string);
     112           0 :           break;
     113             : 
     114             :         case GPGME_CONF_UINT32:
     115           0 :           printf ("%u", arg->value.uint32);
     116           0 :           break;
     117             : 
     118             :         case GPGME_CONF_INT32:
     119           0 :           printf ("%i", arg->value.int32);
     120           0 :           break;
     121             : 
     122             :         case GPGME_CONF_NONE:
     123           0 :           printf ("%i (times)", arg->value.count);
     124           0 :           break;
     125             : 
     126             :         default:
     127           0 :           printf ("(unknown type)");
     128             :         }
     129             : 
     130           0 :       arg = arg->next;
     131           0 :       if (arg)
     132           0 :         printf (" ");
     133             :     }
     134             : }
     135             : 
     136             : 
     137             : void
     138           0 : dump_opt (gpgme_conf_opt_t opt)
     139             : {
     140             :   char level;
     141           0 :   char runtime = (opt->flags & GPGME_CONF_RUNTIME) ? 'r' : ' ';
     142             : 
     143           0 :   switch (opt->level)
     144             :     {
     145             :     case GPGME_CONF_BASIC:
     146           0 :       level = 'b';
     147           0 :       break;
     148             :     case GPGME_CONF_ADVANCED:
     149           0 :       level = 'a';
     150           0 :       break;
     151             :     case GPGME_CONF_EXPERT:
     152           0 :       level = 'e';
     153           0 :       break;
     154             :     case GPGME_CONF_INVISIBLE:
     155           0 :       level = 'i';
     156           0 :       break;
     157             :     case GPGME_CONF_INTERNAL:
     158           0 :       level = '#';
     159           0 :       break;
     160             :     default:
     161           0 :       level = '?';
     162             :     }
     163             : 
     164           0 :   if (opt->flags & GPGME_CONF_GROUP)
     165             :     {
     166           0 :       printf ("\n");
     167           0 :       printf ("%c%c [%s]%s%s\n", level, runtime, opt->name, spaces (opt->name, 5),
     168           0 :               opt->description
     169             :               ? opt->description : "");
     170             :     }
     171             :   else
     172             :     {
     173           0 :       if (opt->argname)
     174             :         {
     175           0 :           char *more = (opt->flags & GPGME_CONF_LIST) ? "..." : "";
     176             :       
     177           0 :           if (opt->flags & GPGME_CONF_OPTIONAL)
     178             :             {
     179           0 :               printf ("%c%c --%s [%s%s] %s", level, runtime, opt->name, opt->argname, more,
     180           0 :                       spaces (opt->name, 9 + strlen (opt->argname) + strlen (more)));
     181             :             }
     182             :           else
     183             :             {
     184           0 :               printf ("%c%c --%s %s%s %s", level, runtime, opt->name, opt->argname, more,
     185           0 :                       spaces (opt->name, 7 + strlen (opt->argname) + strlen (more)));
     186             :             }
     187             :         }
     188             :       else
     189           0 :         printf ("%c%c --%s%s", level, runtime, opt->name, spaces (opt->name, 5));
     190             :       
     191           0 :       if (opt->description)
     192           0 :         printf ("%s", opt->description);
     193           0 :       printf ("\n");
     194             : 
     195           0 :       if (opt->flags & GPGME_CONF_DEFAULT)
     196             :         {
     197           0 :           printf ("%s%s = ", spaces (NULL, 0), opt->argname ? opt->argname : "(default)");
     198           0 :           dump_arg (opt->type, opt->default_value);
     199           0 :           printf ("\n");
     200             :         }
     201           0 :       else if (opt->flags & GPGME_CONF_DEFAULT_DESC)
     202           0 :         printf ("%s%s = %s\n", spaces (NULL, 0), opt->argname ? opt->argname : "(default)",
     203             :                 opt->default_description);
     204             : 
     205           0 :       if (opt->no_arg_value)
     206             :         {
     207           0 :           printf ("%sNo Arg Def = ", spaces (NULL, 0));
     208           0 :           dump_arg (opt->type, opt->no_arg_value);
     209           0 :           printf ("\n");
     210             :         }
     211           0 :       if (opt->value)
     212             :         {
     213           0 :           printf ("%sCurrent = ", spaces (NULL, 0));
     214           0 :           dump_arg (opt->type, opt->value);
     215           0 :           printf ("\n");
     216             :         }
     217             :     }
     218             : 
     219             : #if 0
     220             :   arg = comp->options;
     221             :   while (opt)
     222             :     {
     223             :       dump_opt (opt);
     224             :       opt = opt->next;
     225             :     }
     226             : #endif
     227           0 : }
     228             : 
     229             : 
     230             : void
     231           0 : dump_comp (gpgme_conf_comp_t comp)
     232             : {
     233             :   gpgme_conf_opt_t opt;
     234             : 
     235           0 :   printf ("COMPONENT\n");
     236           0 :   printf ("=========\n");
     237           0 :   printf ("  Name: %s\n", comp->name);
     238           0 :   if (comp->description)
     239           0 :     printf ("  Desc: %s\n", comp->description);
     240           0 :   if (comp->program_name)
     241           0 :     printf ("  Path: %s\n", comp->program_name);
     242           0 :   printf ("\n");
     243             : 
     244           0 :   opt = comp->options;
     245           0 :   while (opt)
     246             :     {
     247           0 :       dump_opt (opt);
     248           0 :       opt = opt->next;
     249             :     }
     250           0 : }
     251             : 
     252             : 
     253             : int 
     254           1 : main (int argc, char **argv)
     255             : {
     256             :   gpgme_ctx_t ctx;
     257             :   gpgme_error_t err;
     258             :   gpgme_conf_comp_t conf;
     259             :   gpgme_conf_comp_t comp;
     260             :   int first;
     261             : 
     262             : #ifndef ENABLE_GPGCONF
     263           1 :   return 0;
     264             : #endif
     265             : 
     266             :   init_gpgme (GPGME_PROTOCOL_GPGCONF);
     267             : 
     268             :   err = gpgme_new (&ctx);
     269             :   fail_if_err (err);
     270             : 
     271             :   err = gpgme_op_conf_load (ctx, &conf);
     272             :   fail_if_err (err);
     273             : 
     274             :   comp = conf;
     275             :   first = 1;
     276             :   while (comp)
     277             :     {
     278             :       if (!first)
     279             :         printf ("\n");
     280             :       else
     281             :         first = 0;
     282             :       dump_comp (comp);
     283             :       comp = comp->next;
     284             :     }
     285             : 
     286             : #if 1
     287             :   /* Now change something.  */
     288             :   {
     289             :     unsigned int count = 1;
     290             :     gpgme_conf_arg_t arg;
     291             :     gpgme_conf_opt_t opt;
     292             : 
     293             :     err = gpgme_conf_arg_new (&arg, GPGME_CONF_NONE, &count);
     294             :     fail_if_err (err);
     295             : 
     296             :     comp = conf;
     297             :     while (comp && strcmp (comp->name, "dirmngr"))
     298             :       comp = comp->next;
     299             : 
     300             :     if (comp)
     301             :       {
     302             :         opt = comp->options;
     303             :         while (opt && strcmp (opt->name, "verbose"))
     304             :           opt = opt->next;
     305             :         
     306             :         /* Allow for the verbose option not to be there.  */
     307             :         if (opt)
     308             :           {
     309             :             err = gpgme_conf_opt_change (opt, 0, arg);
     310             :             fail_if_err (err);
     311             :             
     312             :             err = gpgme_op_conf_save (ctx, comp);
     313             :             fail_if_err (err);
     314             :           }
     315             :       }
     316             :   }
     317             : #endif
     318             : 
     319             :   gpgme_conf_release (conf);
     320             : 
     321             :   return 0;
     322             : }

Generated by: LCOV version 1.11