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