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