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