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