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