gpg: Check for ambiguous or non-matching key specs.
[gnupg.git] / g10 / gpg.c
1 /* gpg.c - The GnuPG utility (main for gpg)
2  * Copyright (C) 1998-2011 Free Software Foundation, Inc.
3  * Copyright (C) 1997-2014 Werner Koch
4  * Copyright (C) 2015 g10 Code GmbH
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG 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
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <errno.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <ctype.h>
28 #include <unistd.h>
29 #include <assert.h>
30 #ifdef HAVE_STAT
31 #include <sys/stat.h> /* for stat() */
32 #endif
33 #include <fcntl.h>
34 #ifdef HAVE_W32_SYSTEM
35 # ifdef HAVE_WINSOCK2_H
36 #  include <winsock2.h>
37 # endif
38 # include <windows.h>
39 #endif
40
41 #define INCLUDED_BY_MAIN_MODULE 1
42 #include "gpg.h"
43 #include <assuan.h>
44 #include "../common/iobuf.h"
45 #include "util.h"
46 #include "packet.h"
47 #include "membuf.h"
48 #include "main.h"
49 #include "options.h"
50 #include "keydb.h"
51 #include "trustdb.h"
52 #include "filter.h"
53 #include "ttyio.h"
54 #include "i18n.h"
55 #include "sysutils.h"
56 #include "status.h"
57 #include "keyserver-internal.h"
58 #include "exec.h"
59 #include "gc-opt-flags.h"
60 #include "asshelp.h"
61 #include "call-dirmngr.h"
62 #include "tofu.h"
63 #include "../common/init.h"
64 #include "../common/shareddefs.h"
65
66 #if defined(HAVE_DOSISH_SYSTEM) || defined(__CYGWIN__)
67 #define MY_O_BINARY  O_BINARY
68 #ifndef S_IRGRP
69 # define S_IRGRP 0
70 # define S_IWGRP 0
71 #endif
72 #else
73 #define MY_O_BINARY  0
74 #endif
75
76
77 enum cmd_and_opt_values
78   {
79     aNull = 0,
80     oArmor        = 'a',
81     aDetachedSign = 'b',
82     aSym          = 'c',
83     aDecrypt      = 'd',
84     aEncr         = 'e',
85     oInteractive  = 'i',
86     aListKeys     = 'k',
87     oDryRun       = 'n',
88     oOutput       = 'o',
89     oQuiet        = 'q',
90     oRecipient    = 'r',
91     oHiddenRecipient = 'R',
92     aSign         = 's',
93     oTextmodeShort= 't',
94     oLocalUser    = 'u',
95     oVerbose      = 'v',
96     oCompress     = 'z',
97     oSetNotation  = 'N',
98     aListSecretKeys = 'K',
99     oBatch        = 500,
100     oMaxOutput,
101     oSigNotation,
102     oCertNotation,
103     oShowNotation,
104     oNoShowNotation,
105     aEncrFiles,
106     aEncrSym,
107     aDecryptFiles,
108     aClearsign,
109     aStore,
110     aQuickKeygen,
111     aFullKeygen,
112     aKeygen,
113     aSignEncr,
114     aSignEncrSym,
115     aSignSym,
116     aSignKey,
117     aLSignKey,
118     aQuickSignKey,
119     aQuickLSignKey,
120     aQuickAddUid,
121     aListConfig,
122     aListGcryptConfig,
123     aGPGConfList,
124     aGPGConfTest,
125     aListPackets,
126     aEditKey,
127     aDeleteKeys,
128     aDeleteSecretKeys,
129     aDeleteSecretAndPublicKeys,
130     aImport,
131     aFastImport,
132     aVerify,
133     aVerifyFiles,
134     aListSigs,
135     aSendKeys,
136     aRecvKeys,
137     aLocateKeys,
138     aSearchKeys,
139     aRefreshKeys,
140     aFetchKeys,
141     aExport,
142     aExportSecret,
143     aExportSecretSub,
144     aCheckKeys,
145     aGenRevoke,
146     aDesigRevoke,
147     aPrimegen,
148     aPrintMD,
149     aPrintMDs,
150     aCheckTrustDB,
151     aUpdateTrustDB,
152     aFixTrustDB,
153     aListTrustDB,
154     aListTrustPath,
155     aExportOwnerTrust,
156     aImportOwnerTrust,
157     aDeArmor,
158     aEnArmor,
159     aGenRandom,
160     aRebuildKeydbCaches,
161     aCardStatus,
162     aCardEdit,
163     aChangePIN,
164     aPasswd,
165     aServer,
166     aTOFUPolicy,
167
168     oTextmode,
169     oNoTextmode,
170     oExpert,
171     oNoExpert,
172     oDefSigExpire,
173     oAskSigExpire,
174     oNoAskSigExpire,
175     oDefCertExpire,
176     oAskCertExpire,
177     oNoAskCertExpire,
178     oDefCertLevel,
179     oMinCertLevel,
180     oAskCertLevel,
181     oNoAskCertLevel,
182     oFingerprint,
183     oWithFingerprint,
184     oWithICAOSpelling,
185     oWithKeygrip,
186     oWithSecret,
187     oAnswerYes,
188     oAnswerNo,
189     oKeyring,
190     oPrimaryKeyring,
191     oSecretKeyring,
192     oShowKeyring,
193     oDefaultKey,
194     oDefRecipient,
195     oDefRecipientSelf,
196     oNoDefRecipient,
197     oTrySecretKey,
198     oOptions,
199     oDebug,
200     oDebugLevel,
201     oDebugAll,
202     oDebugIOLBF,
203     oStatusFD,
204     oStatusFile,
205     oAttributeFD,
206     oAttributeFile,
207     oEmitVersion,
208     oNoEmitVersion,
209     oCompletesNeeded,
210     oMarginalsNeeded,
211     oMaxCertDepth,
212     oLoadExtension,
213     oGnuPG,
214     oRFC2440,
215     oRFC4880,
216     oOpenPGP,
217     oPGP6,
218     oPGP7,
219     oPGP8,
220     oRFC2440Text,
221     oNoRFC2440Text,
222     oCipherAlgo,
223     oDigestAlgo,
224     oCertDigestAlgo,
225     oCompressAlgo,
226     oCompressLevel,
227     oBZ2CompressLevel,
228     oBZ2DecompressLowmem,
229     oPassphrase,
230     oPassphraseFD,
231     oPassphraseFile,
232     oPassphraseRepeat,
233     oPinentryMode,
234     oCommandFD,
235     oCommandFile,
236     oQuickRandom,
237     oNoVerbose,
238     oTrustDBName,
239     oNoSecmemWarn,
240     oRequireSecmem,
241     oNoRequireSecmem,
242     oNoPermissionWarn,
243     oNoMDCWarn,
244     oNoArmor,
245     oNoDefKeyring,
246     oNoGreeting,
247     oNoTTY,
248     oNoOptions,
249     oNoBatch,
250     oHomedir,
251     oWithColons,
252     oWithKeyData,
253     oWithSigList,
254     oWithSigCheck,
255     oSkipVerify,
256     oSkipHiddenRecipients,
257     oNoSkipHiddenRecipients,
258     oAlwaysTrust,
259     oTrustModel,
260     oForceOwnertrust,
261     oSetFilename,
262     oForYourEyesOnly,
263     oNoForYourEyesOnly,
264     oSetPolicyURL,
265     oSigPolicyURL,
266     oCertPolicyURL,
267     oShowPolicyURL,
268     oNoShowPolicyURL,
269     oSigKeyserverURL,
270     oUseEmbeddedFilename,
271     oNoUseEmbeddedFilename,
272     oComment,
273     oDefaultComment,
274     oNoComments,
275     oThrowKeyids,
276     oNoThrowKeyids,
277     oShowPhotos,
278     oNoShowPhotos,
279     oPhotoViewer,
280     oForceMDC,
281     oNoForceMDC,
282     oDisableMDC,
283     oNoDisableMDC,
284     oS2KMode,
285     oS2KDigest,
286     oS2KCipher,
287     oS2KCount,
288     oDisplayCharset,
289     oNotDashEscaped,
290     oEscapeFrom,
291     oNoEscapeFrom,
292     oLockOnce,
293     oLockMultiple,
294     oLockNever,
295     oKeyServer,
296     oKeyServerOptions,
297     oImportOptions,
298     oExportOptions,
299     oListOptions,
300     oVerifyOptions,
301     oTempDir,
302     oExecPath,
303     oEncryptTo,
304     oHiddenEncryptTo,
305     oNoEncryptTo,
306     oEncryptToDefaultKey,
307     oLoggerFD,
308     oLoggerFile,
309     oUtf8Strings,
310     oNoUtf8Strings,
311     oDisableCipherAlgo,
312     oDisablePubkeyAlgo,
313     oAllowNonSelfsignedUID,
314     oNoAllowNonSelfsignedUID,
315     oAllowFreeformUID,
316     oNoAllowFreeformUID,
317     oAllowSecretKeyImport,
318     oEnableSpecialFilenames,
319     oNoLiteral,
320     oSetFilesize,
321     oHonorHttpProxy,
322     oFastListMode,
323     oListOnly,
324     oIgnoreTimeConflict,
325     oIgnoreValidFrom,
326     oIgnoreCrcError,
327     oIgnoreMDCError,
328     oShowSessionKey,
329     oOverrideSessionKey,
330     oNoRandomSeedFile,
331     oAutoKeyRetrieve,
332     oNoAutoKeyRetrieve,
333     oUseAgent,
334     oNoUseAgent,
335     oGpgAgentInfo,
336     oMergeOnly,
337     oTryAllSecrets,
338     oTrustedKey,
339     oNoExpensiveTrustChecks,
340     oFixedListMode,
341     oLegacyListMode,
342     oNoSigCache,
343     oAutoCheckTrustDB,
344     oNoAutoCheckTrustDB,
345     oPreservePermissions,
346     oDefaultPreferenceList,
347     oDefaultKeyserverURL,
348     oPersonalCipherPreferences,
349     oPersonalDigestPreferences,
350     oPersonalCompressPreferences,
351     oAgentProgram,
352     oDirmngrProgram,
353     oDisplay,
354     oTTYname,
355     oTTYtype,
356     oLCctype,
357     oLCmessages,
358     oXauthority,
359     oGroup,
360     oUnGroup,
361     oNoGroups,
362     oStrict,
363     oNoStrict,
364     oMangleDosFilenames,
365     oNoMangleDosFilenames,
366     oEnableProgressFilter,
367     oMultifile,
368     oKeyidFormat,
369     oExitOnStatusWriteError,
370     oLimitCardInsertTries,
371     oReaderPort,
372     octapiDriver,
373     opcscDriver,
374     oDisableCCID,
375     oRequireCrossCert,
376     oNoRequireCrossCert,
377     oAutoKeyLocate,
378     oNoAutoKeyLocate,
379     oAllowMultisigVerification,
380     oEnableLargeRSA,
381     oDisableLargeRSA,
382     oEnableDSA2,
383     oDisableDSA2,
384     oAllowMultipleMessages,
385     oNoAllowMultipleMessages,
386     oAllowWeakDigestAlgos,
387     oFakedSystemTime,
388     oNoAutostart,
389     oPrintPKARecords,
390     oPrintDANERecords,
391     oTOFUDefaultPolicy,
392     oTOFUDBFormat,
393     oWeakDigest,
394     oUnwrap,
395
396     oNoop
397   };
398
399
400 static ARGPARSE_OPTS opts[] = {
401
402   ARGPARSE_group (300, N_("@Commands:\n ")),
403
404   ARGPARSE_c (aSign, "sign", N_("make a signature")),
405   ARGPARSE_c (aClearsign, "clearsign", N_("make a clear text signature")),
406   ARGPARSE_c (aDetachedSign, "detach-sign", N_("make a detached signature")),
407   ARGPARSE_c (aEncr, "encrypt",   N_("encrypt data")),
408   ARGPARSE_c (aEncrFiles, "encrypt-files", "@"),
409   ARGPARSE_c (aSym, "symmetric", N_("encryption only with symmetric cipher")),
410   ARGPARSE_c (aStore, "store",     "@"),
411   ARGPARSE_c (aDecrypt, "decrypt",   N_("decrypt data (default)")),
412   ARGPARSE_c (aDecryptFiles, "decrypt-files", "@"),
413   ARGPARSE_c (aVerify, "verify"   , N_("verify a signature")),
414   ARGPARSE_c (aVerifyFiles, "verify-files" , "@" ),
415   ARGPARSE_c (aListKeys, "list-keys", N_("list keys")),
416   ARGPARSE_c (aListKeys, "list-public-keys", "@" ),
417   ARGPARSE_c (aListSigs, "list-sigs", N_("list keys and signatures")),
418   ARGPARSE_c (aCheckKeys, "check-sigs",N_("list and check key signatures")),
419   ARGPARSE_c (oFingerprint, "fingerprint", N_("list keys and fingerprints")),
420   ARGPARSE_c (aListSecretKeys, "list-secret-keys", N_("list secret keys")),
421   ARGPARSE_c (aKeygen,      "gen-key",
422               N_("generate a new key pair")),
423   ARGPARSE_c (aQuickKeygen, "quick-gen-key" ,
424               N_("quickly generate a new key pair")),
425   ARGPARSE_c (aQuickAddUid,  "quick-adduid",
426               N_("quickly add a new user-id")),
427   ARGPARSE_c (aFullKeygen,  "full-gen-key" ,
428               N_("full featured key pair generation")),
429   ARGPARSE_c (aGenRevoke, "gen-revoke",N_("generate a revocation certificate")),
430   ARGPARSE_c (aDeleteKeys,"delete-keys",
431               N_("remove keys from the public keyring")),
432   ARGPARSE_c (aDeleteSecretKeys, "delete-secret-keys",
433               N_("remove keys from the secret keyring")),
434   ARGPARSE_c (aQuickSignKey,  "quick-sign-key" ,
435               N_("quickly sign a key")),
436   ARGPARSE_c (aQuickLSignKey, "quick-lsign-key",
437               N_("quickly sign a key locally")),
438   ARGPARSE_c (aSignKey,  "sign-key"   ,N_("sign a key")),
439   ARGPARSE_c (aLSignKey, "lsign-key"  ,N_("sign a key locally")),
440   ARGPARSE_c (aEditKey,  "edit-key"   ,N_("sign or edit a key")),
441   ARGPARSE_c (aEditKey,  "key-edit"   ,"@"),
442   ARGPARSE_c (aPasswd,   "passwd",     N_("change a passphrase")),
443   ARGPARSE_c (aDesigRevoke, "desig-revoke","@" ),
444   ARGPARSE_c (aExport, "export"           , N_("export keys") ),
445   ARGPARSE_c (aSendKeys, "send-keys"     , N_("export keys to a key server") ),
446   ARGPARSE_c (aRecvKeys, "recv-keys"     , N_("import keys from a key server") ),
447   ARGPARSE_c (aSearchKeys, "search-keys" ,
448               N_("search for keys on a key server") ),
449   ARGPARSE_c (aRefreshKeys, "refresh-keys",
450               N_("update all keys from a keyserver")),
451   ARGPARSE_c (aLocateKeys, "locate-keys", "@"),
452   ARGPARSE_c (aFetchKeys, "fetch-keys" , "@" ),
453   ARGPARSE_c (aExportSecret, "export-secret-keys" , "@" ),
454   ARGPARSE_c (aExportSecretSub, "export-secret-subkeys" , "@" ),
455   ARGPARSE_c (aImport, "import", N_("import/merge keys")),
456   ARGPARSE_c (aFastImport, "fast-import", "@"),
457 #ifdef ENABLE_CARD_SUPPORT
458   ARGPARSE_c (aCardStatus,  "card-status", N_("print the card status")),
459   ARGPARSE_c (aCardEdit,   "card-edit",  N_("change data on a card")),
460   ARGPARSE_c (aChangePIN,  "change-pin", N_("change a card's PIN")),
461 #endif
462   ARGPARSE_c (aListConfig, "list-config", "@"),
463   ARGPARSE_c (aListGcryptConfig, "list-gcrypt-config", "@"),
464   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@" ),
465   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@" ),
466   ARGPARSE_c (aListPackets, "list-packets","@"),
467
468 #ifndef NO_TRUST_MODELS
469   ARGPARSE_c (aExportOwnerTrust, "export-ownertrust", "@"),
470   ARGPARSE_c (aImportOwnerTrust, "import-ownertrust", "@"),
471   ARGPARSE_c (aUpdateTrustDB,"update-trustdb",
472               N_("update the trust database")),
473   ARGPARSE_c (aCheckTrustDB, "check-trustdb", "@"),
474   ARGPARSE_c (aFixTrustDB, "fix-trustdb", "@"),
475 #endif
476
477   ARGPARSE_c (aDeArmor, "dearmor", "@"),
478   ARGPARSE_c (aDeArmor, "dearmour", "@"),
479   ARGPARSE_c (aEnArmor, "enarmor", "@"),
480   ARGPARSE_c (aEnArmor, "enarmour", "@"),
481   ARGPARSE_c (aPrintMD, "print-md", N_("print message digests")),
482   ARGPARSE_c (aPrimegen, "gen-prime", "@" ),
483   ARGPARSE_c (aGenRandom,"gen-random", "@" ),
484   ARGPARSE_c (aServer,   "server",  N_("run in server mode")),
485   ARGPARSE_c (aTOFUPolicy, "tofu-policy",
486               N_("|VALUE|set the TOFU policy for a key (good, unknown, bad, ask, auto)")),
487
488   ARGPARSE_group (301, N_("@\nOptions:\n ")),
489
490   ARGPARSE_s_n (oArmor, "armor", N_("create ascii armored output")),
491   ARGPARSE_s_n (oArmor, "armour", "@"),
492
493   ARGPARSE_s_s (oRecipient, "recipient", N_("|USER-ID|encrypt for USER-ID")),
494   ARGPARSE_s_s (oHiddenRecipient, "hidden-recipient", "@"),
495   ARGPARSE_s_s (oRecipient, "remote-user", "@"),  /* (old option name) */
496   ARGPARSE_s_s (oDefRecipient, "default-recipient", "@"),
497   ARGPARSE_s_n (oDefRecipientSelf,  "default-recipient-self", "@"),
498   ARGPARSE_s_n (oNoDefRecipient, "no-default-recipient", "@"),
499
500   ARGPARSE_s_s (oTempDir,  "temp-directory", "@"),
501   ARGPARSE_s_s (oExecPath, "exec-path", "@"),
502   ARGPARSE_s_s (oEncryptTo,      "encrypt-to", "@"),
503   ARGPARSE_s_n (oNoEncryptTo, "no-encrypt-to", "@"),
504   ARGPARSE_s_s (oHiddenEncryptTo, "hidden-encrypt-to", "@"),
505   ARGPARSE_s_n (oEncryptToDefaultKey, "encrypt-to-default-key", "@"),
506   ARGPARSE_s_s (oLocalUser, "local-user",
507                 N_("|USER-ID|use USER-ID to sign or decrypt")),
508
509   ARGPARSE_s_s (oTrySecretKey, "try-secret-key", "@"),
510
511   ARGPARSE_s_i (oCompress, NULL,
512                 N_("|N|set compress level to N (0 disables)")),
513   ARGPARSE_s_i (oCompressLevel, "compress-level", "@"),
514   ARGPARSE_s_i (oBZ2CompressLevel, "bzip2-compress-level", "@"),
515   ARGPARSE_s_n (oBZ2DecompressLowmem, "bzip2-decompress-lowmem", "@"),
516
517   ARGPARSE_s_n (oTextmodeShort, NULL, "@"),
518   ARGPARSE_s_n (oTextmode,      "textmode", N_("use canonical text mode")),
519   ARGPARSE_s_n (oNoTextmode, "no-textmode", "@"),
520
521   ARGPARSE_s_n (oExpert,      "expert", "@"),
522   ARGPARSE_s_n (oNoExpert, "no-expert", "@"),
523
524   ARGPARSE_s_s (oDefSigExpire, "default-sig-expire", "@"),
525   ARGPARSE_s_n (oAskSigExpire,      "ask-sig-expire", "@"),
526   ARGPARSE_s_n (oNoAskSigExpire, "no-ask-sig-expire", "@"),
527   ARGPARSE_s_s (oDefCertExpire, "default-cert-expire", "@"),
528   ARGPARSE_s_n (oAskCertExpire,      "ask-cert-expire", "@"),
529   ARGPARSE_s_n (oNoAskCertExpire, "no-ask-cert-expire", "@"),
530   ARGPARSE_s_i (oDefCertLevel, "default-cert-level", "@"),
531   ARGPARSE_s_i (oMinCertLevel, "min-cert-level", "@"),
532   ARGPARSE_s_n (oAskCertLevel,      "ask-cert-level", "@"),
533   ARGPARSE_s_n (oNoAskCertLevel, "no-ask-cert-level", "@"),
534
535   ARGPARSE_s_s (oOutput, "output", N_("|FILE|write output to FILE")),
536   ARGPARSE_p_u (oMaxOutput, "max-output", "@"),
537
538   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
539   ARGPARSE_s_n (oQuiet,   "quiet",   "@"),
540   ARGPARSE_s_n (oNoTTY,   "no-tty",  "@"),
541
542   ARGPARSE_s_n (oForceMDC, "force-mdc", "@"),
543   ARGPARSE_s_n (oNoForceMDC, "no-force-mdc", "@"),
544   ARGPARSE_s_n (oDisableMDC, "disable-mdc", "@"),
545   ARGPARSE_s_n (oNoDisableMDC, "no-disable-mdc", "@"),
546
547   ARGPARSE_s_n (oDryRun, "dry-run", N_("do not make any changes")),
548   ARGPARSE_s_n (oInteractive, "interactive", N_("prompt before overwriting")),
549
550   ARGPARSE_s_n (oBatch, "batch", "@"),
551   ARGPARSE_s_n (oAnswerYes, "yes", "@"),
552   ARGPARSE_s_n (oAnswerNo, "no", "@"),
553   ARGPARSE_s_s (oKeyring, "keyring", "@"),
554   ARGPARSE_s_s (oPrimaryKeyring, "primary-keyring", "@"),
555   ARGPARSE_s_s (oSecretKeyring, "secret-keyring", "@"),
556   ARGPARSE_s_n (oShowKeyring, "show-keyring", "@"),
557   ARGPARSE_s_s (oDefaultKey, "default-key", "@"),
558
559   ARGPARSE_s_s (oKeyServer, "keyserver", "@"),
560   ARGPARSE_s_s (oKeyServerOptions, "keyserver-options", "@"),
561   ARGPARSE_s_s (oImportOptions, "import-options", "@"),
562   ARGPARSE_s_s (oExportOptions, "export-options", "@"),
563   ARGPARSE_s_s (oListOptions,   "list-options", "@"),
564   ARGPARSE_s_s (oVerifyOptions, "verify-options", "@"),
565
566   ARGPARSE_s_s (oDisplayCharset, "display-charset", "@"),
567   ARGPARSE_s_s (oDisplayCharset, "charset", "@"),
568   ARGPARSE_s_s (oOptions, "options", "@"),
569
570   ARGPARSE_s_s (oDebug, "debug", "@"),
571   ARGPARSE_s_s (oDebugLevel, "debug-level", "@"),
572   ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
573   ARGPARSE_s_n (oDebugIOLBF, "debug-iolbf", "@"),
574   ARGPARSE_s_i (oStatusFD, "status-fd", "@"),
575   ARGPARSE_s_s (oStatusFile, "status-file", "@"),
576   ARGPARSE_s_i (oAttributeFD, "attribute-fd", "@"),
577   ARGPARSE_s_s (oAttributeFile, "attribute-file", "@"),
578
579   ARGPARSE_s_i (oCompletesNeeded, "completes-needed", "@"),
580   ARGPARSE_s_i (oMarginalsNeeded, "marginals-needed", "@"),
581   ARGPARSE_s_i (oMaxCertDepth,  "max-cert-depth", "@" ),
582   ARGPARSE_s_s (oTrustedKey, "trusted-key", "@"),
583
584   ARGPARSE_s_s (oLoadExtension, "load-extension", "@"),  /* Dummy.  */
585
586   ARGPARSE_s_n (oGnuPG, "gnupg",   "@"),
587   ARGPARSE_s_n (oGnuPG, "no-pgp2", "@"),
588   ARGPARSE_s_n (oGnuPG, "no-pgp6", "@"),
589   ARGPARSE_s_n (oGnuPG, "no-pgp7", "@"),
590   ARGPARSE_s_n (oGnuPG, "no-pgp8", "@"),
591   ARGPARSE_s_n (oRFC2440, "rfc2440", "@"),
592   ARGPARSE_s_n (oRFC4880, "rfc4880", "@"),
593   ARGPARSE_s_n (oOpenPGP, "openpgp", N_("use strict OpenPGP behavior")),
594   ARGPARSE_s_n (oPGP6, "pgp6", "@"),
595   ARGPARSE_s_n (oPGP7, "pgp7", "@"),
596   ARGPARSE_s_n (oPGP8, "pgp8", "@"),
597
598   ARGPARSE_s_n (oRFC2440Text,      "rfc2440-text", "@"),
599   ARGPARSE_s_n (oNoRFC2440Text, "no-rfc2440-text", "@"),
600   ARGPARSE_s_i (oS2KMode, "s2k-mode", "@"),
601   ARGPARSE_s_s (oS2KDigest, "s2k-digest-algo", "@"),
602   ARGPARSE_s_s (oS2KCipher, "s2k-cipher-algo", "@"),
603   ARGPARSE_s_i (oS2KCount, "s2k-count", "@"),
604   ARGPARSE_s_s (oCipherAlgo, "cipher-algo", "@"),
605   ARGPARSE_s_s (oDigestAlgo, "digest-algo", "@"),
606   ARGPARSE_s_s (oCertDigestAlgo, "cert-digest-algo", "@"),
607   ARGPARSE_s_s (oCompressAlgo,"compress-algo", "@"),
608   ARGPARSE_s_s (oCompressAlgo, "compression-algo", "@"), /* Alias */
609   ARGPARSE_s_n (oThrowKeyids, "throw-keyids", "@"),
610   ARGPARSE_s_n (oNoThrowKeyids, "no-throw-keyids", "@"),
611   ARGPARSE_s_n (oShowPhotos,   "show-photos", "@"),
612   ARGPARSE_s_n (oNoShowPhotos, "no-show-photos", "@"),
613   ARGPARSE_s_s (oPhotoViewer,  "photo-viewer", "@"),
614   ARGPARSE_s_s (oSetNotation,  "set-notation", "@"),
615   ARGPARSE_s_s (oSigNotation,  "sig-notation", "@"),
616   ARGPARSE_s_s (oCertNotation, "cert-notation", "@"),
617
618   ARGPARSE_group (302, N_(
619   "@\n(See the man page for a complete listing of all commands and options)\n"
620                       )),
621
622   ARGPARSE_group (303, N_("@\nExamples:\n\n"
623     " -se -r Bob [file]          sign and encrypt for user Bob\n"
624     " --clearsign [file]         make a clear text signature\n"
625     " --detach-sign [file]       make a detached signature\n"
626     " --list-keys [names]        show keys\n"
627     " --fingerprint [names]      show fingerprints\n")),
628
629   /* More hidden commands and options. */
630   ARGPARSE_c (aPrintMDs, "print-mds", "@"), /* old */
631 #ifndef NO_TRUST_MODELS
632   ARGPARSE_c (aListTrustDB, "list-trustdb", "@"),
633 #endif
634
635   /* Not yet used:
636      ARGPARSE_c (aListTrustPath, "list-trust-path", "@"), */
637   ARGPARSE_c (aDeleteSecretAndPublicKeys,
638               "delete-secret-and-public-keys", "@"),
639   ARGPARSE_c (aRebuildKeydbCaches, "rebuild-keydb-caches", "@"),
640
641   ARGPARSE_s_s (oPassphrase,      "passphrase", "@"),
642   ARGPARSE_s_i (oPassphraseFD,    "passphrase-fd", "@"),
643   ARGPARSE_s_s (oPassphraseFile,  "passphrase-file", "@"),
644   ARGPARSE_s_i (oPassphraseRepeat,"passphrase-repeat", "@"),
645   ARGPARSE_s_s (oPinentryMode,    "pinentry-mode", "@"),
646   ARGPARSE_s_i (oCommandFD, "command-fd", "@"),
647   ARGPARSE_s_s (oCommandFile, "command-file", "@"),
648   ARGPARSE_s_n (oQuickRandom, "debug-quick-random", "@"),
649   ARGPARSE_s_n (oNoVerbose, "no-verbose", "@"),
650
651 #ifndef NO_TRUST_MODELS
652   ARGPARSE_s_s (oTrustDBName, "trustdb-name", "@"),
653   ARGPARSE_s_n (oAutoCheckTrustDB, "auto-check-trustdb", "@"),
654   ARGPARSE_s_n (oNoAutoCheckTrustDB, "no-auto-check-trustdb", "@"),
655   ARGPARSE_s_s (oForceOwnertrust, "force-ownertrust", "@"),
656 #endif
657
658   ARGPARSE_s_n (oNoSecmemWarn, "no-secmem-warning", "@"),
659   ARGPARSE_s_n (oRequireSecmem, "require-secmem", "@"),
660   ARGPARSE_s_n (oNoRequireSecmem, "no-require-secmem", "@"),
661   ARGPARSE_s_n (oNoPermissionWarn, "no-permission-warning", "@"),
662   ARGPARSE_s_n (oNoMDCWarn, "no-mdc-warning", "@"),
663   ARGPARSE_s_n (oNoArmor, "no-armor", "@"),
664   ARGPARSE_s_n (oNoArmor, "no-armour", "@"),
665   ARGPARSE_s_n (oNoDefKeyring, "no-default-keyring", "@"),
666   ARGPARSE_s_n (oNoGreeting, "no-greeting", "@"),
667   ARGPARSE_s_n (oNoOptions, "no-options", "@"),
668   ARGPARSE_s_s (oHomedir, "homedir", "@"),
669   ARGPARSE_s_n (oNoBatch, "no-batch", "@"),
670   ARGPARSE_s_n (oWithColons, "with-colons", "@"),
671   ARGPARSE_s_n (oWithKeyData,"with-key-data", "@"),
672   ARGPARSE_s_n (oWithSigList,"with-sig-list", "@"),
673   ARGPARSE_s_n (oWithSigCheck,"with-sig-check", "@"),
674   ARGPARSE_s_n (aListKeys, "list-key", "@"),   /* alias */
675   ARGPARSE_s_n (aListSigs, "list-sig", "@"),   /* alias */
676   ARGPARSE_s_n (aCheckKeys, "check-sig", "@"), /* alias */
677   ARGPARSE_s_n (oSkipVerify, "skip-verify", "@"),
678   ARGPARSE_s_n (oSkipHiddenRecipients, "skip-hidden-recipients", "@"),
679   ARGPARSE_s_n (oNoSkipHiddenRecipients, "no-skip-hidden-recipients", "@"),
680   ARGPARSE_s_i (oDefCertLevel, "default-cert-check-level", "@"), /* old */
681   ARGPARSE_s_n (oAlwaysTrust, "always-trust", "@"),
682   ARGPARSE_s_s (oTrustModel, "trust-model", "@"),
683   ARGPARSE_s_s (oTOFUDefaultPolicy, "tofu-default-policy", "@"),
684   ARGPARSE_s_s (oTOFUDBFormat, "tofu-db-format", "@"),
685   ARGPARSE_s_s (oSetFilename, "set-filename", "@"),
686   ARGPARSE_s_n (oForYourEyesOnly, "for-your-eyes-only", "@"),
687   ARGPARSE_s_n (oNoForYourEyesOnly, "no-for-your-eyes-only", "@"),
688   ARGPARSE_s_s (oSetPolicyURL,  "set-policy-url", "@"),
689   ARGPARSE_s_s (oSigPolicyURL,  "sig-policy-url", "@"),
690   ARGPARSE_s_s (oCertPolicyURL, "cert-policy-url", "@"),
691   ARGPARSE_s_n (oShowPolicyURL,      "show-policy-url", "@"),
692   ARGPARSE_s_n (oNoShowPolicyURL, "no-show-policy-url", "@"),
693   ARGPARSE_s_s (oSigKeyserverURL, "sig-keyserver-url", "@"),
694   ARGPARSE_s_n (oShowNotation,      "show-notation", "@"),
695   ARGPARSE_s_n (oNoShowNotation, "no-show-notation", "@"),
696   ARGPARSE_s_s (oComment, "comment", "@"),
697   ARGPARSE_s_n (oDefaultComment, "default-comment", "@"),
698   ARGPARSE_s_n (oNoComments, "no-comments", "@"),
699   ARGPARSE_s_n (oEmitVersion,      "emit-version", "@"),
700   ARGPARSE_s_n (oNoEmitVersion, "no-emit-version", "@"),
701   ARGPARSE_s_n (oNoEmitVersion, "no-version", "@"), /* alias */
702   ARGPARSE_s_n (oNotDashEscaped, "not-dash-escaped", "@"),
703   ARGPARSE_s_n (oEscapeFrom,      "escape-from-lines", "@"),
704   ARGPARSE_s_n (oNoEscapeFrom, "no-escape-from-lines", "@"),
705   ARGPARSE_s_n (oLockOnce,     "lock-once", "@"),
706   ARGPARSE_s_n (oLockMultiple, "lock-multiple", "@"),
707   ARGPARSE_s_n (oLockNever,    "lock-never", "@"),
708   ARGPARSE_s_i (oLoggerFD,   "logger-fd", "@"),
709   ARGPARSE_s_s (oLoggerFile, "log-file", "@"),
710   ARGPARSE_s_s (oLoggerFile, "logger-file", "@"),  /* 1.4 compatibility.  */
711   ARGPARSE_s_n (oUseEmbeddedFilename,      "use-embedded-filename", "@"),
712   ARGPARSE_s_n (oNoUseEmbeddedFilename, "no-use-embedded-filename", "@"),
713   ARGPARSE_s_n (oUtf8Strings,      "utf8-strings", "@"),
714   ARGPARSE_s_n (oNoUtf8Strings, "no-utf8-strings", "@"),
715   ARGPARSE_s_n (oWithFingerprint, "with-fingerprint", "@"),
716   ARGPARSE_s_n (oWithICAOSpelling, "with-icao-spelling", "@"),
717   ARGPARSE_s_n (oWithKeygrip,     "with-keygrip", "@"),
718   ARGPARSE_s_n (oWithSecret,      "with-secret", "@"),
719   ARGPARSE_s_s (oDisableCipherAlgo,  "disable-cipher-algo", "@"),
720   ARGPARSE_s_s (oDisablePubkeyAlgo,  "disable-pubkey-algo", "@"),
721   ARGPARSE_s_n (oAllowNonSelfsignedUID,      "allow-non-selfsigned-uid", "@"),
722   ARGPARSE_s_n (oNoAllowNonSelfsignedUID, "no-allow-non-selfsigned-uid", "@"),
723   ARGPARSE_s_n (oAllowFreeformUID,      "allow-freeform-uid", "@"),
724   ARGPARSE_s_n (oNoAllowFreeformUID, "no-allow-freeform-uid", "@"),
725   ARGPARSE_s_n (oNoLiteral, "no-literal", "@"),
726   ARGPARSE_p_u (oSetFilesize, "set-filesize", "@"),
727   ARGPARSE_s_n (oFastListMode, "fast-list-mode", "@"),
728   ARGPARSE_s_n (oFixedListMode, "fixed-list-mode", "@"),
729   ARGPARSE_s_n (oLegacyListMode, "legacy-list-mode", "@"),
730   ARGPARSE_s_n (oListOnly, "list-only", "@"),
731   ARGPARSE_s_n (oPrintPKARecords, "print-pka-records", "@"),
732   ARGPARSE_s_n (oPrintDANERecords, "print-dane-records", "@"),
733   ARGPARSE_s_n (oIgnoreTimeConflict, "ignore-time-conflict", "@"),
734   ARGPARSE_s_n (oIgnoreValidFrom,    "ignore-valid-from", "@"),
735   ARGPARSE_s_n (oIgnoreCrcError, "ignore-crc-error", "@"),
736   ARGPARSE_s_n (oIgnoreMDCError, "ignore-mdc-error", "@"),
737   ARGPARSE_s_n (oShowSessionKey, "show-session-key", "@"),
738   ARGPARSE_s_s (oOverrideSessionKey, "override-session-key", "@"),
739   ARGPARSE_s_n (oNoRandomSeedFile,  "no-random-seed-file", "@"),
740   ARGPARSE_s_n (oAutoKeyRetrieve, "auto-key-retrieve", "@"),
741   ARGPARSE_s_n (oNoAutoKeyRetrieve, "no-auto-key-retrieve", "@"),
742   ARGPARSE_s_n (oNoSigCache,         "no-sig-cache", "@"),
743   ARGPARSE_s_n (oMergeOnly,       "merge-only", "@" ),
744   ARGPARSE_s_n (oAllowSecretKeyImport, "allow-secret-key-import", "@"),
745   ARGPARSE_s_n (oTryAllSecrets,  "try-all-secrets", "@"),
746   ARGPARSE_s_n (oEnableSpecialFilenames, "enable-special-filenames", "@"),
747   ARGPARSE_s_n (oNoExpensiveTrustChecks, "no-expensive-trust-checks", "@"),
748   ARGPARSE_s_n (oPreservePermissions, "preserve-permissions", "@"),
749   ARGPARSE_s_s (oDefaultPreferenceList,  "default-preference-list", "@"),
750   ARGPARSE_s_s (oDefaultKeyserverURL,  "default-keyserver-url", "@"),
751   ARGPARSE_s_s (oPersonalCipherPreferences, "personal-cipher-preferences","@"),
752   ARGPARSE_s_s (oPersonalDigestPreferences, "personal-digest-preferences","@"),
753   ARGPARSE_s_s (oPersonalCompressPreferences,
754                                          "personal-compress-preferences", "@"),
755   ARGPARSE_s_s (oFakedSystemTime, "faked-system-time", "@"),
756   ARGPARSE_s_s (oWeakDigest, "weak-digest","@"),
757   ARGPARSE_s_n (oUnwrap, "unwrap", "@"),
758
759   /* Aliases.  I constantly mistype these, and assume other people do
760      as well. */
761   ARGPARSE_s_s (oPersonalCipherPreferences, "personal-cipher-prefs", "@"),
762   ARGPARSE_s_s (oPersonalDigestPreferences, "personal-digest-prefs", "@"),
763   ARGPARSE_s_s (oPersonalCompressPreferences, "personal-compress-prefs", "@"),
764
765   ARGPARSE_s_s (oAgentProgram, "agent-program", "@"),
766   ARGPARSE_s_s (oDirmngrProgram, "dirmngr-program", "@"),
767   ARGPARSE_s_s (oDisplay,    "display",    "@"),
768   ARGPARSE_s_s (oTTYname,    "ttyname",    "@"),
769   ARGPARSE_s_s (oTTYtype,    "ttytype",    "@"),
770   ARGPARSE_s_s (oLCctype,    "lc-ctype",   "@"),
771   ARGPARSE_s_s (oLCmessages, "lc-messages","@"),
772   ARGPARSE_s_s (oXauthority, "xauthority", "@"),
773   ARGPARSE_s_s (oGroup,      "group",      "@"),
774   ARGPARSE_s_s (oUnGroup,    "ungroup",    "@"),
775   ARGPARSE_s_n (oNoGroups,   "no-groups",  "@"),
776   ARGPARSE_s_n (oStrict,     "strict",     "@"),
777   ARGPARSE_s_n (oNoStrict,   "no-strict",  "@"),
778   ARGPARSE_s_n (oMangleDosFilenames,      "mangle-dos-filenames", "@"),
779   ARGPARSE_s_n (oNoMangleDosFilenames, "no-mangle-dos-filenames", "@"),
780   ARGPARSE_s_n (oEnableProgressFilter, "enable-progress-filter", "@"),
781   ARGPARSE_s_n (oMultifile, "multifile", "@"),
782   ARGPARSE_s_s (oKeyidFormat, "keyid-format", "@"),
783   ARGPARSE_s_n (oExitOnStatusWriteError, "exit-on-status-write-error", "@"),
784   ARGPARSE_s_i (oLimitCardInsertTries, "limit-card-insert-tries", "@"),
785
786   ARGPARSE_s_n (oAllowMultisigVerification,
787                 "allow-multisig-verification", "@"),
788   ARGPARSE_s_n (oEnableLargeRSA, "enable-large-rsa", "@"),
789   ARGPARSE_s_n (oDisableLargeRSA, "disable-large-rsa", "@"),
790   ARGPARSE_s_n (oEnableDSA2, "enable-dsa2", "@"),
791   ARGPARSE_s_n (oDisableDSA2, "disable-dsa2", "@"),
792   ARGPARSE_s_n (oAllowMultipleMessages,      "allow-multiple-messages", "@"),
793   ARGPARSE_s_n (oNoAllowMultipleMessages, "no-allow-multiple-messages", "@"),
794   ARGPARSE_s_n (oAllowWeakDigestAlgos, "allow-weak-digest-algos", "@"),
795
796   /* These two are aliases to help users of the PGP command line
797      product use gpg with minimal pain.  Many commands are common
798      already as they seem to have borrowed commands from us.  Now I'm
799      returning the favor. */
800   ARGPARSE_s_s (oLocalUser, "sign-with", "@"),
801   ARGPARSE_s_s (oRecipient, "user", "@"),
802
803   ARGPARSE_s_n (oRequireCrossCert, "require-backsigs", "@"),
804   ARGPARSE_s_n (oRequireCrossCert, "require-cross-certification", "@"),
805   ARGPARSE_s_n (oNoRequireCrossCert, "no-require-backsigs", "@"),
806   ARGPARSE_s_n (oNoRequireCrossCert, "no-require-cross-certification", "@"),
807
808   /* New options.  Fixme: Should go more to the top.  */
809   ARGPARSE_s_s (oAutoKeyLocate, "auto-key-locate", "@"),
810   ARGPARSE_s_n (oNoAutoKeyLocate, "no-auto-key-locate", "@"),
811   ARGPARSE_s_n (oNoAutostart, "no-autostart", "@"),
812
813   /* Dummy options with warnings.  */
814   ARGPARSE_s_n (oUseAgent,      "use-agent", "@"),
815   ARGPARSE_s_n (oNoUseAgent, "no-use-agent", "@"),
816   ARGPARSE_s_s (oGpgAgentInfo, "gpg-agent-info", "@"),
817   ARGPARSE_s_s (oReaderPort, "reader-port", "@"),
818   ARGPARSE_s_s (octapiDriver, "ctapi-driver", "@"),
819   ARGPARSE_s_s (opcscDriver, "pcsc-driver", "@"),
820   ARGPARSE_s_n (oDisableCCID, "disable-ccid", "@"),
821   ARGPARSE_s_n (oHonorHttpProxy, "honor-http-proxy", "@"),
822
823   /* Dummy options.  */
824   ARGPARSE_s_n (oNoop, "sk-comments", "@"),
825   ARGPARSE_s_n (oNoop, "no-sk-comments", "@"),
826   ARGPARSE_s_n (oNoop, "compress-keys", "@"),
827   ARGPARSE_s_n (oNoop, "compress-sigs", "@"),
828   ARGPARSE_s_n (oNoop, "force-v3-sigs", "@"),
829   ARGPARSE_s_n (oNoop, "no-force-v3-sigs", "@"),
830   ARGPARSE_s_n (oNoop, "force-v4-certs", "@"),
831   ARGPARSE_s_n (oNoop, "no-force-v4-certs", "@"),
832
833   ARGPARSE_end ()
834 };
835
836
837 /* The list of supported debug flags.  */
838 static struct debug_flags_s debug_flags [] =
839   {
840     { DBG_PACKET_VALUE , "packet"  },
841     { DBG_MPI_VALUE    , "mpi"     },
842     { DBG_CRYPTO_VALUE , "crypto"  },
843     { DBG_FILTER_VALUE , "filter"  },
844     { DBG_IOBUF_VALUE  , "iobuf"   },
845     { DBG_MEMORY_VALUE , "memory"  },
846     { DBG_CACHE_VALUE  , "cache"   },
847     { DBG_MEMSTAT_VALUE, "memstat" },
848     { DBG_TRUST_VALUE  , "trust"   },
849     { DBG_HASHING_VALUE, "hashing" },
850     { DBG_CARD_IO_VALUE, "cardio"  },
851     { DBG_IPC_VALUE    , "ipc"     },
852     { DBG_CLOCK_VALUE  , "clock"   },
853     { DBG_LOOKUP_VALUE , "lookup"  },
854     { DBG_EXTPROG_VALUE, "extprog" },
855     { 0, NULL }
856   };
857
858
859 #ifdef ENABLE_SELINUX_HACKS
860 #define ALWAYS_ADD_KEYRINGS 1
861 #else
862 #define ALWAYS_ADD_KEYRINGS 0
863 #endif
864
865
866 int g10_errors_seen = 0;
867
868 static int utf8_strings = 0;
869 static int maybe_setuid = 1;
870
871 static char *build_list( const char *text, char letter,
872                          const char *(*mapf)(int), int (*chkf)(int) );
873 static void set_cmd( enum cmd_and_opt_values *ret_cmd,
874                         enum cmd_and_opt_values new_cmd );
875 static void print_mds( const char *fname, int algo );
876 static void add_notation_data( const char *string, int which );
877 static void add_policy_url( const char *string, int which );
878 static void add_keyserver_url( const char *string, int which );
879 static void emergency_cleanup (void);
880
881
882 static char *
883 make_libversion (const char *libname, const char *(*getfnc)(const char*))
884 {
885   const char *s;
886   char *result;
887
888   if (maybe_setuid)
889     {
890       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
891       maybe_setuid = 0;
892     }
893   s = getfnc (NULL);
894   result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
895   strcpy (stpcpy (stpcpy (result, libname), " "), s);
896   return result;
897 }
898
899
900 static int
901 build_list_pk_test_algo (int algo)
902 {
903   /* Show only one "RSA" string.  If RSA_E or RSA_S is available RSA
904      is also available.  */
905   if (algo == PUBKEY_ALGO_RSA_E
906       || algo == PUBKEY_ALGO_RSA_S)
907     return GPG_ERR_DIGEST_ALGO;
908
909   return openpgp_pk_test_algo (algo);
910 }
911
912 static const char *
913 build_list_pk_algo_name (int algo)
914 {
915   return openpgp_pk_algo_name (algo);
916 }
917
918 static int
919 build_list_cipher_test_algo (int algo)
920 {
921   return openpgp_cipher_test_algo (algo);
922 }
923
924 static const char *
925 build_list_cipher_algo_name (int algo)
926 {
927   return openpgp_cipher_algo_name (algo);
928 }
929
930 static int
931 build_list_md_test_algo (int algo)
932 {
933   /* By default we do not accept MD5 based signatures.  To avoid
934      confusion we do not announce support for it either.  */
935   if (algo == DIGEST_ALGO_MD5)
936     return GPG_ERR_DIGEST_ALGO;
937
938   return openpgp_md_test_algo (algo);
939 }
940
941 static const char *
942 build_list_md_algo_name (int algo)
943 {
944   return openpgp_md_algo_name (algo);
945 }
946
947
948 static const char *
949 my_strusage( int level )
950 {
951   static char *digests, *pubkeys, *ciphers, *zips, *ver_gcry;
952   const char *p;
953
954     switch( level ) {
955       case 11: p = "@GPG@ (@GNUPG@)";
956         break;
957       case 13: p = VERSION; break;
958       case 17: p = PRINTABLE_OS_NAME; break;
959       case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
960
961     case 20:
962       if (!ver_gcry)
963         ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
964       p = ver_gcry;
965       break;
966
967 #ifdef IS_DEVELOPMENT_VERSION
968       case 25:
969         p="NOTE: THIS IS A DEVELOPMENT VERSION!";
970         break;
971       case 26:
972         p="It is only intended for test purposes and should NOT be";
973         break;
974       case 27:
975         p="used in a production environment or with production keys!";
976         break;
977 #endif
978
979       case 1:
980       case 40:  p =
981             _("Usage: @GPG@ [options] [files] (-h for help)");
982         break;
983       case 41:  p =
984             _("Syntax: @GPG@ [options] [files]\n"
985               "Sign, check, encrypt or decrypt\n"
986               "Default operation depends on the input data\n");
987         break;
988
989       case 31: p = "\nHome: "; break;
990 #ifndef __riscos__
991       case 32: p = opt.homedir; break;
992 #else /* __riscos__ */
993       case 32: p = make_filename(opt.homedir, NULL); break;
994 #endif /* __riscos__ */
995       case 33: p = _("\nSupported algorithms:\n"); break;
996       case 34:
997         if (!pubkeys)
998             pubkeys = build_list (_("Pubkey: "), 1,
999                                   build_list_pk_algo_name,
1000                                   build_list_pk_test_algo );
1001         p = pubkeys;
1002         break;
1003       case 35:
1004         if( !ciphers )
1005             ciphers = build_list(_("Cipher: "), 'S',
1006                                  build_list_cipher_algo_name,
1007                                  build_list_cipher_test_algo );
1008         p = ciphers;
1009         break;
1010       case 36:
1011         if( !digests )
1012             digests = build_list(_("Hash: "), 'H',
1013                                  build_list_md_algo_name,
1014                                  build_list_md_test_algo );
1015         p = digests;
1016         break;
1017       case 37:
1018         if( !zips )
1019             zips = build_list(_("Compression: "),'Z',
1020                               compress_algo_to_string,
1021                               check_compress_algo);
1022         p = zips;
1023         break;
1024
1025       default:  p = NULL;
1026     }
1027     return p;
1028 }
1029
1030
1031 static char *
1032 build_list (const char *text, char letter,
1033             const char * (*mapf)(int), int (*chkf)(int))
1034 {
1035   membuf_t mb;
1036   int indent;
1037   int i, j, len;
1038   const char *s;
1039   char *string;
1040
1041   if (maybe_setuid)
1042     gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
1043
1044   indent = utf8_charcount (text);
1045   len = 0;
1046   init_membuf (&mb, 512);
1047
1048   for (i=0; i <= 110; i++ )
1049     {
1050       if (!chkf (i) && (s = mapf (i)))
1051         {
1052           if (mb.len - len > 60)
1053             {
1054               put_membuf_str (&mb, ",\n");
1055               len = mb.len;
1056               for (j=0; j < indent; j++)
1057                 put_membuf_str (&mb, " ");
1058             }
1059           else if (mb.len)
1060             put_membuf_str (&mb, ", ");
1061           else
1062             put_membuf_str (&mb, text);
1063
1064           put_membuf_str (&mb, s);
1065           if (opt.verbose && letter)
1066             {
1067               char num[20];
1068               if (letter == 1)
1069                 snprintf (num, sizeof num, " (%d)", i);
1070               else
1071                 snprintf (num, sizeof num, " (%c%d)", letter, i);
1072               put_membuf_str (&mb, num);
1073             }
1074         }
1075     }
1076   if (mb.len)
1077     put_membuf_str (&mb, "\n");
1078   put_membuf (&mb, "", 1);
1079
1080   string = get_membuf (&mb, NULL);
1081   return xrealloc (string, strlen (string)+1);
1082 }
1083
1084
1085 static void
1086 wrong_args( const char *text)
1087 {
1088   es_fprintf (es_stderr, _("usage: %s [options] %s\n"), GPG_NAME, text);
1089   g10_exit(2);
1090 }
1091
1092
1093 static char *
1094 make_username( const char *string )
1095 {
1096     char *p;
1097     if( utf8_strings )
1098         p = xstrdup(string);
1099     else
1100         p = native_to_utf8( string );
1101     return p;
1102 }
1103
1104
1105 static void
1106 set_opt_session_env (const char *name, const char *value)
1107 {
1108   gpg_error_t err;
1109
1110   err = session_env_setenv (opt.session_env, name, value);
1111   if (err)
1112     log_fatal ("error setting session environment: %s\n",
1113                gpg_strerror (err));
1114 }
1115
1116
1117 /* Setup the debugging.  With a LEVEL of NULL only the active debug
1118    flags are propagated to the subsystems.  With LEVEL set, a specific
1119    set of debug flags is set; thus overriding all flags already
1120    set. */
1121 static void
1122 set_debug (const char *level)
1123 {
1124   int numok = (level && digitp (level));
1125   int numlvl = numok? atoi (level) : 0;
1126
1127   if (!level)
1128     ;
1129   else if (!strcmp (level, "none") || (numok && numlvl < 1))
1130     opt.debug = 0;
1131   else if (!strcmp (level, "basic") || (numok && numlvl <= 2))
1132     opt.debug = DBG_MEMSTAT_VALUE;
1133   else if (!strcmp (level, "advanced") || (numok && numlvl <= 5))
1134     opt.debug = DBG_MEMSTAT_VALUE|DBG_TRUST_VALUE|DBG_EXTPROG_VALUE;
1135   else if (!strcmp (level, "expert")  || (numok && numlvl <= 8))
1136     opt.debug = (DBG_MEMSTAT_VALUE|DBG_TRUST_VALUE|DBG_EXTPROG_VALUE
1137                  |DBG_CACHE_VALUE|DBG_LOOKUP|DBG_FILTER_VALUE|DBG_PACKET_VALUE);
1138   else if (!strcmp (level, "guru") || numok)
1139     {
1140       opt.debug = ~0;
1141       /* Unless the "guru" string has been used we don't want to allow
1142          hashing debugging.  The rationale is that people tend to
1143          select the highest debug value and would then clutter their
1144          disk with debug files which may reveal confidential data.  */
1145       if (numok)
1146         opt.debug &= ~(DBG_HASHING_VALUE);
1147     }
1148   else
1149     {
1150       log_error (_("invalid debug-level '%s' given\n"), level);
1151       g10_exit (2);
1152     }
1153
1154   if (opt.debug & DBG_MEMORY_VALUE )
1155     memory_debug_mode = 1;
1156   if (opt.debug & DBG_MEMSTAT_VALUE )
1157     memory_stat_debug_mode = 1;
1158   if (opt.debug & DBG_MPI_VALUE)
1159     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
1160   if (opt.debug & DBG_CRYPTO_VALUE )
1161     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
1162   if (opt.debug & DBG_IOBUF_VALUE )
1163     iobuf_debug_mode = 1;
1164   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1165
1166   if (opt.debug)
1167     parse_debug_flag (NULL, &opt.debug, debug_flags);
1168 }
1169
1170
1171
1172 /* We need the home directory also in some other directories, so make
1173    sure that both variables are always in sync. */
1174 static void
1175 set_homedir (const char *dir)
1176 {
1177   if (!dir)
1178     dir = "";
1179   opt.homedir = dir;
1180 }
1181
1182
1183 /* We set the screen dimensions for UI purposes.  Do not allow screens
1184    smaller than 80x24 for the sake of simplicity. */
1185 static void
1186 set_screen_dimensions(void)
1187 {
1188 #ifndef HAVE_W32_SYSTEM
1189   char *str;
1190
1191   str=getenv("COLUMNS");
1192   if(str)
1193     opt.screen_columns=atoi(str);
1194
1195   str=getenv("LINES");
1196   if(str)
1197     opt.screen_lines=atoi(str);
1198 #endif
1199
1200   if(opt.screen_columns<80 || opt.screen_columns>255)
1201     opt.screen_columns=80;
1202
1203   if(opt.screen_lines<24 || opt.screen_lines>255)
1204     opt.screen_lines=24;
1205 }
1206
1207
1208 /* Helper to open a file FNAME either for reading or writing to be
1209    used with --status-file etc functions.  Not generally useful but it
1210    avoids the riscos specific functions and well some Windows people
1211    might like it too.  Prints an error message and returns -1 on
1212    error.  On success the file descriptor is returned.  */
1213 static int
1214 open_info_file (const char *fname, int for_write, int binary)
1215 {
1216 #ifdef __riscos__
1217   return riscos_fdopenfile (fname, for_write);
1218 #elif defined (ENABLE_SELINUX_HACKS)
1219   /* We can't allow these even when testing for a secured filename
1220      because files to be secured might not yet been secured.  This is
1221      similar to the option file but in that case it is unlikely that
1222      sensitive information may be retrieved by means of error
1223      messages.  */
1224   (void)fname;
1225   (void)for_write;
1226   (void)binary;
1227   return -1;
1228 #else
1229   int fd;
1230
1231   if (binary)
1232     binary = MY_O_BINARY;
1233
1234 /*   if (is_secured_filename (fname)) */
1235 /*     { */
1236 /*       fd = -1; */
1237 /*       gpg_err_set_errno (EPERM); */
1238 /*     } */
1239 /*   else */
1240 /*     { */
1241       do
1242         {
1243           if (for_write)
1244             fd = open (fname, O_CREAT | O_TRUNC | O_WRONLY | binary,
1245                         S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
1246           else
1247             fd = open (fname, O_RDONLY | binary);
1248         }
1249       while (fd == -1 && errno == EINTR);
1250 /*     } */
1251   if ( fd == -1)
1252     log_error ( for_write? _("can't create '%s': %s\n")
1253                          : _("can't open '%s': %s\n"), fname, strerror(errno));
1254
1255   return fd;
1256 #endif
1257 }
1258
1259 static void
1260 set_cmd( enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd )
1261 {
1262     enum cmd_and_opt_values cmd = *ret_cmd;
1263
1264     if( !cmd || cmd == new_cmd )
1265         cmd = new_cmd;
1266     else if( cmd == aSign && new_cmd == aEncr )
1267         cmd = aSignEncr;
1268     else if( cmd == aEncr && new_cmd == aSign )
1269         cmd = aSignEncr;
1270     else if( cmd == aSign && new_cmd == aSym )
1271         cmd = aSignSym;
1272     else if( cmd == aSym && new_cmd == aSign )
1273         cmd = aSignSym;
1274     else if( cmd == aSym && new_cmd == aEncr )
1275         cmd = aEncrSym;
1276     else if( cmd == aEncr && new_cmd == aSym )
1277         cmd = aEncrSym;
1278     else if (cmd == aSignEncr && new_cmd == aSym)
1279         cmd = aSignEncrSym;
1280     else if (cmd == aSignSym && new_cmd == aEncr)
1281         cmd = aSignEncrSym;
1282     else if (cmd == aEncrSym && new_cmd == aSign)
1283         cmd = aSignEncrSym;
1284     else if(    ( cmd == aSign     && new_cmd == aClearsign )
1285              || ( cmd == aClearsign && new_cmd == aSign )  )
1286         cmd = aClearsign;
1287     else {
1288         log_error(_("conflicting commands\n"));
1289         g10_exit(2);
1290     }
1291
1292     *ret_cmd = cmd;
1293 }
1294
1295
1296 static void
1297 add_group(char *string)
1298 {
1299   char *name,*value;
1300   struct groupitem *item;
1301
1302   /* Break off the group name */
1303   name=strsep(&string,"=");
1304   if(string==NULL)
1305     {
1306       log_error(_("no = sign found in group definition '%s'\n"),name);
1307       return;
1308     }
1309
1310   trim_trailing_ws(name,strlen(name));
1311
1312   /* Does this group already exist? */
1313   for(item=opt.grouplist;item;item=item->next)
1314     if(strcasecmp(item->name,name)==0)
1315       break;
1316
1317   if(!item)
1318     {
1319       item=xmalloc(sizeof(struct groupitem));
1320       item->name=name;
1321       item->next=opt.grouplist;
1322       item->values=NULL;
1323       opt.grouplist=item;
1324     }
1325
1326   /* Break apart the values */
1327   while ((value= strsep(&string," \t")))
1328     {
1329       if (*value)
1330         add_to_strlist2(&item->values,value,utf8_strings);
1331     }
1332 }
1333
1334
1335 static void
1336 rm_group(char *name)
1337 {
1338   struct groupitem *item,*last=NULL;
1339
1340   trim_trailing_ws(name,strlen(name));
1341
1342   for(item=opt.grouplist;item;last=item,item=item->next)
1343     {
1344       if(strcasecmp(item->name,name)==0)
1345         {
1346           if(last)
1347             last->next=item->next;
1348           else
1349             opt.grouplist=item->next;
1350
1351           free_strlist(item->values);
1352           xfree(item);
1353           break;
1354         }
1355     }
1356 }
1357
1358
1359 /* We need to check three things.
1360
1361    0) The homedir.  It must be x00, a directory, and owned by the
1362    user.
1363
1364    1) The options/gpg.conf file.  Okay unless it or its containing
1365    directory is group or other writable or not owned by us.  Disable
1366    exec in this case.
1367
1368    2) Extensions.  Same as #1.
1369
1370    Returns true if the item is unsafe. */
1371 static int
1372 check_permissions (const char *path, int item)
1373 {
1374 #if defined(HAVE_STAT) && !defined(HAVE_DOSISH_SYSTEM)
1375   static int homedir_cache=-1;
1376   char *tmppath,*dir;
1377   struct stat statbuf,dirbuf;
1378   int homedir=0,ret=0,checkonly=0;
1379   int perm=0,own=0,enc_dir_perm=0,enc_dir_own=0;
1380
1381   if(opt.no_perm_warn)
1382     return 0;
1383
1384   assert(item==0 || item==1 || item==2);
1385
1386   /* extensions may attach a path */
1387   if(item==2 && path[0]!=DIRSEP_C)
1388     {
1389       if(strchr(path,DIRSEP_C))
1390         tmppath=make_filename(path,NULL);
1391       else
1392         tmppath=make_filename(gnupg_libdir (),path,NULL);
1393     }
1394   else
1395     tmppath=xstrdup(path);
1396
1397   /* If the item is located in the homedir, but isn't the homedir,
1398      don't continue if we already checked the homedir itself.  This is
1399      to avoid user confusion with an extra options file warning which
1400      could be rectified if the homedir itself had proper
1401      permissions. */
1402   if(item!=0 && homedir_cache>-1
1403      && ascii_strncasecmp(opt.homedir,tmppath,strlen(opt.homedir))==0)
1404     {
1405       ret=homedir_cache;
1406       goto end;
1407     }
1408
1409   /* It's okay if the file or directory doesn't exist */
1410   if(stat(tmppath,&statbuf)!=0)
1411     {
1412       ret=0;
1413       goto end;
1414     }
1415
1416   /* Now check the enclosing directory.  Theoretically, we could walk
1417      this test up to the root directory /, but for the sake of sanity,
1418      I'm stopping at one level down. */
1419   dir=make_dirname(tmppath);
1420
1421   if(stat(dir,&dirbuf)!=0 || !S_ISDIR(dirbuf.st_mode))
1422     {
1423       /* Weird error */
1424       ret=1;
1425       goto end;
1426     }
1427
1428   xfree(dir);
1429
1430   /* Assume failure */
1431   ret=1;
1432
1433   if(item==0)
1434     {
1435       /* The homedir must be x00, a directory, and owned by the user. */
1436
1437       if(S_ISDIR(statbuf.st_mode))
1438         {
1439           if(statbuf.st_uid==getuid())
1440             {
1441               if((statbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1442                 ret=0;
1443               else
1444                 perm=1;
1445             }
1446           else
1447             own=1;
1448
1449           homedir_cache=ret;
1450         }
1451     }
1452   else if(item==1 || item==2)
1453     {
1454       /* The options or extension file.  Okay unless it or its
1455          containing directory is group or other writable or not owned
1456          by us or root. */
1457
1458       if(S_ISREG(statbuf.st_mode))
1459         {
1460           if(statbuf.st_uid==getuid() || statbuf.st_uid==0)
1461             {
1462               if((statbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1463                 {
1464                   /* it's not writable, so make sure the enclosing
1465                      directory is also not writable */
1466                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1467                     {
1468                       if((dirbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1469                         ret=0;
1470                       else
1471                         enc_dir_perm=1;
1472                     }
1473                   else
1474                     enc_dir_own=1;
1475                 }
1476               else
1477                 {
1478                   /* it's writable, so the enclosing directory had
1479                      better not let people get to it. */
1480                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1481                     {
1482                       if((dirbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1483                         ret=0;
1484                       else
1485                         perm=enc_dir_perm=1; /* unclear which one to fix! */
1486                     }
1487                   else
1488                     enc_dir_own=1;
1489                 }
1490             }
1491           else
1492             own=1;
1493         }
1494     }
1495   else
1496     BUG();
1497
1498   if(!checkonly)
1499     {
1500       if(own)
1501         {
1502           if(item==0)
1503             log_info(_("WARNING: unsafe ownership on"
1504                        " homedir '%s'\n"),tmppath);
1505           else if(item==1)
1506             log_info(_("WARNING: unsafe ownership on"
1507                        " configuration file '%s'\n"),tmppath);
1508           else
1509             log_info(_("WARNING: unsafe ownership on"
1510                        " extension '%s'\n"),tmppath);
1511         }
1512       if(perm)
1513         {
1514           if(item==0)
1515             log_info(_("WARNING: unsafe permissions on"
1516                        " homedir '%s'\n"),tmppath);
1517           else if(item==1)
1518             log_info(_("WARNING: unsafe permissions on"
1519                        " configuration file '%s'\n"),tmppath);
1520           else
1521             log_info(_("WARNING: unsafe permissions on"
1522                        " extension '%s'\n"),tmppath);
1523         }
1524       if(enc_dir_own)
1525         {
1526           if(item==0)
1527             log_info(_("WARNING: unsafe enclosing directory ownership on"
1528                        " homedir '%s'\n"),tmppath);
1529           else if(item==1)
1530             log_info(_("WARNING: unsafe enclosing directory ownership on"
1531                        " configuration file '%s'\n"),tmppath);
1532           else
1533             log_info(_("WARNING: unsafe enclosing directory ownership on"
1534                        " extension '%s'\n"),tmppath);
1535         }
1536       if(enc_dir_perm)
1537         {
1538           if(item==0)
1539             log_info(_("WARNING: unsafe enclosing directory permissions on"
1540                        " homedir '%s'\n"),tmppath);
1541           else if(item==1)
1542             log_info(_("WARNING: unsafe enclosing directory permissions on"
1543                        " configuration file '%s'\n"),tmppath);
1544           else
1545             log_info(_("WARNING: unsafe enclosing directory permissions on"
1546                        " extension '%s'\n"),tmppath);
1547         }
1548     }
1549
1550  end:
1551   xfree(tmppath);
1552
1553   if(homedir)
1554     homedir_cache=ret;
1555
1556   return ret;
1557
1558 #else /*!(HAVE_STAT && !HAVE_DOSISH_SYSTEM)*/
1559   (void)path;
1560   (void)item;
1561   return 0;
1562 #endif /*!(HAVE_STAT && !HAVE_DOSISH_SYSTEM)*/
1563 }
1564
1565
1566 /* Print the OpenPGP defined algo numbers.  */
1567 static void
1568 print_algo_numbers(int (*checker)(int))
1569 {
1570   int i,first=1;
1571
1572   for(i=0;i<=110;i++)
1573     {
1574       if(!checker(i))
1575         {
1576           if(first)
1577             first=0;
1578           else
1579             es_printf (";");
1580           es_printf ("%d",i);
1581         }
1582     }
1583 }
1584
1585
1586 static void
1587 print_algo_names(int (*checker)(int),const char *(*mapper)(int))
1588 {
1589   int i,first=1;
1590
1591   for(i=0;i<=110;i++)
1592     {
1593       if(!checker(i))
1594         {
1595           if(first)
1596             first=0;
1597           else
1598             es_printf (";");
1599           es_printf ("%s",mapper(i));
1600         }
1601     }
1602 }
1603
1604 /* In the future, we can do all sorts of interesting configuration
1605    output here.  For now, just give "group" as the Enigmail folks need
1606    it, and pubkey, cipher, hash, and compress as they may be useful
1607    for frontends. */
1608 static void
1609 list_config(char *items)
1610 {
1611   int show_all = !items;
1612   char *name = NULL;
1613   const char *s;
1614   struct groupitem *giter;
1615   int first, iter;
1616
1617   if(!opt.with_colons)
1618     return;
1619
1620   while(show_all || (name=strsep(&items," ")))
1621     {
1622       int any=0;
1623
1624       if(show_all || ascii_strcasecmp(name,"group")==0)
1625         {
1626           for (giter = opt.grouplist; giter; giter = giter->next)
1627             {
1628               strlist_t sl;
1629
1630               es_fprintf (es_stdout, "cfg:group:");
1631               es_write_sanitized (es_stdout, giter->name, strlen(giter->name),
1632                                   ":", NULL);
1633               es_putc (':', es_stdout);
1634
1635               for(sl=giter->values; sl; sl=sl->next)
1636                 {
1637                   es_write_sanitized (es_stdout, sl->d, strlen (sl->d),
1638                                       ":;", NULL);
1639                   if(sl->next)
1640                     es_printf(";");
1641                 }
1642
1643               es_printf("\n");
1644             }
1645
1646           any=1;
1647         }
1648
1649       if(show_all || ascii_strcasecmp(name,"version")==0)
1650         {
1651           es_printf("cfg:version:");
1652           es_write_sanitized (es_stdout, VERSION, strlen(VERSION), ":", NULL);
1653           es_printf ("\n");
1654           any=1;
1655         }
1656
1657       if(show_all || ascii_strcasecmp(name,"pubkey")==0)
1658         {
1659           es_printf ("cfg:pubkey:");
1660           print_algo_numbers (build_list_pk_test_algo);
1661           es_printf ("\n");
1662           any=1;
1663         }
1664
1665       if(show_all || ascii_strcasecmp(name,"pubkeyname")==0)
1666         {
1667           es_printf ("cfg:pubkeyname:");
1668           print_algo_names (build_list_pk_test_algo,
1669                             build_list_pk_algo_name);
1670           es_printf ("\n");
1671           any=1;
1672         }
1673
1674       if(show_all || ascii_strcasecmp(name,"cipher")==0)
1675         {
1676           es_printf ("cfg:cipher:");
1677           print_algo_numbers (build_list_cipher_test_algo);
1678           es_printf ("\n");
1679           any=1;
1680         }
1681
1682       if (show_all || !ascii_strcasecmp (name,"ciphername"))
1683         {
1684           es_printf ("cfg:ciphername:");
1685           print_algo_names (build_list_cipher_test_algo,
1686                             build_list_cipher_algo_name);
1687           es_printf ("\n");
1688           any = 1;
1689         }
1690
1691       if(show_all
1692          || ascii_strcasecmp(name,"digest")==0
1693          || ascii_strcasecmp(name,"hash")==0)
1694         {
1695           es_printf ("cfg:digest:");
1696           print_algo_numbers (build_list_md_test_algo);
1697           es_printf ("\n");
1698           any=1;
1699         }
1700
1701       if (show_all
1702           || !ascii_strcasecmp(name,"digestname")
1703           || !ascii_strcasecmp(name,"hashname"))
1704         {
1705           es_printf ("cfg:digestname:");
1706           print_algo_names (build_list_md_test_algo,
1707                             build_list_md_algo_name);
1708           es_printf ("\n");
1709           any=1;
1710         }
1711
1712       if(show_all || ascii_strcasecmp(name,"compress")==0)
1713         {
1714           es_printf ("cfg:compress:");
1715           print_algo_numbers(check_compress_algo);
1716           es_printf ("\n");
1717           any=1;
1718         }
1719
1720       if (show_all || !ascii_strcasecmp(name,"ccid-reader-id"))
1721         {
1722           /* We ignore this for GnuPG 1.4 backward compatibility.  */
1723           any=1;
1724         }
1725
1726       if (show_all || !ascii_strcasecmp (name,"curve"))
1727         {
1728           es_printf ("cfg:curve:");
1729           for (iter=0, first=1; (s = openpgp_enum_curves (&iter)); first=0)
1730             es_printf ("%s%s", first?"":";", s);
1731           es_printf ("\n");
1732           any=1;
1733         }
1734
1735       /* Curve OIDs are rarely useful and thus only printed if requested.  */
1736       if (name && !ascii_strcasecmp (name,"curveoid"))
1737         {
1738           es_printf ("cfg:curveoid:");
1739           for (iter=0, first=1; (s = openpgp_enum_curves (&iter)); first = 0)
1740             {
1741               s = openpgp_curve_to_oid (s, NULL);
1742               es_printf ("%s%s", first?"":";", s? s:"[?]");
1743             }
1744           es_printf ("\n");
1745           any=1;
1746         }
1747
1748       if(show_all)
1749         break;
1750
1751       if(!any)
1752         log_error(_("unknown configuration item '%s'\n"),name);
1753     }
1754 }
1755
1756
1757 /* List options and default values in the GPG Conf format.  This is a
1758    new tool distributed with gnupg 1.9.x but we also want some limited
1759    support in older gpg versions.  The output is the name of the
1760    configuration file and a list of options available for editing by
1761    gpgconf.  */
1762 static void
1763 gpgconf_list (const char *configfile)
1764 {
1765   char *configfile_esc = percent_escape (configfile, NULL);
1766
1767   es_printf ("%s-%s.conf:%lu:\"%s\n",
1768              GPGCONF_NAME, GPG_NAME,
1769              GC_OPT_FLAG_DEFAULT,
1770              configfile_esc ? configfile_esc : "/dev/null");
1771   es_printf ("verbose:%lu:\n", GC_OPT_FLAG_NONE);
1772   es_printf ("quiet:%lu:\n",   GC_OPT_FLAG_NONE);
1773   es_printf ("keyserver:%lu:\n", GC_OPT_FLAG_NONE);
1774   es_printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE);
1775   es_printf ("default-key:%lu:\n", GC_OPT_FLAG_NONE);
1776   es_printf ("encrypt-to:%lu:\n", GC_OPT_FLAG_NONE);
1777   es_printf ("try-secret-key:%lu:\n", GC_OPT_FLAG_NONE);
1778   es_printf ("auto-key-locate:%lu:\n", GC_OPT_FLAG_NONE);
1779   es_printf ("log-file:%lu:\n", GC_OPT_FLAG_NONE);
1780   es_printf ("debug-level:%lu:\"none:\n", GC_OPT_FLAG_DEFAULT);
1781   es_printf ("group:%lu:\n", GC_OPT_FLAG_NONE);
1782
1783   /* The next one is an info only item and should match the macros at
1784      the top of keygen.c  */
1785   es_printf ("default_pubkey_algo:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT,
1786              "RSA-2048");
1787
1788   xfree (configfile_esc);
1789 }
1790
1791
1792 static int
1793 parse_subpacket_list(char *list)
1794 {
1795   char *tok;
1796   byte subpackets[128],i;
1797   int count=0;
1798
1799   if(!list)
1800     {
1801       /* No arguments means all subpackets */
1802       memset(subpackets+1,1,sizeof(subpackets)-1);
1803       count=127;
1804     }
1805   else
1806     {
1807       memset(subpackets,0,sizeof(subpackets));
1808
1809       /* Merge with earlier copy */
1810       if(opt.show_subpackets)
1811         {
1812           byte *in;
1813
1814           for(in=opt.show_subpackets;*in;in++)
1815             {
1816               if(*in>127 || *in<1)
1817                 BUG();
1818
1819               if(!subpackets[*in])
1820                 count++;
1821               subpackets[*in]=1;
1822             }
1823         }
1824
1825       while((tok=strsep(&list," ,")))
1826         {
1827           if(!*tok)
1828             continue;
1829
1830           i=atoi(tok);
1831           if(i>127 || i<1)
1832             return 0;
1833
1834           if(!subpackets[i])
1835             count++;
1836           subpackets[i]=1;
1837         }
1838     }
1839
1840   xfree(opt.show_subpackets);
1841   opt.show_subpackets=xmalloc(count+1);
1842   opt.show_subpackets[count--]=0;
1843
1844   for(i=1;i<128 && count>=0;i++)
1845     if(subpackets[i])
1846       opt.show_subpackets[count--]=i;
1847
1848   return 1;
1849 }
1850
1851
1852 static int
1853 parse_list_options(char *str)
1854 {
1855   char *subpackets=""; /* something that isn't NULL */
1856   struct parse_options lopts[]=
1857     {
1858       {"show-photos",LIST_SHOW_PHOTOS,NULL,
1859        N_("display photo IDs during key listings")},
1860       {"show-usage",LIST_SHOW_USAGE,NULL,
1861        N_("show key usage information during key listings")},
1862       {"show-policy-urls",LIST_SHOW_POLICY_URLS,NULL,
1863        N_("show policy URLs during signature listings")},
1864       {"show-notations",LIST_SHOW_NOTATIONS,NULL,
1865        N_("show all notations during signature listings")},
1866       {"show-std-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1867        N_("show IETF standard notations during signature listings")},
1868       {"show-standard-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1869        NULL},
1870       {"show-user-notations",LIST_SHOW_USER_NOTATIONS,NULL,
1871        N_("show user-supplied notations during signature listings")},
1872       {"show-keyserver-urls",LIST_SHOW_KEYSERVER_URLS,NULL,
1873        N_("show preferred keyserver URLs during signature listings")},
1874       {"show-uid-validity",LIST_SHOW_UID_VALIDITY,NULL,
1875        N_("show user ID validity during key listings")},
1876       {"show-unusable-uids",LIST_SHOW_UNUSABLE_UIDS,NULL,
1877        N_("show revoked and expired user IDs in key listings")},
1878       {"show-unusable-subkeys",LIST_SHOW_UNUSABLE_SUBKEYS,NULL,
1879        N_("show revoked and expired subkeys in key listings")},
1880       {"show-keyring",LIST_SHOW_KEYRING,NULL,
1881        N_("show the keyring name in key listings")},
1882       {"show-sig-expire",LIST_SHOW_SIG_EXPIRE,NULL,
1883        N_("show expiration dates during signature listings")},
1884       {"show-sig-subpackets",LIST_SHOW_SIG_SUBPACKETS,NULL,
1885        NULL},
1886       {NULL,0,NULL,NULL}
1887     };
1888
1889   /* C99 allows for non-constant initializers, but we'd like to
1890      compile everywhere, so fill in the show-sig-subpackets argument
1891      here.  Note that if the parse_options array changes, we'll have
1892      to change the subscript here. */
1893   lopts[13].value=&subpackets;
1894
1895   if(parse_options(str,&opt.list_options,lopts,1))
1896     {
1897       if(opt.list_options&LIST_SHOW_SIG_SUBPACKETS)
1898         {
1899           /* Unset so users can pass multiple lists in. */
1900           opt.list_options&=~LIST_SHOW_SIG_SUBPACKETS;
1901           if(!parse_subpacket_list(subpackets))
1902             return 0;
1903         }
1904       else if(subpackets==NULL && opt.show_subpackets)
1905         {
1906           /* User did 'no-show-subpackets' */
1907           xfree(opt.show_subpackets);
1908           opt.show_subpackets=NULL;
1909         }
1910
1911       return 1;
1912     }
1913   else
1914     return 0;
1915 }
1916
1917
1918 /* Collapses argc/argv into a single string that must be freed */
1919 static char *
1920 collapse_args(int argc,char *argv[])
1921 {
1922   char *str=NULL;
1923   int i,first=1,len=0;
1924
1925   for(i=0;i<argc;i++)
1926     {
1927       len+=strlen(argv[i])+2;
1928       str=xrealloc(str,len);
1929       if(first)
1930         {
1931           str[0]='\0';
1932           first=0;
1933         }
1934       else
1935         strcat(str," ");
1936
1937       strcat(str,argv[i]);
1938     }
1939
1940   return str;
1941 }
1942
1943
1944 #ifndef NO_TRUST_MODELS
1945 static void
1946 parse_trust_model(const char *model)
1947 {
1948   if(ascii_strcasecmp(model,"pgp")==0)
1949     opt.trust_model=TM_PGP;
1950   else if(ascii_strcasecmp(model,"classic")==0)
1951     opt.trust_model=TM_CLASSIC;
1952   else if(ascii_strcasecmp(model,"always")==0)
1953     opt.trust_model=TM_ALWAYS;
1954   else if(ascii_strcasecmp(model,"direct")==0)
1955     opt.trust_model=TM_DIRECT;
1956 #ifdef USE_TOFU
1957   else if(ascii_strcasecmp(model,"tofu")==0)
1958     opt.trust_model=TM_TOFU;
1959   else if(ascii_strcasecmp(model,"tofu+pgp")==0)
1960     opt.trust_model=TM_TOFU_PGP;
1961 #endif /*USE_TOFU*/
1962   else if(ascii_strcasecmp(model,"auto")==0)
1963     opt.trust_model=TM_AUTO;
1964   else
1965     log_error("unknown trust model '%s'\n",model);
1966 }
1967 #endif /*NO_TRUST_MODELS*/
1968
1969 static int
1970 parse_tofu_policy (const char *policy)
1971 {
1972 #ifdef USE_TOFU
1973   if (ascii_strcasecmp (policy, "auto") == 0)
1974     return TOFU_POLICY_AUTO;
1975   else if (ascii_strcasecmp (policy, "good") == 0)
1976     return TOFU_POLICY_GOOD;
1977   else if (ascii_strcasecmp (policy, "unknown") == 0)
1978     return TOFU_POLICY_UNKNOWN;
1979   else if (ascii_strcasecmp (policy, "bad") == 0)
1980     return TOFU_POLICY_BAD;
1981   else if (ascii_strcasecmp (policy, "ask") == 0)
1982     return TOFU_POLICY_ASK;
1983   else
1984 #endif /*USE_TOFU*/
1985     {
1986       log_error (_("unknown TOFU policy '%s'\n"), policy);
1987       g10_exit (1);
1988     }
1989 }
1990
1991 static int
1992 parse_tofu_db_format (const char *db_format)
1993 {
1994 #ifdef USE_TOFU
1995   if (ascii_strcasecmp (db_format, "auto") == 0)
1996     return TOFU_DB_AUTO;
1997   else if (ascii_strcasecmp (db_format, "split") == 0)
1998     return TOFU_DB_SPLIT;
1999   else if (ascii_strcasecmp (db_format, "flat") == 0)
2000     return TOFU_DB_FLAT;
2001   else
2002 #endif /*USE_TOFU*/
2003     {
2004       log_error (_("unknown TOFU DB format '%s'\n"), db_format);
2005       g10_exit (1);
2006     }
2007 }
2008
2009 /* This fucntion called to initialized a new control object.  It is
2010    assumed that this object has been zeroed out before calling this
2011    function. */
2012 static void
2013 gpg_init_default_ctrl (ctrl_t ctrl)
2014 {
2015   (void)ctrl;
2016 }
2017
2018
2019 /* This function is called to deinitialize a control object.  It is
2020    not deallocated. */
2021 static void
2022 gpg_deinit_default_ctrl (ctrl_t ctrl)
2023 {
2024   gpg_dirmngr_deinit_session_data (ctrl);
2025 }
2026
2027
2028 char *
2029 get_default_configname (void)
2030 {
2031   char *configname = NULL;
2032   char *name = xstrdup (GPG_NAME EXTSEP_S "conf-" SAFE_VERSION);
2033   char *ver = &name[strlen (GPG_NAME EXTSEP_S "conf-")];
2034
2035   do
2036     {
2037       if (configname)
2038         {
2039           char *tok;
2040
2041           xfree (configname);
2042           configname = NULL;
2043
2044           if ((tok = strrchr (ver, SAFE_VERSION_DASH)))
2045             *tok='\0';
2046           else if ((tok = strrchr (ver, SAFE_VERSION_DOT)))
2047             *tok='\0';
2048           else
2049             break;
2050         }
2051
2052       configname = make_filename (opt.homedir, name, NULL);
2053     }
2054   while (access (configname, R_OK));
2055
2056   xfree(name);
2057
2058   if (! configname)
2059     configname = make_filename (opt.homedir, GPG_NAME EXTSEP_S "conf", NULL);
2060   if (! access (configname, R_OK))
2061     {
2062       /* Print a warning when both config files are present.  */
2063       char *p = make_filename (opt.homedir, "options", NULL);
2064       if (! access (p, R_OK))
2065         log_info (_("Note: old default options file '%s' ignored\n"), p);
2066       xfree (p);
2067     }
2068   else
2069     {
2070       /* Use the old default only if it exists.  */
2071       char *p = make_filename (opt.homedir, "options", NULL);
2072       if (!access (p, R_OK))
2073         {
2074           xfree (configname);
2075           configname = p;
2076         }
2077       else
2078         xfree (p);
2079     }
2080
2081   return configname;
2082 }
2083
2084 gpg_error_t
2085 check_user_ids (strlist_t *sp,
2086                 int warn_possibly_ambiguous,
2087                 int error_if_not_found)
2088 {
2089   strlist_t s = *sp;
2090   strlist_t s2 = NULL;
2091   strlist_t t;
2092
2093   gpg_error_t rc = 0;
2094   gpg_error_t err;
2095
2096   KEYDB_HANDLE hd = NULL;
2097
2098   if (! s)
2099     return 0;
2100
2101   for (t = s; t; t = t->next)
2102     {
2103       const char *option;
2104
2105       KEYDB_SEARCH_DESC desc;
2106       KBNODE kb;
2107       PKT_public_key *pk;
2108       char fingerprint_bin[MAX_FINGERPRINT_LEN];
2109       size_t fingerprint_bin_len = sizeof (fingerprint_bin);
2110       char fingerprint[2 * MAX_FINGERPRINT_LEN + 1];
2111
2112
2113       switch (t->flags >> 2)
2114         {
2115         case oDefaultKey: option = "--default-key"; break;
2116         case oEncryptTo: option = "--encrypt-to"; break;
2117         case oHiddenEncryptTo: option = "--hidden-encrypt-to"; break;
2118         case oEncryptToDefaultKey: option = "--encrypt-to-default-key"; break;
2119         case oRecipient: option = "--recipient"; break;
2120         case oHiddenRecipient: option = "--hidden-recipient"; break;
2121         case oLocalUser: option = "--local-user"; break;
2122         default: log_bug ("Unsupport option: %d\n", t->flags >> 2);
2123         }
2124
2125       err = classify_user_id (t->d, &desc, 1);
2126       if (err)
2127         {
2128           if (! rc)
2129             rc = err;
2130
2131           log_error (_("Invalid value ('%s')."), t->d);
2132           if (!opt.quiet)
2133             log_info (_("(check argument of option '%s')\n"), option);
2134           continue;
2135         }
2136
2137       if (warn_possibly_ambiguous
2138           && ! (desc.mode == KEYDB_SEARCH_MODE_LONG_KID
2139                 || desc.mode == KEYDB_SEARCH_MODE_FPR16
2140                 || desc.mode == KEYDB_SEARCH_MODE_FPR20
2141                 || desc.mode == KEYDB_SEARCH_MODE_FPR))
2142         log_info (_("Warning: value '%s' for %s"
2143                     " should be a long keyid or a fingerprint.\n"),
2144                   t->d, option);
2145
2146       if (! hd)
2147         hd = keydb_new ();
2148       else
2149         keydb_search_reset (hd);
2150
2151       err = keydb_search (hd, &desc, 1, NULL);
2152       if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
2153         {
2154           if (error_if_not_found)
2155             {
2156               if (! rc)
2157                 rc = err;
2158
2159               log_error (_("no such key corresponding to '%s'\n"), t->d);
2160               if (!opt.quiet)
2161                 log_info (_("(check argument of option '%s')\n"), option);
2162             }
2163           continue;
2164         }
2165       if (err)
2166         {
2167           if (! rc)
2168             rc = err;
2169
2170           log_error (_("error looking up '%s' in keyring: %s.\n"),
2171                      t->d, gpg_strerror (err));
2172           break;
2173         }
2174
2175       err = keydb_get_keyblock (hd, &kb);
2176       if (err)
2177         {
2178           if (! rc)
2179             rc = err;
2180
2181           log_error (_("error reading key block for '%s': %s\n"),
2182                      t->d, gpg_strerror (err));
2183           continue;
2184         }
2185
2186       pk = kb->pkt->pkt.public_key;
2187       fingerprint_from_pk (pk, fingerprint_bin, &fingerprint_bin_len);
2188       assert (fingerprint_bin_len == sizeof (fingerprint_bin));
2189       bin2hex (fingerprint_bin, MAX_FINGERPRINT_LEN, fingerprint);
2190       add_to_strlist (&s2, fingerprint);
2191       s2->flags = s->flags;
2192
2193       release_kbnode (kb);
2194
2195       /* Continue the search.  */
2196       err = keydb_search (hd, &desc, 1, NULL);
2197       if (! (gpg_err_code (err) == GPG_ERR_NOT_FOUND
2198              || gpg_err_code (err) == GPG_ERR_EOF))
2199         {
2200           char fingerprint_bin2[MAX_FINGERPRINT_LEN];
2201           size_t fingerprint_bin2_len = sizeof (fingerprint_bin2);
2202           char fingerprint2[2 * MAX_FINGERPRINT_LEN + 1];
2203
2204           log_error (_("Error: the key specification '%s' is ambiguous.\n"),
2205                      t->d);
2206           if (!opt.quiet)
2207             log_info (_("(check argument of option '%s')\n"), option);
2208
2209           err = keydb_get_keyblock (hd, &kb);
2210           if (err)
2211             log_error (_("error reading key block for '%s': %s.\n"),
2212                        t->d, gpg_strerror (err));
2213           else
2214             {
2215               pk = kb->pkt->pkt.public_key;
2216               fingerprint_from_pk (pk, fingerprint_bin2, &fingerprint_bin2_len);
2217               assert (fingerprint_bin2_len == sizeof (fingerprint_bin2));
2218               bin2hex (fingerprint_bin2, MAX_FINGERPRINT_LEN, fingerprint2);
2219
2220               log_error ("'%s' matches at least: %s and %s.\n",
2221                          t->d, fingerprint, fingerprint2);
2222
2223               release_kbnode (kb);
2224             }
2225         }
2226     }
2227
2228   strlist_rev (&s2);
2229
2230   if (hd)
2231     keydb_release (hd);
2232
2233   free_strlist (s);
2234   *sp = s2;
2235   return rc;
2236 }
2237
2238 int
2239 main (int argc, char **argv)
2240 {
2241     ARGPARSE_ARGS pargs;
2242     IOBUF a;
2243     int rc=0;
2244     int orig_argc;
2245     char **orig_argv;
2246     const char *fname;
2247     char *username;
2248     int may_coredump;
2249     strlist_t sl, remusr= NULL, locusr=NULL;
2250     strlist_t nrings = NULL;
2251     armor_filter_context_t *afx = NULL;
2252     int detached_sig = 0;
2253     FILE *configfp = NULL;
2254     char *configname = NULL;
2255     char *save_configname = NULL;
2256     char *default_configname = NULL;
2257     unsigned configlineno;
2258     int parse_debug = 0;
2259     int default_config = 1;
2260     int default_keyring = 1;
2261     int greeting = 0;
2262     int nogreeting = 0;
2263     char *logfile = NULL;
2264     int use_random_seed = 1;
2265     enum cmd_and_opt_values cmd = 0;
2266     const char *debug_level = NULL;
2267 #ifndef NO_TRUST_MODELS
2268     const char *trustdb_name = NULL;
2269 #endif /*!NO_TRUST_MODELS*/
2270     char *def_cipher_string = NULL;
2271     char *def_digest_string = NULL;
2272     char *compress_algo_string = NULL;
2273     char *cert_digest_string = NULL;
2274     char *s2k_cipher_string = NULL;
2275     char *s2k_digest_string = NULL;
2276     char *pers_cipher_list = NULL;
2277     char *pers_digest_list = NULL;
2278     char *pers_compress_list = NULL;
2279     int eyes_only=0;
2280     int multifile=0;
2281     int pwfd = -1;
2282     int fpr_maybe_cmd = 0; /* --fingerprint maybe a command.  */
2283     int any_explicit_recipient = 0;
2284     int require_secmem=0,got_secmem=0;
2285     struct assuan_malloc_hooks malloc_hooks;
2286     ctrl_t ctrl;
2287
2288 #ifdef __riscos__
2289     opt.lock_once = 1;
2290 #endif /* __riscos__ */
2291
2292
2293     /* Please note that we may running SUID(ROOT), so be very CAREFUL
2294        when adding any stuff between here and the call to
2295        secmem_init() somewhere after the option parsing. */
2296     early_system_init ();
2297     gnupg_reopen_std (GPG_NAME);
2298     trap_unaligned ();
2299     gnupg_rl_initialize ();
2300     set_strusage (my_strusage);
2301     gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
2302     log_set_prefix (GPG_NAME, 1);
2303
2304     /* Make sure that our subsystems are ready.  */
2305     i18n_init();
2306     init_common_subsystems (&argc, &argv);
2307
2308     /* Check that the libraries are suitable.  Do it right here because the
2309        option parsing may need services of the library.  */
2310     if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
2311       {
2312         log_fatal ( _("libgcrypt is too old (need %s, have %s)\n"),
2313                     NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
2314       }
2315
2316     /* Use our own logging handler for Libcgrypt.  */
2317     setup_libgcrypt_logging ();
2318
2319     /* Put random number into secure memory */
2320     gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
2321
2322     may_coredump = disable_core_dumps();
2323
2324     gnupg_init_signals (0, emergency_cleanup);
2325
2326     dotlock_create (NULL, 0); /* Register lock file cleanup. */
2327
2328     opt.autostart = 1;
2329     opt.session_env = session_env_new ();
2330     if (!opt.session_env)
2331       log_fatal ("error allocating session environment block: %s\n",
2332                  strerror (errno));
2333
2334     opt.command_fd = -1; /* no command fd */
2335     opt.compress_level = -1; /* defaults to standard compress level */
2336     opt.bz2_compress_level = -1; /* defaults to standard compress level */
2337     /* note: if you change these lines, look at oOpenPGP */
2338     opt.def_cipher_algo = 0;
2339     opt.def_digest_algo = 0;
2340     opt.cert_digest_algo = 0;
2341     opt.compress_algo = -1; /* defaults to DEFAULT_COMPRESS_ALGO */
2342     opt.s2k_mode = 3; /* iterated+salted */
2343     opt.s2k_count = 0; /* Auto-calibrate when needed.  */
2344     opt.s2k_cipher_algo = DEFAULT_CIPHER_ALGO;
2345     opt.completes_needed = 1;
2346     opt.marginals_needed = 3;
2347     opt.max_cert_depth = 5;
2348     opt.escape_from = 1;
2349     opt.flags.require_cross_cert = 1;
2350     opt.import_options = 0;
2351     opt.export_options = EXPORT_ATTRIBUTES;
2352     opt.keyserver_options.import_options = IMPORT_REPAIR_PKS_SUBKEY_BUG;
2353     opt.keyserver_options.export_options = EXPORT_ATTRIBUTES;
2354     opt.keyserver_options.options = KEYSERVER_HONOR_PKA_RECORD;
2355     opt.verify_options = (LIST_SHOW_UID_VALIDITY
2356                           | VERIFY_SHOW_POLICY_URLS
2357                           | VERIFY_SHOW_STD_NOTATIONS
2358                           | VERIFY_SHOW_KEYSERVER_URLS);
2359     opt.list_options   = LIST_SHOW_UID_VALIDITY;
2360 #ifdef NO_TRUST_MODELS
2361     opt.trust_model = TM_ALWAYS;
2362 #else
2363     opt.trust_model = TM_AUTO;
2364 #endif
2365     opt.tofu_default_policy = TOFU_POLICY_AUTO;
2366     opt.tofu_db_format = TOFU_DB_AUTO;
2367     opt.mangle_dos_filenames = 0;
2368     opt.min_cert_level = 2;
2369     set_screen_dimensions ();
2370     opt.keyid_format = KF_SHORT;
2371     opt.def_sig_expire = "0";
2372     opt.def_cert_expire = "0";
2373     set_homedir (default_homedir ());
2374     opt.passphrase_repeat = 1;
2375     opt.emit_version = 1; /* Limit to the major number.  */
2376     opt.weak_digests = NULL;
2377     additional_weak_digest("MD5");
2378
2379     /* Check whether we have a config file on the command line.  */
2380     orig_argc = argc;
2381     orig_argv = argv;
2382     pargs.argc = &argc;
2383     pargs.argv = &argv;
2384     pargs.flags= (ARGPARSE_FLAG_KEEP | ARGPARSE_FLAG_NOVERSION);
2385     while( arg_parse( &pargs, opts) ) {
2386         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
2387             parse_debug++;
2388         else if (pargs.r_opt == oDebugIOLBF)
2389             es_setvbuf (es_stdout, NULL, _IOLBF, 0);
2390         else if( pargs.r_opt == oOptions ) {
2391             /* yes there is one, so we do not try the default one, but
2392              * read the option file when it is encountered at the commandline
2393              */
2394             default_config = 0;
2395         }
2396         else if( pargs.r_opt == oNoOptions )
2397           {
2398             default_config = 0; /* --no-options */
2399             opt.no_homedir_creation = 1;
2400           }
2401         else if( pargs.r_opt == oHomedir )
2402             set_homedir ( pargs.r.ret_str );
2403         else if( pargs.r_opt == oNoPermissionWarn )
2404             opt.no_perm_warn=1;
2405         else if (pargs.r_opt == oStrict )
2406           {
2407             /* Not used */
2408           }
2409         else if (pargs.r_opt == oNoStrict )
2410           {
2411             /* Not used */
2412           }
2413     }
2414
2415 #ifdef HAVE_DOSISH_SYSTEM
2416     if ( strchr (opt.homedir,'\\') ) {
2417         char *d, *buf = xmalloc (strlen (opt.homedir)+1);
2418         const char *s = opt.homedir;
2419         for (d=buf,s=opt.homedir; *s; s++)
2420           {
2421             *d++ = *s == '\\'? '/': *s;
2422 #ifdef HAVE_W32_SYSTEM
2423             if (s[1] && IsDBCSLeadByte (*s))
2424               *d++ = *++s;
2425 #endif
2426           }
2427         *d = 0;
2428         set_homedir (buf);
2429     }
2430 #endif
2431
2432     /* Initialize the secure memory. */
2433     if (!gcry_control (GCRYCTL_INIT_SECMEM, SECMEM_BUFFER_SIZE, 0))
2434       got_secmem = 1;
2435 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
2436     /* There should be no way to get to this spot while still carrying
2437        setuid privs.  Just in case, bomb out if we are. */
2438     if ( getuid () != geteuid () )
2439       BUG ();
2440 #endif
2441     maybe_setuid = 0;
2442
2443     /* Okay, we are now working under our real uid */
2444
2445     /* malloc hooks go here ... */
2446     malloc_hooks.malloc = gcry_malloc;
2447     malloc_hooks.realloc = gcry_realloc;
2448     malloc_hooks.free = gcry_free;
2449     assuan_set_malloc_hooks (&malloc_hooks);
2450     assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
2451     setup_libassuan_logging (&opt.debug);
2452
2453     /* Try for a version specific config file first */
2454     default_configname = get_default_configname ();
2455     if (default_config)
2456       configname = xstrdup (default_configname);
2457
2458     argc = orig_argc;
2459     argv = orig_argv;
2460     pargs.argc = &argc;
2461     pargs.argv = &argv;
2462     pargs.flags= ARGPARSE_FLAG_KEEP;
2463
2464     /* By this point we have a homedir, and cannot change it. */
2465     check_permissions(opt.homedir,0);
2466
2467   next_pass:
2468     if( configname ) {
2469       if(check_permissions(configname,1))
2470         {
2471           /* If any options file is unsafe, then disable any external
2472              programs for keyserver calls or photo IDs.  Since the
2473              external program to call is set in the options file, a
2474              unsafe options file can lead to an arbitrary program
2475              being run. */
2476
2477           opt.exec_disable=1;
2478         }
2479
2480         configlineno = 0;
2481         configfp = fopen( configname, "r" );
2482         if (configfp && is_secured_file (fileno (configfp)))
2483           {
2484             fclose (configfp);
2485             configfp = NULL;
2486             gpg_err_set_errno (EPERM);
2487           }
2488         if( !configfp ) {
2489             if( default_config ) {
2490                 if( parse_debug )
2491                     log_info(_("Note: no default option file '%s'\n"),
2492                                                             configname );
2493             }
2494             else {
2495                 log_error(_("option file '%s': %s\n"),
2496                                     configname, strerror(errno) );
2497                 g10_exit(2);
2498             }
2499             xfree(configname); configname = NULL;
2500         }
2501         if( parse_debug && configname )
2502             log_info(_("reading options from '%s'\n"), configname );
2503         default_config = 0;
2504     }
2505
2506     while( optfile_parse( configfp, configname, &configlineno,
2507                                                 &pargs, opts) )
2508       {
2509         switch( pargs.r_opt )
2510           {
2511           case aCheckKeys:
2512           case aListConfig:
2513           case aListGcryptConfig:
2514           case aGPGConfList:
2515           case aGPGConfTest:
2516           case aListPackets:
2517           case aImport:
2518           case aFastImport:
2519           case aSendKeys:
2520           case aRecvKeys:
2521           case aSearchKeys:
2522           case aRefreshKeys:
2523           case aFetchKeys:
2524           case aExport:
2525 #ifdef ENABLE_CARD_SUPPORT
2526           case aCardStatus:
2527           case aCardEdit:
2528           case aChangePIN:
2529 #endif /* ENABLE_CARD_SUPPORT*/
2530           case aListKeys:
2531           case aLocateKeys:
2532           case aListSigs:
2533           case aExportSecret:
2534           case aExportSecretSub:
2535           case aSym:
2536           case aClearsign:
2537           case aGenRevoke:
2538           case aDesigRevoke:
2539           case aPrimegen:
2540           case aGenRandom:
2541           case aPrintMD:
2542           case aPrintMDs:
2543           case aListTrustDB:
2544           case aCheckTrustDB:
2545           case aUpdateTrustDB:
2546           case aFixTrustDB:
2547           case aListTrustPath:
2548           case aDeArmor:
2549           case aEnArmor:
2550           case aSign:
2551           case aQuickSignKey:
2552           case aQuickLSignKey:
2553           case aSignKey:
2554           case aLSignKey:
2555           case aStore:
2556           case aQuickKeygen:
2557           case aQuickAddUid:
2558           case aExportOwnerTrust:
2559           case aImportOwnerTrust:
2560           case aRebuildKeydbCaches:
2561             set_cmd (&cmd, pargs.r_opt);
2562             break;
2563
2564           case aKeygen:
2565           case aFullKeygen:
2566           case aEditKey:
2567           case aDeleteSecretKeys:
2568           case aDeleteSecretAndPublicKeys:
2569           case aDeleteKeys:
2570           case aPasswd:
2571             set_cmd (&cmd, pargs.r_opt);
2572             greeting=1;
2573             break;
2574
2575           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
2576
2577           case aDecryptFiles: multifile=1; /* fall through */
2578           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
2579
2580           case aEncrFiles: multifile=1; /* fall through */
2581           case aEncr: set_cmd( &cmd, aEncr); break;
2582
2583           case aVerifyFiles: multifile=1; /* fall through */
2584           case aVerify: set_cmd( &cmd, aVerify); break;
2585
2586           case aServer:
2587             set_cmd (&cmd, pargs.r_opt);
2588             opt.batch = 1;
2589             break;
2590
2591           case aTOFUPolicy:
2592             set_cmd (&cmd, pargs.r_opt);
2593             break;
2594
2595           case oArmor: opt.armor = 1; opt.no_armor=0; break;
2596           case oOutput: opt.outfile = pargs.r.ret_str; break;
2597           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
2598           case oQuiet: opt.quiet = 1; break;
2599           case oNoTTY: tty_no_terminal(1); break;
2600           case oDryRun: opt.dry_run = 1; break;
2601           case oInteractive: opt.interactive = 1; break;
2602           case oVerbose:
2603             opt.verbose++;
2604             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2605             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
2606             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
2607             break;
2608
2609           case oBatch:
2610             opt.batch = 1;
2611             nogreeting = 1;
2612             break;
2613
2614           case oUseAgent: /* Dummy. */
2615             break;
2616
2617           case oNoUseAgent:
2618             obsolete_option (configname, configlineno, "no-use-agent");
2619             break;
2620           case oGpgAgentInfo:
2621             obsolete_option (configname, configlineno, "gpg-agent-info");
2622             break;
2623           case oReaderPort:
2624             obsolete_scdaemon_option (configname, configlineno, "reader-port");
2625             break;
2626           case octapiDriver:
2627             obsolete_scdaemon_option (configname, configlineno, "ctapi-driver");
2628             break;
2629           case opcscDriver:
2630             obsolete_scdaemon_option (configname, configlineno, "pcsc-driver");
2631             break;
2632           case oDisableCCID:
2633             obsolete_scdaemon_option (configname, configlineno, "disable-ccid");
2634             break;
2635           case oHonorHttpProxy:
2636             obsolete_option (configname, configlineno, "honor-http-proxy");
2637             break;
2638
2639           case oAnswerYes: opt.answer_yes = 1; break;
2640           case oAnswerNo: opt.answer_no = 1; break;
2641           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
2642           case oPrimaryKeyring:
2643             sl = append_to_strlist (&nrings, pargs.r.ret_str);
2644             sl->flags = KEYDB_RESOURCE_FLAG_PRIMARY;
2645             break;
2646           case oShowKeyring:
2647             deprecated_warning(configname,configlineno,"--show-keyring",
2648                                "--list-options ","show-keyring");
2649             opt.list_options|=LIST_SHOW_KEYRING;
2650             break;
2651
2652           case oDebug:
2653             if (parse_debug_flag (pargs.r.ret_str, &opt.debug, debug_flags))
2654               {
2655                 pargs.r_opt = ARGPARSE_INVALID_ARG;
2656                 pargs.err = ARGPARSE_PRINT_ERROR;
2657               }
2658             break;
2659
2660           case oDebugAll: opt.debug = ~0; break;
2661           case oDebugLevel: debug_level = pargs.r.ret_str; break;
2662
2663           case oDebugIOLBF: break; /* Already set in pre-parse step.  */
2664
2665           case oStatusFD:
2666             set_status_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2667             break;
2668           case oStatusFile:
2669             set_status_fd ( open_info_file (pargs.r.ret_str, 1, 0) );
2670             break;
2671           case oAttributeFD:
2672             set_attrib_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2673             break;
2674           case oAttributeFile:
2675             set_attrib_fd ( open_info_file (pargs.r.ret_str, 1, 1) );
2676             break;
2677           case oLoggerFD:
2678             log_set_fd (translate_sys2libc_fd_int (pargs.r.ret_int, 1));
2679             break;
2680           case oLoggerFile:
2681             logfile = pargs.r.ret_str;
2682             break;
2683
2684           case oWithFingerprint:
2685             opt.with_fingerprint = 1;
2686             opt.fingerprint++;
2687             break;
2688           case oWithICAOSpelling:
2689             opt.with_icao_spelling = 1;
2690             break;
2691           case oFingerprint:
2692             opt.fingerprint++;
2693             fpr_maybe_cmd = 1;
2694             break;
2695
2696           case oWithKeygrip:
2697             opt.with_keygrip = 1;
2698             break;
2699
2700           case oWithSecret:
2701             opt.with_secret = 1;
2702             break;
2703
2704           case oSecretKeyring:
2705             /* Ignore this old option.  */
2706             break;
2707
2708           case oOptions:
2709             /* config files may not be nested (silently ignore them) */
2710             if( !configfp ) {
2711                 xfree(configname);
2712                 configname = xstrdup(pargs.r.ret_str);
2713                 goto next_pass;
2714             }
2715             break;
2716           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
2717           case oNoDefKeyring: default_keyring = 0; break;
2718           case oNoGreeting: nogreeting = 1; break;
2719           case oNoVerbose:
2720             opt.verbose = 0;
2721             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2722             opt.list_sigs=0;
2723             break;
2724           case oQuickRandom:
2725             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
2726             break;
2727           case oEmitVersion: opt.emit_version++; break;
2728           case oNoEmitVersion: opt.emit_version=0; break;
2729           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
2730           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
2731           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
2732
2733 #ifndef NO_TRUST_MODELS
2734           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
2735
2736 #endif /*!NO_TRUST_MODELS*/
2737           case oDefaultKey:
2738             sl = add_to_strlist (&opt.def_secret_key, pargs.r.ret_str);
2739             sl->flags = (pargs.r_opt << 2);
2740             break;
2741           case oDefRecipient:
2742             if( *pargs.r.ret_str )
2743               {
2744                 xfree (opt.def_recipient);
2745                 opt.def_recipient = make_username(pargs.r.ret_str);
2746               }
2747             break;
2748           case oDefRecipientSelf:
2749             xfree(opt.def_recipient); opt.def_recipient = NULL;
2750             opt.def_recipient_self = 1;
2751             break;
2752           case oNoDefRecipient:
2753             xfree(opt.def_recipient); opt.def_recipient = NULL;
2754             opt.def_recipient_self = 0;
2755             break;
2756           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
2757           case oHomedir: break;
2758           case oNoBatch: opt.batch = 0; break;
2759
2760           case oWithKeyData: opt.with_key_data=1; /*FALLTHRU*/
2761           case oWithColons: opt.with_colons=':'; break;
2762
2763           case oWithSigCheck: opt.check_sigs = 1; /*FALLTHRU*/
2764           case oWithSigList: opt.list_sigs = 1; break;
2765
2766           case oSkipVerify: opt.skip_verify=1; break;
2767
2768           case oSkipHiddenRecipients: opt.skip_hidden_recipients = 1; break;
2769           case oNoSkipHiddenRecipients: opt.skip_hidden_recipients = 0; break;
2770
2771           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
2772
2773 #ifndef NO_TRUST_MODELS
2774             /* There are many programs (like mutt) that call gpg with
2775                --always-trust so keep this option around for a long
2776                time. */
2777           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
2778           case oTrustModel:
2779             parse_trust_model(pargs.r.ret_str);
2780             break;
2781 #endif /*!NO_TRUST_MODELS*/
2782           case oTOFUDefaultPolicy:
2783             opt.tofu_default_policy = parse_tofu_policy (pargs.r.ret_str);
2784             break;
2785           case oTOFUDBFormat:
2786             opt.tofu_db_format = parse_tofu_db_format (pargs.r.ret_str);
2787             break;
2788
2789           case oForceOwnertrust:
2790             log_info(_("Note: %s is not for normal use!\n"),
2791                      "--force-ownertrust");
2792             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
2793             if(opt.force_ownertrust==-1)
2794               {
2795                 log_error("invalid ownertrust '%s'\n",pargs.r.ret_str);
2796                 opt.force_ownertrust=0;
2797               }
2798             break;
2799           case oLoadExtension:
2800             /* Dummy so that gpg 1.4 conf files can work. Should
2801                eventually be removed.  */
2802             break;
2803           case oOpenPGP:
2804           case oRFC4880:
2805             /* This is effectively the same as RFC2440, but with
2806                "--enable-dsa2 --no-rfc2440-text --escape-from-lines
2807                --require-cross-certification". */
2808             opt.compliance = CO_RFC4880;
2809             opt.flags.dsa2 = 1;
2810             opt.flags.require_cross_cert = 1;
2811             opt.rfc2440_text = 0;
2812             opt.allow_non_selfsigned_uid = 1;
2813             opt.allow_freeform_uid = 1;
2814             opt.escape_from = 1;
2815             opt.not_dash_escaped = 0;
2816             opt.def_cipher_algo = 0;
2817             opt.def_digest_algo = 0;
2818             opt.cert_digest_algo = 0;
2819             opt.compress_algo = -1;
2820             opt.s2k_mode = 3; /* iterated+salted */
2821             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2822             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2823             break;
2824           case oRFC2440:
2825             opt.compliance = CO_RFC2440;
2826             opt.flags.dsa2 = 0;
2827             opt.rfc2440_text = 1;
2828             opt.allow_non_selfsigned_uid = 1;
2829             opt.allow_freeform_uid = 1;
2830             opt.escape_from = 0;
2831             opt.not_dash_escaped = 0;
2832             opt.def_cipher_algo = 0;
2833             opt.def_digest_algo = 0;
2834             opt.cert_digest_algo = 0;
2835             opt.compress_algo = -1;
2836             opt.s2k_mode = 3; /* iterated+salted */
2837             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2838             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2839             break;
2840           case oPGP6:  opt.compliance = CO_PGP6;  break;
2841           case oPGP7:  opt.compliance = CO_PGP7;  break;
2842           case oPGP8:  opt.compliance = CO_PGP8;  break;
2843           case oGnuPG: opt.compliance = CO_GNUPG; break;
2844           case oRFC2440Text: opt.rfc2440_text=1; break;
2845           case oNoRFC2440Text: opt.rfc2440_text=0; break;
2846           case oSetFilename:
2847             if(utf8_strings)
2848               opt.set_filename = pargs.r.ret_str;
2849             else
2850               opt.set_filename = native_to_utf8(pargs.r.ret_str);
2851             break;
2852           case oForYourEyesOnly: eyes_only = 1; break;
2853           case oNoForYourEyesOnly: eyes_only = 0; break;
2854           case oSetPolicyURL:
2855             add_policy_url(pargs.r.ret_str,0);
2856             add_policy_url(pargs.r.ret_str,1);
2857             break;
2858           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
2859           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
2860           case oShowPolicyURL:
2861             deprecated_warning(configname,configlineno,"--show-policy-url",
2862                                "--list-options ","show-policy-urls");
2863             deprecated_warning(configname,configlineno,"--show-policy-url",
2864                                "--verify-options ","show-policy-urls");
2865             opt.list_options|=LIST_SHOW_POLICY_URLS;
2866             opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
2867             break;
2868           case oNoShowPolicyURL:
2869             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2870                                "--list-options ","no-show-policy-urls");
2871             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2872                                "--verify-options ","no-show-policy-urls");
2873             opt.list_options&=~LIST_SHOW_POLICY_URLS;
2874             opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
2875             break;
2876           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
2877           case oUseEmbeddedFilename:
2878             opt.flags.use_embedded_filename=1;
2879             break;
2880           case oNoUseEmbeddedFilename:
2881             opt.flags.use_embedded_filename=0;
2882             break;
2883           case oComment:
2884             if(pargs.r.ret_str[0])
2885               append_to_strlist(&opt.comments,pargs.r.ret_str);
2886             break;
2887           case oDefaultComment:
2888             deprecated_warning(configname,configlineno,
2889                                "--default-comment","--no-comments","");
2890             /* fall through */
2891           case oNoComments:
2892             free_strlist(opt.comments);
2893             opt.comments=NULL;
2894             break;
2895           case oThrowKeyids: opt.throw_keyids = 1; break;
2896           case oNoThrowKeyids: opt.throw_keyids = 0; break;
2897           case oShowPhotos:
2898             deprecated_warning(configname,configlineno,"--show-photos",
2899                                "--list-options ","show-photos");
2900             deprecated_warning(configname,configlineno,"--show-photos",
2901                                "--verify-options ","show-photos");
2902             opt.list_options|=LIST_SHOW_PHOTOS;
2903             opt.verify_options|=VERIFY_SHOW_PHOTOS;
2904             break;
2905           case oNoShowPhotos:
2906             deprecated_warning(configname,configlineno,"--no-show-photos",
2907                                "--list-options ","no-show-photos");
2908             deprecated_warning(configname,configlineno,"--no-show-photos",
2909                                "--verify-options ","no-show-photos");
2910             opt.list_options&=~LIST_SHOW_PHOTOS;
2911             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
2912             break;
2913           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
2914
2915           case oForceMDC: opt.force_mdc = 1; break;
2916           case oNoForceMDC: opt.force_mdc = 0; break;
2917           case oDisableMDC: opt.disable_mdc = 1; break;
2918           case oNoDisableMDC: opt.disable_mdc = 0; break;
2919           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
2920           case oS2KDigest: s2k_digest_string = xstrdup(pargs.r.ret_str); break;
2921           case oS2KCipher: s2k_cipher_string = xstrdup(pargs.r.ret_str); break;
2922           case oS2KCount:
2923             if (pargs.r.ret_int)
2924               opt.s2k_count = encode_s2k_iterations (pargs.r.ret_int);
2925             else
2926               opt.s2k_count = 0;  /* Auto-calibrate when needed.  */
2927             break;
2928           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
2929           case oEncryptTo: /* store the recipient in the second list */
2930             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2931             sl->flags = (pargs.r_opt << 2) | 1;
2932             break;
2933           case oHiddenEncryptTo: /* store the recipient in the second list */
2934             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2935             sl->flags = (pargs.r_opt << 2) | 1|2;
2936             break;
2937           case oEncryptToDefaultKey:
2938             opt.encrypt_to_default_key = 1;
2939             break;
2940           case oRecipient: /* store the recipient */
2941             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2942             sl->flags = (pargs.r_opt << 2);
2943             any_explicit_recipient = 1;
2944             break;
2945           case oHiddenRecipient: /* store the recipient with a flag */
2946             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2947             sl->flags = (pargs.r_opt << 2) | 2;
2948             any_explicit_recipient = 1;
2949             break;
2950
2951           case oTrySecretKey:
2952             add_to_strlist2 (&opt.secret_keys_to_try,
2953                              pargs.r.ret_str, utf8_strings);
2954             break;
2955
2956           case oTextmodeShort: opt.textmode = 2; break;
2957           case oTextmode: opt.textmode=1;  break;
2958           case oNoTextmode: opt.textmode=0;  break;
2959           case oExpert: opt.expert = 1; break;
2960           case oNoExpert: opt.expert = 0; break;
2961           case oDefSigExpire:
2962             if(*pargs.r.ret_str!='\0')
2963               {
2964                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
2965                   log_error(_("'%s' is not a valid signature expiration\n"),
2966                             pargs.r.ret_str);
2967                 else
2968                   opt.def_sig_expire=pargs.r.ret_str;
2969               }
2970             break;
2971           case oAskSigExpire: opt.ask_sig_expire = 1; break;
2972           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
2973           case oDefCertExpire:
2974             if(*pargs.r.ret_str!='\0')
2975               {
2976                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
2977                   log_error(_("'%s' is not a valid signature expiration\n"),
2978                             pargs.r.ret_str);
2979                 else
2980                   opt.def_cert_expire=pargs.r.ret_str;
2981               }
2982             break;
2983           case oAskCertExpire: opt.ask_cert_expire = 1; break;
2984           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
2985           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
2986           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
2987           case oAskCertLevel: opt.ask_cert_level = 1; break;
2988           case oNoAskCertLevel: opt.ask_cert_level = 0; break;
2989           case oLocalUser: /* store the local users */
2990             sl = add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
2991             sl->flags = (pargs.r_opt << 2);
2992             break;
2993           case oCompress:
2994             /* this is the -z command line option */
2995             opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
2996             break;
2997           case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
2998           case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
2999           case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
3000           case oPassphrase:
3001             set_passphrase_from_string(pargs.r.ret_str);
3002             break;
3003           case oPassphraseFD:
3004             pwfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
3005             break;
3006           case oPassphraseFile:
3007             pwfd = open_info_file (pargs.r.ret_str, 0, 1);
3008             break;
3009           case oPassphraseRepeat:
3010             opt.passphrase_repeat = pargs.r.ret_int;
3011             break;
3012
3013           case oPinentryMode:
3014             opt.pinentry_mode = parse_pinentry_mode (pargs.r.ret_str);
3015             if (opt.pinentry_mode == -1)
3016               log_error (_("invalid pinentry mode '%s'\n"), pargs.r.ret_str);
3017             break;
3018
3019           case oCommandFD:
3020             opt.command_fd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
3021             break;
3022           case oCommandFile:
3023             opt.command_fd = open_info_file (pargs.r.ret_str, 0, 1);
3024             break;
3025           case oCipherAlgo:
3026             def_cipher_string = xstrdup(pargs.r.ret_str);
3027             break;
3028           case oDigestAlgo:
3029             def_digest_string = xstrdup(pargs.r.ret_str);
3030             break;
3031           case oCompressAlgo:
3032             /* If it is all digits, stick a Z in front of it for
3033                later.  This is for backwards compatibility with
3034                versions that took the compress algorithm number. */
3035             {
3036               char *pt=pargs.r.ret_str;
3037               while(*pt)
3038                 {
3039                   if (!isascii (*pt) || !isdigit (*pt))
3040                     break;
3041
3042                   pt++;
3043                 }
3044
3045               if(*pt=='\0')
3046                 {
3047                   compress_algo_string=xmalloc(strlen(pargs.r.ret_str)+2);
3048                   strcpy(compress_algo_string,"Z");
3049                   strcat(compress_algo_string,pargs.r.ret_str);
3050                 }
3051               else
3052                 compress_algo_string = xstrdup(pargs.r.ret_str);
3053             }
3054             break;
3055           case oCertDigestAlgo:
3056             cert_digest_string = xstrdup(pargs.r.ret_str);
3057             break;
3058
3059           case oNoSecmemWarn:
3060             gcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
3061             break;
3062
3063           case oRequireSecmem: require_secmem=1; break;
3064           case oNoRequireSecmem: require_secmem=0; break;
3065           case oNoPermissionWarn: opt.no_perm_warn=1; break;
3066           case oNoMDCWarn: opt.no_mdc_warn=1; break;
3067           case oDisplayCharset:
3068             if( set_native_charset( pargs.r.ret_str ) )
3069                 log_error(_("'%s' is not a valid character set\n"),
3070                           pargs.r.ret_str);
3071             break;
3072           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
3073           case oEscapeFrom: opt.escape_from = 1; break;
3074           case oNoEscapeFrom: opt.escape_from = 0; break;
3075           case oLockOnce: opt.lock_once = 1; break;
3076           case oLockNever:
3077             dotlock_disable ();
3078             break;
3079           case oLockMultiple:
3080 #ifndef __riscos__
3081             opt.lock_once = 0;
3082 #else /* __riscos__ */
3083             riscos_not_implemented("lock-multiple");
3084 #endif /* __riscos__ */
3085             break;
3086           case oKeyServer:
3087             {
3088               keyserver_spec_t keyserver;
3089               keyserver = parse_keyserver_uri (pargs.r.ret_str, 0);
3090               if (!keyserver)
3091                 log_error (_("could not parse keyserver URL\n"));
3092               else
3093                 {
3094                   /* We only support a single keyserver.  Later ones
3095                      override earlier ones.  (Since we parse the
3096                      config file first and then the command line
3097                      arguments, the command line takes
3098                      precedence.)  */
3099                   if (opt.keyserver)
3100                     free_keyserver_spec (opt.keyserver);
3101                   opt.keyserver = keyserver;
3102                 }
3103             }
3104             break;
3105           case oKeyServerOptions:
3106             if(!parse_keyserver_options(pargs.r.ret_str))
3107               {
3108                 if(configname)
3109                   log_error(_("%s:%d: invalid keyserver options\n"),
3110                             configname,configlineno);
3111                 else
3112                   log_error(_("invalid keyserver options\n"));
3113               }
3114             break;
3115           case oImportOptions:
3116             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
3117               {
3118                 if(configname)
3119                   log_error(_("%s:%d: invalid import options\n"),
3120                             configname,configlineno);
3121                 else
3122                   log_error(_("invalid import options\n"));
3123               }
3124             break;
3125           case oExportOptions:
3126             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
3127               {
3128                 if(configname)
3129                   log_error(_("%s:%d: invalid export options\n"),
3130                             configname,configlineno);
3131                 else
3132                   log_error(_("invalid export options\n"));
3133               }
3134             break;
3135           case oListOptions:
3136             if(!parse_list_options(pargs.r.ret_str))
3137               {
3138                 if(configname)
3139                   log_error(_("%s:%d: invalid list options\n"),
3140                             configname,configlineno);
3141                 else
3142                   log_error(_("invalid list options\n"));
3143               }
3144             break;
3145           case oVerifyOptions:
3146             {
3147               struct parse_options vopts[]=
3148                 {
3149                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL,
3150                    N_("display photo IDs during signature verification")},
3151                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL,
3152                    N_("show policy URLs during signature verification")},
3153                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL,
3154                    N_("show all notations during signature verification")},
3155                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
3156                    N_("show IETF standard notations during signature verification")},
3157                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
3158                    NULL},
3159                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL,
3160                    N_("show user-supplied notations during signature verification")},
3161                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL,
3162                    N_("show preferred keyserver URLs during signature verification")},
3163                   {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL,
3164                    N_("show user ID validity during signature verification")},
3165                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL,
3166                    N_("show revoked and expired user IDs in signature verification")},
3167                   {"show-primary-uid-only",VERIFY_SHOW_PRIMARY_UID_ONLY,NULL,
3168                    N_("show only the primary user ID in signature verification")},
3169                   {"pka-lookups",VERIFY_PKA_LOOKUPS,NULL,
3170                    N_("validate signatures with PKA data")},
3171                   {"pka-trust-increase",VERIFY_PKA_TRUST_INCREASE,NULL,
3172                    N_("elevate the trust of signatures with valid PKA data")},
3173                   {NULL,0,NULL,NULL}
3174                 };
3175
3176               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
3177                 {
3178                   if(configname)
3179                     log_error(_("%s:%d: invalid verify options\n"),
3180                               configname,configlineno);
3181                   else
3182                     log_error(_("invalid verify options\n"));
3183                 }
3184             }
3185             break;
3186           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
3187           case oExecPath:
3188             if(set_exec_path(pargs.r.ret_str))
3189               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
3190             else
3191               opt.exec_path_set=1;
3192             break;
3193           case oSetNotation:
3194             add_notation_data( pargs.r.ret_str, 0 );
3195             add_notation_data( pargs.r.ret_str, 1 );
3196             break;
3197           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
3198           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
3199           case oShowNotation:
3200             deprecated_warning(configname,configlineno,"--show-notation",
3201                                "--list-options ","show-notations");
3202             deprecated_warning(configname,configlineno,"--show-notation",
3203                                "--verify-options ","show-notations");
3204             opt.list_options|=LIST_SHOW_NOTATIONS;
3205             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
3206             break;
3207           case oNoShowNotation:
3208             deprecated_warning(configname,configlineno,"--no-show-notation",
3209                                "--list-options ","no-show-notations");
3210             deprecated_warning(configname,configlineno,"--no-show-notation",
3211                                "--verify-options ","no-show-notations");
3212             opt.list_options&=~LIST_SHOW_NOTATIONS;
3213             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
3214             break;
3215           case oUtf8Strings: utf8_strings = 1; break;
3216           case oNoUtf8Strings: utf8_strings = 0; break;
3217           case oDisableCipherAlgo:
3218             {
3219               int algo = string_to_cipher_algo (pargs.r.ret_str);
3220               gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
3221             }
3222             break;
3223           case oDisablePubkeyAlgo:
3224             {
3225               int algo = gcry_pk_map_name (pargs.r.ret_str);
3226               gcry_pk_ctl (GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
3227             }
3228             break;
3229           case oNoSigCache: opt.no_sig_cache = 1; break;
3230           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
3231           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
3232           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
3233           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
3234           case oNoLiteral: opt.no_literal = 1; break;
3235           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
3236           case oFastListMode: opt.fast_list_mode = 1; break;
3237           case oFixedListMode: /* Dummy */ break;
3238           case oLegacyListMode: opt.legacy_list_mode = 1; break;
3239           case oPrintPKARecords: opt.print_pka_records = 1; break;
3240           case oPrintDANERecords: opt.print_dane_records = 1; break;
3241           case oListOnly: opt.list_only=1; break;
3242           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
3243           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
3244           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
3245           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
3246           case oNoRandomSeedFile: use_random_seed = 0; break;
3247           case oAutoKeyRetrieve:
3248           case oNoAutoKeyRetrieve:
3249                 if(pargs.r_opt==oAutoKeyRetrieve)
3250                   opt.keyserver_options.options|=KEYSERVER_AUTO_KEY_RETRIEVE;
3251                 else
3252                   opt.keyserver_options.options&=~KEYSERVER_AUTO_KEY_RETRIEVE;
3253
3254                 deprecated_warning(configname,configlineno,
3255                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
3256                                "--no-auto-key-retrieve","--keyserver-options ",
3257                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
3258                                "no-auto-key-retrieve");
3259                 break;
3260           case oShowSessionKey: opt.show_session_key = 1; break;
3261           case oOverrideSessionKey:
3262                 opt.override_session_key = pargs.r.ret_str;
3263                 break;
3264           case oMergeOnly:
3265                 deprecated_warning(configname,configlineno,"--merge-only",
3266                                    "--import-options ","merge-only");
3267                 opt.import_options|=IMPORT_MERGE_ONLY;
3268             break;
3269           case oAllowSecretKeyImport: /* obsolete */ break;
3270           case oTryAllSecrets: opt.try_all_secrets = 1; break;
3271           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
3272           case oEnableSpecialFilenames:
3273             iobuf_enable_special_filenames (1);
3274             break;
3275           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
3276           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
3277           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
3278           case oPreservePermissions: opt.preserve_permissions=1; break;
3279           case oDefaultPreferenceList:
3280             opt.def_preference_list = pargs.r.ret_str;
3281             break;
3282           case oDefaultKeyserverURL:
3283             {
3284               keyserver_spec_t keyserver;
3285               keyserver = parse_keyserver_uri (pargs.r.ret_str,1 );
3286               if (!keyserver)
3287                 log_error (_("could not parse keyserver URL\n"));
3288               else
3289                 free_keyserver_spec (keyserver);
3290
3291               opt.def_keyserver_url = pargs.r.ret_str;
3292             }
3293             break;
3294           case oPersonalCipherPreferences:
3295             pers_cipher_list=pargs.r.ret_str;
3296             break;
3297           case oPersonalDigestPreferences:
3298             pers_digest_list=pargs.r.ret_str;
3299             break;
3300           case oPersonalCompressPreferences:
3301             pers_compress_list=pargs.r.ret_str;
3302             break;
3303           case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
3304           case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str; break;
3305           case oWeakDigest:
3306             additional_weak_digest(pargs.r.ret_str);
3307             break;
3308           case oUnwrap:
3309             opt.unwrap_encryption = 1;
3310             break;
3311
3312           case oDisplay:
3313             set_opt_session_env ("DISPLAY", pargs.r.ret_str);
3314             break;
3315           case oTTYname:
3316             set_opt_session_env ("GPG_TTY", pargs.r.ret_str);
3317             break;
3318           case oTTYtype:
3319             set_opt_session_env ("TERM", pargs.r.ret_str);
3320             break;
3321           case oXauthority:
3322             set_opt_session_env ("XAUTHORITY", pargs.r.ret_str);
3323             break;
3324
3325           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
3326           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
3327
3328           case oGroup: add_group(pargs.r.ret_str); break;
3329           case oUnGroup: rm_group(pargs.r.ret_str); break;
3330           case oNoGroups:
3331             while(opt.grouplist)
3332               {
3333                 struct groupitem *iter=opt.grouplist;
3334                 free_strlist(iter->values);
3335                 opt.grouplist=opt.grouplist->next;
3336                 xfree(iter);
3337               }
3338             break;
3339
3340           case oStrict:
3341           case oNoStrict:
3342             /* Not used */
3343             break;
3344
3345           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
3346           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
3347           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
3348           case oMultifile: multifile=1; break;
3349           case oKeyidFormat:
3350             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
3351               opt.keyid_format=KF_SHORT;
3352             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
3353               opt.keyid_format=KF_LONG;
3354             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
3355               opt.keyid_format=KF_0xSHORT;
3356             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
3357               opt.keyid_format=KF_0xLONG;
3358             else
3359               log_error("unknown keyid-format '%s'\n",pargs.r.ret_str);
3360             break;
3361
3362           case oExitOnStatusWriteError:
3363             opt.exit_on_status_write_error = 1;
3364             break;
3365
3366           case oLimitCardInsertTries:
3367             opt.limit_card_insert_tries = pargs.r.ret_int;
3368             break;
3369
3370           case oRequireCrossCert: opt.flags.require_cross_cert=1; break;
3371           case oNoRequireCrossCert: opt.flags.require_cross_cert=0; break;
3372
3373           case oAutoKeyLocate:
3374             if(!parse_auto_key_locate(pargs.r.ret_str))
3375               {
3376                 if(configname)
3377                   log_error(_("%s:%d: invalid auto-key-locate list\n"),
3378                             configname,configlineno);
3379                 else
3380                   log_error(_("invalid auto-key-locate list\n"));
3381               }
3382             break;
3383           case oNoAutoKeyLocate:
3384             release_akl();
3385             break;
3386
3387           case oEnableLargeRSA:
3388 #if SECMEM_BUFFER_SIZE >= 65536
3389             opt.flags.large_rsa=1;
3390 #else
3391             if (configname)
3392               log_info("%s:%d: WARNING: gpg not built with large secure "
3393                          "memory buffer.  Ignoring enable-large-rsa\n",
3394                         configname,configlineno);
3395             else
3396               log_info("WARNING: gpg not built with large secure "
3397                          "memory buffer.  Ignoring --enable-large-rsa\n");
3398 #endif /* SECMEM_BUFFER_SIZE >= 65536 */
3399             break;
3400           case oDisableLargeRSA: opt.flags.large_rsa=0;
3401             break;
3402
3403           case oEnableDSA2: opt.flags.dsa2=1; break;
3404           case oDisableDSA2: opt.flags.dsa2=0; break;
3405
3406           case oAllowMultisigVerification:
3407           case oAllowMultipleMessages:
3408             opt.flags.allow_multiple_messages=1;
3409             break;
3410
3411           case oNoAllowMultipleMessages:
3412             opt.flags.allow_multiple_messages=0;
3413             break;
3414
3415           case oAllowWeakDigestAlgos:
3416             opt.flags.allow_weak_digest_algos = 1;
3417             break;
3418
3419           case oFakedSystemTime:
3420             {
3421               time_t faked_time = isotime2epoch (pargs.r.ret_str);
3422               if (faked_time == (time_t)(-1))
3423                 faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
3424               gnupg_set_time (faked_time, 0);
3425             }
3426             break;
3427
3428           case oNoAutostart: opt.autostart = 0; break;
3429
3430           case oNoop: break;
3431
3432           default:
3433             pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR;
3434             break;
3435           }
3436       }
3437
3438     if (configfp)
3439       {
3440         fclose( configfp );
3441         configfp = NULL;
3442         /* Remember the first config file name. */
3443         if (!save_configname)
3444           save_configname = configname;
3445         else
3446           xfree(configname);
3447         configname = NULL;
3448         goto next_pass;
3449       }
3450     xfree(configname); configname = NULL;
3451     if (log_get_errorcount (0))
3452       g10_exit(2);
3453
3454     /* The command --gpgconf-list is pretty simple and may be called
3455        directly after the option parsing. */
3456     if (cmd == aGPGConfList)
3457       {
3458         gpgconf_list (save_configname ? save_configname : default_configname);
3459         g10_exit (0);
3460       }
3461     xfree (save_configname);
3462     xfree (default_configname);
3463
3464     if( nogreeting )
3465         greeting = 0;
3466
3467     if( greeting )
3468       {
3469         es_fprintf (es_stderr, "%s %s; %s\n",
3470                     strusage(11), strusage(13), strusage(14) );
3471         es_fprintf (es_stderr, "%s\n", strusage(15) );
3472       }
3473 #ifdef IS_DEVELOPMENT_VERSION
3474     if (!opt.batch)
3475       {
3476         const char *s;
3477
3478         if((s=strusage(25)))
3479           log_info("%s\n",s);
3480         if((s=strusage(26)))
3481           log_info("%s\n",s);
3482         if((s=strusage(27)))
3483           log_info("%s\n",s);
3484       }
3485 #endif
3486
3487     /* FIXME: We should use logging to a file only in server mode;
3488        however we have not yet implemetyed that.  Thus we try to get
3489        away with --batch as indication for logging to file
3490        required. */
3491     if (logfile && opt.batch)
3492       {
3493         log_set_file (logfile);
3494         log_set_prefix (NULL, 1|2|4);
3495       }
3496
3497     if (opt.verbose > 2)
3498         log_info ("using character set '%s'\n", get_native_charset ());
3499
3500     if( may_coredump && !opt.quiet )
3501         log_info(_("WARNING: program may create a core file!\n"));
3502
3503     if (eyes_only) {
3504       if (opt.set_filename)
3505           log_info(_("WARNING: %s overrides %s\n"),
3506                    "--for-your-eyes-only","--set-filename");
3507
3508       opt.set_filename="_CONSOLE";
3509     }
3510
3511     if (opt.no_literal) {
3512         log_info(_("Note: %s is not for normal use!\n"), "--no-literal");
3513         if (opt.textmode)
3514             log_error(_("%s not allowed with %s!\n"),
3515                        "--textmode", "--no-literal" );
3516         if (opt.set_filename)
3517             log_error(_("%s makes no sense with %s!\n"),
3518                         eyes_only?"--for-your-eyes-only":"--set-filename",
3519                         "--no-literal" );
3520     }
3521
3522
3523     if (opt.set_filesize)
3524         log_info(_("Note: %s is not for normal use!\n"), "--set-filesize");
3525     if( opt.batch )
3526         tty_batchmode( 1 );
3527
3528     if (gnupg_faked_time_p ())
3529       {
3530         gnupg_isotime_t tbuf;
3531
3532         log_info (_("WARNING: running with faked system time: "));
3533         gnupg_get_isotime (tbuf);
3534         dump_isotime (tbuf);
3535         log_printf ("\n");
3536       }
3537
3538     /* Print a warning if an argument looks like an option.  */
3539     if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
3540       {
3541         int i;
3542
3543         for (i=0; i < argc; i++)
3544           if (argv[i][0] == '-' && argv[i][1] == '-')
3545             log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
3546       }
3547
3548
3549     gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
3550
3551     if(require_secmem && !got_secmem)
3552       {
3553         log_info(_("will not run with insecure memory due to %s\n"),
3554                  "--require-secmem");
3555         g10_exit(2);
3556       }
3557
3558     set_debug (debug_level);
3559     if (DBG_CLOCK)
3560       log_clock ("start");
3561
3562     /* Do these after the switch(), so they can override settings. */
3563     if(PGP6)
3564       {
3565         /* That does not anymore work becuase we have no more support
3566            for v3 signatures.  */
3567         opt.disable_mdc=1;
3568         opt.escape_from=1;
3569         opt.ask_sig_expire=0;
3570       }
3571     else if(PGP7)
3572       {
3573         /* That does not anymore work because we have no more support
3574            for v3 signatures.  */
3575         opt.escape_from=1;
3576         opt.ask_sig_expire=0;
3577       }
3578     else if(PGP8)
3579       {
3580         opt.escape_from=1;
3581       }
3582
3583
3584     if( def_cipher_string ) {
3585         opt.def_cipher_algo = string_to_cipher_algo (def_cipher_string);
3586         xfree(def_cipher_string); def_cipher_string = NULL;
3587         if ( openpgp_cipher_test_algo (opt.def_cipher_algo) )
3588             log_error(_("selected cipher algorithm is invalid\n"));
3589     }
3590     if( def_digest_string ) {
3591         opt.def_digest_algo = string_to_digest_algo (def_digest_string);
3592         xfree(def_digest_string); def_digest_string = NULL;
3593         if ( openpgp_md_test_algo (opt.def_digest_algo) )
3594             log_error(_("selected digest algorithm is invalid\n"));
3595     }
3596     if( compress_algo_string ) {
3597         opt.compress_algo = string_to_compress_algo(compress_algo_string);
3598         xfree(compress_algo_string); compress_algo_string = NULL;
3599         if( check_compress_algo(opt.compress_algo) )
3600           log_error(_("selected compression algorithm is invalid\n"));
3601     }
3602     if( cert_digest_string ) {
3603         opt.cert_digest_algo = string_to_digest_algo (cert_digest_string);
3604         xfree(cert_digest_string); cert_digest_string = NULL;
3605         if (openpgp_md_test_algo(opt.cert_digest_algo))
3606           log_error(_("selected certification digest algorithm is invalid\n"));
3607     }
3608     if( s2k_cipher_string ) {
3609         opt.s2k_cipher_algo = string_to_cipher_algo (s2k_cipher_string);
3610         xfree(s2k_cipher_string); s2k_cipher_string = NULL;
3611         if (openpgp_cipher_test_algo (opt.s2k_cipher_algo))
3612           log_error(_("selected cipher algorithm is invalid\n"));
3613     }
3614     if( s2k_digest_string ) {
3615         opt.s2k_digest_algo = string_to_digest_algo (s2k_digest_string);
3616         xfree(s2k_digest_string); s2k_digest_string = NULL;
3617         if (openpgp_md_test_algo(opt.s2k_digest_algo))
3618           log_error(_("selected digest algorithm is invalid\n"));
3619     }
3620     if( opt.completes_needed < 1 )
3621       log_error(_("completes-needed must be greater than 0\n"));
3622     if( opt.marginals_needed < 2 )
3623       log_error(_("marginals-needed must be greater than 1\n"));
3624     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
3625       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
3626     if(opt.def_cert_level<0 || opt.def_cert_level>3)
3627       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
3628     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
3629       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
3630     switch( opt.s2k_mode ) {
3631       case 0:
3632         log_info(_("Note: simple S2K mode (0) is strongly discouraged\n"));
3633         break;
3634       case 1: case 3: break;
3635       default:
3636         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
3637     }
3638
3639     /* This isn't actually needed, but does serve to error out if the
3640        string is invalid. */
3641     if(opt.def_preference_list &&
3642         keygen_set_std_prefs(opt.def_preference_list,0))
3643       log_error(_("invalid default preferences\n"));
3644
3645     if(pers_cipher_list &&
3646        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
3647       log_error(_("invalid personal cipher preferences\n"));
3648
3649     if(pers_digest_list &&
3650        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
3651       log_error(_("invalid personal digest preferences\n"));
3652
3653     if(pers_compress_list &&
3654        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
3655       log_error(_("invalid personal compress preferences\n"));
3656
3657     /* We don't support all possible commands with multifile yet */
3658     if(multifile)
3659       {
3660         char *cmdname;
3661
3662         switch(cmd)
3663           {
3664           case aSign:
3665             cmdname="--sign";
3666             break;
3667           case aSignEncr:
3668             cmdname="--sign --encrypt";
3669             break;
3670           case aClearsign:
3671             cmdname="--clearsign";
3672             break;
3673           case aDetachedSign:
3674             cmdname="--detach-sign";
3675             break;
3676           case aSym:
3677             cmdname="--symmetric";
3678             break;
3679           case aEncrSym:
3680             cmdname="--symmetric --encrypt";
3681             break;
3682           case aStore:
3683             cmdname="--store";
3684             break;
3685           default:
3686             cmdname=NULL;
3687             break;
3688           }
3689
3690         if(cmdname)
3691           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
3692       }
3693
3694     if( log_get_errorcount(0) )
3695         g10_exit(2);
3696
3697     if(opt.compress_level==0)
3698       opt.compress_algo=COMPRESS_ALGO_NONE;
3699
3700     /* Check our chosen algorithms against the list of legal
3701        algorithms. */
3702
3703     if(!GNUPG)
3704       {
3705         const char *badalg=NULL;
3706         preftype_t badtype=PREFTYPE_NONE;
3707
3708         if(opt.def_cipher_algo
3709            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
3710           {
3711             badalg = openpgp_cipher_algo_name (opt.def_cipher_algo);
3712             badtype = PREFTYPE_SYM;
3713           }
3714         else if(opt.def_digest_algo
3715                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
3716           {
3717             badalg = gcry_md_algo_name (opt.def_digest_algo);
3718             badtype = PREFTYPE_HASH;
3719           }
3720         else if(opt.cert_digest_algo
3721                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
3722           {
3723             badalg = gcry_md_algo_name (opt.cert_digest_algo);
3724             badtype = PREFTYPE_HASH;
3725           }
3726         else if(opt.compress_algo!=-1
3727                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
3728           {
3729             badalg = compress_algo_to_string(opt.compress_algo);
3730             badtype = PREFTYPE_ZIP;
3731           }
3732
3733         if(badalg)
3734           {
3735             switch(badtype)
3736               {
3737               case PREFTYPE_SYM:
3738                 log_info(_("you may not use cipher algorithm '%s'"
3739                            " while in %s mode\n"),
3740                          badalg,compliance_option_string());
3741                 break;
3742               case PREFTYPE_HASH:
3743                 log_info(_("you may not use digest algorithm '%s'"
3744                            " while in %s mode\n"),
3745                          badalg,compliance_option_string());
3746                 break;
3747               case PREFTYPE_ZIP:
3748                 log_info(_("you may not use compression algorithm '%s'"
3749                            " while in %s mode\n"),
3750                          badalg,compliance_option_string());
3751                 break;
3752               default:
3753                 BUG();
3754               }
3755
3756             compliance_failure();
3757           }
3758       }
3759
3760     /* Set the random seed file. */
3761     if( use_random_seed ) {
3762         char *p = make_filename(opt.homedir, "random_seed", NULL );
3763         gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
3764         if (!access (p, F_OK))
3765           register_secured_file (p);
3766         xfree(p);
3767     }
3768
3769     /* If there is no command but the --fingerprint is given, default
3770        to the --list-keys command.  */
3771     if (!cmd && fpr_maybe_cmd)
3772       {
3773         set_cmd (&cmd, aListKeys);
3774       }
3775
3776
3777     if( opt.verbose > 1 )
3778         set_packet_list_mode(1);
3779
3780     /* Add the keyrings, but not for some special commands.
3781        We always need to add the keyrings if we are running under
3782        SELinux, this is so that the rings are added to the list of
3783        secured files. */
3784     if( ALWAYS_ADD_KEYRINGS
3785         || (cmd != aDeArmor && cmd != aEnArmor && cmd != aGPGConfTest) )
3786       {
3787         if (!nrings || default_keyring)  /* Add default ring. */
3788             keydb_add_resource ("pubring" EXTSEP_S GPGEXT_GPG,
3789                                 KEYDB_RESOURCE_FLAG_DEFAULT);
3790         for (sl = nrings; sl; sl = sl->next )
3791           keydb_add_resource (sl->d, sl->flags);
3792       }
3793     FREE_STRLIST(nrings);
3794
3795     if (opt.pinentry_mode == PINENTRY_MODE_LOOPBACK)
3796       /* In loopback mode, never ask for the password multiple
3797          times.  */
3798       {
3799         opt.passphrase_repeat = 0;
3800       }
3801
3802     if (cmd == aGPGConfTest)
3803       g10_exit(0);
3804
3805
3806     if( pwfd != -1 )  /* Read the passphrase now. */
3807         read_passphrase_from_fd( pwfd );
3808
3809     fname = argc? *argv : NULL;
3810
3811     if(fname && utf8_strings)
3812       opt.flags.utf8_filename=1;
3813
3814     ctrl = xcalloc (1, sizeof *ctrl);
3815     gpg_init_default_ctrl (ctrl);
3816
3817 #ifndef NO_TRUST_MODELS
3818     switch (cmd)
3819       {
3820       case aPrimegen:
3821       case aPrintMD:
3822       case aPrintMDs:
3823       case aGenRandom:
3824       case aDeArmor:
3825       case aEnArmor:
3826         break;
3827       case aFixTrustDB:
3828       case aExportOwnerTrust:
3829         rc = setup_trustdb (0, trustdb_name);
3830         break;
3831       case aListTrustDB:
3832         rc = setup_trustdb (argc? 1:0, trustdb_name);
3833         break;
3834       default:
3835         /* If we are using TM_ALWAYS, we do not need to create the
3836            trustdb.  */
3837         rc = setup_trustdb (opt.trust_model != TM_ALWAYS, trustdb_name);
3838         break;
3839       }
3840     if (rc)
3841       log_error (_("failed to initialize the TrustDB: %s\n"),
3842                  gpg_strerror (rc));
3843 #endif /*!NO_TRUST_MODELS*/
3844
3845     switch (cmd)
3846       {
3847       case aStore:
3848       case aSym:
3849       case aSign:
3850       case aSignSym:
3851       case aClearsign:
3852         if (!opt.quiet && any_explicit_recipient)
3853           log_info (_("WARNING: recipients (-r) given "
3854                       "without using public key encryption\n"));
3855         break;
3856       default:
3857         break;
3858       }
3859
3860
3861     /* Check for certain command whether we need to migrate a
3862        secring.gpg to the gpg-agent. */
3863     switch (cmd)
3864       {
3865       case aListSecretKeys:
3866       case aSign:
3867       case aSignEncr:
3868       case aSignEncrSym:
3869       case aSignSym:
3870       case aClearsign:
3871       case aDecrypt:
3872       case aSignKey:
3873       case aLSignKey:
3874       case aEditKey:
3875       case aPasswd:
3876       case aDeleteSecretKeys:
3877       case aDeleteSecretAndPublicKeys:
3878       case aQuickKeygen:
3879       case aQuickAddUid:
3880       case aFullKeygen:
3881       case aKeygen:
3882       case aImport:
3883       case aExportSecret:
3884       case aExportSecretSub:
3885       case aGenRevoke:
3886       case aDesigRevoke:
3887       case aCardEdit:
3888       case aChangePIN:
3889         migrate_secring (ctrl);
3890         break;
3891       case aListKeys:
3892         if (opt.with_secret)
3893           migrate_secring (ctrl);
3894         break;
3895       default:
3896         break;
3897       }
3898
3899     {
3900       int have_def_secret_key = opt.def_secret_key != NULL;
3901
3902       rc = check_user_ids (&locusr, 1, 1);
3903       if (rc)
3904         g10_exit (1);
3905       rc = check_user_ids (&remusr, 0, 1);
3906       if (rc)
3907         g10_exit (1);
3908       rc = check_user_ids (&opt.def_secret_key, 1, 0);
3909       if (rc)
3910         g10_exit (1);
3911
3912       if (opt.encrypt_to_default_key)
3913         {
3914           const char *default_key = parse_def_secret_key (ctrl);
3915           if (default_key)
3916             {
3917               sl = add_to_strlist2 (&remusr, default_key, utf8_strings);
3918               sl->flags = (oEncryptToDefaultKey << 2) | 1;
3919             }
3920           else if (have_def_secret_key)
3921             log_info (_("--encrypt-to-default-key specified, but no valid default keys specified.\n"));
3922           else
3923             log_info (_("--encrypt-to-default-key specified, but --default-key not specified.\n"));
3924         }
3925     }
3926
3927     /* The command dispatcher.  */
3928     switch( cmd )
3929       {
3930       case aServer:
3931         gpg_server (ctrl);
3932         break;
3933
3934       case aStore: /* only store the file */
3935         if( argc > 1 )
3936             wrong_args(_("--store [filename]"));
3937         if( (rc = encrypt_store(fname)) )
3938           {
3939             write_status_failure ("store", rc);
3940             log_error ("storing '%s' failed: %s\n",
3941                        print_fname_stdin(fname),gpg_strerror (rc) );
3942           }
3943         break;
3944       case aSym: /* encrypt the given file only with the symmetric cipher */
3945         if( argc > 1 )
3946             wrong_args(_("--symmetric [filename]"));
3947         if( (rc = encrypt_symmetric(fname)) )
3948           {
3949             write_status_failure ("symencrypt", rc);
3950             log_error (_("symmetric encryption of '%s' failed: %s\n"),
3951                         print_fname_stdin(fname),gpg_strerror (rc) );
3952           }
3953         break;
3954
3955       case aEncr: /* encrypt the given file */
3956         if(multifile)
3957           encrypt_crypt_files (ctrl, argc, argv, remusr);
3958         else
3959           {
3960             if( argc > 1 )
3961               wrong_args(_("--encrypt [filename]"));
3962             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 0, NULL, -1)) )
3963               {
3964                 write_status_failure ("encrypt", rc);
3965                 log_error("%s: encryption failed: %s\n",
3966                           print_fname_stdin(fname), gpg_strerror (rc) );
3967               }
3968           }
3969         break;
3970
3971       case aEncrSym:
3972         /* This works with PGP 8 in the sense that it acts just like a
3973            symmetric message.  It doesn't work at all with 2 or 6.  It
3974            might work with 7, but alas, I don't have a copy to test
3975            with right now. */
3976         if( argc > 1 )
3977           wrong_args(_("--symmetric --encrypt [filename]"));
3978         else if(opt.s2k_mode==0)
3979           log_error(_("you cannot use --symmetric --encrypt"
3980                       " with --s2k-mode 0\n"));
3981         else if(PGP6 || PGP7)
3982           log_error(_("you cannot use --symmetric --encrypt"
3983                       " while in %s mode\n"),compliance_option_string());
3984         else
3985           {
3986             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 1, NULL, -1)) )
3987               {
3988                 write_status_failure ("encrypt", rc);
3989                 log_error ("%s: encryption failed: %s\n",
3990                            print_fname_stdin(fname), gpg_strerror (rc) );
3991               }
3992           }
3993         break;
3994
3995       case aSign: /* sign the given file */
3996         sl = NULL;
3997         if( detached_sig ) { /* sign all files */
3998             for( ; argc; argc--, argv++ )
3999                 add_to_strlist( &sl, *argv );
4000         }
4001         else {
4002             if( argc > 1 )
4003                 wrong_args(_("--sign [filename]"));
4004             if( argc ) {
4005                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
4006                 strcpy(sl->d, fname);
4007             }
4008         }
4009         if ((rc = sign_file (ctrl, sl, detached_sig, locusr, 0, NULL, NULL)))
4010           {
4011             write_status_failure ("sign", rc);
4012             log_error ("signing failed: %s\n", gpg_strerror (rc) );
4013           }
4014         free_strlist(sl);
4015         break;
4016
4017       case aSignEncr: /* sign and encrypt the given file */
4018         if( argc > 1 )
4019             wrong_args(_("--sign --encrypt [filename]"));
4020         if( argc ) {
4021             sl = xmalloc_clear( sizeof *sl + strlen(fname));
4022             strcpy(sl->d, fname);
4023         }
4024         else
4025             sl = NULL;
4026         if ((rc = sign_file (ctrl, sl, detached_sig, locusr, 1, remusr, NULL)))
4027           {
4028             write_status_failure ("sign-encrypt", rc);
4029             log_error("%s: sign+encrypt failed: %s\n",
4030                       print_fname_stdin(fname), gpg_strerror (rc) );
4031           }
4032         free_strlist(sl);
4033         break;
4034
4035       case aSignEncrSym: /* sign and encrypt the given file */
4036         if( argc > 1 )
4037             wrong_args(_("--symmetric --sign --encrypt [filename]"));
4038         else if(opt.s2k_mode==0)
4039           log_error(_("you cannot use --symmetric --sign --encrypt"
4040                       " with --s2k-mode 0\n"));
4041         else if(PGP6 || PGP7)
4042           log_error(_("you cannot use --symmetric --sign --encrypt"
4043                       " while in %s mode\n"),compliance_option_string());
4044         else
4045           {
4046             if( argc )
4047               {
4048                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
4049                 strcpy(sl->d, fname);
4050               }
4051             else
4052               sl = NULL;
4053             if ((rc = sign_file (ctrl, sl, detached_sig, locusr,
4054                                  2, remusr, NULL)))
4055               {
4056                 write_status_failure ("sign-encrypt", rc);
4057                 log_error("%s: symmetric+sign+encrypt failed: %s\n",
4058                           print_fname_stdin(fname), gpg_strerror (rc) );
4059               }
4060             free_strlist(sl);
4061           }
4062         break;
4063
4064       case aSignSym: /* sign and conventionally encrypt the given file */
4065         if (argc > 1)
4066             wrong_args(_("--sign --symmetric [filename]"));
4067         rc = sign_symencrypt_file (ctrl, fname, locusr);
4068         if (rc)
4069           {
4070             write_status_failure ("sign-symencrypt", rc);
4071             log_error("%s: sign+symmetric failed: %s\n",
4072                       print_fname_stdin(fname), gpg_strerror (rc) );
4073           }
4074         break;
4075
4076       case aClearsign: /* make a clearsig */
4077         if( argc > 1 )
4078             wrong_args(_("--clearsign [filename]"));
4079         if( (rc = clearsign_file (ctrl, fname, locusr, NULL)) )
4080           {
4081             write_status_failure ("sign", rc);
4082             log_error("%s: clearsign failed: %s\n",
4083                       print_fname_stdin(fname), gpg_strerror (rc) );
4084           }
4085         break;
4086
4087       case aVerify:
4088         rc = 0;
4089         if (multifile)
4090           {
4091             if ((rc = verify_files (ctrl, argc, argv)))
4092               log_error("verify files failed: %s\n", gpg_strerror (rc) );
4093           }
4094         else
4095           {
4096             if ((rc = verify_signatures (ctrl, argc, argv)))
4097               log_error("verify signatures failed: %s\n", gpg_strerror (rc) );
4098           }
4099         if (rc)
4100           write_status_failure ("verify", rc);
4101         break;
4102
4103       case aDecrypt:
4104         if (multifile)
4105           decrypt_messages (ctrl, argc, argv);
4106         else
4107           {
4108             if( argc > 1 )
4109               wrong_args(_("--decrypt [filename]"));
4110             if( (rc = decrypt_message (ctrl, fname) ))
4111               {
4112                 write_status_failure ("decrypt", rc);
4113                 log_error("decrypt_message failed: %s\n", gpg_strerror (rc) );
4114               }
4115           }
4116         break;
4117
4118       case aQuickSignKey:
4119       case aQuickLSignKey:
4120         {
4121           const char *fpr;
4122
4123           if (argc < 1)
4124             wrong_args ("--quick-[l]sign-key fingerprint [userids]");
4125           fpr = *argv++; argc--;
4126           sl = NULL;
4127           for( ; argc; argc--, argv++)
4128             append_to_strlist2 (&sl, *argv, utf8_strings);
4129           keyedit_quick_sign (ctrl, fpr, sl, locusr, (cmd == aQuickLSignKey));
4130           free_strlist (sl);
4131         }
4132         break;
4133
4134       case aSignKey:
4135         if( argc != 1 )
4136           wrong_args(_("--sign-key user-id"));
4137         /* fall through */
4138       case aLSignKey:
4139         if( argc != 1 )
4140           wrong_args(_("--lsign-key user-id"));
4141         /* fall through */
4142
4143         sl=NULL;
4144
4145         if(cmd==aSignKey)
4146           append_to_strlist(&sl,"sign");
4147         else if(cmd==aLSignKey)
4148           append_to_strlist(&sl,"lsign");
4149         else
4150           BUG();
4151
4152         append_to_strlist( &sl, "save" );
4153         username = make_username( fname );
4154         keyedit_menu (ctrl, username, locusr, sl, 0, 0 );
4155         xfree(username);
4156         free_strlist(sl);
4157         break;
4158
4159       case aEditKey: /* Edit a key signature */
4160         if( !argc )
4161             wrong_args(_("--edit-key user-id [commands]"));
4162         username = make_username( fname );
4163         if( argc > 1 ) {
4164             sl = NULL;
4165             for( argc--, argv++ ; argc; argc--, argv++ )
4166                 append_to_strlist( &sl, *argv );
4167             keyedit_menu (ctrl, username, locusr, sl, 0, 1 );
4168             free_strlist(sl);
4169         }
4170         else
4171             keyedit_menu (ctrl, username, locusr, NULL, 0, 1 );
4172         xfree(username);
4173         break;
4174
4175       case aPasswd:
4176         if (argc != 1)
4177           wrong_args (_("--passwd <user-id>"));
4178         else
4179           {
4180             username = make_username (fname);
4181             keyedit_passwd (ctrl, username);
4182             xfree (username);
4183           }
4184         break;
4185
4186       case aDeleteKeys:
4187       case aDeleteSecretKeys:
4188       case aDeleteSecretAndPublicKeys:
4189         sl = NULL;
4190         /* I'm adding these in reverse order as add_to_strlist2
4191            reverses them again, and it's easier to understand in the
4192            proper order :) */
4193         for( ; argc; argc-- )