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