Documentaion updates.
[gnupg.git] / sm / gpgsm.c
1 /* gpgsm.c - GnuPG for S/MIME 
2  * Copyright (C) 2001, 2002, 2003, 2004, 2005,
3  *               2006, 2007  Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <unistd.h>
28 #include <fcntl.h>
29 /*#include <mcheck.h>*/
30
31 #include "gpgsm.h"
32 #include <gcrypt.h>
33 #include <assuan.h> /* malloc hooks */
34
35 #include "../kbx/keybox.h" /* malloc hooks */
36 #include "i18n.h"
37 #include "keydb.h"
38 #include "sysutils.h"
39 #include "gc-opt-flags.h"
40
41
42 #ifndef O_BINARY
43 #define O_BINARY 0
44 #endif
45
46 enum cmd_and_opt_values {
47   aNull = 0,
48   oArmor        = 'a',
49   aDetachedSign = 'b',
50   aSym          = 'c',
51   aDecrypt      = 'd',
52   aEncr         = 'e',
53   oInteractive  = 'i',
54   aListKeys     = 'k',
55   aListSecretKeys = 'K',
56   oDryRun       = 'n',
57   oOutput       = 'o',
58   oQuiet        = 'q',
59   oRecipient    = 'r',
60   aSign         = 's',
61   oTextmodeShort= 't',
62   oUser         = 'u',
63   oVerbose      = 'v',
64   oCompress     = 'z',
65   oNotation     = 'N',
66   oBatch        = 500,
67   aClearsign,
68   aStore,
69   aKeygen,
70   aSignEncr,
71   aSignKey,
72   aLSignKey,
73   aListPackets,
74   aEditKey,
75   aDeleteKey,
76   aImport,
77   aVerify,
78   aVerifyFiles,
79   aListExternalKeys,
80   aListChain,
81   aSendKeys,
82   aRecvKeys,
83   aExport,
84   aExportSecretKeyP12,
85   aCheckKeys, /* nyi */
86   aServer,                        
87   aLearnCard,
88   aCallDirmngr,
89   aCallProtectTool,
90   aPasswd,
91   aGPGConfList,
92   aGPGConfTest,
93   aDumpKeys,
94   aDumpChain,
95   aDumpSecretKeys,
96   aDumpExternalKeys,
97   aKeydbClearSomeCertFlags,
98
99   oOptions,
100   oDebug,
101   oDebugLevel,
102   oDebugAll,
103   oDebugNone,
104   oDebugWait,
105   oDebugAllowCoreDump,
106   oDebugNoChainValidation,
107   oDebugIgnoreExpiration,
108   oFixedPassphrase,
109   oLogFile,
110   oNoLogFile,
111
112   oEnableSpecialFilenames,
113
114   oAgentProgram,
115   oDisplay,
116   oTTYname,
117   oTTYtype,
118   oLCctype,
119   oLCmessages,
120
121   oPreferSystemDirmngr,
122   oDirmngrProgram,
123   oProtectToolProgram,
124   oFakedSystemTime,
125
126
127   oAssumeArmor,
128   oAssumeBase64,
129   oAssumeBinary,
130
131   oBase64,
132   oNoArmor,
133   oP12Charset,
134
135   oDisableCRLChecks,
136   oEnableCRLChecks,
137   oDisableTrustedCertCRLCheck,
138   oEnableTrustedCertCRLCheck,
139   oForceCRLRefresh,
140
141   oDisableOCSP,
142   oEnableOCSP,
143
144   oIncludeCerts,
145   oPolicyFile,
146   oDisablePolicyChecks,
147   oEnablePolicyChecks,
148   oAutoIssuerKeyRetrieve,
149   
150
151   oTextmode,
152   oFingerprint,
153   oWithFingerprint,
154   oWithMD5Fingerprint,
155   oAnswerYes,
156   oAnswerNo,
157   oKeyring,
158   oSecretKeyring,
159   oDefaultKey,
160   oDefRecipient,
161   oDefRecipientSelf,
162   oNoDefRecipient,
163   oStatusFD,
164   oNoComment,
165   oNoVersion,
166   oEmitVersion,
167   oCompletesNeeded,
168   oMarginalsNeeded,
169   oMaxCertDepth,
170   oLoadExtension,
171   oRFC1991,
172   oOpenPGP,
173   oCipherAlgo,
174   oDigestAlgo,
175   oCompressAlgo,
176   oCommandFD,
177   oNoVerbose,
178   oTrustDBName,
179   oNoSecmemWarn,
180   oNoDefKeyring,
181   oNoGreeting,
182   oNoTTY,
183   oNoOptions,
184   oNoBatch,
185   oHomedir,
186   oWithColons,
187   oWithKeyData,
188   oWithValidation,
189   oWithEphemeralKeys,
190   oSkipVerify,
191   oCompressKeys,
192   oCompressSigs,
193   oAlwaysTrust,
194   oRunAsShmCP,
195   oSetFilename,
196   oSetPolicyURL,
197   oUseEmbeddedFilename,
198   oValidationModel,
199   oComment,
200   oDefaultComment,
201   oThrowKeyid,
202   oForceV3Sigs,
203   oForceMDC,
204   oS2KMode,
205   oS2KDigest,
206   oS2KCipher,
207   oCharset,
208   oNotDashEscaped,
209   oEscapeFrom,
210   oLockOnce,
211   oLockMultiple,
212   oLockNever,
213   oKeyServer,
214   oEncryptTo,
215   oNoEncryptTo,
216   oLoggerFD,
217   oUtf8Strings,
218   oNoUtf8Strings,
219   oDisableCipherAlgo,
220   oDisablePubkeyAlgo,
221   oAllowNonSelfsignedUID,
222   oAllowFreeformUID,
223   oNoLiteral,
224   oSetFilesize,
225   oHonorHttpProxy,
226   oFastListMode,
227   oListOnly,
228   oIgnoreTimeConflict,
229   oNoRandomSeedFile,
230   oNoAutoKeyRetrieve,
231   oUseAgent,
232   oMergeOnly,
233   oTryAllSecrets,
234   oTrustedKey,
235   oEmuMDEncodeBug,
236   aDummy
237  };
238
239
240 static ARGPARSE_OPTS opts[] = {
241
242     { 300, NULL, 0, N_("@Commands:\n ") },
243
244     { aSign, "sign",      256, N_("|[FILE]|make a signature")},
245     { aClearsign, "clearsign", 256, N_("|[FILE]|make a clear text signature") },
246     { aDetachedSign, "detach-sign", 256, N_("make a detached signature")},
247     { aEncr, "encrypt",   256, N_("encrypt data")},
248     { aSym, "symmetric", 256, N_("encryption only with symmetric cipher")},
249     { aDecrypt, "decrypt",   256, N_("decrypt data (default)")},
250     { aVerify, "verify"   , 256, N_("verify a signature")},
251     { aVerifyFiles, "verify-files" , 256, "@" },
252     { aListKeys, "list-keys", 256, N_("list keys")},
253     { aListExternalKeys, "list-external-keys", 256, N_("list external keys")},
254     { aListSecretKeys, "list-secret-keys", 256, N_("list secret keys")},
255     { aListChain,   "list-chain",  256, N_("list certificate chain")}, 
256     { oFingerprint, "fingerprint", 256, N_("list keys and fingerprints")},
257     { aKeygen,     "gen-key",  256, "@" },
258     { aDeleteKey, "delete-key",256, N_("remove key from the public keyring")},
259     { aSendKeys, "send-keys"     , 256, N_("export keys to a key server") },
260     { aRecvKeys, "recv-keys"     , 256, N_("import keys from a key server") },
261     { aImport, "import",      256     , N_("import certificates")},
262     { aExport, "export",      256     , N_("export certificates")},
263     { aLearnCard, "learn-card", 256 ,N_("register a smartcard")},
264     { aServer, "server",      256, N_("run in server mode")},
265     { aCallDirmngr, "call-dirmngr", 256, N_("pass a command to the dirmngr")},
266     { aCallProtectTool, "call-protect-tool", 256,
267                                    N_("invoke gpg-protect-tool")},
268     { aPasswd, "passwd",      256, N_("change a passphrase")},
269     { aGPGConfList, "gpgconf-list", 256, "@" },
270     { aGPGConfTest, "gpgconf-test", 256, "@" },
271
272     { aDumpKeys, "dump-cert", 256, "@"},
273     { aDumpKeys, "dump-keys", 256, "@"},
274     { aDumpChain, "dump-chain", 256, "@"},
275     { aDumpExternalKeys, "dump-external-keys", 256, "@"},
276     { aDumpSecretKeys, "dump-secret-keys", 256, "@"},
277     { aKeydbClearSomeCertFlags, "keydb-clear-some-cert-flags", 256, "@"},
278
279     { 301, NULL, 0, N_("@\nOptions:\n ") },
280
281     { oArmor, "armor",     0, N_("create ascii armored output")},
282     { oArmor, "armour",    0, "@" },
283     { oBase64, "base64",    0, N_("create base-64 encoded output")},
284
285     { oP12Charset, "p12-charset", 2, "@" },
286     
287     { oAssumeArmor,  "assume-armor", 0, N_("assume input is in PEM format")},
288     { oAssumeBase64, "assume-base64", 0,
289                                       N_("assume input is in base-64 format")},
290     { oAssumeBinary, "assume-binary", 0,
291                                       N_("assume input is in binary format")},
292
293     { oRecipient, "recipient", 2, N_("|NAME|encrypt for NAME")},
294
295     { oPreferSystemDirmngr,"prefer-system-dirmngr", 0,
296       N_("use system's dirmngr if available")},
297     { oDisableCRLChecks, "disable-crl-checks", 0, N_("never consult a CRL")},
298     { oEnableCRLChecks, "enable-crl-checks", 0, "@"},
299     { oDisableTrustedCertCRLCheck, "disable-trusted-cert-crl-check", 0, "@"},
300     { oEnableTrustedCertCRLCheck, "enable-trusted-cert-crl-check", 0, "@"},
301     { oForceCRLRefresh, "force-crl-refresh", 0, "@"},
302
303     { oDisableOCSP, "disable-ocsp", 0, "@" },
304     { oEnableOCSP,  "enable-ocsp", 0, N_("check validity using OCSP")},
305
306     { oValidationModel, "validation-model", 2, "@"},
307
308     { oIncludeCerts, "include-certs", 1,
309                                  N_("|N|number of certificates to include") },
310
311     { oPolicyFile, "policy-file", 2,
312                     N_("|FILE|take policy information from FILE") },
313
314     { oDisablePolicyChecks, "disable-policy-checks", 0,
315                            N_("do not check certificate policies")},
316     { oEnablePolicyChecks, "enable-policy-checks", 0, "@"},
317
318     { oAutoIssuerKeyRetrieve, "auto-issuer-key-retrieve", 0, 
319       N_("fetch missing issuer certificates")},
320
321 #if 0
322     { oDefRecipient, "default-recipient" ,2,
323                                   N_("|NAME|use NAME as default recipient")},
324     { oDefRecipientSelf, "default-recipient-self" ,0,
325                                 N_("use the default key as default recipient")},
326     { oNoDefRecipient, "no-default-recipient", 0, "@" },
327 #endif
328     { oEncryptTo, "encrypt-to", 2, "@" },
329     { oNoEncryptTo, "no-encrypt-to", 0, "@" },
330
331     { oUser, "local-user",2, N_("use this user-id to sign or decrypt")},
332
333 #if 0
334     { oCompress, NULL,        1, N_("|N|set compress level N (0 disables)") },
335     { oTextmodeShort, NULL,   0, "@"},
336     { oTextmode, "textmode",  0, N_("use canonical text mode")},
337 #endif
338
339     { oOutput, "output",    2, N_("use as output file")},
340     { oVerbose, "verbose",   0, N_("verbose") },
341     { oQuiet,   "quiet",   0, N_("be somewhat more quiet") },
342     { oNoTTY, "no-tty", 0, N_("don't use the terminal at all") },
343     { oLogFile, "log-file"   ,2, N_("use a log file for the server")},
344     { oNoLogFile, "no-log-file" ,0, "@"},
345 #if 0
346     { oForceV3Sigs, "force-v3-sigs", 0, N_("force v3 signatures") },
347     { oForceMDC, "force-mdc", 0, N_("always use a MDC for encryption") },
348 #endif
349     { oDryRun, "dry-run",   0, N_("do not make any changes") },
350   /*{ oInteractive, "interactive", 0, N_("prompt before overwriting") }, */
351     /*{ oUseAgent, "use-agent",0, N_("use the gpg-agent")},*/
352     { oBatch, "batch",     0, N_("batch mode: never ask")},
353     { oAnswerYes, "yes",       0, N_("assume yes on most questions")},
354     { oAnswerNo,  "no",        0, N_("assume no on most questions")},
355
356     { oKeyring, "keyring"   ,2, N_("add this keyring to the list of keyrings")},
357     { oSecretKeyring, "secret-keyring" ,2, N_("add this secret keyring to the list")},
358     { oDefaultKey, "default-key" ,2, N_("|NAME|use NAME as default secret key")},
359     { oKeyServer, "keyserver",2, N_("|HOST|use this keyserver to lookup keys")},
360     { oCharset, "charset"   , 2, N_("|NAME|set terminal charset to NAME") },
361     { oOptions, "options"   , 2, N_("read options from file")},
362
363     { oDebug, "debug"     ,4|16, "@"},
364     { oDebugLevel, "debug-level" ,2, N_("|LEVEL|set the debugging level to LEVEL")},
365     { oDebugAll, "debug-all" ,0, "@"},
366     { oDebugNone, "debug-none" ,0, "@"},
367     { oDebugWait, "debug-wait" ,1, "@"},
368     { oDebugAllowCoreDump, "debug-allow-core-dump", 0, "@" },
369     { oDebugNoChainValidation, "debug-no-chain-validation", 0, "@"},
370     { oDebugIgnoreExpiration,  "debug-ignore-expiration", 0, "@"},
371     { oFixedPassphrase,        "fixed-passphrase", 2, "@"},
372     { oStatusFD, "status-fd" ,1, N_("|FD|write status info to this FD") },
373     { aDummy, "no-comment", 0,   "@"},
374     { aDummy, "completes-needed", 1, "@"},
375     { aDummy, "marginals-needed", 1, "@"},
376     { oMaxCertDepth,    "max-cert-depth", 1, "@" },
377     { aDummy, "trusted-key", 2, "@"},
378     { oLoadExtension, "load-extension" ,2,
379       N_("|FILE|load extension module FILE")},
380     { aDummy, "rfc1991",   0, "@"},
381     { aDummy, "openpgp",   0, "@"},
382     { aDummy, "s2k-mode",  1, "@"},
383     { aDummy, "s2k-digest-algo",2, "@"},
384     { aDummy, "s2k-cipher-algo",2, "@"},
385     { oCipherAlgo, "cipher-algo", 2 , N_("|NAME|use cipher algorithm NAME")},
386     { oDigestAlgo, "digest-algo", 2 ,
387       N_("|NAME|use message digest algorithm NAME")},
388 #if 0
389     { oCompressAlgo, "compress-algo", 1 , N_("|N|use compress algorithm N")},
390 #endif
391     { aDummy, "throw-keyid", 0, "@"},
392     { aDummy, "notation-data", 2, "@"},
393     { aExportSecretKeyP12, "export-secret-key-p12", 256, "@"}, 
394     
395
396     { 302, NULL, 0, N_(
397   "@\n(See the man page for a complete listing of all commands and options)\n"
398                       )},
399
400     { 303, NULL, 0, N_("@\nExamples:\n\n"
401     " -se -r Bob [file]          sign and encrypt for user Bob\n"
402     " --clearsign [file]         make a clear text signature\n"
403     " --detach-sign [file]       make a detached signature\n"
404     " --list-keys [names]        show keys\n"
405     " --fingerprint [names]      show fingerprints\n"  ) },
406
407   /* hidden options */
408     { oNoVerbose, "no-verbose", 0, "@"},
409
410     { oEnableSpecialFilenames, "enable-special-filenames", 0, "@" },
411
412
413     { oTrustDBName, "trustdb-name", 2, "@" },
414     { oNoSecmemWarn, "no-secmem-warning", 0, "@" }, 
415     { oNoArmor, "no-armor",   0, "@"},
416     { oNoArmor, "no-armour",   0, "@"},
417     { oNoDefKeyring, "no-default-keyring", 0, "@" },
418     { oNoGreeting, "no-greeting", 0, "@" },
419     { oNoOptions, "no-options", 0, "@" }, /* shortcut for --options /dev/null */
420     { oHomedir, "homedir", 2, "@" },   /* defaults to "~/.gnupg" */
421     { oAgentProgram, "agent-program", 2 , "@" },
422     { oDisplay,    "display",     2, "@" },
423     { oTTYname,    "ttyname",     2, "@" },
424     { oTTYtype,    "ttytype",     2, "@" },
425     { oLCctype,    "lc-ctype",    2, "@" },
426     { oLCmessages, "lc-messages", 2, "@" },
427     { oDirmngrProgram, "dirmngr-program", 2 , "@" },
428     { oProtectToolProgram, "protect-tool-program", 2 , "@" },
429     { oFakedSystemTime, "faked-system-time", 2, "@" }, /* (epoch time) */
430
431
432     { oNoBatch, "no-batch", 0, "@" },
433     { oWithColons, "with-colons", 0, "@"},
434     { oWithKeyData,"with-key-data", 0, "@"},
435     { oWithValidation, "with-validation", 0, "@"},
436     { oWithMD5Fingerprint, "with-md5-fingerprint", 0, "@"},
437     { oWithEphemeralKeys,  "with-ephemeral-keys", 0, "@"},
438     { aListKeys, "list-key", 256, "@" },  /* alias */
439     { aListChain, "list-sig", 256, "@" }, /* alias */
440     { aListChain, "list-sigs",256, "@" }, /* alias */
441     { aListChain, "check-sig",256, "@" }, /* alias */
442     { aListChain, "check-sigs",256, "@"}, /* alias */
443     { oSkipVerify, "skip-verify",0, "@" },
444     { oCompressKeys, "compress-keys",0, "@"},
445     { oCompressSigs, "compress-sigs",0, "@"},
446     { oAlwaysTrust, "always-trust", 0, "@"},
447     { oNoVersion, "no-version", 0, "@"},
448     { oLockOnce, "lock-once", 0, "@" },
449     { oLockMultiple, "lock-multiple", 0, "@" },
450     { oLockNever, "lock-never", 0, "@" },
451     { oLoggerFD, "logger-fd",1, "@" },
452     { oWithFingerprint, "with-fingerprint", 0, "@" },
453     { oDisableCipherAlgo,  "disable-cipher-algo", 2, "@" },
454     { oDisablePubkeyAlgo,  "disable-pubkey-algo", 2, "@" },
455     { oHonorHttpProxy,"honor-http-proxy", 0, "@" },
456     { oListOnly, "list-only", 0, "@"},
457     { oIgnoreTimeConflict, "ignore-time-conflict", 0, "@" },
458     { oNoRandomSeedFile,  "no-random-seed-file", 0, "@" },
459 {0} };
460
461
462
463 int gpgsm_errors_seen = 0;
464
465 /* It is possible that we are currentlu running under setuid permissions */
466 static int maybe_setuid = 1;
467
468 /* Helper to implement --debug-level and --debug*/
469 static const char *debug_level;
470 static unsigned int debug_value;
471
472 /* Option --enable-special-filenames */
473 static int allow_special_filenames;
474
475 /* Default value for include-certs. */
476 static int default_include_certs = 1; /* Only include the signer's cert. */
477
478 /* Whether the chain mode shall be used for validation.  */
479 static int default_validation_model;
480
481
482 static char *build_list (const char *text,
483                          const char *(*mapf)(int), int (*chkf)(int));
484 static void set_cmd (enum cmd_and_opt_values *ret_cmd,
485                      enum cmd_and_opt_values new_cmd );
486
487 static void emergency_cleanup (void);
488 static int check_special_filename (const char *fname, int for_write);
489 static int open_read (const char *filename);
490 static FILE *open_fwrite (const char *filename);
491 static estream_t open_es_fwrite (const char *filename);
492 static void run_protect_tool (int argc, char **argv);
493
494 /* Remove this if libgcrypt 1.3.0 is required. */
495 #define MY_GCRY_PK_ECDSA  301
496
497
498 static int
499 our_pk_test_algo (int algo)
500 {
501   switch (algo)
502     {
503     case GCRY_PK_RSA:
504     case MY_GCRY_PK_ECDSA:
505       return gcry_pk_test_algo (algo);
506     default:
507       return 1;
508     }
509 }
510
511 static int
512 our_cipher_test_algo (int algo)
513 {
514   switch (algo)
515     {
516     case GCRY_CIPHER_3DES:
517     case GCRY_CIPHER_AES128:
518     case GCRY_CIPHER_AES192:
519     case GCRY_CIPHER_AES256:
520     case GCRY_CIPHER_SERPENT128:
521     case GCRY_CIPHER_SERPENT192:
522     case GCRY_CIPHER_SERPENT256:
523     case 309 /*GCRY_CIPHER_SEED*/:
524     case 310 /*GCRY_CIPHER_CAMELLIA128*/:
525     case 311 /*GCRY_CIPHER_CAMELLIA192*/:
526     case 312 /*GCRY_CIPHER_CAMELLIA256*/:
527       return gcry_cipher_test_algo (algo);
528     default:
529       return 1;
530     }
531 }
532
533
534 static int
535 our_md_test_algo (int algo)
536 {
537   switch (algo)
538     {
539     case GCRY_MD_MD5:
540     case GCRY_MD_SHA1:
541     case GCRY_MD_RMD160:
542     case GCRY_MD_SHA256:
543     case GCRY_MD_SHA384:
544     case GCRY_MD_SHA512:
545     case 305 /*GCRY_MD_WHIRLPOOL*/:
546       return gcry_md_test_algo (algo);
547     default:
548       return 1;
549     }
550 }
551
552
553 static const char *
554 my_strusage( int level )
555 {
556   static char *digests, *pubkeys, *ciphers;
557   const char *p;
558
559   switch (level)
560     {
561     case 11: p = "gpgsm (GnuPG)";
562       break;
563     case 13: p = VERSION; break;
564     case 17: p = PRINTABLE_OS_NAME; break;
565     case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
566       break;
567     case 1:
568     case 40: p = _("Usage: gpgsm [options] [files] (-h for help)");
569       break;
570     case 41:
571       p = _("Syntax: gpgsm [options] [files]\n"
572             "sign, check, encrypt or decrypt using the S/MIME protocol\n"
573             "default operation depends on the input data\n");
574       break;
575
576     case 31: p = "\nHome: "; break;
577     case 32: p = opt.homedir; break;
578     case 33: p = _("\nSupported algorithms:\n"); break;
579     case 34:
580       if (!ciphers)
581         ciphers = build_list ("Cipher: ", gcry_cipher_algo_name,
582                               our_cipher_test_algo );
583       p = ciphers;
584       break;
585     case 35:
586       if (!pubkeys)
587         pubkeys = build_list ("Pubkey: ", gcry_pk_algo_name,
588                               our_pk_test_algo );
589       p = pubkeys;
590       break;
591     case 36:
592       if (!digests)
593         digests = build_list("Hash: ", gcry_md_algo_name, our_md_test_algo );
594       p = digests;
595       break;
596       
597     default: p = NULL; break;
598     }
599   return p;
600 }
601
602
603 static char *
604 build_list (const char *text, const char * (*mapf)(int), int (*chkf)(int))
605 {
606   int i;
607   size_t n=strlen(text)+2;
608   char *list, *p;
609   
610   if (maybe_setuid) {
611     gcry_control (GCRYCTL_DROP_PRIVS); /* drop setuid */
612   }
613
614   for (i=1; i < 400; i++ )
615     if (!chkf(i))
616       n += strlen(mapf(i)) + 2;
617   list = xmalloc (21 + n);
618   *list = 0;
619   for (p=NULL, i=1; i < 400; i++)
620     {
621       if (!chkf(i))
622         {
623           if( !p )
624             p = stpcpy (list, text );
625           else
626             p = stpcpy (p, ", ");
627           p = stpcpy (p, mapf(i) );
628         }
629     }
630   if (p)
631     p = stpcpy(p, "\n" );
632   return list;
633 }
634
635
636 /* Set the file pointer into binary mode if required.  */
637 static void
638 set_binary (FILE *fp)
639 {
640 #ifdef HAVE_DOSISH_SYSTEM
641   setmode (fileno (fp), O_BINARY);
642 #endif
643 }
644
645
646
647 static void
648 wrong_args (const char *text)
649 {
650   fputs (_("usage: gpgsm [options] "), stderr);
651   fputs (text, stderr);
652   putc ('\n', stderr);
653   gpgsm_exit (2);
654 }
655
656
657 /* Setup the debugging.  With a DEBUG_LEVEL of NULL only the active
658    debug flags are propagated to the subsystems.  With DEBUG_LEVEL
659    set, a specific set of debug flags is set; and individual debugging
660    flags will be added on top.  */
661 static void
662 set_debug (void)
663 {
664   if (!debug_level)
665     ;
666   else if (!strcmp (debug_level, "none"))
667     opt.debug = 0;
668   else if (!strcmp (debug_level, "basic"))
669     opt.debug = DBG_ASSUAN_VALUE;
670   else if (!strcmp (debug_level, "advanced"))
671     opt.debug = DBG_ASSUAN_VALUE|DBG_X509_VALUE;
672   else if (!strcmp (debug_level, "expert"))
673     opt.debug = (DBG_ASSUAN_VALUE|DBG_X509_VALUE
674                  |DBG_CACHE_VALUE|DBG_CRYPTO_VALUE);
675   else if (!strcmp (debug_level, "guru"))
676     opt.debug = ~0;
677   else
678     {
679       log_error (_("invalid debug-level `%s' given\n"), debug_level);
680       gpgsm_exit(2);
681     }
682
683   opt.debug |= debug_value;
684
685   if (opt.debug && !opt.verbose)
686     opt.verbose = 1;
687   if (opt.debug)
688     opt.quiet = 0;
689
690   if (opt.debug & DBG_MPI_VALUE)
691     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
692   if (opt.debug & DBG_CRYPTO_VALUE )
693     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
694   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
695 }
696  
697
698
699 static void
700 set_cmd (enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd)
701 {
702   enum cmd_and_opt_values cmd = *ret_cmd;
703
704   if (!cmd || cmd == new_cmd)
705     cmd = new_cmd;
706   else if ( cmd == aSign && new_cmd == aEncr )
707     cmd = aSignEncr;
708   else if ( cmd == aEncr && new_cmd == aSign )
709     cmd = aSignEncr;
710   else if ( (cmd == aSign && new_cmd == aClearsign)
711             || (cmd == aClearsign && new_cmd == aSign) )
712     cmd = aClearsign;
713   else 
714     {
715       log_error(_("conflicting commands\n"));
716       gpgsm_exit(2);
717     }
718
719   *ret_cmd = cmd;
720 }
721
722
723 /* Helper to add recipients to a list. */
724 static void
725 do_add_recipient (ctrl_t ctrl, const char *name,
726                   certlist_t *recplist, int is_encrypt_to, int recp_required)
727 {
728   int rc = gpgsm_add_to_certlist (ctrl, name, 0, recplist, is_encrypt_to);
729   if (rc)
730     {
731       if (recp_required)
732         {
733           log_error ("can't encrypt to `%s': %s\n", name, gpg_strerror (rc));
734           gpgsm_status2 (ctrl, STATUS_INV_RECP,
735                      gpg_err_code (rc) == -1?                         "1":
736                      gpg_err_code (rc) == GPG_ERR_NO_PUBKEY?          "1":
737                      gpg_err_code (rc) == GPG_ERR_AMBIGUOUS_NAME?     "2":
738                      gpg_err_code (rc) == GPG_ERR_WRONG_KEY_USAGE?    "3":
739                      gpg_err_code (rc) == GPG_ERR_CERT_REVOKED?       "4":
740                      gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED?       "5":
741                      gpg_err_code (rc) == GPG_ERR_NO_CRL_KNOWN?       "6":
742                      gpg_err_code (rc) == GPG_ERR_CRL_TOO_OLD?        "7":
743                      gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH?    "8":
744                      "0",
745                      name, NULL);
746         }
747       else
748         log_info (_("NOTE: won't be able to encrypt to `%s': %s\n"),
749                   name, gpg_strerror (rc));
750     }
751 }
752
753
754 static void
755 parse_validation_model (const char *model)
756 {
757   int i = gpgsm_parse_validation_model (model);
758   if (i == -1)
759     log_error (_("unknown validation model `%s'\n"), model);
760   else
761     default_validation_model = i;
762 }
763
764
765 int
766 main ( int argc, char **argv)
767 {
768   ARGPARSE_ARGS pargs;
769   int orig_argc;
770   char **orig_argv;
771   const char *fname;
772   /*  char *username;*/
773   int may_coredump;
774   strlist_t sl, remusr= NULL, locusr=NULL;
775   strlist_t nrings=NULL;
776   int detached_sig = 0;
777   FILE *configfp = NULL;
778   char *configname = NULL;
779   unsigned configlineno;
780   int parse_debug = 0;
781   int no_more_options = 0;
782   int default_config =1;
783   int default_keyring = 1;
784   char *logfile = NULL;
785   int greeting = 0;
786   int nogreeting = 0;
787   int debug_wait = 0;
788   int use_random_seed = 1;
789   int with_fpr = 0;
790   char *def_digest_string = NULL;
791   enum cmd_and_opt_values cmd = 0;
792   struct server_control_s ctrl;
793   certlist_t recplist = NULL;
794   certlist_t signerlist = NULL;
795   int do_not_setup_keys = 0;
796   int recp_required = 0;
797
798   /*mtrace();*/
799
800   /* trap_unaligned ();*/
801   gnupg_rl_initialize ();
802   set_strusage (my_strusage);
803   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
804   /* We don't need any locking in libgcrypt unless we use any kind of
805      threading. */
806   gcry_control (GCRYCTL_DISABLE_INTERNAL_LOCKING);
807
808   /* Please note that we may running SUID(ROOT), so be very CAREFUL
809      when adding any stuff between here and the call to secmem_init()
810      somewhere after the option parsing */
811   log_set_prefix ("gpgsm", 1);
812
813   /* Make sure that our subsystems are ready.  */
814   init_common_subsystems ();
815
816   /* Check that the libraries are suitable.  Do it here because the
817      option parse may need services of the library */
818   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
819     log_fatal (_("%s is too old (need %s, have %s)\n"), "libgcrypt", 
820                NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
821   if (!ksba_check_version (NEED_KSBA_VERSION) )
822     log_fatal (_("%s is too old (need %s, have %s)\n"), "libksba",
823                NEED_KSBA_VERSION, ksba_check_version (NULL) );
824
825
826   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
827
828   may_coredump = disable_core_dumps ();
829   
830   gnupg_init_signals (0, emergency_cleanup);
831   
832   create_dotlock (NULL); /* register locking cleanup */
833   i18n_init();
834
835   opt.def_cipher_algoid = "3DES";  /*des-EDE3-CBC*/
836
837   opt.homedir = default_homedir ();
838
839   /* First check whether we have a config file on the commandline */
840   orig_argc = argc;
841   orig_argv = argv;
842   pargs.argc = &argc;
843   pargs.argv = &argv;
844   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
845   while (arg_parse( &pargs, opts))
846     {
847       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
848         parse_debug++;
849       else if (pargs.r_opt == oOptions)
850         { /* yes there is one, so we do not try the default one but
851              read the config file when it is encountered at the
852              commandline */
853           default_config = 0;
854         }
855       else if (pargs.r_opt == oNoOptions)
856         default_config = 0; /* --no-options */
857       else if (pargs.r_opt == oHomedir)
858         opt.homedir = pargs.r.ret_str;
859       else if (pargs.r_opt == aCallProtectTool)
860         break; /* This break makes sure that --version and --help are
861                   passed to the protect-tool. */
862     }
863   
864   
865   /* initialize the secure memory. */
866   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
867   maybe_setuid = 0;
868
869   /* 
870      Now we are now working under our real uid 
871   */
872
873   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
874
875   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
876   assuan_set_assuan_log_stream (log_get_stream ());
877   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
878   assuan_set_assuan_err_source (GPG_ERR_SOURCE_DEFAULT);
879
880   keybox_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
881
882   /* Setup a default control structure for command line mode */
883   memset (&ctrl, 0, sizeof ctrl);
884   gpgsm_init_default_ctrl (&ctrl);
885   ctrl.no_server = 1;
886   ctrl.status_fd = -1; /* not status output */
887   ctrl.autodetect_encoding = 1;
888
889   /* Set the default option file */
890   if (default_config )
891     configname = make_filename (opt.homedir, "gpgsm.conf", NULL);
892   /* Set the default policy file */
893   opt.policy_file = make_filename (opt.homedir, "policies.txt", NULL);
894   
895   argc        = orig_argc;
896   argv        = orig_argv;
897   pargs.argc  = &argc;
898   pargs.argv  = &argv;
899   pargs.flags =  1;  /* do not remove the args */
900
901  next_pass:
902   if (configname) {
903     configlineno = 0;
904     configfp = fopen (configname, "r");
905     if (!configfp)
906       {
907         if (default_config)
908           {
909             if (parse_debug)
910               log_info (_("NOTE: no default option file `%s'\n"), configname);
911           }
912         else 
913           {
914             log_error (_("option file `%s': %s\n"), configname, strerror(errno));
915             gpgsm_exit(2);
916           }
917         xfree(configname);
918         configname = NULL;
919       }
920     if (parse_debug && configname)
921       log_info (_("reading options from `%s'\n"), configname);
922     default_config = 0;
923   }
924
925   while (!no_more_options 
926          && optfile_parse (configfp, configname, &configlineno, &pargs, opts))
927     {
928       switch (pargs.r_opt)
929         {
930         case aGPGConfList: 
931         case aGPGConfTest: 
932           set_cmd (&cmd, pargs.r_opt);
933           do_not_setup_keys = 1;
934           nogreeting = 1;
935           break;
936
937         case aServer: 
938           opt.batch = 1;
939           set_cmd (&cmd, aServer);
940           break;
941
942         case aCallDirmngr:
943           opt.batch = 1;
944           set_cmd (&cmd, aCallDirmngr);
945           do_not_setup_keys = 1;
946           break;
947
948         case aCallProtectTool:
949           opt.batch = 1;
950           set_cmd (&cmd, aCallProtectTool);
951           no_more_options = 1; /* Stop parsing. */
952           do_not_setup_keys = 1;
953           break;
954         
955         case aDeleteKey:
956           set_cmd (&cmd, aDeleteKey);
957           /*greeting=1;*/
958           do_not_setup_keys = 1;
959           break;
960
961         case aDetachedSign:
962           detached_sig = 1;
963           set_cmd (&cmd, aSign ); 
964           break;
965
966         case aKeygen:
967           set_cmd (&cmd, aKeygen);
968           greeting=1; 
969           do_not_setup_keys = 1;
970           break;
971
972         case aCheckKeys:
973         case aImport: 
974         case aSendKeys: 
975         case aRecvKeys: 
976         case aExport: 
977         case aExportSecretKeyP12: 
978         case aDumpKeys:
979         case aDumpChain:
980         case aDumpExternalKeys: 
981         case aDumpSecretKeys: 
982         case aListKeys:
983         case aListExternalKeys: 
984         case aListSecretKeys: 
985         case aListChain: 
986         case aLearnCard: 
987         case aPasswd: 
988         case aKeydbClearSomeCertFlags:
989           do_not_setup_keys = 1;
990           set_cmd (&cmd, pargs.r_opt);
991           break;
992
993         case aEncr: 
994           recp_required = 1;
995           set_cmd (&cmd, pargs.r_opt);
996           break;
997
998         case aSym:
999         case aDecrypt: 
1000         case aSign: 
1001         case aClearsign: 
1002         case aVerify: 
1003           set_cmd (&cmd, pargs.r_opt);
1004           break;
1005
1006           /* Output encoding selection.  */
1007         case oArmor:
1008           ctrl.create_pem = 1;
1009           break;
1010         case oBase64: 
1011           ctrl.create_pem = 0;
1012           ctrl.create_base64 = 1;
1013           break;
1014         case oNoArmor: 
1015           ctrl.create_pem = 0;
1016           ctrl.create_base64 = 0;
1017           break;
1018           
1019         case oP12Charset:
1020           opt.p12_charset = pargs.r.ret_str;
1021           break;
1022
1023           /* Input encoding selection.  */
1024         case oAssumeArmor:
1025           ctrl.autodetect_encoding = 0;
1026           ctrl.is_pem = 1;
1027           ctrl.is_base64 = 0;
1028           break;
1029         case oAssumeBase64:
1030           ctrl.autodetect_encoding = 0;
1031           ctrl.is_pem = 0;
1032           ctrl.is_base64 = 1;
1033           break;
1034         case oAssumeBinary:
1035           ctrl.autodetect_encoding = 0;
1036           ctrl.is_pem = 0;
1037           ctrl.is_base64 = 0;
1038           break;
1039
1040         case oDisableCRLChecks:
1041           opt.no_crl_check = 1;
1042           break;
1043         case oEnableCRLChecks:
1044           opt.no_crl_check = 0;
1045           break;
1046         case oDisableTrustedCertCRLCheck:
1047           opt.no_trusted_cert_crl_check = 1;
1048           break;
1049         case oEnableTrustedCertCRLCheck:
1050           opt.no_trusted_cert_crl_check = 0;
1051           break;
1052         case oForceCRLRefresh:
1053           opt.force_crl_refresh = 1;
1054           break;
1055
1056         case oDisableOCSP:
1057           ctrl.use_ocsp = opt.enable_ocsp = 0;
1058           break;
1059         case oEnableOCSP:
1060           ctrl.use_ocsp = opt.enable_ocsp = 1;
1061           break;
1062
1063         case oIncludeCerts: 
1064           ctrl.include_certs = default_include_certs = pargs.r.ret_int; 
1065           break;
1066
1067         case oPolicyFile:
1068           xfree (opt.policy_file);
1069           if (*pargs.r.ret_str)
1070             opt.policy_file = xstrdup (pargs.r.ret_str);
1071           else
1072             opt.policy_file = NULL;
1073           break;
1074
1075         case oDisablePolicyChecks:
1076           opt.no_policy_check = 1;
1077           break;
1078         case oEnablePolicyChecks:
1079           opt.no_policy_check = 0;
1080           break;
1081           
1082         case oAutoIssuerKeyRetrieve:
1083           opt.auto_issuer_key_retrieve = 1;
1084           break;
1085
1086         case oOutput: opt.outfile = pargs.r.ret_str; break;
1087
1088         
1089         case oQuiet: opt.quiet = 1; break;
1090         case oNoTTY: /* fixme:tty_no_terminal(1);*/ break;
1091         case oDryRun: opt.dry_run = 1; break;
1092
1093         case oVerbose:
1094           opt.verbose++;
1095           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1096           break;
1097         case oNoVerbose:
1098           opt.verbose = 0;
1099           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1100           break;
1101
1102         case oLogFile: logfile = pargs.r.ret_str; break;
1103         case oNoLogFile: logfile = NULL; break;          
1104
1105         case oBatch: 
1106           opt.batch = 1;
1107           greeting = 0;
1108           break;
1109         case oNoBatch: opt.batch = 0; break;
1110           
1111         case oAnswerYes: opt.answer_yes = 1; break;
1112         case oAnswerNo: opt.answer_no = 1; break;
1113
1114         case oKeyring: append_to_strlist (&nrings, pargs.r.ret_str); break;
1115
1116         case oDebug: debug_value |= pargs.r.ret_ulong; break;
1117         case oDebugAll: debug_value = ~0; break;
1118         case oDebugNone: debug_value = 0; break;
1119         case oDebugLevel: debug_level = pargs.r.ret_str; break;
1120         case oDebugWait: debug_wait = pargs.r.ret_int; break;
1121         case oDebugAllowCoreDump:
1122           may_coredump = enable_core_dumps ();
1123           break;
1124         case oDebugNoChainValidation: opt.no_chain_validation = 1; break;
1125         case oDebugIgnoreExpiration: opt.ignore_expiration = 1; break;
1126         case oFixedPassphrase: opt.fixed_passphrase = pargs.r.ret_str; break;
1127
1128         case oStatusFD: ctrl.status_fd = pargs.r.ret_int; break;
1129         case oLoggerFD: log_set_fd (pargs.r.ret_int ); break;
1130         case oWithMD5Fingerprint:
1131           opt.with_md5_fingerprint=1; /*fall thru*/
1132         case oWithFingerprint:
1133           with_fpr=1; /*fall thru*/
1134         case oFingerprint:
1135           opt.fingerprint++;
1136           break;
1137
1138         case oOptions:
1139           /* config files may not be nested (silently ignore them) */
1140           if (!configfp)
1141             {
1142               xfree(configname);
1143               configname = xstrdup (pargs.r.ret_str);
1144               goto next_pass;
1145             }
1146           break;
1147         case oNoOptions: break; /* no-options */
1148         case oHomedir: opt.homedir = pargs.r.ret_str; break;
1149         case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
1150         case oDisplay: opt.display = xstrdup (pargs.r.ret_str); break;
1151         case oTTYname: opt.ttyname = xstrdup (pargs.r.ret_str); break;
1152         case oTTYtype: opt.ttytype = xstrdup (pargs.r.ret_str); break;
1153         case oLCctype: opt.lc_ctype = xstrdup (pargs.r.ret_str); break;
1154         case oLCmessages: opt.lc_messages = xstrdup (pargs.r.ret_str); break;
1155         case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str;  break;
1156         case oPreferSystemDirmngr: opt.prefer_system_dirmngr = 1; break;
1157         case oProtectToolProgram:
1158           opt.protect_tool_program = pargs.r.ret_str; 
1159           break;
1160           
1161         case oFakedSystemTime:
1162           {
1163             time_t faked_time = isotime2epoch (pargs.r.ret_str); 
1164             if (faked_time == (time_t)(-1))
1165               faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
1166             gnupg_set_time (faked_time, 0);
1167           }
1168           break;
1169
1170         case oNoDefKeyring: default_keyring = 0; break;
1171         case oNoGreeting: nogreeting = 1; break;
1172
1173         case oDefaultKey:
1174           if (*pargs.r.ret_str)
1175             {
1176               xfree (opt.local_user);
1177               opt.local_user = xstrdup (pargs.r.ret_str);
1178             }
1179           break;
1180         case oDefRecipient:
1181           if (*pargs.r.ret_str)
1182             opt.def_recipient = xstrdup (pargs.r.ret_str);
1183           break;
1184         case oDefRecipientSelf:
1185           xfree (opt.def_recipient);
1186           opt.def_recipient = NULL;
1187           opt.def_recipient_self = 1;
1188           break;
1189         case oNoDefRecipient:
1190           xfree (opt.def_recipient);
1191           opt.def_recipient = NULL;
1192           opt.def_recipient_self = 0;
1193           break;
1194
1195         case oWithKeyData: opt.with_key_data=1; /* fall thru */
1196         case oWithColons: ctrl.with_colons = 1; break;
1197         case oWithValidation: ctrl.with_validation=1; break;
1198         case oWithEphemeralKeys: opt.with_ephemeral_keys=1; break;
1199
1200         case oSkipVerify: opt.skip_verify=1; break;
1201
1202         case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1203         case oEncryptTo: /* Store the recipient in the second list */
1204           sl = add_to_strlist (&remusr, pargs.r.ret_str);
1205           sl->flags = 1;
1206           break;
1207
1208         case oRecipient: /* store the recipient */
1209           add_to_strlist ( &remusr, pargs.r.ret_str);
1210           break;
1211
1212         case oTextmodeShort: /*fixme:opt.textmode = 2;*/ break;
1213         case oTextmode: /*fixme:opt.textmode=1;*/  break;
1214
1215         case oUser: /* Store the local users, the first one is the default */
1216           if (!opt.local_user)
1217             opt.local_user = xstrdup (pargs.r.ret_str);
1218           add_to_strlist (&locusr, pargs.r.ret_str);
1219           break;
1220
1221         case oNoSecmemWarn:
1222           gcry_control (GCRYCTL_DISABLE_SECMEM_WARN); 
1223           break;
1224
1225         case oCipherAlgo:
1226           opt.def_cipher_algoid = pargs.r.ret_str;
1227           break;
1228
1229         case oDisableCipherAlgo: 
1230           {
1231             int algo = gcry_cipher_map_name (pargs.r.ret_str);
1232             gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
1233           }
1234           break;
1235         case oDisablePubkeyAlgo: 
1236           {
1237             int algo = gcry_pk_map_name (pargs.r.ret_str);
1238             gcry_pk_ctl (GCRYCTL_DISABLE_ALGO,&algo, sizeof algo );
1239           }
1240           break;
1241
1242         case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1243         case oNoRandomSeedFile: use_random_seed = 0; break;
1244
1245         case oEnableSpecialFilenames: allow_special_filenames =1; break;
1246
1247         case oValidationModel: parse_validation_model (pargs.r.ret_str); break;
1248
1249         case aDummy:
1250           break;
1251         default: 
1252           pargs.err = configfp? 1:2; 
1253           break;
1254         }
1255     }
1256
1257   if (configfp)
1258     {
1259       fclose (configfp);
1260       configfp = NULL;
1261       /* Keep a copy of the config filename. */
1262       opt.config_filename = configname;
1263       configname = NULL;
1264       goto next_pass;
1265     }
1266   xfree (configname);
1267   configname = NULL;
1268
1269   if (!opt.config_filename)
1270     opt.config_filename = make_filename (opt.homedir, "gpgsm.conf", NULL);
1271
1272   if (log_get_errorcount(0))
1273     gpgsm_exit(2);
1274
1275   /* Now that we have the optiosn parsed we need to update the default
1276      control structure.  */
1277   gpgsm_init_default_ctrl (&ctrl);
1278
1279   if (nogreeting)
1280     greeting = 0;
1281   
1282   if (greeting)
1283     {
1284       fprintf(stderr, "%s %s; %s\n",
1285               strusage(11), strusage(13), strusage(14) );
1286       fprintf(stderr, "%s\n", strusage(15) );
1287     }
1288 #  ifdef IS_DEVELOPMENT_VERSION
1289   if (!opt.batch)
1290     {
1291       log_info ("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1292       log_info ("It is only intended for test purposes and should NOT be\n");
1293       log_info ("used in a production environment or with production keys!\n");
1294     }
1295 #  endif
1296
1297   if (may_coredump && !opt.quiet)
1298     log_info (_("WARNING: program may create a core file!\n"));
1299
1300 /*   if (opt.qualsig_approval && !opt.quiet) */
1301 /*     log_info (_("This software has offically been approved to " */
1302 /*                 "create and verify\n" */
1303 /*                 "qualified signatures according to German law.\n")); */
1304
1305   if (logfile && cmd == aServer)
1306     {
1307       log_set_file (logfile);
1308       log_set_prefix (NULL, 1|2|4);
1309     }
1310
1311   if (gnupg_faked_time_p ())
1312     {
1313       gnupg_isotime_t tbuf;
1314
1315       log_info (_("WARNING: running with faked system time: "));
1316       gnupg_get_isotime (tbuf);
1317       gpgsm_dump_time (tbuf);
1318       log_printf ("\n");
1319     }
1320   
1321 /*FIXME    if (opt.batch) */
1322 /*      tty_batchmode (1); */
1323
1324   gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
1325
1326   set_debug ();
1327
1328   /* Although we alwasy use gpgsm_exit, we better install a regualr
1329      exit handler so that at least the secure memory gets wiped
1330      out. */
1331   if (atexit (emergency_cleanup))
1332     {
1333       log_error ("atexit failed\n");
1334       gpgsm_exit (2);
1335     }
1336
1337   /* Must do this after dropping setuid, because the mapping functions
1338      may try to load an module and we may have disabled an algorithm.
1339      We remap the commonly used algorithms to the OIDs for
1340      convenience.  We need to work with the OIDs because they are used
1341      to check whether the encryption mode is actually available. */
1342   if (!strcmp (opt.def_cipher_algoid, "3DES") )
1343     opt.def_cipher_algoid = "1.2.840.113549.3.7";
1344   else if (!strcmp (opt.def_cipher_algoid, "AES")
1345            || !strcmp (opt.def_cipher_algoid, "AES128"))
1346     opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.2";
1347   else if (!strcmp (opt.def_cipher_algoid, "AES256") )
1348     opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.42";
1349   else if (!strcmp (opt.def_cipher_algoid, "SERPENT")
1350            || !strcmp (opt.def_cipher_algoid, "SERPENT128") )
1351     opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.2";
1352   else if (!strcmp (opt.def_cipher_algoid, "SERPENT192") )
1353     opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.22";
1354   else if (!strcmp (opt.def_cipher_algoid, "SERPENT192") )
1355     opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.42";
1356   else if (!strcmp (opt.def_cipher_algoid, "SEED") )
1357     opt.def_cipher_algoid = "1.2.410.200004.1.4";
1358   else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA") 
1359            || !strcmp (opt.def_cipher_algoid, "CAMELLIA128") )
1360     opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.2";
1361   else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA192") )
1362     opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.3";
1363   else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA256") )
1364     opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.4";
1365
1366   if (cmd != aGPGConfList)
1367     {
1368       if ( !gcry_cipher_map_name (opt.def_cipher_algoid)
1369            || !gcry_cipher_mode_from_oid (opt.def_cipher_algoid))
1370         log_error (_("selected cipher algorithm is invalid\n"));
1371
1372       if (def_digest_string)
1373         {
1374           opt.def_digest_algo = gcry_md_map_name (def_digest_string);
1375           xfree (def_digest_string);
1376           def_digest_string = NULL;
1377           if (our_md_test_algo(opt.def_digest_algo) )
1378             log_error (_("selected digest algorithm is invalid\n"));
1379         }
1380     }
1381
1382   if (log_get_errorcount(0))
1383     gpgsm_exit(2);
1384   
1385   /* Set the random seed file. */
1386   if (use_random_seed) 
1387     {
1388       char *p = make_filename (opt.homedir, "random_seed", NULL);
1389       gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
1390       xfree(p);
1391     }
1392   
1393   if (!cmd && opt.fingerprint && !with_fpr)
1394     set_cmd (&cmd, aListKeys);
1395   
1396   /* Add default keybox. */
1397   if (!nrings && default_keyring)
1398     {
1399       int created;
1400
1401       keydb_add_resource ("pubring.kbx", 0, 0, &created);
1402       if (created)
1403         {
1404           /* Import the standard certificates for a new default keybox. */
1405           char *filelist[2];
1406           
1407           filelist[0] = make_filename (gnupg_datadir (),"com-certs.pem", NULL);
1408           filelist[1] = NULL;
1409           if (!access (filelist[0], F_OK))
1410             {
1411               log_info (_("importing common certificates `%s'\n"),
1412                         filelist[0]);
1413               gpgsm_import_files (&ctrl, 1, filelist, open_read);
1414             }
1415           xfree (filelist[0]);
1416         }
1417     }
1418   for (sl = nrings; sl; sl = sl->next)
1419     keydb_add_resource (sl->d, 0, 0, NULL);
1420   FREE_STRLIST(nrings);
1421
1422   if (!do_not_setup_keys)
1423     {
1424       for (sl = locusr; sl ; sl = sl->next)
1425         {
1426           int rc = gpgsm_add_to_certlist (&ctrl, sl->d, 1, &signerlist, 0);
1427           if (rc)
1428             {
1429               log_error (_("can't sign using `%s': %s\n"),
1430                          sl->d, gpg_strerror (rc));
1431               gpgsm_status2 (&ctrl, STATUS_INV_RECP,
1432                          gpg_err_code (rc) == -1?                      "1":
1433                          gpg_err_code (rc) == GPG_ERR_NO_PUBKEY?       "1":
1434                          gpg_err_code (rc) == GPG_ERR_AMBIGUOUS_NAME?  "2":
1435                          gpg_err_code (rc) == GPG_ERR_WRONG_KEY_USAGE? "3":
1436                          gpg_err_code (rc) == GPG_ERR_CERT_REVOKED?    "4":
1437                          gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED?    "5":
1438                          gpg_err_code (rc) == GPG_ERR_NO_CRL_KNOWN?    "6":
1439                          gpg_err_code (rc) == GPG_ERR_CRL_TOO_OLD?     "7":
1440                          gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH? "8":
1441                          gpg_err_code (rc) == GPG_ERR_NO_SECKEY?       "9":
1442                          "0",
1443                          sl->d, NULL);
1444             }
1445         }
1446       
1447       /* Build the recipient list.  We first add the regular ones and then
1448          the encrypt-to ones because the underlying function will silently
1449          ignore duplicates and we can't allow to keep a duplicate which is
1450          flagged as encrypt-to as the actually encrypt function would then
1451          complain about no (regular) recipients. */
1452       for (sl = remusr; sl; sl = sl->next)
1453         if (!(sl->flags & 1))
1454           do_add_recipient (&ctrl, sl->d, &recplist, 0, recp_required);
1455       if (!opt.no_encrypt_to)
1456         {
1457           for (sl = remusr; sl; sl = sl->next)
1458             if ((sl->flags & 1))
1459               do_add_recipient (&ctrl, sl->d, &recplist, 1, recp_required);
1460         }
1461     }
1462
1463   if (log_get_errorcount(0))
1464     gpgsm_exit(1); /* Must stop for invalid recipients. */
1465   
1466   fname = argc? *argv : NULL;
1467   
1468   switch (cmd)
1469     {
1470     case aGPGConfList: 
1471       { /* List options and default values in the GPG Conf format.  */
1472         char *config_filename_esc = percent_escape (opt.config_filename, NULL);
1473
1474         printf ("gpgconf-gpgsm.conf:%lu:\"%s\n",
1475                 GC_OPT_FLAG_DEFAULT, config_filename_esc);
1476         xfree (config_filename_esc);
1477
1478         printf ("verbose:%lu:\n"
1479                 "quiet:%lu:\n"
1480                 "debug-level:%lu:\"none:\n"
1481                 "log-file:%lu:\n",
1482                 GC_OPT_FLAG_NONE,
1483                 GC_OPT_FLAG_NONE,
1484                 GC_OPT_FLAG_DEFAULT,
1485                 GC_OPT_FLAG_NONE );
1486         printf ("disable-crl-checks:%lu:\n",
1487                 GC_OPT_FLAG_NONE );
1488         printf ("disable-trusted-cert-crl-check:%lu:\n",
1489                 GC_OPT_FLAG_NONE );
1490         printf ("enable-ocsp:%lu:\n",
1491                 GC_OPT_FLAG_NONE );
1492         printf ("include-certs:%lu:1:\n",
1493                 GC_OPT_FLAG_DEFAULT );
1494         printf ("disable-policy-checks:%lu:\n",
1495                 GC_OPT_FLAG_NONE );
1496         printf ("auto-issuer-key-retrieve:%lu:\n",
1497                 GC_OPT_FLAG_NONE );
1498 #ifndef HAVE_W32_SYSTEM
1499         printf ("prefer-system-dirmngr:%lu:\n",
1500                 GC_OPT_FLAG_NONE );
1501 #endif
1502         printf ("cipher-algo:%lu:\"3DES:\n",
1503                 GC_OPT_FLAG_DEFAULT );
1504         printf ("p12-charset:%lu:\n",
1505                 GC_OPT_FLAG_DEFAULT );
1506         printf ("default-key:%lu:\n",
1507                 GC_OPT_FLAG_DEFAULT );
1508         printf ("encrypt-to:%lu:\n",
1509                 GC_OPT_FLAG_DEFAULT );
1510
1511       }
1512       break;
1513     case aGPGConfTest:
1514       /* This is merely a dummy command to test whether the
1515          configuration file is valid.  */
1516       break;
1517
1518     case aServer:
1519       if (debug_wait)
1520         {
1521           log_debug ("waiting for debugger - my pid is %u .....\n",
1522                      (unsigned int)getpid());
1523           gnupg_sleep (debug_wait);
1524           log_debug ("... okay\n");
1525          }
1526       gpgsm_server (recplist);
1527       break;
1528
1529     case aCallDirmngr:
1530       if (!argc)
1531         wrong_args ("--call-dirmngr <command> {args}");
1532       else
1533         if (gpgsm_dirmngr_run_command (&ctrl, *argv, argc-1, argv+1))
1534           gpgsm_exit (1);
1535       break;
1536
1537     case aCallProtectTool:
1538       run_protect_tool (argc, argv);
1539       break;
1540
1541     case aEncr: /* Encrypt the given file. */
1542       {
1543         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1544
1545         set_binary (stdin);
1546
1547         if (!argc) /* Source is stdin. */
1548           gpgsm_encrypt (&ctrl, recplist, 0, fp); 
1549         else if (argc == 1)  /* Source is the given file. */
1550           gpgsm_encrypt (&ctrl, recplist, open_read (*argv), fp);
1551         else
1552           wrong_args ("--encrypt [datafile]");
1553
1554         if (fp != stdout)
1555           fclose (fp);
1556       }
1557       break;
1558
1559     case aSign: /* Sign the given file. */
1560       {
1561         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1562
1563         /* Fixme: We should also allow to concatenate multiple files for
1564            signing because that is what gpg does.*/
1565         set_binary (stdin);
1566         if (!argc) /* Create from stdin. */
1567           gpgsm_sign (&ctrl, signerlist, 0, detached_sig, fp); 
1568         else if (argc == 1) /* From file. */
1569           gpgsm_sign (&ctrl, signerlist,
1570                       open_read (*argv), detached_sig, fp); 
1571         else
1572           wrong_args ("--sign [datafile]");
1573
1574         if (fp != stdout)
1575           fclose (fp);
1576       }
1577       break;
1578         
1579     case aSignEncr: /* sign and encrypt the given file */
1580       log_error ("this command has not yet been implemented\n");
1581       break;
1582
1583     case aClearsign: /* make a clearsig */
1584       log_error ("this command has not yet been implemented\n");
1585       break;
1586
1587     case aVerify:
1588       {
1589         FILE *fp = NULL;
1590
1591         set_binary (stdin);
1592         if (argc == 2 && opt.outfile)
1593           log_info ("option --output ignored for a detached signature\n");
1594         else if (opt.outfile)
1595           fp = open_fwrite (opt.outfile);
1596
1597         if (!argc)
1598           gpgsm_verify (&ctrl, 0, -1, fp); /* normal signature from stdin */
1599         else if (argc == 1)
1600           gpgsm_verify (&ctrl, open_read (*argv), -1, fp); /* std signature */
1601         else if (argc == 2) /* detached signature (sig, detached) */
1602           gpgsm_verify (&ctrl, open_read (*argv), open_read (argv[1]), NULL); 
1603         else
1604           wrong_args ("--verify [signature [detached_data]]");
1605
1606         if (fp && fp != stdout)
1607           fclose (fp);
1608       }
1609       break;
1610
1611     case aVerifyFiles:
1612       log_error (_("this command has not yet been implemented\n"));
1613       break;
1614
1615     case aDecrypt:
1616       {
1617         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1618
1619         set_binary (stdin);
1620         if (!argc)
1621           gpgsm_decrypt (&ctrl, 0, fp); /* from stdin */
1622         else if (argc == 1)
1623           gpgsm_decrypt (&ctrl, open_read (*argv), fp); /* from file */
1624         else
1625           wrong_args ("--decrypt [filename]");
1626         if (fp != stdout)
1627           fclose (fp);
1628       }
1629       break;
1630
1631     case aDeleteKey:
1632       for (sl=NULL; argc; argc--, argv++)
1633         add_to_strlist (&sl, *argv);
1634       gpgsm_delete (&ctrl, sl);
1635       free_strlist(sl);
1636       break;
1637
1638     case aListChain:
1639     case aDumpChain:
1640        ctrl.with_chain = 1;
1641     case aListKeys:
1642     case aDumpKeys:
1643     case aListExternalKeys:
1644     case aDumpExternalKeys:
1645     case aListSecretKeys:
1646     case aDumpSecretKeys:
1647       {
1648         unsigned int mode;
1649         estream_t fp;
1650
1651         switch (cmd)
1652           {
1653           case aListChain:
1654           case aListKeys:         mode = (0   | 0 | (1<<6)); break;
1655           case aDumpChain: 
1656           case aDumpKeys:         mode = (256 | 0 | (1<<6)); break;
1657           case aListExternalKeys: mode = (0   | 0 | (1<<7)); break;
1658           case aDumpExternalKeys: mode = (256 | 0 | (1<<7)); break;
1659           case aListSecretKeys:   mode = (0   | 2 | (1<<6)); break;
1660           case aDumpSecretKeys:   mode = (256 | 2 | (1<<6)); break;
1661           default: BUG();
1662           }
1663
1664         fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1665         for (sl=NULL; argc; argc--, argv++)
1666           add_to_strlist (&sl, *argv);
1667         gpgsm_list_keys (&ctrl, sl, fp, mode);
1668         free_strlist(sl);
1669         es_fclose (fp);
1670       }
1671       break;
1672
1673
1674     case aKeygen: /* Generate a key; well kind of. */
1675       {
1676         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1677         gpgsm_gencertreq_tty (&ctrl, fp);
1678         if (fp != stdout)
1679           fclose (fp);
1680       }
1681       break;
1682
1683
1684     case aImport:
1685       gpgsm_import_files (&ctrl, argc, argv, open_read);
1686       break;
1687
1688     case aExport:
1689       {
1690         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1691
1692         for (sl=NULL; argc; argc--, argv++)
1693           add_to_strlist (&sl, *argv);
1694         gpgsm_export (&ctrl, sl, fp, NULL);
1695         free_strlist(sl);
1696         if (fp != stdout)
1697           fclose (fp);
1698       }
1699       break;
1700
1701     case aExportSecretKeyP12:
1702       {
1703         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1704
1705         if (argc == 1)
1706           gpgsm_p12_export (&ctrl, *argv, stdout);
1707         else
1708           wrong_args ("--export-secret-key-p12 KEY-ID");
1709         if (fp != stdout)
1710           fclose (fp);
1711       }
1712       break;
1713       
1714     case aSendKeys:
1715     case aRecvKeys:
1716       log_error ("this command has not yet been implemented\n");
1717       break;
1718
1719
1720     case aLearnCard:
1721       if (argc)
1722         wrong_args ("--learn-card");
1723       else
1724         {
1725           int rc = gpgsm_agent_learn (&ctrl);
1726           if (rc)
1727             log_error ("error learning card: %s\n", gpg_strerror (rc));
1728         }
1729       break;
1730
1731     case aPasswd:
1732       if (argc != 1)
1733         wrong_args ("--passwd <key-Id>");
1734       else
1735         {
1736           int rc;
1737           ksba_cert_t cert = NULL;
1738           char *grip = NULL;
1739
1740           rc = gpgsm_find_cert (*argv, NULL, &cert);
1741           if (rc)
1742             ;
1743           else if (!(grip = gpgsm_get_keygrip_hexstring (cert)))
1744             rc = gpg_error (GPG_ERR_BUG);
1745           else 
1746             {
1747               char *desc = gpgsm_format_keydesc (cert);
1748               rc = gpgsm_agent_passwd (&ctrl, grip, desc);
1749               xfree (desc);
1750             }
1751           if (rc)
1752             log_error ("error changing passphrase: %s\n", gpg_strerror (rc));
1753           xfree (grip);
1754           ksba_cert_release (cert);
1755         }
1756       break;
1757
1758     case aKeydbClearSomeCertFlags:
1759       for (sl=NULL; argc; argc--, argv++)
1760         add_to_strlist (&sl, *argv);
1761       keydb_clear_some_cert_flags (&ctrl, sl);
1762       free_strlist(sl);
1763       break;
1764
1765
1766     default:
1767         log_error ("invalid command (there is no implicit command)\n");
1768         break;
1769     }
1770   
1771   /* cleanup */
1772   gpgsm_release_certlist (recplist);
1773   gpgsm_release_certlist (signerlist);
1774   FREE_STRLIST (remusr);
1775   FREE_STRLIST (locusr);
1776   gpgsm_exit(0);
1777   return 8; /*NOTREACHED*/
1778 }
1779
1780 /* Note: This function is used by signal handlers!. */
1781 static void
1782 emergency_cleanup (void)
1783 {
1784   gcry_control (GCRYCTL_TERM_SECMEM );
1785 }
1786
1787
1788 void
1789 gpgsm_exit (int rc)
1790 {
1791   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
1792   if (opt.debug & DBG_MEMSTAT_VALUE)
1793     {
1794       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1795       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1796     }
1797   if (opt.debug)
1798     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1799   emergency_cleanup ();
1800   rc = rc? rc : log_get_errorcount(0)? 2 : gpgsm_errors_seen? 1 : 0;
1801   exit (rc);
1802 }
1803
1804
1805 void
1806 gpgsm_init_default_ctrl (struct server_control_s *ctrl)
1807 {
1808   ctrl->include_certs = default_include_certs;
1809   ctrl->use_ocsp = opt.enable_ocsp;
1810   ctrl->validation_model = default_validation_model;
1811 }
1812
1813
1814 int
1815 gpgsm_parse_validation_model (const char *model)
1816 {     
1817   if (!ascii_strcasecmp (model, "shell") )
1818     return 0;
1819   else if ( !ascii_strcasecmp (model, "chain") )
1820     return 1;
1821   else
1822     return -1;
1823 }
1824
1825
1826 /* Check whether the filename has the form "-&nnnn", where n is a
1827    non-zero number.  Returns this number or -1 if it is not the case.  */
1828 static int
1829 check_special_filename (const char *fname, int for_write)
1830 {
1831   if (allow_special_filenames
1832       && fname && *fname == '-' && fname[1] == '&' ) {
1833     int i;
1834     
1835     fname += 2;
1836     for (i=0; isdigit (fname[i]); i++ )
1837       ;
1838     if ( !fname[i] ) 
1839       return translate_sys2libc_fd_int (atoi (fname), for_write);
1840   }
1841   return -1;
1842 }
1843
1844
1845
1846 /* Open the FILENAME for read and return the filedescriptor.  Stop
1847    with an error message in case of problems.  "-" denotes stdin and
1848    if special filenames are allowed the given fd is opened instead. */
1849 static int 
1850 open_read (const char *filename)
1851 {
1852   int fd;
1853
1854   if (filename[0] == '-' && !filename[1])
1855     {
1856       set_binary (stdin);
1857       return 0; /* stdin */
1858     }
1859   fd = check_special_filename (filename, 0);
1860   if (fd != -1)
1861     return fd;
1862   fd = open (filename, O_RDONLY | O_BINARY);
1863   if (fd == -1)
1864     {
1865       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1866       gpgsm_exit (2);
1867     }
1868   return fd;
1869 }
1870
1871 /* Open FILENAME for fwrite and return the stream.  Stop with an error
1872    message in case of problems.  "-" denotes stdout and if special
1873    filenames are allowed the given fd is opened instead. Caller must
1874    close the returned stream unless it is stdout. */
1875 static FILE *
1876 open_fwrite (const char *filename)
1877 {
1878   int fd;
1879   FILE *fp;
1880
1881   if (filename[0] == '-' && !filename[1])
1882     {
1883       set_binary (stdout);
1884       return stdout;
1885     }
1886
1887   fd = check_special_filename (filename, 1);
1888   if (fd != -1)
1889     {
1890       fp = fdopen (dup (fd), "wb");
1891       if (!fp)
1892         {
1893           log_error ("fdopen(%d) failed: %s\n", fd, strerror (errno));
1894           gpgsm_exit (2);
1895         }
1896       set_binary (fp);
1897       return fp;
1898     }
1899   fp = fopen (filename, "wb");
1900   if (!fp)
1901     {
1902       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1903       gpgsm_exit (2);
1904     }
1905   return fp;
1906 }
1907
1908
1909 /* Open FILENAME for fwrite and return an extended stream.  Stop with
1910    an error message in case of problems.  "-" denotes stdout and if
1911    special filenames are allowed the given fd is opened instead.
1912    Caller must close the returned stream. */
1913 static estream_t
1914 open_es_fwrite (const char *filename)
1915 {
1916   int fd;
1917   estream_t fp;
1918
1919   if (filename[0] == '-' && !filename[1])
1920     {
1921       fflush (stdout);
1922       fp = es_fdopen_nc (fileno(stdout), "wb");
1923       return fp;
1924     }
1925
1926   fd = check_special_filename (filename, 1);
1927   if (fd != -1)
1928     {
1929       fp = es_fdopen_nc (fd, "wb");
1930       if (!fp)
1931         {
1932           log_error ("es_fdopen(%d) failed: %s\n", fd, strerror (errno));
1933           gpgsm_exit (2);
1934         }
1935       return fp;
1936     }
1937   fp = es_fopen (filename, "wb");
1938   if (!fp)
1939     {
1940       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1941       gpgsm_exit (2);
1942     }
1943   return fp;
1944 }
1945
1946
1947 static void
1948 run_protect_tool (int argc, char **argv)
1949 {
1950 #ifndef HAVE_W32_SYSTEM
1951   const char *pgm;
1952   char **av;
1953   int i;
1954
1955   if (!opt.protect_tool_program || !*opt.protect_tool_program)
1956     pgm = gnupg_module_name (GNUPG_MODULE_NAME_PROTECT_TOOL);
1957   else
1958     pgm = opt.protect_tool_program;
1959
1960   av = xcalloc (argc+2, sizeof *av);
1961   av[0] = strrchr (pgm, '/');
1962   if (!av[0])
1963     av[0] = xstrdup (pgm);
1964   for (i=1; argc; i++, argc--, argv++)
1965     av[i] = *argv;
1966   av[i] = NULL;
1967   execv (pgm, av); 
1968   log_error ("error executing `%s': %s\n", pgm, strerror (errno));
1969 #endif /*HAVE_W32_SYSTEM*/
1970   gpgsm_exit (2);
1971 }