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