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