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