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