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