Update config.{guess,sub} and some copyright notices.
[gnupg.git] / g10 / gpg.c
1 /* gpg.c - The GnuPG utility (main for gpg)
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
3  *               2007, 2008, 2009, 2010, 2012 Free Software Foundation, Inc.
4  * Copyright (C) 1997, 1998, 2013 Werner Koch
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <errno.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #ifdef HAVE_STRINGS_H
28 #include <strings.h>
29 #endif
30 #include <ctype.h>
31 #include <unistd.h>
32 #include <assert.h>
33 #ifdef HAVE_DOSISH_SYSTEM
34 #include <fcntl.h> /* for setmode() */
35 #endif
36 #ifdef HAVE_STAT
37 #include <sys/stat.h> /* for stat() */
38 #endif
39 #include <fcntl.h>
40 #ifdef HAVE_W32_SYSTEM
41 #include <windows.h>
42 #endif
43 #ifdef __VMS
44 # include "vms.h"
45 #endif
46
47 #define INCLUDED_BY_MAIN_MODULE 1
48 #include "packet.h"
49 #include "iobuf.h"
50 #include "memory.h"
51 #include "util.h"
52 #include "main.h"
53 #include "options.h"
54 #include "keydb.h"
55 #include "trustdb.h"
56 #include "mpi.h"
57 #include "cipher.h"
58 #include "filter.h"
59 #include "ttyio.h"
60 #include "i18n.h"
61 #include "status.h"
62 #include "keyserver-internal.h"
63 #include "exec.h"
64 #include "cardglue.h"
65 #ifdef ENABLE_CARD_SUPPORT
66 #include "ccid-driver.h"
67 #endif
68
69 #if defined(HAVE_DOSISH_SYSTEM) || defined(__CYGWIN__)
70 #define MY_O_BINARY  O_BINARY
71 #ifndef S_IRGRP
72 # define S_IRGRP 0
73 # define S_IWGRP 0
74 #endif
75 #else
76 #define MY_O_BINARY  0
77 #endif
78
79
80 enum cmd_and_opt_values
81   {
82     aNull = 0,
83     oArmor        = 'a',
84     aDetachedSign = 'b',
85     aSym          = 'c',
86     aDecrypt      = 'd',
87     aEncr         = 'e',
88     oInteractive  = 'i',
89     oKOption      = 'k',
90     oDryRun       = 'n',
91     oOutput       = 'o',
92     oQuiet        = 'q',
93     oRecipient    = 'r',
94     oHiddenRecipient = 'R',
95     aSign         = 's',
96     oTextmodeShort= 't',
97     oLocalUser    = 'u',
98     oVerbose      = 'v',
99     oCompress     = 'z',
100     oSetNotation  = 'N',
101     aListSecretKeys = 'K',
102     oBatch        = 500,
103     oMaxOutput,
104     oSigNotation,
105     oCertNotation,
106     oShowNotation,
107     oNoShowNotation,
108     aEncrFiles,
109     aEncrSym,
110     aDecryptFiles,
111     aClearsign,
112     aStore,
113     aKeygen,
114     aSignEncr,
115     aSignEncrSym,
116     aSignSym,
117     aSignKey,
118     aLSignKey,
119     aListConfig,
120     aGPGConfList,
121     aGPGConfTest,
122     aListPackets,
123     aEditKey,
124     aDeleteKeys,
125     aDeleteSecretKeys,
126     aDeleteSecretAndPublicKeys,
127     aKMode,
128     aKModeC,
129     aImport,
130     aFastImport,
131     aVerify,
132     aVerifyFiles,
133     aListKeys,
134     aListSigs,
135     aSendKeys,
136     aRecvKeys,
137     aSearchKeys,
138     aRefreshKeys,
139     aFetchKeys,
140     aExport,
141     aExportSecret,
142     aExportSecretSub,
143     aCheckKeys,
144     aGenRevoke,
145     aDesigRevoke,
146     aPrimegen,
147     aPrintMD,
148     aPrintMDs,
149     aCheckTrustDB,
150     aUpdateTrustDB,
151     aFixTrustDB,
152     aListTrustDB,
153     aListTrustPath,
154     aExportOwnerTrust,
155     aListOwnerTrust,
156     aImportOwnerTrust,
157     aDeArmor,
158     aEnArmor,
159     aGenRandom,
160     aPipeMode,
161     aRebuildKeydbCaches,
162     aCardStatus,
163     aCardEdit,
164     aChangePIN,
165
166     oTextmode,
167     oNoTextmode,
168     oExpert,
169     oNoExpert,
170     oDefSigExpire,
171     oAskSigExpire,
172     oNoAskSigExpire,
173     oDefCertExpire,
174     oAskCertExpire,
175     oNoAskCertExpire,
176     oDefCertLevel,
177     oMinCertLevel,
178     oAskCertLevel,
179     oNoAskCertLevel,
180     oFingerprint,
181     oWithFingerprint,
182     oAnswerYes,
183     oAnswerNo,
184     oKeyring,
185     oPrimaryKeyring,
186     oSecretKeyring,
187     oShowKeyring,
188     oDefaultKey,
189     oDefRecipient,
190     oDefRecipientSelf,
191     oNoDefRecipient,
192     oOptions,
193     oDebug,
194     oDebugAll,
195     oDebugLevel,
196     oDebugCCIDDriver,
197     oStatusFD,
198     oStatusFile,
199     oAttributeFD,
200     oAttributeFile,
201     oEmitVersion,
202     oNoEmitVersion,
203     oCompletesNeeded,
204     oMarginalsNeeded,
205     oMaxCertDepth,
206     oLoadExtension,
207     oGnuPG,
208     oRFC1991,
209     oRFC2440,
210     oRFC4880,
211     oOpenPGP,
212     oPGP2,
213     oPGP6,
214     oPGP7,
215     oPGP8,
216     oRFC2440Text,
217     oNoRFC2440Text,
218     oCipherAlgo,
219     oDigestAlgo,
220     oCertDigestAlgo,
221     oCompressAlgo,
222     oCompressLevel,
223     oBZ2CompressLevel,
224     oBZ2DecompressLowmem,
225     oPasswd,
226     oPasswdFD,
227     oPasswdFile,
228     oPasswdRepeat,
229     oCommandFD,
230     oCommandFile,
231     oQuickRandom,
232     oNoVerbose,
233     oTrustDBName,
234     oNoSecmemWarn,
235     oRequireSecmem,
236     oNoRequireSecmem,
237     oNoPermissionWarn,
238     oNoMDCWarn,
239     oNoArmor,
240     oNoDefKeyring,
241     oNoGreeting,
242     oNoTTY,
243     oNoOptions,
244     oNoBatch,
245     oHomedir,
246     oWithColons,
247     oWithKeyData,
248     oSkipVerify,
249     oCompressKeys,
250     oCompressSigs,
251     oAlwaysTrust,
252     oTrustModel,
253     oForceOwnertrust,
254     oRunAsShmCP,
255     oSetFilename,
256     oForYourEyesOnly,
257     oNoForYourEyesOnly,
258     oSetPolicyURL,
259     oSigPolicyURL,
260     oCertPolicyURL,
261     oShowPolicyURL,
262     oNoShowPolicyURL,
263     oSigKeyserverURL,
264     oUseEmbeddedFilename,
265     oNoUseEmbeddedFilename,
266     oComment,
267     oDefaultComment,
268     oNoComments,
269     oThrowKeyids,
270     oNoThrowKeyids,
271     oShowPhotos,
272     oNoShowPhotos,
273     oPhotoViewer,
274     oForceV3Sigs,
275     oNoForceV3Sigs,
276     oForceV4Certs,
277     oNoForceV4Certs,
278     oForceMDC,
279     oNoForceMDC,
280     oDisableMDC,
281     oNoDisableMDC,
282     oS2KMode,
283     oS2KDigest,
284     oS2KCipher,
285     oS2KCount,
286     oSimpleSKChecksum,
287     oDisplayCharset,
288     oNotDashEscaped,
289     oEscapeFrom,
290     oNoEscapeFrom,
291     oLockOnce,
292     oLockMultiple,
293     oLockNever,
294     oKeyServer,
295     oKeyServerOptions,
296     oImportOptions,
297     oExportOptions,
298     oListOptions,
299     oVerifyOptions,
300     oTempDir,
301     oExecPath,
302     oEncryptTo,
303     oHiddenEncryptTo,
304     oNoEncryptTo,
305     oLoggerFD,
306     oLoggerFile,
307     oUtf8Strings,
308     oNoUtf8Strings,
309     oDisableCipherAlgo,
310     oDisablePubkeyAlgo,
311     oAllowNonSelfsignedUID,
312     oNoAllowNonSelfsignedUID,
313     oAllowFreeformUID,
314     oNoAllowFreeformUID,
315     oAllowSecretKeyImport,
316     oEnableSpecialFilenames,
317     oNoLiteral,
318     oSetFilesize,
319     oHonorHttpProxy,
320     oFastListMode,
321     oListOnly,
322     oIgnoreTimeConflict,
323     oIgnoreValidFrom,
324     oIgnoreCrcError,
325     oIgnoreMDCError,
326     oShowSessionKey,
327     oOverrideSessionKey,
328     oNoRandomSeedFile,
329     oAutoKeyRetrieve,
330     oNoAutoKeyRetrieve,
331     oUseAgent,
332     oNoUseAgent,
333     oGpgAgentInfo,
334     oMergeOnly,
335     oTryAllSecrets,
336     oTrustedKey,
337     oNoExpensiveTrustChecks,
338     oFixedListMode,
339     oNoSigCache,
340     oNoSigCreateCheck,
341     oAutoCheckTrustDB,
342     oNoAutoCheckTrustDB,
343     oPreservePermissions,
344     oDefaultPreferenceList,
345     oDefaultKeyserverURL,
346     oPersonalCipherPreferences,
347     oPersonalDigestPreferences,
348     oPersonalCompressPreferences,
349     oDisplay,
350     oTTYname,
351     oTTYtype,
352     oLCctype,
353     oLCmessages,
354     oGroup,
355     oUnGroup,
356     oNoGroups,
357     oStrict,
358     oNoStrict,
359     oMangleDosFilenames,
360     oNoMangleDosFilenames,
361     oEnableProgressFilter,
362     oMultifile,
363     oKeyidFormat,
364     oExitOnStatusWriteError,
365     oLimitCardInsertTries,
366     oReaderPort,
367     octapiDriver,
368     opcscDriver,
369     oDisableCCID,
370     oRequireCrossCert,
371     oNoRequireCrossCert,
372     oAutoKeyLocate,
373     oNoAutoKeyLocate,
374     oAllowMultisigVerification,
375     oEnableDSA2,
376     oDisableDSA2,
377     oAllowMultipleMessages,
378     oNoAllowMultipleMessages,
379
380     oNoop
381   };
382
383
384 static ARGPARSE_OPTS opts[] = {
385
386     { 300, NULL, 0, N_("@Commands:\n ") },
387
388     { aSign, "sign",      256, N_("|[file]|make a signature")},
389     { aClearsign, "clearsign", 256, N_("|[file]|make a clear text signature")},
390     { aDetachedSign, "detach-sign", 256, N_("make a detached signature")},
391     { aEncr, "encrypt",   256, N_("encrypt data")},
392     { aEncrFiles, "encrypt-files", 256, "@"},
393     { aSym, "symmetric", 256, N_("encryption only with symmetric cipher")},
394     { aStore, "store",     256, "@"},
395     { aDecrypt, "decrypt",   256, N_("decrypt data (default)")},
396     { aDecryptFiles, "decrypt-files", 256, "@"},
397     { aVerify, "verify"   , 256, N_("verify a signature")},
398     { aVerifyFiles, "verify-files" , 256, "@" },
399     { aListKeys, "list-keys", 256, N_("list keys")},
400     { aListKeys, "list-public-keys", 256, "@" },
401     { aListSigs, "list-sigs", 256, N_("list keys and signatures")},
402     { aCheckKeys, "check-sigs",256, N_("list and check key signatures")},
403     { oFingerprint, "fingerprint", 256, N_("list keys and fingerprints")},
404     { aListSecretKeys, "list-secret-keys", 256, N_("list secret keys")},
405     { aKeygen,     "gen-key",  256, N_("generate a new key pair")},
406     { aDeleteKeys,"delete-keys",256,N_("remove keys from the public keyring")},
407     { aDeleteSecretKeys, "delete-secret-keys",256,
408                                     N_("remove keys from the secret keyring")},
409     { aSignKey,  "sign-key"   ,256, N_("sign a key")},
410     { aLSignKey, "lsign-key"  ,256, N_("sign a key locally")},
411     { aEditKey,  "edit-key"   ,256, N_("sign or edit a key")},
412     { aGenRevoke, "gen-revoke",256, N_("generate a revocation certificate")},
413     { aDesigRevoke, "desig-revoke",256, "@" },
414     { aExport, "export"           , 256, N_("export keys") },
415     { aSendKeys, "send-keys"     , 256, N_("export keys to a key server") },
416     { aRecvKeys, "recv-keys"     , 256, N_("import keys from a key server") },
417     { aSearchKeys, "search-keys" , 256,
418                                     N_("search for keys on a key server") },
419     { aRefreshKeys, "refresh-keys", 256,
420                                     N_("update all keys from a keyserver")},
421     { aFetchKeys, "fetch-keys" , 256, "@" },
422     { aExportSecret, "export-secret-keys" , 256, "@" },
423     { aExportSecretSub, "export-secret-subkeys" , 256, "@" },
424     { aImport, "import",      256     , N_("import/merge keys")},
425     { aFastImport, "fast-import",  256 , "@"},
426 #ifdef ENABLE_CARD_SUPPORT
427     { aCardStatus,  "card-status", 256, N_("print the card status")},
428     { aCardEdit,   "card-edit",  256, N_("change data on a card")},
429     { aChangePIN,  "change-pin", 256, N_("change a card's PIN")},
430 #endif
431     { aListConfig, "list-config", 256, "@"},
432     { aGPGConfList, "gpgconf-list", 256, "@" },
433     { aGPGConfTest, "gpgconf-test", 256, "@" },
434     { aListPackets, "list-packets",256, "@"},
435     { aExportOwnerTrust, "export-ownertrust", 256, "@"},
436     { aImportOwnerTrust, "import-ownertrust", 256, "@"},
437     { aUpdateTrustDB,
438               "update-trustdb",0 , N_("update the trust database")},
439     { aCheckTrustDB, "check-trustdb", 0, "@"},
440     { aFixTrustDB, "fix-trustdb", 0, "@"},
441     { aDeArmor, "dearmor", 256, "@"},
442     { aDeArmor, "dearmour", 256, "@"},
443     { aEnArmor, "enarmor", 256, "@"},
444     { aEnArmor, "enarmour", 256, "@"},
445     { aPrintMD,  "print-md" , 256, N_("|algo [files]|print message digests")},
446     { aPrimegen, "gen-prime" , 256, "@" },
447     { aGenRandom, "gen-random" , 256, "@" },
448
449     { 301, NULL, 0, N_("@\nOptions:\n ") },
450
451     { oArmor, "armor",     0, N_("create ascii armored output")},
452     { oArmor, "armour",     0, "@" },
453     { oRecipient, "recipient", 2, N_("|NAME|encrypt for NAME")},
454     { oHiddenRecipient, "hidden-recipient", 2, "@" },
455     { oRecipient, "remote-user", 2, "@"},  /* old option name */
456     { oDefRecipient, "default-recipient", 2, "@"},
457     { oDefRecipientSelf, "default-recipient-self", 0, "@"},
458     { oNoDefRecipient, "no-default-recipient", 0, "@" },
459     { oTempDir, "temp-directory", 2, "@" },
460     { oExecPath, "exec-path", 2, "@" },
461     { oEncryptTo, "encrypt-to", 2, "@" },
462     { oHiddenEncryptTo, "hidden-encrypt-to", 2, "@" },
463     { oNoEncryptTo, "no-encrypt-to", 0, "@" },
464     { oLocalUser, "local-user",2, N_("use this user-id to sign or decrypt")},
465     { oCompress, NULL, 1, N_("|N|set compress level N (0 disables)") },
466     { oCompressLevel, "compress-level", 1, "@" },
467     { oBZ2CompressLevel, "bzip2-compress-level", 1, "@" },
468     { oBZ2DecompressLowmem, "bzip2-decompress-lowmem", 0, "@" },
469     { oTextmodeShort, NULL,   0, "@"},
470     { oTextmode, "textmode",  0, N_("use canonical text mode")},
471     { oNoTextmode, "no-textmode",  0, "@"},
472     { oExpert, "expert",   0, "@"},
473     { oNoExpert, "no-expert",   0, "@"},
474     { oDefSigExpire, "default-sig-expire", 2, "@"},
475     { oAskSigExpire, "ask-sig-expire",   0, "@"},
476     { oNoAskSigExpire, "no-ask-sig-expire",   0, "@"},
477     { oDefCertExpire, "default-cert-expire", 2, "@"},
478     { oAskCertExpire, "ask-cert-expire",   0, "@"},
479     { oNoAskCertExpire, "no-ask-cert-expire",   0, "@"},
480     { oDefCertLevel, "default-cert-level", 1, "@"},
481     { oMinCertLevel, "min-cert-level", 1, "@"},
482     { oAskCertLevel, "ask-cert-level",   0, "@"},
483     { oNoAskCertLevel, "no-ask-cert-level",   0, "@"},
484     { oOutput, "output",    2, N_("use as output file")},
485     { oMaxOutput, "max-output", 16|4, "@" },
486     { oVerbose, "verbose",   0, N_("verbose") },
487     { oQuiet,   "quiet",   0, "@"},
488     { oNoTTY, "no-tty", 0, "@"},
489     { oForceV3Sigs, "force-v3-sigs", 0, "@"},
490     { oNoForceV3Sigs, "no-force-v3-sigs", 0, "@"},
491     { oForceV4Certs, "force-v4-certs", 0, "@"},
492     { oNoForceV4Certs, "no-force-v4-certs", 0, "@"},
493     { oForceMDC, "force-mdc", 0, "@"},
494     { oNoForceMDC, "no-force-mdc", 0, "@" },
495     { oDisableMDC, "disable-mdc", 0, "@"},
496     { oNoDisableMDC, "no-disable-mdc", 0, "@" },
497     { oDryRun, "dry-run",   0, N_("do not make any changes") },
498     { oInteractive, "interactive", 0, N_("prompt before overwriting") },
499     { oUseAgent, "use-agent",0, "@"},
500     { oNoUseAgent, "no-use-agent",0, "@"},
501     { oGpgAgentInfo, "gpg-agent-info",2, "@"},
502     { oBatch, "batch", 0, "@"},
503     { oAnswerYes, "yes", 0, "@"},
504     { oAnswerNo, "no", 0, "@"},
505     { oKeyring, "keyring", 2, "@"},
506     { oPrimaryKeyring, "primary-keyring",2, "@" },
507     { oSecretKeyring, "secret-keyring", 2, "@"},
508     { oShowKeyring, "show-keyring", 0, "@"},
509     { oDefaultKey, "default-key", 2, "@"},
510     { oKeyServer, "keyserver", 2, "@"},
511     { oKeyServerOptions, "keyserver-options",2,"@"},
512     { oImportOptions, "import-options",2,"@"},
513     { oExportOptions, "export-options",2,"@"},
514     { oListOptions, "list-options",2,"@"},
515     { oVerifyOptions, "verify-options",2,"@"},
516     { oDisplayCharset, "display-charset", 2, "@"},
517     { oDisplayCharset, "charset", 2, "@"},
518     { oOptions, "options", 2, "@"},
519     { oDebug, "debug"     ,4|16, "@"},
520     { oDebugAll, "debug-all" ,0, "@"},
521     { oDebugLevel, "debug-level" ,0, "@"},
522     { oStatusFD, "status-fd" ,1, "@"},
523     { oStatusFile, "status-file" ,2, "@"},
524     { oAttributeFD, "attribute-fd" ,1, "@" },
525     { oAttributeFile, "attribute-file" ,2, "@" },
526     { oNoop, "sk-comments", 0,   "@"},
527     { oNoop, "no-sk-comments", 0,   "@"},
528     { oCompletesNeeded, "completes-needed", 1, "@"},
529     { oMarginalsNeeded, "marginals-needed", 1, "@"},
530     { oMaxCertDepth,    "max-cert-depth", 1, "@" },
531     { oTrustedKey, "trusted-key", 2, "@"},
532     { oLoadExtension, "load-extension", 2, "@"},
533     { oGnuPG, "gnupg",   0, "@"},
534     { oGnuPG, "no-pgp2", 0, "@"},
535     { oGnuPG, "no-pgp6", 0, "@"},
536     { oGnuPG, "no-pgp7", 0, "@"},
537     { oGnuPG, "no-pgp8", 0, "@"},
538     { oRFC1991, "rfc1991",   0, "@"},
539     { oRFC2440, "rfc2440", 0, "@" },
540     { oRFC4880, "rfc4880", 0, "@" },
541     { oOpenPGP, "openpgp", 0, N_("use strict OpenPGP behavior")},
542     { oPGP2, "pgp2", 0, N_("generate PGP 2.x compatible messages")},
543     { oPGP6, "pgp6", 0, "@"},
544     { oPGP7, "pgp7", 0, "@"},
545     { oPGP8, "pgp8", 0, "@"},
546     { oRFC2440Text, "rfc2440-text", 0, "@"},
547     { oNoRFC2440Text, "no-rfc2440-text", 0, "@"},
548     { oS2KMode, "s2k-mode", 1, "@"},
549     { oS2KDigest, "s2k-digest-algo", 2, "@"},
550     { oS2KCipher, "s2k-cipher-algo", 2, "@"},
551     { oS2KCount, "s2k-count", 1, "@"},
552     { oSimpleSKChecksum, "simple-sk-checksum", 0, "@"},
553     { oCipherAlgo, "cipher-algo", 2, "@"},
554     { oDigestAlgo, "digest-algo", 2, "@"},
555     { oCertDigestAlgo, "cert-digest-algo", 2 , "@" },
556     { oCompressAlgo,"compress-algo", 2, "@"},
557     { oCompressAlgo, "compression-algo", 2, "@"}, /* Alias */
558     { oThrowKeyids, "throw-keyid", 0, "@"},
559     { oThrowKeyids, "throw-keyids", 0, "@"},
560     { oNoThrowKeyids, "no-throw-keyid", 0, "@" },
561     { oNoThrowKeyids, "no-throw-keyids", 0, "@" },
562     { oShowPhotos,   "show-photos", 0, "@" },
563     { oNoShowPhotos, "no-show-photos", 0, "@" },
564     { oPhotoViewer,  "photo-viewer", 2, "@" },
565     { oSetNotation,  "set-notation", 2, "@" },
566     { oSetNotation,  "notation-data", 2, "@" }, /* Alias */
567     { oSigNotation,  "sig-notation", 2, "@" },
568     { oCertNotation, "cert-notation", 2, "@" },
569
570     { 302, NULL, 0, N_(
571   "@\n(See the man page for a complete listing of all commands and options)\n"
572                       )},
573
574     { 303, NULL, 0, N_("@\nExamples:\n\n"
575     " -se -r Bob [file]          sign and encrypt for user Bob\n"
576     " --clearsign [file]         make a clear text signature\n"
577     " --detach-sign [file]       make a detached signature\n"
578     " --list-keys [names]        show keys\n"
579     " --fingerprint [names]      show fingerprints\n"  ) },
580
581   /* hidden options */
582     { aListOwnerTrust, "list-ownertrust", 256, "@"}, /* deprecated */
583     { aPrintMDs, "print-mds" , 256, "@"}, /* old */
584     { aListTrustDB, "list-trustdb",0 , "@"},
585     /* Not yet used */
586     /* { aListTrustPath, "list-trust-path",0, "@"}, */
587     { aPipeMode,  "pipemode", 0, "@" },
588     { oKOption, NULL,    0, "@"},
589     { oPasswd, "passphrase",2, "@" },
590     { oPasswdFD, "passphrase-fd",1, "@" },
591     { oPasswdFile, "passphrase-file",2, "@" },
592     { oPasswdRepeat, "passphrase-repeat", 1, "@"},
593     { oCommandFD, "command-fd",1, "@" },
594     { oCommandFile, "command-file",2, "@" },
595     { oQuickRandom, "quick-random", 0, "@"},
596     { oNoVerbose, "no-verbose", 0, "@"},
597     { oTrustDBName, "trustdb-name", 2, "@" },
598     { oNoSecmemWarn, "no-secmem-warning", 0, "@" },
599     { oRequireSecmem,"require-secmem", 0, "@" },
600     { oNoRequireSecmem,"no-require-secmem", 0, "@" },
601     { oNoPermissionWarn, "no-permission-warning", 0, "@" },
602     { oNoMDCWarn, "no-mdc-warning", 0, "@" },
603     { oNoArmor, "no-armor",   0, "@"},
604     { oNoArmor, "no-armour",   0, "@"},
605     { oNoDefKeyring, "no-default-keyring", 0, "@" },
606     { oNoGreeting, "no-greeting", 0, "@" },
607     { oNoOptions, "no-options", 0, "@" }, /* shortcut for --options /dev/null */
608     { oHomedir, "homedir", 2, "@" },   /* defaults to "~/.gnupg" */
609     { oNoBatch, "no-batch", 0, "@" },
610     { oWithColons, "with-colons", 0, "@"},
611     { oWithKeyData,"with-key-data", 0, "@"},
612     { aListKeys, "list-key", 0, "@" }, /* alias */
613     { aListSigs, "list-sig", 0, "@" }, /* alias */
614     { aCheckKeys, "check-sig",0, "@" }, /* alias */
615     { oSkipVerify, "skip-verify",0, "@" },
616     { oCompressKeys, "compress-keys",0, "@"},
617     { oCompressSigs, "compress-sigs",0, "@"},
618     { oDefCertLevel, "default-cert-check-level", 1, "@"}, /* Old option */
619     { oAlwaysTrust, "always-trust", 0, "@"},
620     { oTrustModel, "trust-model", 2, "@"},
621     { oForceOwnertrust, "force-ownertrust", 2, "@"},
622     { oRunAsShmCP, "run-as-shm-coprocess", 4, "@" },
623     { oSetFilename, "set-filename", 2, "@" },
624     { oForYourEyesOnly, "for-your-eyes-only", 0, "@" },
625     { oNoForYourEyesOnly, "no-for-your-eyes-only", 0, "@" },
626     { oSetPolicyURL, "set-policy-url", 2, "@" },
627     { oSigPolicyURL, "sig-policy-url", 2, "@" },
628     { oCertPolicyURL, "cert-policy-url", 2, "@" },
629     { oShowPolicyURL, "show-policy-url", 0, "@" },
630     { oNoShowPolicyURL, "no-show-policy-url", 0, "@" },
631     { oSigKeyserverURL, "sig-keyserver-url", 2, "@" },
632     { oShowNotation, "show-notation", 0, "@" },
633     { oNoShowNotation, "no-show-notation", 0, "@" },
634     { oComment, "comment", 2, "@" },
635     { oDefaultComment, "default-comment", 0, "@" },
636     { oNoComments, "no-comments", 0, "@" },
637     { oEmitVersion, "emit-version", 0, "@"},
638     { oNoEmitVersion, "no-emit-version", 0, "@"},
639     { oNoEmitVersion, "no-version", 0, "@"}, /* alias */
640     { oNotDashEscaped, "not-dash-escaped", 0, "@" },
641     { oEscapeFrom, "escape-from-lines", 0, "@" },
642     { oNoEscapeFrom, "no-escape-from-lines", 0, "@" },
643     { oLockOnce, "lock-once", 0, "@" },
644     { oLockMultiple, "lock-multiple", 0, "@" },
645     { oLockNever, "lock-never", 0, "@" },
646     { oLoggerFD, "logger-fd",1, "@" },
647     { oLoggerFile, "logger-file",2, "@" },
648     { oUseEmbeddedFilename, "use-embedded-filename", 0, "@" },
649     { oNoUseEmbeddedFilename, "no-use-embedded-filename", 0, "@" },
650     { oUtf8Strings, "utf8-strings", 0, "@" },
651     { oNoUtf8Strings, "no-utf8-strings", 0, "@" },
652     { oWithFingerprint, "with-fingerprint", 0, "@" },
653     { oDisableCipherAlgo,  "disable-cipher-algo", 2, "@" },
654     { oDisablePubkeyAlgo,  "disable-pubkey-algo", 2, "@" },
655     { oAllowNonSelfsignedUID, "allow-non-selfsigned-uid", 0, "@" },
656     { oNoAllowNonSelfsignedUID, "no-allow-non-selfsigned-uid", 0, "@" },
657     { oAllowFreeformUID, "allow-freeform-uid", 0, "@" },
658     { oNoAllowFreeformUID, "no-allow-freeform-uid", 0, "@" },
659     { oNoLiteral, "no-literal", 0, "@" },
660     { oSetFilesize, "set-filesize", 20, "@" },
661     { oHonorHttpProxy,"honor-http-proxy", 0, "@" },
662     { oFastListMode,"fast-list-mode", 0, "@" },
663     { oFixedListMode,"fixed-list-mode", 0, "@" },
664     { oListOnly, "list-only", 0, "@"},
665     { oIgnoreTimeConflict, "ignore-time-conflict", 0, "@" },
666     { oIgnoreValidFrom,    "ignore-valid-from",    0, "@" },
667     { oIgnoreCrcError, "ignore-crc-error", 0,"@" },
668     { oIgnoreMDCError, "ignore-mdc-error", 0,"@" },
669     { oShowSessionKey, "show-session-key", 0, "@" },
670     { oOverrideSessionKey, "override-session-key", 2, "@" },
671     { oNoRandomSeedFile,  "no-random-seed-file", 0, "@" },
672     { oAutoKeyRetrieve, "auto-key-retrieve", 0, "@" },
673     { oNoAutoKeyRetrieve, "no-auto-key-retrieve", 0, "@" },
674     { oNoSigCache,         "no-sig-cache", 0, "@" },
675     { oNoSigCreateCheck,   "no-sig-create-check", 0, "@" },
676     { oAutoCheckTrustDB, "auto-check-trustdb", 0, "@"},
677     { oNoAutoCheckTrustDB, "no-auto-check-trustdb", 0, "@"},
678     { oMergeOnly,         "merge-only", 0, "@" },
679     { oAllowSecretKeyImport, "allow-secret-key-import", 0, "@" },
680     { oTryAllSecrets,  "try-all-secrets", 0, "@" },
681     { oEnableSpecialFilenames, "enable-special-filenames", 0, "@" },
682     { oNoExpensiveTrustChecks, "no-expensive-trust-checks", 0, "@" },
683     { aDeleteSecretAndPublicKeys, "delete-secret-and-public-keys",256, "@" },
684     { aRebuildKeydbCaches, "rebuild-keydb-caches", 256, "@"},
685     { oPreservePermissions, "preserve-permissions", 0, "@"},
686     { oDefaultPreferenceList,  "default-preference-list", 2, "@"},
687     { oDefaultKeyserverURL,  "default-keyserver-url", 2, "@"},
688     { oPersonalCipherPreferences,  "personal-cipher-preferences", 2, "@"},
689     { oPersonalDigestPreferences,  "personal-digest-preferences", 2, "@"},
690     { oPersonalCompressPreferences,  "personal-compress-preferences", 2, "@"},
691     /* Aliases.  I constantly mistype these, and assume other people
692        do as well. */
693     { oPersonalCipherPreferences, "personal-cipher-prefs", 2, "@"},
694     { oPersonalDigestPreferences, "personal-digest-prefs", 2, "@"},
695     { oPersonalCompressPreferences, "personal-compress-prefs", 2, "@"},
696     { oDisplay,    "display",     2, "@" },
697     { oTTYname,    "ttyname",     2, "@" },
698     { oTTYtype,    "ttytype",     2, "@" },
699     { oLCctype,    "lc-ctype",    2, "@" },
700     { oLCmessages, "lc-messages", 2, "@" },
701     { oGroup,      "group",       2, "@" },
702     { oUnGroup,    "ungroup",     2, "@" },
703     { oNoGroups,   "no-groups",    0, "@" },
704     { oStrict,     "strict",      0, "@" },
705     { oNoStrict,   "no-strict",   0, "@" },
706     { oMangleDosFilenames, "mangle-dos-filenames", 0, "@" },
707     { oNoMangleDosFilenames, "no-mangle-dos-filenames", 0, "@" },
708     { oEnableProgressFilter, "enable-progress-filter", 0, "@" },
709     { oMultifile, "multifile", 0, "@" },
710     { oKeyidFormat, "keyid-format", 2, "@" },
711     { oExitOnStatusWriteError, "exit-on-status-write-error", 0, "@" },
712     { oLimitCardInsertTries, "limit-card-insert-tries", 1, "@"},
713
714     { oReaderPort, "reader-port",    2, "@"},
715     { octapiDriver, "ctapi-driver",  2, "@"},
716     { opcscDriver, "pcsc-driver",    2, "@"},
717     { oDisableCCID, "disable-ccid", 0, "@"},
718 #if defined(ENABLE_CARD_SUPPORT) && defined(HAVE_LIBUSB)
719     { oDebugCCIDDriver, "debug-ccid-driver", 0, "@"},
720 #endif
721     { oAllowMultisigVerification, "allow-multisig-verification", 0, "@"},
722     { oEnableDSA2, "enable-dsa2", 0, "@"},
723     { oDisableDSA2, "disable-dsa2", 0, "@"},
724     { oAllowMultipleMessages, "allow-multiple-messages", 0, "@"},
725     { oNoAllowMultipleMessages, "no-allow-multiple-messages", 0, "@"},
726
727     /* These two are aliases to help users of the PGP command line
728        product use gpg with minimal pain.  Many commands are common
729        already as they seem to have borrowed commands from us.  Now
730        I'm returning the favor. */
731     { oLocalUser, "sign-with", 2, "@" },
732     { oRecipient, "user", 2, "@" },
733     { oRequireCrossCert, "require-backsigs", 0, "@"},
734     { oRequireCrossCert, "require-cross-certification", 0, "@"},
735     { oNoRequireCrossCert, "no-require-backsigs", 0, "@"},
736     { oNoRequireCrossCert, "no-require-cross-certification", 0, "@"},
737     { oAutoKeyLocate, "auto-key-locate", 2, "@"},
738     { oNoAutoKeyLocate, "no-auto-key-locate", 0, "@"},
739     {0,NULL,0,NULL}
740 };
741
742
743 #ifdef ENABLE_SELINUX_HACKS
744 #define ALWAYS_ADD_KEYRINGS 1
745 #else
746 #define ALWAYS_ADD_KEYRINGS 0
747 #endif
748
749
750 int g10_errors_seen = 0;
751
752 static int utf8_strings = 0;
753 static int maybe_setuid = 1;
754
755 static char *build_list( const char *text, char letter,
756                          const char *(*mapf)(int), int (*chkf)(int) );
757 static void set_cmd( enum cmd_and_opt_values *ret_cmd,
758                         enum cmd_and_opt_values new_cmd );
759 static void print_mds( const char *fname, int algo );
760 static void add_notation_data( const char *string, int which );
761 static void add_policy_url( const char *string, int which );
762 static void add_keyserver_url( const char *string, int which );
763
764 const char *
765 strusage( int level )
766 {
767   static char *digests, *pubkeys, *ciphers, *zips;
768     const char *p;
769     switch( level ) {
770       case 11: p = "gpg (GnuPG)";
771         break;
772       case 13: p = VERSION; break;
773       case 17: p = PRINTABLE_OS_NAME; break;
774       case 19: p =
775             _("Please report bugs to <gnupg-bugs@gnu.org>.\n");
776         break;
777
778 #ifdef IS_DEVELOPMENT_VERSION
779       case 20:
780         p="NOTE: THIS IS A DEVELOPMENT VERSION!";
781         break;
782       case 21:
783         p="It is only intended for test purposes and should NOT be";
784         break;
785       case 22:
786         p="used in a production environment or with production keys!";
787         break;
788 #endif
789
790       case 1:
791       case 40:  p =
792             _("Usage: gpg [options] [files] (-h for help)");
793         break;
794       case 41:  p =
795             _("Syntax: gpg [options] [files]\n"
796               "Sign, check, encrypt or decrypt\n"
797               "Default operation depends on the input data\n");
798         break;
799
800       case 31: p = "\nHome: "; break;
801 #ifndef __riscos__
802       case 32: p = opt.homedir; break;
803 #else /* __riscos__ */
804       case 32: p = make_filename(opt.homedir, NULL); break;
805 #endif /* __riscos__ */
806       case 33: p = _("\nSupported algorithms:\n"); break;
807       case 34:
808         if( !pubkeys )
809             pubkeys = build_list(_("Pubkey: "), 0, pubkey_algo_to_string,
810                                                         check_pubkey_algo );
811         p = pubkeys;
812         break;
813       case 35:
814         if( !ciphers )
815             ciphers = build_list(_("Cipher: "), 'S', cipher_algo_to_string,
816                                                         check_cipher_algo );
817         p = ciphers;
818         break;
819       case 36:
820         if( !digests )
821             digests = build_list(_("Hash: "), 'H', digest_algo_to_string,
822                                                         check_digest_algo );
823         p = digests;
824         break;
825       case 37:
826         if( !zips )
827             zips = build_list(_("Compression: "),'Z',compress_algo_to_string,
828                                                         check_compress_algo);
829         p = zips;
830         break;
831
832       default:  p = default_strusage(level);
833     }
834     return p;
835 }
836
837
838 static char *
839 build_list (const char *text, char letter,
840             const char * (*mapf)(int), int (*chkf)(int))
841 {
842   membuf_t mb;
843   int indent;
844   int i, j, len;
845   const char *s;
846   char *string;
847
848   if (maybe_setuid)
849     secmem_init (0);    /* Drop setuid */
850
851   indent = strlen (text);
852   len = 0;
853   init_membuf (&mb, 512);
854
855   for (i=0; i <= 110; i++ )
856     {
857       if (!chkf (i) && (s = mapf (i)))
858         {
859           if (mb.len - len > 60)
860             {
861               put_membuf_str (&mb, ",\n");
862               len = mb.len;
863               for (j=0; j < indent; j++)
864                 put_membuf_str (&mb, " ");
865             }
866           else if (mb.len)
867             put_membuf_str (&mb, ", ");
868           else
869             put_membuf_str (&mb, text);
870
871           put_membuf_str (&mb, s);
872           if (opt.verbose && letter)
873             {
874               char num[20];
875               snprintf (num, sizeof num, " (%c%d)", letter, i);
876               put_membuf_str (&mb, num);
877             }
878         }
879     }
880   if (mb.len)
881     put_membuf_str (&mb, "\n");
882   put_membuf (&mb, "", 1);
883
884   string = get_membuf (&mb, NULL);
885   return xrealloc (string, strlen (string)+1);
886 }
887
888
889 static void
890 i18n_init(void)
891 {
892 #ifdef USE_SIMPLE_GETTEXT
893     set_gettext_file (PACKAGE, "Software\\GNU\\GnuPG");
894 #else
895 #ifdef ENABLE_NLS
896     setlocale( LC_ALL, "" );
897     bindtextdomain (PACKAGE, LOCALEDIR);
898     textdomain( PACKAGE );
899 #endif
900 #endif
901 }
902
903 static void
904 wrong_args( const char *text)
905 {
906     fputs(_("usage: gpg [options] "),stderr);
907     fputs(text,stderr);
908     putc('\n',stderr);
909     g10_exit(2);
910 }
911
912
913 static char *
914 make_username( const char *string )
915 {
916     char *p;
917     if( utf8_strings )
918         p = xstrdup(string);
919     else
920         p = native_to_utf8( string );
921     return p;
922 }
923
924
925 static void
926 set_debug(void)
927 {
928     if( opt.debug & DBG_MEMORY_VALUE )
929         memory_debug_mode = 1;
930     if( opt.debug & DBG_MEMSTAT_VALUE )
931         memory_stat_debug_mode = 1;
932     if( opt.debug & DBG_MPI_VALUE )
933         mpi_debug_mode = 1;
934     if( opt.debug & DBG_CIPHER_VALUE )
935         g10c_debug_mode = 1;
936     if( opt.debug & DBG_IOBUF_VALUE )
937         iobuf_debug_mode = 1;
938
939 }
940
941
942 /* We need the home directory also in some other directories, so make
943    sure that both variables are always in sync. */
944 static void
945 set_homedir (char *dir)
946 {
947   if (!dir)
948     dir = "";
949   g10_opt_homedir = opt.homedir = dir;
950 }
951
952
953 /* We set the screen dimensions for UI purposes.  Do not allow screens
954    smaller than 80x24 for the sake of simplicity. */
955 static void
956 set_screen_dimensions(void)
957 {
958 #ifndef _WIN32
959   char *str;
960
961   str=getenv("COLUMNS");
962   if(str)
963     opt.screen_columns=atoi(str);
964
965   str=getenv("LINES");
966   if(str)
967     opt.screen_lines=atoi(str);
968 #endif
969
970   if(opt.screen_columns<80 || opt.screen_columns>255)
971     opt.screen_columns=80;
972
973   if(opt.screen_lines<24 || opt.screen_lines>255)
974     opt.screen_lines=24;
975 }
976
977
978 /* Helper to open a file FNAME either for reading or writing to be
979    used with --status-file etc functions.  Not generally useful but it
980    avoids the riscos specific functions and well some Windows people
981    might like it too.  Prints an error message and returns -1 on
982    error. On success the file descriptor is returned.  */
983 static int
984 open_info_file (const char *fname, int for_write)
985 {
986 #ifdef __riscos__
987   return riscos_fdopenfile (fname, for_write);
988 #elif defined (ENABLE_SELINUX_HACKS)
989   /* We can't allow these even when testing for a secured filename
990      because files to be secured might not yet been secured.  This is
991      similar to the option file but in that case it is unlikely that
992      sensitive information may be retrieved by means of error
993      messages.  */
994   return -1;
995 #else
996   int fd;
997
998 /*   if (is_secured_filename (fname)) */
999 /*     { */
1000 /*       fd = -1; */
1001 /*       errno = EPERM; */
1002 /*     } */
1003 /*   else */
1004 /*     { */
1005       do
1006         {
1007           if (for_write)
1008             fd = open (fname, O_CREAT | O_TRUNC | O_WRONLY,
1009                         S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
1010           else
1011             fd = open (fname, O_RDONLY | MY_O_BINARY);
1012         }
1013       while (fd == -1 && errno == EINTR);
1014 /*     } */
1015   if ( fd == -1)
1016     log_error ( for_write? _("can't create `%s': %s\n")
1017                          : _("can't open `%s': %s\n"), fname, strerror(errno));
1018
1019   return fd;
1020 #endif
1021 }
1022
1023 static void
1024 set_cmd( enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd )
1025 {
1026     enum cmd_and_opt_values cmd = *ret_cmd;
1027
1028     if( !cmd || cmd == new_cmd )
1029         cmd = new_cmd;
1030     else if( cmd == aSign && new_cmd == aEncr )
1031         cmd = aSignEncr;
1032     else if( cmd == aEncr && new_cmd == aSign )
1033         cmd = aSignEncr;
1034     else if( cmd == aSign && new_cmd == aSym )
1035         cmd = aSignSym;
1036     else if( cmd == aSym && new_cmd == aSign )
1037         cmd = aSignSym;
1038     else if( cmd == aSym && new_cmd == aEncr )
1039         cmd = aEncrSym;
1040     else if( cmd == aEncr && new_cmd == aSym )
1041         cmd = aEncrSym;
1042     else if( cmd == aKMode && new_cmd == aSym )
1043         cmd = aKModeC;
1044     else if (cmd == aSignEncr && new_cmd == aSym)
1045         cmd = aSignEncrSym;
1046     else if (cmd == aSignSym && new_cmd == aEncr)
1047         cmd = aSignEncrSym;
1048     else if (cmd == aEncrSym && new_cmd == aSign)
1049         cmd = aSignEncrSym;
1050     else if(    ( cmd == aSign     && new_cmd == aClearsign )
1051              || ( cmd == aClearsign && new_cmd == aSign )  )
1052         cmd = aClearsign;
1053     else {
1054         log_error(_("conflicting commands\n"));
1055         g10_exit(2);
1056     }
1057
1058     *ret_cmd = cmd;
1059 }
1060
1061
1062 static void
1063 add_group(char *string)
1064 {
1065   char *name,*value;
1066   struct groupitem *item;
1067
1068   /* Break off the group name */
1069   name=strsep(&string,"=");
1070   if(string==NULL)
1071     {
1072       log_error(_("no = sign found in group definition `%s'\n"),name);
1073       return;
1074     }
1075
1076   trim_trailing_ws(name,strlen(name));
1077
1078   /* Does this group already exist? */
1079   for(item=opt.grouplist;item;item=item->next)
1080     if(strcasecmp(item->name,name)==0)
1081       break;
1082
1083   if(!item)
1084     {
1085       item=xmalloc(sizeof(struct groupitem));
1086       item->name=name;
1087       item->next=opt.grouplist;
1088       item->values=NULL;
1089       opt.grouplist=item;
1090     }
1091
1092   /* Break apart the values */
1093   while ((value= strsep(&string," \t")))
1094     {
1095       if (*value)
1096         add_to_strlist2(&item->values,value,utf8_strings);
1097     }
1098 }
1099
1100
1101 static void
1102 rm_group(char *name)
1103 {
1104   struct groupitem *item,*last=NULL;
1105
1106   trim_trailing_ws(name,strlen(name));
1107
1108   for(item=opt.grouplist;item;last=item,item=item->next)
1109     {
1110       if(strcasecmp(item->name,name)==0)
1111         {
1112           if(last)
1113             last->next=item->next;
1114           else
1115             opt.grouplist=item->next;
1116
1117           free_strlist(item->values);
1118           xfree(item);
1119           break;
1120         }
1121     }
1122 }
1123
1124
1125 /* We need to check three things.
1126
1127    0) The homedir.  It must be x00, a directory, and owned by the
1128    user.
1129
1130    1) The options/gpg.conf file.  Okay unless it or its containing
1131    directory is group or other writable or not owned by us.  Disable
1132    exec in this case.
1133
1134    Returns true if the item is unsafe. */
1135 static int
1136 check_permissions(const char *path,int item)
1137 {
1138 #if defined(HAVE_STAT) && !defined(HAVE_DOSISH_SYSTEM)
1139   static int homedir_cache=-1;
1140   char *tmppath,*dir;
1141   struct stat statbuf,dirbuf;
1142   int homedir=0,ret=0,checkonly=0;
1143   int perm=0,own=0,enc_dir_perm=0,enc_dir_own=0;
1144
1145   if(opt.no_perm_warn)
1146     return 0;
1147
1148   assert(item==0 || item==1 || item==2);
1149
1150   tmppath=xstrdup(path);
1151
1152   /* If the item is located in the homedir, but isn't the homedir,
1153      don't continue if we already checked the homedir itself.  This is
1154      to avoid user confusion with an extra options file warning which
1155      could be rectified if the homedir itself had proper
1156      permissions. */
1157   if(item!=0 && homedir_cache>-1
1158      && ascii_strncasecmp(opt.homedir,tmppath,strlen(opt.homedir))==0)
1159     {
1160       ret=homedir_cache;
1161       goto end;
1162     }
1163
1164   /* It's okay if the file or directory doesn't exist */
1165   if(stat(tmppath,&statbuf)!=0)
1166     {
1167       ret=0;
1168       goto end;
1169     }
1170
1171   /* Now check the enclosing directory.  Theoretically, we could walk
1172      this test up to the root directory /, but for the sake of sanity,
1173      I'm stopping at one level down. */
1174   dir=make_dirname(tmppath);
1175
1176   if(stat(dir,&dirbuf)!=0 || !S_ISDIR(dirbuf.st_mode))
1177     {
1178       /* Weird error */
1179       ret=1;
1180       goto end;
1181     }
1182
1183   xfree(dir);
1184
1185   /* Assume failure */
1186   ret=1;
1187
1188   if(item==0)
1189     {
1190       /* The homedir must be x00, a directory, and owned by the user. */
1191
1192       if(S_ISDIR(statbuf.st_mode))
1193         {
1194           if(statbuf.st_uid==getuid())
1195             {
1196               if((statbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1197                 ret=0;
1198               else
1199                 perm=1;
1200             }
1201           else
1202             own=1;
1203
1204           homedir_cache=ret;
1205         }
1206     }
1207   else if(item==1)
1208     {
1209       /* The options file.  Okay unless it or its
1210          containing directory is group or other writable or not owned
1211          by us or root. */
1212
1213       if(S_ISREG(statbuf.st_mode))
1214         {
1215           if(statbuf.st_uid==getuid() || statbuf.st_uid==0)
1216             {
1217               if((statbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1218                 {
1219                   /* it's not writable, so make sure the enclosing
1220                      directory is also not writable */
1221                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1222                     {
1223                       if((dirbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1224                         ret=0;
1225                       else
1226                         enc_dir_perm=1;
1227                     }
1228                   else
1229                     enc_dir_own=1;
1230                 }
1231               else
1232                 {
1233                   /* it's writable, so the enclosing directory had
1234                      better not let people get to it. */
1235                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1236                     {
1237                       if((dirbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1238                         ret=0;
1239                       else
1240                         perm=enc_dir_perm=1; /* unclear which one to fix! */
1241                     }
1242                   else
1243                     enc_dir_own=1;
1244                 }
1245             }
1246           else
1247             own=1;
1248         }
1249     }
1250   else
1251     BUG();
1252
1253   if(!checkonly)
1254     {
1255       if(own)
1256         {
1257           if(item==0)
1258             log_info(_("WARNING: unsafe ownership on"
1259                        " homedir `%s'\n"),tmppath);
1260           else
1261             log_info(_("WARNING: unsafe ownership on"
1262                        " configuration file `%s'\n"),tmppath);
1263         }
1264       if(perm)
1265         {
1266           if(item==0)
1267             log_info(_("WARNING: unsafe permissions on"
1268                        " homedir `%s'\n"),tmppath);
1269           else
1270             log_info(_("WARNING: unsafe permissions on"
1271                        " configuration file `%s'\n"),tmppath);
1272         }
1273       if(enc_dir_own)
1274         {
1275           if(item==0)
1276             log_info(_("WARNING: unsafe enclosing directory ownership on"
1277                        " homedir `%s'\n"),tmppath);
1278           else
1279             log_info(_("WARNING: unsafe enclosing directory ownership on"
1280                        " configuration file `%s'\n"),tmppath);
1281         }
1282       if(enc_dir_perm)
1283         {
1284           if(item==0)
1285             log_info(_("WARNING: unsafe enclosing directory permissions on"
1286                        " homedir `%s'\n"),tmppath);
1287           else
1288             log_info(_("WARNING: unsafe enclosing directory permissions on"
1289                        " configuration file `%s'\n"),tmppath);
1290         }
1291     }
1292
1293  end:
1294   xfree(tmppath);
1295
1296   if(homedir)
1297     homedir_cache=ret;
1298
1299   return ret;
1300
1301 #endif /* HAVE_STAT && !HAVE_DOSISH_SYSTEM */
1302
1303   return 0;
1304 }
1305
1306 static void
1307 print_algo_numbers(int (*checker)(int))
1308 {
1309   int i,first=1;
1310
1311   for(i=0;i<=110;i++)
1312     {
1313       if(!checker(i))
1314         {
1315           if(first)
1316             first=0;
1317           else
1318             printf(";");
1319           printf("%d",i);
1320         }
1321     }
1322 }
1323
1324 static void
1325 print_algo_names(int (*checker)(int),const char *(*mapper)(int))
1326 {
1327   int i,first=1;
1328
1329   for(i=0;i<=110;i++)
1330     {
1331       if(!checker(i))
1332         {
1333           if(first)
1334             first=0;
1335           else
1336             printf(";");
1337           printf("%s",mapper(i));
1338         }
1339     }
1340 }
1341
1342 /* In the future, we can do all sorts of interesting configuration
1343    output here.  For now, just give "group" as the Enigmail folks need
1344    it, and pubkey, cipher, hash, and compress as they may be useful
1345    for frontends. */
1346 static void
1347 list_config(char *items)
1348 {
1349   int show_all=(items==NULL);
1350   char *name=NULL;
1351
1352   if(!opt.with_colons)
1353     return;
1354
1355   while(show_all || (name=strsep(&items," ")))
1356     {
1357       int any=0;
1358
1359       if(show_all || ascii_strcasecmp(name,"group")==0)
1360         {
1361           struct groupitem *iter;
1362
1363           for(iter=opt.grouplist;iter;iter=iter->next)
1364             {
1365               STRLIST sl;
1366
1367               printf("cfg:group:");
1368               print_string(stdout,iter->name,strlen(iter->name),':');
1369               printf(":");
1370
1371               for(sl=iter->values;sl;sl=sl->next)
1372                 {
1373                   print_string2(stdout,sl->d,strlen(sl->d),':',';');
1374                   if(sl->next)
1375                     printf(";");
1376                 }
1377
1378               printf("\n");
1379             }
1380
1381           any=1;
1382         }
1383
1384       if(show_all || ascii_strcasecmp(name,"version")==0)
1385         {
1386           printf("cfg:version:");
1387           print_string(stdout,VERSION,strlen(VERSION),':');
1388           printf("\n");
1389           any=1;
1390         }
1391
1392       if(show_all || ascii_strcasecmp(name,"pubkey")==0)
1393         {
1394           printf("cfg:pubkey:");
1395           print_algo_numbers(check_pubkey_algo);
1396           printf("\n");
1397           any=1;
1398         }
1399
1400       if(show_all || ascii_strcasecmp(name,"cipher")==0)
1401         {
1402           printf("cfg:cipher:");
1403           print_algo_numbers(check_cipher_algo);
1404           printf("\n");
1405           any=1;
1406         }
1407
1408       if(show_all || ascii_strcasecmp(name,"ciphername")==0)
1409         {
1410           printf("cfg:ciphername:");
1411           print_algo_names(check_cipher_algo,cipher_algo_to_string);
1412           printf("\n");
1413           any=1;
1414         }
1415
1416       if(show_all
1417          || ascii_strcasecmp(name,"digest")==0
1418          || ascii_strcasecmp(name,"hash")==0)
1419         {
1420           printf("cfg:digest:");
1421           print_algo_numbers(check_digest_algo);
1422           printf("\n");
1423           any=1;
1424         }
1425
1426       if(show_all
1427          || ascii_strcasecmp(name,"digestname")==0
1428          || ascii_strcasecmp(name,"hashname")==0)
1429         {
1430           printf("cfg:digestname:");
1431           print_algo_names(check_digest_algo,digest_algo_to_string);
1432           printf("\n");
1433           any=1;
1434         }
1435
1436       if(show_all || ascii_strcasecmp(name,"compress")==0)
1437         {
1438           printf("cfg:compress:");
1439           print_algo_numbers(check_compress_algo);
1440           printf("\n");
1441           any=1;
1442         }
1443
1444       if(show_all || ascii_strcasecmp(name,"ccid-reader-id")==0)
1445         {
1446 #if defined(ENABLE_CARD_SUPPORT) && defined(HAVE_LIBUSB)
1447           char *p, *p2, *list = ccid_get_reader_list ();
1448
1449           for (p=list; p && (p2 = strchr (p, '\n')); p = p2+1)
1450             {
1451               *p2 = 0;
1452               printf("cfg:ccid-reader-id:%s\n", p);
1453             }
1454           free (list);
1455 #endif
1456           any=1;
1457         }
1458
1459       if(show_all)
1460         break;
1461
1462       if(!any)
1463         log_error(_("unknown configuration item `%s'\n"),name);
1464     }
1465 }
1466
1467
1468 /* List options and default values in the GPG Conf format.  This is a
1469    new tool distributed with gnupg 1.9.x but we also want some limited
1470    support in older gpg versions.  The output is the name of the
1471    configuration file and a list of options available for editing by
1472    gpgconf.  */
1473 static void
1474 gpgconf_list (const char *configfile)
1475 {
1476   /* The following definitions are taken from gnupg/tools/gpgconf-comp.c.  */
1477 #define GC_OPT_FLAG_NONE        0UL
1478 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
1479
1480   printf ("gpgconf-gpg.conf:%lu:\"%s\n",
1481           GC_OPT_FLAG_DEFAULT,configfile?configfile:"/dev/null");
1482   printf ("verbose:%lu:\n", GC_OPT_FLAG_NONE);
1483   printf ("quiet:%lu:\n",   GC_OPT_FLAG_NONE);
1484   printf ("keyserver:%lu:\n", GC_OPT_FLAG_NONE);
1485   printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE);
1486 }
1487
1488
1489 static int
1490 parse_subpacket_list(char *list)
1491 {
1492   char *tok;
1493   byte subpackets[128],i;
1494   int count=0;
1495
1496   if(!list)
1497     {
1498       /* No arguments means all subpackets */
1499       memset(subpackets+1,1,sizeof(subpackets)-1);
1500       count=127;
1501     }
1502   else
1503     {
1504       memset(subpackets,0,sizeof(subpackets));
1505
1506       /* Merge with earlier copy */
1507       if(opt.show_subpackets)
1508         {
1509           byte *in;
1510
1511           for(in=opt.show_subpackets;*in;in++)
1512             {
1513               if(*in>127 || *in<1)
1514                 BUG();
1515
1516               if(!subpackets[*in])
1517                 count++;
1518               subpackets[*in]=1;
1519             }
1520         }
1521
1522       while((tok=strsep(&list," ,")))
1523         {
1524           if(!*tok)
1525             continue;
1526
1527           i=atoi(tok);
1528           if(i>127 || i<1)
1529             return 0;
1530
1531           if(!subpackets[i])
1532             count++;
1533           subpackets[i]=1;
1534         }
1535     }
1536
1537   xfree(opt.show_subpackets);
1538   opt.show_subpackets=xmalloc(count+1);
1539   opt.show_subpackets[count--]=0;
1540
1541   for(i=1;i<128 && count>=0;i++)
1542     if(subpackets[i])
1543       opt.show_subpackets[count--]=i;
1544
1545   return 1;
1546 }
1547
1548
1549 static int
1550 parse_list_options(char *str)
1551 {
1552   char *subpackets=""; /* something that isn't NULL */
1553   struct parse_options lopts[]=
1554     {
1555       {"show-photos",LIST_SHOW_PHOTOS,NULL,
1556        N_("display photo IDs during key listings")},
1557       {"show-policy-urls",LIST_SHOW_POLICY_URLS,NULL,
1558        N_("show policy URLs during signature listings")},
1559       {"show-notations",LIST_SHOW_NOTATIONS,NULL,
1560        N_("show all notations during signature listings")},
1561       {"show-std-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1562        N_("show IETF standard notations during signature listings")},
1563       {"show-standard-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1564        NULL},
1565       {"show-user-notations",LIST_SHOW_USER_NOTATIONS,NULL,
1566        N_("show user-supplied notations during signature listings")},
1567       {"show-keyserver-urls",LIST_SHOW_KEYSERVER_URLS,NULL,
1568        N_("show preferred keyserver URLs during signature listings")},
1569       {"show-uid-validity",LIST_SHOW_UID_VALIDITY,NULL,
1570        N_("show user ID validity during key listings")},
1571       {"show-unusable-uids",LIST_SHOW_UNUSABLE_UIDS,NULL,
1572        N_("show revoked and expired user IDs in key listings")},
1573       {"show-unusable-subkeys",LIST_SHOW_UNUSABLE_SUBKEYS,NULL,
1574        N_("show revoked and expired subkeys in key listings")},
1575       {"show-keyring",LIST_SHOW_KEYRING,NULL,
1576        N_("show the keyring name in key listings")},
1577       {"show-sig-expire",LIST_SHOW_SIG_EXPIRE,NULL,
1578        N_("show expiration dates during signature listings")},
1579       {"show-sig-subpackets",LIST_SHOW_SIG_SUBPACKETS,NULL,
1580        NULL},
1581       {NULL,0,NULL,NULL}
1582     };
1583
1584   /* C99 allows for non-constant initializers, but we'd like to
1585      compile everywhere, so fill in the show-sig-subpackets argument
1586      here.  Note that if the parse_options array changes, we'll have
1587      to change the subscript here. */
1588   lopts[12].value=&subpackets;
1589
1590   if(parse_options(str,&opt.list_options,lopts,1))
1591     {
1592       if(opt.list_options&LIST_SHOW_SIG_SUBPACKETS)
1593         {
1594           /* Unset so users can pass multiple lists in. */
1595           opt.list_options&=~LIST_SHOW_SIG_SUBPACKETS;
1596           if(!parse_subpacket_list(subpackets))
1597             return 0;
1598         }
1599       else if(subpackets==NULL && opt.show_subpackets)
1600         {
1601           /* User did 'no-show-subpackets' */
1602           xfree(opt.show_subpackets);
1603           opt.show_subpackets=NULL;
1604         }
1605
1606       return 1;
1607     }
1608   else
1609     return 0;
1610 }
1611
1612
1613 /* Collapses argc/argv into a single string that must be freed */
1614 static char *
1615 collapse_args(int argc,char *argv[])
1616 {
1617   char *str=NULL;
1618   int i,first=1,len=0;
1619
1620   for(i=0;i<argc;i++)
1621     {
1622       len+=strlen(argv[i])+2;
1623       str=xrealloc(str,len);
1624       if(first)
1625         {
1626           str[0]='\0';
1627           first=0;
1628         }
1629       else
1630         strcat(str," ");
1631
1632       strcat(str,argv[i]);
1633     }
1634
1635   return str;
1636 }
1637
1638 static void
1639 parse_trust_model(const char *model)
1640 {
1641   if(ascii_strcasecmp(model,"pgp")==0)
1642     opt.trust_model=TM_PGP;
1643   else if(ascii_strcasecmp(model,"classic")==0)
1644     opt.trust_model=TM_CLASSIC;
1645   else if(ascii_strcasecmp(model,"always")==0)
1646     opt.trust_model=TM_ALWAYS;
1647   else if(ascii_strcasecmp(model,"direct")==0)
1648     opt.trust_model=TM_DIRECT;
1649   else if(ascii_strcasecmp(model,"auto")==0)
1650     opt.trust_model=TM_AUTO;
1651   else
1652     log_error("unknown trust model `%s'\n",model);
1653 }
1654
1655 /* Must be called before we open any files. */
1656 static void
1657 reopen_std(void)
1658 {
1659 #if defined(HAVE_STAT) && !defined(HAVE_W32_SYSTEM)
1660   struct stat statbuf;
1661   int did_stdin=0,did_stdout=0,did_stderr=0;
1662   FILE *complain;
1663
1664   if(fstat(STDIN_FILENO,&statbuf)==-1 && errno==EBADF)
1665     {
1666       if(open("/dev/null",O_RDONLY)==STDIN_FILENO)
1667         did_stdin=1;
1668       else
1669         did_stdin=2;
1670     }
1671
1672   if(fstat(STDOUT_FILENO,&statbuf)==-1 && errno==EBADF)
1673     {
1674       if(open("/dev/null",O_WRONLY)==STDOUT_FILENO)
1675         did_stdout=1;
1676       else
1677         did_stdout=2;
1678     }
1679
1680   if(fstat(STDERR_FILENO,&statbuf)==-1 && errno==EBADF)
1681     {
1682       if(open("/dev/null",O_WRONLY)==STDERR_FILENO)
1683         did_stderr=1;
1684       else
1685         did_stderr=2;
1686     }
1687
1688   /* It's hard to log this sort of thing since the filehandle we would
1689      complain to may be closed... */
1690   if(did_stderr==0)
1691     complain=stderr;
1692   else if(did_stdout==0)
1693     complain=stdout;
1694   else
1695     complain=NULL;
1696
1697   if(complain)
1698     {
1699       if(did_stdin==1)
1700         fprintf(complain,"gpg: WARNING: standard input reopened\n");
1701       if(did_stdout==1)
1702         fprintf(complain,"gpg: WARNING: standard output reopened\n");
1703       if(did_stderr==1)
1704         fprintf(complain,"gpg: WARNING: standard error reopened\n");
1705
1706       if(did_stdin==2 || did_stdout==2 || did_stderr==2)
1707         fprintf(complain,"gpg: fatal: unable to reopen standard input,"
1708                 " output, or error\n");
1709     }
1710
1711   if(did_stdin==2 || did_stdout==2 || did_stderr==2)
1712     exit(3);
1713 #endif /* HAVE_STAT && !HAVE_W32_SYSTEM */
1714 }
1715
1716 /* Pack an s2k iteration count into the form specified in 2440.  If
1717    we're in between valid values, round up. */
1718 static unsigned char
1719 encode_s2k_iterations(int iterations)
1720 {
1721   unsigned char c=0,result;
1722   unsigned int count;
1723
1724   if(iterations<=1024)
1725     return 0;
1726
1727   if(iterations>=65011712)
1728     return 255;
1729
1730   /* Need count to be in the range 16-31 */
1731   for(count=iterations>>6;count>=32;count>>=1)
1732     c++;
1733
1734   result=(c<<4)|(count-16);
1735
1736   if(S2K_DECODE_COUNT(result)<iterations)
1737     result++;
1738
1739   return result;
1740 }
1741
1742
1743 char *
1744 get_default_configname (void)
1745 {
1746   char *configname = NULL;
1747   char *name = xstrdup ("gpg" EXTSEP_S "conf-" SAFE_VERSION);
1748   char *ver = &name[strlen ("gpg" EXTSEP_S "conf-")];
1749
1750   do
1751     {
1752       if (configname)
1753         {
1754           char *tok;
1755
1756           xfree (configname);
1757           configname = NULL;
1758
1759           if ((tok = strrchr (ver, SAFE_VERSION_DASH)))
1760             *tok='\0';
1761           else if ((tok = strrchr (ver, SAFE_VERSION_DOT)))
1762             *tok='\0';
1763           else
1764             break;
1765         }
1766
1767       configname = make_filename (opt.homedir, name, NULL);
1768     }
1769   while (access (configname, R_OK));
1770
1771   xfree(name);
1772
1773   if (! configname)
1774     configname = make_filename (opt.homedir, "gpg" EXTSEP_S "conf", NULL);
1775   if (! access (configname, R_OK))
1776     {
1777       /* Print a warning when both config files are present.  */
1778       char *p = make_filename (opt.homedir, "options", NULL);
1779       if (! access (p, R_OK))
1780         log_info (_("NOTE: old default options file `%s' ignored\n"), p);
1781       xfree (p);
1782     }
1783   else
1784     {
1785       /* Use the old default only if it exists.  */
1786       char *p = make_filename (opt.homedir, "options", NULL);
1787       if (!access (p, R_OK))
1788         {
1789           xfree (configname);
1790           configname = p;
1791         }
1792       else
1793         xfree (p);
1794     }
1795
1796   return configname;
1797 }
1798
1799
1800
1801 int
1802 main (int argc, char **argv )
1803 {
1804     ARGPARSE_ARGS pargs;
1805     IOBUF a;
1806     int rc=0;
1807     int orig_argc;
1808     char **orig_argv;
1809     const char *fname;
1810     char *username;
1811     int may_coredump;
1812     STRLIST sl, remusr= NULL, locusr=NULL;
1813     STRLIST nrings=NULL, sec_nrings=NULL;
1814     armor_filter_context_t afx;
1815     int detached_sig = 0;
1816     FILE *configfp = NULL;
1817     char *configname = NULL;
1818     char *save_configname = NULL;
1819     char *default_configname = NULL;
1820     unsigned configlineno;
1821     int parse_debug = 0;
1822     int default_config = 1;
1823     int default_keyring = 1;
1824     int greeting = 0;
1825     int nogreeting = 0;
1826     int use_random_seed = 1;
1827     enum cmd_and_opt_values cmd = 0;
1828     const char *trustdb_name = NULL;
1829     char *def_cipher_string = NULL;
1830     char *def_digest_string = NULL;
1831     char *compress_algo_string = NULL;
1832     char *cert_digest_string = NULL;
1833     char *s2k_cipher_string = NULL;
1834     char *s2k_digest_string = NULL;
1835     char *pers_cipher_list = NULL;
1836     char *pers_digest_list = NULL;
1837     char *pers_compress_list = NULL;
1838     int eyes_only=0;
1839     int multifile=0;
1840     int pwfd = -1;
1841     int fpr_maybe_cmd = 0; /* --fingerprint maybe a command.  */
1842     int any_explicit_recipient = 0;
1843     int require_secmem=0,got_secmem=0;
1844 #ifdef USE_SHM_COPROCESSING
1845     ulong requested_shm_size=0;
1846 #endif
1847
1848 #ifdef __riscos__
1849     opt.lock_once = 1;
1850 #endif /* __riscos__ */
1851
1852 #ifdef __VMS
1853     /* On VMS, set the default value of the "--[no-]batch" flag
1854      * according to the actual process mode.  The user can override
1855      * this with an explicit command-line "--[no-]batch" option.  This
1856      * avoids that the process stops while trying to initialize the
1857      * tty in batch mode.  */
1858     opt.batch = batch_mode_vms();
1859 #endif
1860
1861     reopen_std();
1862     trap_unaligned();
1863     secmem_set_flags( secmem_get_flags() | 2 ); /* suspend warnings */
1864     /* Please note that we may running SUID(ROOT), so be very CAREFUL
1865      * when adding any stuff between here and the call to
1866      * secmem_init()  somewhere after the option parsing
1867      */
1868     log_set_name("gpg");
1869     secure_randoxmalloc(); /* put random number into secure memory */
1870     may_coredump = disable_core_dumps();
1871     init_signals();
1872     dotlock_create (NULL, 0); /* Register locking cleanup.  */
1873     i18n_init();
1874     opt.command_fd = -1; /* no command fd */
1875     opt.compress_level = -1; /* defaults to standard compress level */
1876     opt.bz2_compress_level = -1; /* defaults to standard compress level */
1877     /* note: if you change these lines, look at oOpenPGP */
1878     opt.def_cipher_algo = 0;
1879     opt.def_digest_algo = 0;
1880     opt.cert_digest_algo = 0;
1881     opt.compress_algo = -1; /* defaults to DEFAULT_COMPRESS_ALGO */
1882     opt.s2k_mode = 3; /* iterated+salted */
1883     opt.s2k_count = 96; /* 65536 iterations */
1884 #ifdef USE_CAST5
1885     opt.s2k_cipher_algo = CIPHER_ALGO_CAST5;
1886 #else
1887     opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
1888 #endif
1889     opt.completes_needed = 1;
1890     opt.marginals_needed = 3;
1891     opt.max_cert_depth = 5;
1892     opt.pgp2_workarounds = 1;
1893     opt.escape_from = 1;
1894     opt.flags.require_cross_cert = 1;
1895     opt.import_options=IMPORT_SK2PK;
1896     opt.export_options=EXPORT_ATTRIBUTES;
1897     opt.keyserver_options.import_options=IMPORT_REPAIR_PKS_SUBKEY_BUG;
1898     opt.keyserver_options.export_options=EXPORT_ATTRIBUTES;
1899     opt.keyserver_options.options=
1900       KEYSERVER_HONOR_KEYSERVER_URL|KEYSERVER_HONOR_PKA_RECORD;
1901     opt.verify_options=
1902       VERIFY_SHOW_POLICY_URLS|VERIFY_SHOW_STD_NOTATIONS|VERIFY_SHOW_KEYSERVER_URLS;
1903     opt.trust_model=TM_AUTO;
1904     opt.mangle_dos_filenames=0;
1905     opt.min_cert_level=2;
1906     set_screen_dimensions();
1907     opt.keyid_format=KF_SHORT;
1908     opt.def_sig_expire="0";
1909     opt.def_cert_expire="0";
1910     set_homedir ( default_homedir () );
1911     opt.passwd_repeat=1;
1912     opt.emit_version = 1; /* Limit to the major number.  */
1913
1914 #ifdef ENABLE_CARD_SUPPORT
1915 #if defined(_WIN32) || defined(__CYGWIN__)
1916     opt.pcsc_driver = "winscard.dll";
1917 #elif defined(__APPLE__)
1918     opt.pcsc_driver = "/System/Library/Frameworks/PCSC.framework/PCSC";
1919 #elif defined(__GLIBC__)
1920     opt.pcsc_driver = "libpcsclite.so.1";
1921 #else
1922     opt.pcsc_driver = "libpcsclite.so";
1923 #endif
1924     opt.disable_keypad = 1;  /* No keypad support; use gpg2 instead.  */
1925 #endif /*ENABLE_CARD_SUPPORT*/
1926
1927     /* check whether we have a config file on the commandline */
1928     orig_argc = argc;
1929     orig_argv = argv;
1930     pargs.argc = &argc;
1931     pargs.argv = &argv;
1932     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
1933     while( arg_parse( &pargs, opts) ) {
1934         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
1935             parse_debug++;
1936         else if( pargs.r_opt == oOptions ) {
1937             /* yes there is one, so we do not try the default one, but
1938              * read the option file when it is encountered at the commandline
1939              */
1940             default_config = 0;
1941         }
1942         else if( pargs.r_opt == oNoOptions )
1943           {
1944             default_config = 0; /* --no-options */
1945             opt.no_homedir_creation = 1;
1946           }
1947         else if( pargs.r_opt == oHomedir )
1948             set_homedir ( pargs.r.ret_str );
1949         else if( pargs.r_opt == oNoPermissionWarn )
1950             opt.no_perm_warn=1;
1951         else if (pargs.r_opt == oStrict )
1952           {
1953             opt.strict=1;
1954             log_set_strict(1);
1955           }
1956         else if (pargs.r_opt == oNoStrict )
1957           {
1958             opt.strict=0;
1959             log_set_strict(0);
1960           }
1961 #ifdef USE_SHM_COPROCESSING
1962         else if( pargs.r_opt == oRunAsShmCP ) {
1963             /* does not make sense in a options file, we do it here,
1964              * so that we are the able to drop setuid as soon as possible */
1965             opt.shm_coprocess = 1;
1966             requested_shm_size = pargs.r.ret_ulong;
1967         }
1968         else if ( pargs.r_opt == oStatusFD ) {
1969             /* this is needed to ensure that the status-fd filedescriptor is
1970              * initialized when init_shm_coprocessing() is called */
1971             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1972         }
1973 #endif
1974     }
1975
1976 #ifdef HAVE_DOSISH_SYSTEM
1977     if ( strchr (opt.homedir,'\\') ) {
1978         char *d, *buf = xmalloc (strlen (opt.homedir)+1);
1979         const char *s = opt.homedir;
1980         for (d=buf,s=opt.homedir; *s; s++)
1981           {
1982             *d++ = *s == '\\'? '/': *s;
1983 #ifdef HAVE_W32_SYSTEM
1984             if (s[1] && IsDBCSLeadByte (*s))
1985               *d++ = *++s;
1986 #endif
1987           }
1988         *d = 0;
1989         set_homedir (buf);
1990     }
1991 #endif
1992 #ifdef USE_SHM_COPROCESSING
1993     if( opt.shm_coprocess ) {
1994         init_shm_coprocessing(requested_shm_size, 1 );
1995     }
1996 #endif
1997     /* initialize the secure memory. */
1998     got_secmem=secmem_init( 32768 );
1999     maybe_setuid = 0;
2000     /* Okay, we are now working under our real uid */
2001
2002 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
2003     /* There should be no way to get to this spot while still carrying
2004        setuid privs.  Just in case, bomb out if we are. */
2005     if ( getuid () != geteuid () )
2006       BUG();
2007 #endif
2008
2009     set_native_charset (NULL); /* Try to auto set the character set */
2010
2011     /* Try for a version specific config file first */
2012     default_configname = get_default_configname ();
2013     if (default_config)
2014       configname = xstrdup (default_configname);
2015
2016     argc = orig_argc;
2017     argv = orig_argv;
2018     pargs.argc = &argc;
2019     pargs.argv = &argv;
2020     pargs.flags=  1;  /* do not remove the args */
2021
2022     /* By this point we have a homedir, and cannot change it. */
2023     check_permissions(opt.homedir,0);
2024
2025   next_pass:
2026     if( configname ) {
2027       if(check_permissions(configname,1))
2028         {
2029           /* If any options file is unsafe, then disable any external
2030              programs for keyserver calls or photo IDs.  Since the
2031              external program to call is set in the options file, a
2032              unsafe options file can lead to an arbitrary program
2033              being run. */
2034
2035           opt.exec_disable=1;
2036         }
2037
2038         configlineno = 0;
2039         configfp = fopen( configname, "r" );
2040         if (configfp && is_secured_file (fileno (configfp)))
2041           {
2042             fclose (configfp);
2043             configfp = NULL;
2044             errno = EPERM;
2045           }
2046         if( !configfp ) {
2047             if( default_config ) {
2048                 if( parse_debug )
2049                     log_info(_("NOTE: no default option file `%s'\n"),
2050                                                             configname );
2051             }
2052             else {
2053                 log_error(_("option file `%s': %s\n"),
2054                                     configname, strerror(errno) );
2055                 g10_exit(2);
2056             }
2057             xfree(configname); configname = NULL;
2058         }
2059         if( parse_debug && configname )
2060             log_info(_("reading options from `%s'\n"), configname );
2061         default_config = 0;
2062     }
2063
2064     while( optfile_parse( configfp, configname, &configlineno,
2065                                                 &pargs, opts) )
2066       {
2067         switch( pargs.r_opt )
2068           {
2069           case aCheckKeys:
2070           case aListConfig:
2071           case aGPGConfList:
2072           case aGPGConfTest:
2073           case aListPackets:
2074           case aImport:
2075           case aFastImport:
2076           case aSendKeys:
2077           case aRecvKeys:
2078           case aSearchKeys:
2079           case aRefreshKeys:
2080           case aFetchKeys:
2081           case aExport:
2082             set_cmd (&cmd, pargs.r_opt);
2083             break;
2084           case aListKeys: set_cmd( &cmd, aListKeys); break;
2085           case aListSigs: set_cmd( &cmd, aListSigs); break;
2086           case aExportSecret: set_cmd( &cmd, aExportSecret); break;
2087           case aExportSecretSub: set_cmd( &cmd, aExportSecretSub); break;
2088           case aDeleteSecretKeys:
2089             set_cmd( &cmd, aDeleteSecretKeys);
2090             greeting=1;
2091             break;
2092           case aDeleteSecretAndPublicKeys:
2093             set_cmd( &cmd, aDeleteSecretAndPublicKeys);
2094             greeting=1;
2095             break;
2096           case aDeleteKeys: set_cmd( &cmd, aDeleteKeys); greeting=1; break;
2097
2098           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
2099           case aSym: set_cmd( &cmd, aSym); break;
2100
2101           case aDecryptFiles: multifile=1; /* fall through */
2102           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
2103
2104           case aEncrFiles: multifile=1; /* fall through */
2105           case aEncr: set_cmd( &cmd, aEncr); break;
2106
2107           case aVerifyFiles: multifile=1; /* fall through */
2108           case aVerify: set_cmd( &cmd, aVerify); break;
2109
2110           case aSign: set_cmd( &cmd, aSign );  break;
2111           case aKeygen: set_cmd( &cmd, aKeygen); greeting=1; break;
2112           case aSignKey: set_cmd( &cmd, aSignKey); break;
2113           case aLSignKey: set_cmd( &cmd, aLSignKey); break;
2114           case aStore: set_cmd( &cmd, aStore); break;
2115           case aEditKey: set_cmd( &cmd, aEditKey); greeting=1; break;
2116           case aClearsign: set_cmd( &cmd, aClearsign); break;
2117           case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
2118           case aDesigRevoke: set_cmd( &cmd, aDesigRevoke); break;
2119           case aPrimegen: set_cmd( &cmd, aPrimegen); break;
2120           case aGenRandom: set_cmd( &cmd, aGenRandom); break;
2121           case aPrintMD: set_cmd( &cmd, aPrintMD); break;
2122           case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
2123           case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
2124           case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
2125           case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
2126           case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
2127           case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
2128           case aDeArmor: set_cmd( &cmd, aDeArmor); break;
2129           case aEnArmor: set_cmd( &cmd, aEnArmor); break;
2130           case aListOwnerTrust:
2131             deprecated_warning(configname,configlineno,
2132                                "--list-ownertrust","--export-ownertrust","");
2133           case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
2134           case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
2135           case aPipeMode:
2136             deprecated_command ("--pipemode");
2137             set_cmd( &cmd, aPipeMode);
2138             break;
2139
2140           case aRebuildKeydbCaches: set_cmd( &cmd, aRebuildKeydbCaches); break;
2141
2142 #ifdef ENABLE_CARD_SUPPORT
2143           case aCardStatus: set_cmd (&cmd, aCardStatus); break;
2144           case aCardEdit: set_cmd (&cmd, aCardEdit); break;
2145           case aChangePIN: set_cmd (&cmd, aChangePIN); break;
2146           case oReaderPort:
2147             card_set_reader_port (pargs.r.ret_str);
2148             break;
2149           case octapiDriver: opt.ctapi_driver = pargs.r.ret_str; break;
2150           case opcscDriver: opt.pcsc_driver = pargs.r.ret_str; break;
2151           case oDisableCCID: opt.disable_ccid = 1; break;
2152 #endif /* ENABLE_CARD_SUPPORT*/
2153
2154           case oArmor: opt.armor = 1; opt.no_armor=0; break;
2155           case oOutput: opt.outfile = pargs.r.ret_str; break;
2156           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
2157           case oQuiet: opt.quiet = 1; break;
2158           case oNoTTY: tty_no_terminal(1); break;
2159           case oDryRun: opt.dry_run = 1; break;
2160           case oInteractive: opt.interactive = 1; break;
2161           case oVerbose:
2162             g10_opt_verbose++;
2163             opt.verbose++;
2164             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
2165             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
2166             break;
2167           case oKOption: set_cmd( &cmd, aKMode ); break;
2168
2169           case oBatch: opt.batch = 1; nogreeting = 1; break;
2170           case oUseAgent:
2171 #ifndef __riscos__
2172             opt.use_agent = 1;
2173 #else /* __riscos__ */
2174             opt.use_agent = 0;
2175             riscos_not_implemented("use-agent");
2176 #endif /* __riscos__ */
2177             break;
2178           case oNoUseAgent: opt.use_agent = 0; break;
2179           case oGpgAgentInfo: opt.gpg_agent_info = pargs.r.ret_str; break;
2180           case oAnswerYes: opt.answer_yes = 1; break;
2181           case oAnswerNo: opt.answer_no = 1; break;
2182           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
2183           case oPrimaryKeyring:
2184             sl=append_to_strlist( &nrings, pargs.r.ret_str);
2185             sl->flags=2;
2186             break;
2187           case oShowKeyring:
2188             deprecated_warning(configname,configlineno,"--show-keyring",
2189                                "--list-options ","show-keyring");
2190             opt.list_options|=LIST_SHOW_KEYRING;
2191             break;
2192           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
2193           case oDebugAll: opt.debug = ~0; break;
2194           case oDebugLevel: break; /* Not supported.  */
2195           case oDebugCCIDDriver:
2196 #if defined(ENABLE_CARD_SUPPORT) && defined(HAVE_LIBUSB)
2197             ccid_set_debug_level (ccid_set_debug_level (1)+1);
2198 #endif
2199             break;
2200           case oStatusFD:
2201             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
2202             break;
2203           case oStatusFile:
2204             set_status_fd ( open_info_file (pargs.r.ret_str, 1) );
2205             break;
2206           case oAttributeFD:
2207             set_attrib_fd(iobuf_translate_file_handle (pargs.r.ret_int, 1));
2208             break;
2209           case oAttributeFile:
2210             set_attrib_fd ( open_info_file (pargs.r.ret_str, 1) );
2211             break;
2212           case oLoggerFD:
2213             log_set_logfile( NULL,
2214                              iobuf_translate_file_handle (pargs.r.ret_int, 1));
2215             break;
2216           case oLoggerFile:
2217             /* Our log code does not support the socket feature.  Thus
2218                we ignore such log files to avoid problems with
2219                gpg.conf files which are also used by gpg2.  */
2220             if (strncmp (pargs.r.ret_str, "socket://", 9))
2221               log_set_logfile( NULL, open_info_file (pargs.r.ret_str, 1) );
2222             break;
2223
2224           case oWithFingerprint:
2225             opt.with_fingerprint = 1;
2226             opt.fingerprint++;
2227             break;
2228           case oFingerprint:
2229             opt.fingerprint++;
2230             fpr_maybe_cmd = 1;
2231             break;
2232
2233           case oSecretKeyring:
2234             append_to_strlist( &sec_nrings, pargs.r.ret_str);
2235             break;
2236           case oOptions:
2237             /* config files may not be nested (silently ignore them) */
2238             if( !configfp ) {
2239                 xfree(configname);
2240                 configname = xstrdup(pargs.r.ret_str);
2241                 goto next_pass;
2242             }
2243             break;
2244           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
2245           case oNoDefKeyring: default_keyring = 0; break;
2246           case oNoGreeting: nogreeting = 1; break;
2247           case oNoVerbose: g10_opt_verbose = 0;
2248                            opt.verbose = 0; opt.list_sigs=0; break;
2249           case oQuickRandom: quick_random_gen(1); break;
2250           case oEmitVersion: opt.emit_version++; break;
2251           case oNoEmitVersion: opt.emit_version=0; break;
2252           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
2253           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
2254           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
2255           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
2256           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
2257           case oDefRecipient:
2258                     if( *pargs.r.ret_str )
2259                         opt.def_recipient = make_username(pargs.r.ret_str);
2260                     break;
2261           case oDefRecipientSelf:
2262                     xfree(opt.def_recipient); opt.def_recipient = NULL;
2263                     opt.def_recipient_self = 1;
2264                     break;
2265           case oNoDefRecipient:
2266                     xfree(opt.def_recipient); opt.def_recipient = NULL;
2267                     opt.def_recipient_self = 0;
2268                     break;
2269           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
2270           case oHomedir: break;
2271           case oNoBatch: opt.batch = 0; break;
2272           case oWithKeyData: opt.with_key_data=1; /* fall thru */
2273           case oWithColons: opt.with_colons=':'; break;
2274
2275           case oSkipVerify: opt.skip_verify=1; break;
2276           case oCompressKeys: opt.compress_keys = 1; break;
2277           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
2278             /* There are many programs (like mutt) that call gpg with
2279                --always-trust so keep this option around for a long
2280                time. */
2281           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
2282           case oTrustModel:
2283             parse_trust_model(pargs.r.ret_str);
2284             break;
2285           case oForceOwnertrust:
2286             log_info(_("NOTE: %s is not for normal use!\n"),
2287                      "--force-ownertrust");
2288             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
2289             if(opt.force_ownertrust==-1)
2290               {
2291                 log_error("invalid ownertrust `%s'\n",pargs.r.ret_str);
2292                 opt.force_ownertrust=0;
2293               }
2294             break;
2295           case oLoadExtension:
2296             break;  /* This is a dummy option since 1.4.13.  */
2297           case oRFC1991:
2298             opt.compliance = CO_RFC1991;
2299             opt.force_v4_certs = 0;
2300             opt.escape_from = 1;
2301             break;
2302           case oOpenPGP:
2303           case oRFC4880:
2304             /* This is effectively the same as RFC2440, but with
2305                "--enable-dsa2 --no-rfc2440-text --escape-from-lines
2306                --require-cross-certification". */
2307             opt.compliance = CO_RFC4880;
2308             opt.flags.dsa2 = 1;
2309             opt.flags.require_cross_cert = 1;
2310             opt.rfc2440_text = 0;
2311             opt.allow_non_selfsigned_uid = 1;
2312             opt.allow_freeform_uid = 1;
2313             opt.pgp2_workarounds = 0;
2314             opt.escape_from = 1;
2315             opt.force_v3_sigs = 0;
2316             opt.compress_keys = 0;          /* not mandated, but we do it */
2317             opt.compress_sigs = 0;          /* ditto. */
2318             opt.not_dash_escaped = 0;
2319             opt.def_cipher_algo = 0;
2320             opt.def_digest_algo = 0;
2321             opt.cert_digest_algo = 0;
2322             opt.compress_algo = -1;
2323             opt.s2k_mode = 3; /* iterated+salted */
2324             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2325             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2326             break;
2327           case oRFC2440:
2328             opt.compliance = CO_RFC2440;
2329             opt.flags.dsa2 = 0;
2330             opt.rfc2440_text = 1;
2331             opt.allow_non_selfsigned_uid = 1;
2332             opt.allow_freeform_uid = 1;
2333             opt.pgp2_workarounds = 0;
2334             opt.escape_from = 0;
2335             opt.force_v3_sigs = 0;
2336             opt.compress_keys = 0;          /* not mandated, but we do it */
2337             opt.compress_sigs = 0;          /* ditto. */
2338             opt.not_dash_escaped = 0;
2339             opt.def_cipher_algo = 0;
2340             opt.def_digest_algo = 0;
2341             opt.cert_digest_algo = 0;
2342             opt.compress_algo = -1;
2343             opt.s2k_mode = 3; /* iterated+salted */
2344             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2345             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2346             break;
2347           case oPGP2:  opt.compliance = CO_PGP2;  break;
2348           case oPGP6:  opt.compliance = CO_PGP6;  break;
2349           case oPGP7:  opt.compliance = CO_PGP7;  break;
2350           case oPGP8:  opt.compliance = CO_PGP8;  break;
2351           case oGnuPG: opt.compliance = CO_GNUPG; break;
2352           case oCompressSigs: opt.compress_sigs = 1; break;
2353           case oRFC2440Text: opt.rfc2440_text=1; break;
2354           case oNoRFC2440Text: opt.rfc2440_text=0; break;
2355           case oRunAsShmCP:
2356 #ifndef __riscos__
2357 # ifndef USE_SHM_COPROCESSING
2358             /* not possible in the option file,
2359              * but we print the warning here anyway */
2360             log_error("shared memory coprocessing is not available\n");
2361 # endif
2362 #else /* __riscos__ */
2363             riscos_not_implemented("run-as-shm-coprocess");
2364 #endif /* __riscos__ */
2365             break;
2366           case oSetFilename:
2367             if(utf8_strings)
2368               opt.set_filename = pargs.r.ret_str;
2369             else
2370               opt.set_filename = native_to_utf8(pargs.r.ret_str);
2371             break;
2372           case oForYourEyesOnly: eyes_only = 1; break;
2373           case oNoForYourEyesOnly: eyes_only = 0; break;
2374           case oSetPolicyURL:
2375             add_policy_url(pargs.r.ret_str,0);
2376             add_policy_url(pargs.r.ret_str,1);
2377             break;
2378           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
2379           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
2380           case oShowPolicyURL:
2381             deprecated_warning(configname,configlineno,"--show-policy-url",
2382                                "--list-options ","show-policy-urls");
2383             deprecated_warning(configname,configlineno,"--show-policy-url",
2384                                "--verify-options ","show-policy-urls");
2385             opt.list_options|=LIST_SHOW_POLICY_URLS;
2386             opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
2387             break;
2388           case oNoShowPolicyURL:
2389             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2390                                "--list-options ","no-show-policy-urls");
2391             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2392                                "--verify-options ","no-show-policy-urls");
2393             opt.list_options&=~LIST_SHOW_POLICY_URLS;
2394             opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
2395             break;
2396           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
2397           case oUseEmbeddedFilename:
2398             opt.flags.use_embedded_filename=1;
2399             break;
2400           case oNoUseEmbeddedFilename:
2401             opt.flags.use_embedded_filename=0;
2402             break;
2403           case oComment:
2404             if(pargs.r.ret_str[0])
2405               append_to_strlist(&opt.comments,pargs.r.ret_str);
2406             break;
2407           case oDefaultComment:
2408             deprecated_warning(configname,configlineno,
2409                                "--default-comment","--no-comments","");
2410             /* fall through */
2411           case oNoComments:
2412             free_strlist(opt.comments);
2413             opt.comments=NULL;
2414             break;
2415           case oThrowKeyids: opt.throw_keyid = 1; break;
2416           case oNoThrowKeyids: opt.throw_keyid = 0; break;
2417           case oShowPhotos:
2418             deprecated_warning(configname,configlineno,"--show-photos",
2419                                "--list-options ","show-photos");
2420             deprecated_warning(configname,configlineno,"--show-photos",
2421                                "--verify-options ","show-photos");
2422             opt.list_options|=LIST_SHOW_PHOTOS;
2423             opt.verify_options|=VERIFY_SHOW_PHOTOS;
2424             break;
2425           case oNoShowPhotos:
2426             deprecated_warning(configname,configlineno,"--no-show-photos",
2427                                "--list-options ","no-show-photos");
2428             deprecated_warning(configname,configlineno,"--no-show-photos",
2429                                "--verify-options ","no-show-photos");
2430             opt.list_options&=~LIST_SHOW_PHOTOS;
2431             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
2432             break;
2433           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
2434           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
2435           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
2436           case oForceV4Certs: opt.force_v4_certs = 1; break;
2437           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
2438           case oForceMDC: opt.force_mdc = 1; break;
2439           case oNoForceMDC: opt.force_mdc = 0; break;
2440           case oDisableMDC: opt.disable_mdc = 1; break;
2441           case oNoDisableMDC: opt.disable_mdc = 0; break;
2442           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
2443           case oS2KDigest: s2k_digest_string = xstrdup(pargs.r.ret_str); break;
2444           case oS2KCipher: s2k_cipher_string = xstrdup(pargs.r.ret_str); break;
2445           case oS2KCount:
2446             opt.s2k_count=encode_s2k_iterations(pargs.r.ret_int);
2447             break;
2448           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
2449           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
2450           case oEncryptTo: /* store the recipient in the second list */
2451             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2452             sl->flags = 1;
2453             break;
2454           case oHiddenEncryptTo: /* store the recipient in the second list */
2455             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2456             sl->flags = 1|2;
2457             break;
2458           case oRecipient: /* store the recipient */
2459             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2460             any_explicit_recipient = 1;
2461             break;
2462           case oHiddenRecipient: /* store the recipient with a flag */
2463             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2464             sl->flags = 2;
2465             any_explicit_recipient = 1;
2466             break;
2467           case oTextmodeShort: opt.textmode = 2; break;
2468           case oTextmode: opt.textmode=1;  break;
2469           case oNoTextmode: opt.textmode=0;  break;
2470           case oExpert: opt.expert = 1; break;
2471           case oNoExpert: opt.expert = 0; break;
2472           case oDefSigExpire:
2473             if(*pargs.r.ret_str!='\0')
2474               {
2475                 if(parse_expire_string(0,pargs.r.ret_str)==(u32)-1)
2476                   log_error(_("`%s' is not a valid signature expiration\n"),
2477                             pargs.r.ret_str);
2478                 else
2479                   opt.def_sig_expire=pargs.r.ret_str;
2480               }
2481             break;
2482           case oAskSigExpire: opt.ask_sig_expire = 1; break;
2483           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
2484           case oDefCertExpire:
2485             if(*pargs.r.ret_str!='\0')
2486               {
2487                 if(parse_expire_string(0,pargs.r.ret_str)==(u32)-1)
2488                   log_error(_("`%s' is not a valid signature expiration\n"),
2489                             pargs.r.ret_str);
2490                 else
2491                   opt.def_cert_expire=pargs.r.ret_str;
2492               }
2493             break;
2494           case oAskCertExpire: opt.ask_cert_expire = 1; break;
2495           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
2496           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
2497           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
2498           case oAskCertLevel: opt.ask_cert_level = 1; break;
2499           case oNoAskCertLevel: opt.ask_cert_level = 0; break;
2500           case oLocalUser: /* store the local users */
2501             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
2502             break;
2503           case oCompress:
2504             /* this is the -z command line option */
2505             opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
2506             break;
2507           case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
2508           case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
2509           case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
2510           case oPasswd:
2511             set_passphrase_from_string(pargs.r.ret_str);
2512             break;
2513           case oPasswdFD:
2514             pwfd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
2515             opt.use_agent = 0;
2516             break;
2517           case oPasswdFile:
2518             pwfd = open_info_file (pargs.r.ret_str, 0);
2519             break;
2520           case oPasswdRepeat: opt.passwd_repeat=pargs.r.ret_int; break;
2521           case oCommandFD:
2522             opt.command_fd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
2523             break;
2524           case oCommandFile:
2525             opt.command_fd = open_info_file (pargs.r.ret_str, 0);
2526             break;
2527           case oCipherAlgo:
2528             def_cipher_string = xstrdup(pargs.r.ret_str);
2529             break;
2530           case oDigestAlgo:
2531             def_digest_string = xstrdup(pargs.r.ret_str);
2532             break;
2533           case oCompressAlgo:
2534             /* If it is all digits, stick a Z in front of it for
2535                later.  This is for backwards compatibility with
2536                versions that took the compress algorithm number. */
2537             {
2538               char *pt=pargs.r.ret_str;
2539               while(*pt)
2540                 {
2541                   if (!isascii (*pt) || !isdigit (*pt))
2542                     break;
2543
2544                   pt++;
2545                 }
2546
2547               if(*pt=='\0')
2548                 {
2549                   compress_algo_string=xmalloc(strlen(pargs.r.ret_str)+2);
2550                   strcpy(compress_algo_string,"Z");
2551                   strcat(compress_algo_string,pargs.r.ret_str);
2552                 }
2553               else
2554                 compress_algo_string = xstrdup(pargs.r.ret_str);
2555             }
2556             break;
2557           case oCertDigestAlgo: cert_digest_string = xstrdup(pargs.r.ret_str); break;
2558           case oNoSecmemWarn: secmem_set_flags( secmem_get_flags() | 1 ); break;
2559           case oRequireSecmem: require_secmem=1; break;
2560           case oNoRequireSecmem: require_secmem=0; break;
2561           case oNoPermissionWarn: opt.no_perm_warn=1; break;
2562           case oNoMDCWarn: opt.no_mdc_warn=1; break;
2563           case oDisplayCharset:
2564             if( set_native_charset( pargs.r.ret_str ) )
2565                 log_error(_("`%s' is not a valid character set\n"),
2566                           pargs.r.ret_str);
2567             break;
2568           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
2569           case oEscapeFrom: opt.escape_from = 1; break;
2570           case oNoEscapeFrom: opt.escape_from = 0; break;
2571           case oLockOnce: opt.lock_once = 1; break;
2572           case oLockNever:
2573             dotlock_disable ();
2574             random_disable_locking ();
2575             break;
2576           case oLockMultiple:
2577 #ifndef __riscos__
2578             opt.lock_once = 0;
2579 #else /* __riscos__ */
2580             riscos_not_implemented("lock-multiple");
2581 #endif /* __riscos__ */
2582             break;
2583           case oKeyServer:
2584             {
2585               struct keyserver_spec *keyserver;
2586               keyserver=parse_keyserver_uri(pargs.r.ret_str,0,
2587                                             configname,configlineno);
2588               if(!keyserver)
2589                 log_error(_("could not parse keyserver URL\n"));
2590               else
2591                 {
2592                   keyserver->next=opt.keyserver;
2593                   opt.keyserver=keyserver;
2594                 }
2595             }
2596             break;
2597           case oKeyServerOptions:
2598             if(!parse_keyserver_options(pargs.r.ret_str))
2599               {
2600                 if(configname)
2601                   log_error(_("%s:%d: invalid keyserver options\n"),
2602                             configname,configlineno);
2603                 else
2604                   log_error(_("invalid keyserver options\n"));
2605               }
2606             break;
2607           case oImportOptions:
2608             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
2609               {
2610                 if(configname)
2611                   log_error(_("%s:%d: invalid import options\n"),
2612                             configname,configlineno);
2613                 else
2614                   log_error(_("invalid import options\n"));
2615               }
2616             break;
2617           case oExportOptions:
2618             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
2619               {
2620                 if(configname)
2621                   log_error(_("%s:%d: invalid export options\n"),
2622                             configname,configlineno);
2623                 else
2624                   log_error(_("invalid export options\n"));
2625               }
2626             break;
2627           case oListOptions:
2628             if(!parse_list_options(pargs.r.ret_str))
2629               {
2630                 if(configname)
2631                   log_error(_("%s:%d: invalid list options\n"),
2632                             configname,configlineno);
2633                 else
2634                   log_error(_("invalid list options\n"));
2635               }
2636             break;
2637           case oVerifyOptions:
2638             {
2639               struct parse_options vopts[]=
2640                 {
2641                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL,
2642                    N_("display photo IDs during signature verification")},
2643                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL,
2644                    N_("show policy URLs during signature verification")},
2645                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL,
2646                    N_("show all notations during signature verification")},
2647                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
2648                    N_("show IETF standard notations during signature verification")},
2649                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
2650                    NULL},
2651                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL,
2652                    N_("show user-supplied notations during signature verification")},
2653                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL,
2654                    N_("show preferred keyserver URLs during signature verification")},
2655                   {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL,
2656                    N_("show user ID validity during signature verification")},
2657                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL,
2658                    N_("show revoked and expired user IDs in signature verification")},
2659                   {"show-primary-uid-only",VERIFY_SHOW_PRIMARY_UID_ONLY,NULL,
2660                    N_("show only the primary user ID in signature verification")},
2661                   {"pka-lookups",VERIFY_PKA_LOOKUPS,NULL,
2662                    N_("validate signatures with PKA data")},
2663                   {"pka-trust-increase",VERIFY_PKA_TRUST_INCREASE,NULL,
2664                    N_("elevate the trust of signatures with valid PKA data")},
2665                   {NULL,0,NULL,NULL}
2666                 };
2667
2668               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
2669                 {
2670                   if(configname)
2671                     log_error(_("%s:%d: invalid verify options\n"),
2672                               configname,configlineno);
2673                   else
2674                     log_error(_("invalid verify options\n"));
2675                 }
2676             }
2677             break;
2678           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
2679           case oExecPath:
2680             if(set_exec_path(pargs.r.ret_str))
2681               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
2682             else
2683               opt.exec_path_set=1;
2684             break;
2685           case oSetNotation:
2686             add_notation_data( pargs.r.ret_str, 0 );
2687             add_notation_data( pargs.r.ret_str, 1 );
2688             break;
2689           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
2690           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
2691           case oShowNotation:
2692             deprecated_warning(configname,configlineno,"--show-notation",
2693                                "--list-options ","show-notations");
2694             deprecated_warning(configname,configlineno,"--show-notation",
2695                                "--verify-options ","show-notations");
2696             opt.list_options|=LIST_SHOW_NOTATIONS;
2697             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
2698             break;
2699           case oNoShowNotation:
2700             deprecated_warning(configname,configlineno,"--no-show-notation",
2701                                "--list-options ","no-show-notations");
2702             deprecated_warning(configname,configlineno,"--no-show-notation",
2703                                "--verify-options ","no-show-notations");
2704             opt.list_options&=~LIST_SHOW_NOTATIONS;
2705             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
2706             break;
2707           case oUtf8Strings: utf8_strings = 1; break;
2708           case oNoUtf8Strings: utf8_strings = 0; break;
2709           case oDisableCipherAlgo:
2710                 disable_cipher_algo( string_to_cipher_algo(pargs.r.ret_str) );
2711                 break;
2712           case oDisablePubkeyAlgo:
2713                 disable_pubkey_algo( string_to_pubkey_algo(pargs.r.ret_str) );
2714                 break;
2715           case oNoSigCache: opt.no_sig_cache = 1; break;
2716           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
2717           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
2718           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
2719           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
2720           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
2721           case oNoLiteral: opt.no_literal = 1; break;
2722           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
2723           case oHonorHttpProxy:
2724                 add_to_strlist(&opt.keyserver_options.other,"http-proxy");
2725                 deprecated_warning(configname,configlineno,
2726                                    "--honor-http-proxy",
2727                                    "--keyserver-options ","http-proxy");
2728                 break;
2729           case oFastListMode: opt.fast_list_mode = 1; break;
2730           case oFixedListMode: opt.fixed_list_mode = 1; break;
2731           case oListOnly: opt.list_only=1; break;
2732           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
2733           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
2734           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
2735           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
2736           case oNoRandomSeedFile: use_random_seed = 0; break;
2737           case oAutoKeyRetrieve:
2738           case oNoAutoKeyRetrieve:
2739                 if(pargs.r_opt==oAutoKeyRetrieve)
2740                   opt.keyserver_options.options|=KEYSERVER_AUTO_KEY_RETRIEVE;
2741                 else
2742                   opt.keyserver_options.options&=~KEYSERVER_AUTO_KEY_RETRIEVE;
2743
2744                 deprecated_warning(configname,configlineno,
2745                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
2746                                "--no-auto-key-retrieve","--keyserver-options ",
2747                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
2748                                "no-auto-key-retrieve");
2749                 break;
2750           case oShowSessionKey: opt.show_session_key = 1; break;
2751           case oOverrideSessionKey:
2752                 opt.override_session_key = pargs.r.ret_str;
2753                 break;
2754           case oMergeOnly:
2755                 deprecated_warning(configname,configlineno,"--merge-only",
2756                                    "--import-options ","merge-only");
2757                 opt.import_options|=IMPORT_MERGE_ONLY;
2758             break;
2759           case oAllowSecretKeyImport: /* obsolete */ break;
2760           case oTryAllSecrets: opt.try_all_secrets = 1; break;
2761           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
2762           case oEnableSpecialFilenames:
2763             iobuf_enable_special_filenames (1);
2764             break;
2765           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
2766           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
2767           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
2768           case oPreservePermissions: opt.preserve_permissions=1; break;
2769           case oDefaultPreferenceList:
2770             opt.def_preference_list = pargs.r.ret_str;
2771             break;
2772           case oDefaultKeyserverURL:
2773             {
2774               struct keyserver_spec *keyserver;
2775               keyserver=parse_keyserver_uri(pargs.r.ret_str,1,
2776                                             configname,configlineno);
2777               if(!keyserver)
2778                 log_error(_("could not parse keyserver URL\n"));
2779               else
2780                 free_keyserver_spec(keyserver);
2781
2782               opt.def_keyserver_url = pargs.r.ret_str;
2783             }
2784             break;
2785           case oPersonalCipherPreferences:
2786             pers_cipher_list=pargs.r.ret_str;
2787             break;
2788           case oPersonalDigestPreferences:
2789             pers_digest_list=pargs.r.ret_str;
2790             break;
2791           case oPersonalCompressPreferences:
2792             pers_compress_list=pargs.r.ret_str;
2793             break;
2794           case oDisplay: opt.display = pargs.r.ret_str; break;
2795           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
2796           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
2797           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
2798           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
2799           case oGroup: add_group(pargs.r.ret_str); break;
2800           case oUnGroup: rm_group(pargs.r.ret_str); break;
2801           case oNoGroups:
2802             while(opt.grouplist)
2803               {
2804                 struct groupitem *iter=opt.grouplist;
2805                 free_strlist(iter->values);
2806                 opt.grouplist=opt.grouplist->next;
2807                 xfree(iter);
2808               }
2809             break;
2810           case oStrict: opt.strict=1; log_set_strict(1); break;
2811           case oNoStrict: opt.strict=0; log_set_strict(0); break;
2812           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
2813           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
2814           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
2815           case oMultifile: multifile=1; break;
2816           case oKeyidFormat:
2817             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
2818               opt.keyid_format=KF_SHORT;
2819             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
2820               opt.keyid_format=KF_LONG;
2821             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
2822               opt.keyid_format=KF_0xSHORT;
2823             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
2824               opt.keyid_format=KF_0xLONG;
2825             else
2826               log_error("unknown keyid-format `%s'\n",pargs.r.ret_str);
2827             break;
2828
2829           case oExitOnStatusWriteError:
2830             opt.exit_on_status_write_error = 1;
2831             break;
2832
2833           case oLimitCardInsertTries:
2834             opt.limit_card_insert_tries = pargs.r.ret_int;
2835             break;
2836
2837           case oRequireCrossCert: opt.flags.require_cross_cert=1; break;
2838           case oNoRequireCrossCert: opt.flags.require_cross_cert=0; break;
2839
2840           case oAutoKeyLocate:
2841             if(!parse_auto_key_locate(pargs.r.ret_str))
2842               {
2843                 if(configname)
2844                   log_error(_("%s:%d: invalid auto-key-locate list\n"),
2845                             configname,configlineno);
2846                 else
2847                   log_error(_("invalid auto-key-locate list\n"));
2848               }
2849             break;
2850           case oNoAutoKeyLocate:
2851             release_akl();
2852             break;
2853
2854           case oEnableDSA2: opt.flags.dsa2=1; break;
2855           case oDisableDSA2: opt.flags.dsa2=0; break;
2856
2857           case oAllowMultisigVerification:
2858           case oAllowMultipleMessages:
2859             opt.flags.allow_multiple_messages=1;
2860             break;
2861
2862           case oNoAllowMultipleMessages:
2863             opt.flags.allow_multiple_messages=0;
2864             break;
2865
2866           case oNoop: break;
2867
2868           default : pargs.err = configfp? 1:2; break;
2869           }
2870       }
2871
2872
2873     if( configfp ) {
2874         fclose( configfp );
2875         configfp = NULL;
2876         /* Remember the first config file name. */
2877         if (!save_configname)
2878           save_configname = configname;
2879         else
2880           xfree(configname);
2881         configname = NULL;
2882         goto next_pass;
2883     }
2884     xfree( configname ); configname = NULL;
2885     if( log_get_errorcount(0) )
2886         g10_exit(2);
2887
2888     /* The command --gpgconf-list is pretty simple and may be called
2889        directly after the option parsing. */
2890     if (cmd == aGPGConfList)
2891       {
2892         gpgconf_list (save_configname ? save_configname : default_configname);
2893         g10_exit (0);
2894       }
2895     xfree (save_configname);
2896     xfree (default_configname);
2897
2898     if( nogreeting )
2899         greeting = 0;
2900
2901     if( greeting ) {
2902         fprintf(stderr, "%s %s; %s\n",
2903                         strusage(11), strusage(13), strusage(14) );
2904         fprintf(stderr, "%s\n", strusage(15) );
2905     }
2906 #ifdef IS_DEVELOPMENT_VERSION
2907     if( !opt.batch )
2908       {
2909         const char *s;
2910
2911         if((s=strusage(20)))
2912           log_info("%s\n",s);
2913         if((s=strusage(21)))
2914           log_info("%s\n",s);
2915         if((s=strusage(22)))
2916           log_info("%s\n",s);
2917       }
2918 #endif
2919
2920     if (opt.verbose > 2)
2921         log_info ("using character set `%s'\n", get_native_charset ());
2922
2923     if( may_coredump && !opt.quiet )
2924         log_info(_("WARNING: program may create a core file!\n"));
2925
2926     if (eyes_only) {
2927       if (opt.set_filename)
2928           log_info(_("WARNING: %s overrides %s\n"),
2929                    "--for-your-eyes-only","--set-filename");
2930
2931       opt.set_filename="_CONSOLE";
2932     }
2933
2934     if (opt.no_literal) {
2935         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
2936         if (opt.textmode)
2937             log_error(_("%s not allowed with %s!\n"),
2938                        "--textmode", "--no-literal" );
2939         if (opt.set_filename)
2940             log_error(_("%s makes no sense with %s!\n"),
2941                         eyes_only?"--for-your-eyes-only":"--set-filename",
2942                         "--no-literal" );
2943     }
2944
2945 #ifndef ENABLE_AGENT_SUPPORT
2946     if (opt.use_agent) {
2947       log_info(_("NOTE: %s is not available in this version\n"),
2948                "--use-agent");
2949       opt.use_agent = 0;
2950     }
2951 #endif /*!ENABLE_AGENT_SUPPORT*/
2952
2953     if (opt.set_filesize)
2954         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
2955     if( opt.batch )
2956         tty_batchmode( 1 );
2957
2958     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
2959
2960     if(require_secmem && !got_secmem)
2961       {
2962         log_info(_("will not run with insecure memory due to %s\n"),
2963                  "--require-secmem");
2964         g10_exit(2);
2965       }
2966
2967     set_debug();
2968
2969     /* Do these after the switch(), so they can override settings. */
2970     if(PGP2)
2971       {
2972         int unusable=0;
2973
2974         if(cmd==aSign && !detached_sig)
2975           {
2976             log_info(_("you can only make detached or clear signatures "
2977                        "while in --pgp2 mode\n"));
2978             unusable=1;
2979           }
2980         else if(cmd==aSignEncr || cmd==aSignSym)
2981           {
2982             log_info(_("you can't sign and encrypt at the "
2983                        "same time while in --pgp2 mode\n"));
2984             unusable=1;
2985           }
2986         else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
2987           {
2988             log_info(_("you must use files (and not a pipe) when "
2989                        "working with --pgp2 enabled.\n"));
2990             unusable=1;
2991           }
2992         else if(cmd==aEncr || cmd==aSym)
2993           {
2994             /* Everything else should work without IDEA (except using
2995                a secret key encrypted with IDEA and setting an IDEA
2996                preference, but those have their own error
2997                messages). */
2998
2999             if(check_cipher_algo(CIPHER_ALGO_IDEA))
3000               {
3001                 log_info(_("encrypting a message in --pgp2 mode requires "
3002                            "the IDEA cipher\n"));
3003                 unusable=1;
3004               }
3005             else if(cmd==aSym)
3006               {
3007                 /* This only sets IDEA for symmetric encryption
3008                    since it is set via select_algo_from_prefs for
3009                    pk encryption. */
3010                 xfree(def_cipher_string);
3011                 def_cipher_string = xstrdup("idea");
3012               }
3013
3014             /* PGP2 can't handle the output from the textmode
3015                filter, so we disable it for anything that could
3016                create a literal packet (only encryption and
3017                symmetric encryption, since we disable signing
3018                above). */
3019             if(!unusable)
3020               opt.textmode=0;
3021           }
3022
3023         if(unusable)
3024           compliance_failure();
3025         else
3026           {
3027             opt.force_v4_certs = 0;
3028             opt.escape_from = 1;
3029             opt.force_v3_sigs = 1;
3030             opt.pgp2_workarounds = 1;
3031             opt.ask_sig_expire = 0;
3032             opt.ask_cert_expire = 0;
3033             xfree(def_digest_string);
3034             def_digest_string = xstrdup("md5");
3035             xfree(s2k_digest_string);
3036             s2k_digest_string = xstrdup("md5");
3037             opt.compress_algo = COMPRESS_ALGO_ZIP;
3038           }
3039       }
3040     else if(PGP6)
3041       {
3042         opt.disable_mdc=1;
3043         opt.escape_from=1;
3044         opt.force_v3_sigs=1;
3045         opt.ask_sig_expire=0;
3046       }
3047     else if(PGP7)
3048       {
3049         opt.escape_from=1;
3050         opt.force_v3_sigs=1;
3051         opt.ask_sig_expire=0;
3052       }
3053     else if(PGP8)
3054       {
3055         opt.escape_from=1;
3056       }
3057
3058     /* must do this after dropping setuid, because string_to...
3059      * may try to load an module */
3060     if( def_cipher_string ) {
3061         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
3062         xfree(def_cipher_string); def_cipher_string = NULL;
3063         if( check_cipher_algo(opt.def_cipher_algo) )
3064             log_error(_("selected cipher algorithm is invalid\n"));
3065     }
3066     if( def_digest_string ) {
3067         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
3068         xfree(def_digest_string); def_digest_string = NULL;
3069         if( check_digest_algo(opt.def_digest_algo) )
3070             log_error(_("selected digest algorithm is invalid\n"));
3071     }
3072     if( compress_algo_string ) {
3073         opt.compress_algo = string_to_compress_algo(compress_algo_string);
3074         xfree(compress_algo_string); compress_algo_string = NULL;
3075         if( check_compress_algo(opt.compress_algo) )
3076             log_error(_("selected compression algorithm is invalid\n"));
3077     }
3078     if( cert_digest_string ) {
3079         opt.cert_digest_algo = string_to_digest_algo(cert_digest_string);
3080         xfree(cert_digest_string); cert_digest_string = NULL;
3081         if( check_digest_algo(opt.cert_digest_algo) )
3082             log_error(_("selected certification digest algorithm is invalid\n"));
3083     }
3084     if( s2k_cipher_string ) {
3085         opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
3086         xfree(s2k_cipher_string); s2k_cipher_string = NULL;
3087         if( check_cipher_algo(opt.s2k_cipher_algo) )
3088             log_error(_("selected cipher algorithm is invalid\n"));
3089     }
3090     if( s2k_digest_string ) {
3091         opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
3092         xfree(s2k_digest_string); s2k_digest_string = NULL;
3093         if( check_digest_algo(opt.s2k_digest_algo) )
3094             log_error(_("selected digest algorithm is invalid\n"));
3095     }
3096     if( opt.completes_needed < 1 )
3097       log_error(_("completes-needed must be greater than 0\n"));
3098     if( opt.marginals_needed < 2 )
3099       log_error(_("marginals-needed must be greater than 1\n"));
3100     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
3101       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
3102     if(opt.def_cert_level<0 || opt.def_cert_level>3)
3103       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
3104     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
3105       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
3106     switch( opt.s2k_mode ) {
3107       case 0:
3108         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
3109         break;
3110       case 1: case 3: break;
3111       default:
3112         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
3113     }
3114
3115     /* This isn't actually needed, but does serve to error out if the
3116        string is invalid. */
3117     if(opt.def_preference_list &&
3118         keygen_set_std_prefs(opt.def_preference_list,0))
3119       log_error(_("invalid default preferences\n"));
3120
3121     if(pers_cipher_list &&
3122        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
3123       log_error(_("invalid personal cipher preferences\n"));
3124
3125     if(pers_digest_list &&
3126        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
3127       log_error(_("invalid personal digest preferences\n"));
3128
3129     if(pers_compress_list &&
3130        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
3131       log_error(_("invalid personal compress preferences\n"));
3132
3133     /* We don't support all possible commands with multifile yet */
3134     if(multifile)
3135       {
3136         char *cmdname;
3137
3138         switch(cmd)
3139           {
3140           case aSign:
3141             cmdname="--sign";
3142             break;
3143           case aClearsign:
3144             cmdname="--clearsign";
3145             break;
3146           case aDetachedSign:
3147             cmdname="--detach-sign";
3148             break;
3149           case aSym:
3150             cmdname="--symmetric";
3151             break;
3152           case aEncrSym:
3153             cmdname="--symmetric --encrypt";
3154             break;
3155           case aStore:
3156             cmdname="--store";
3157             break;
3158           default:
3159             cmdname=NULL;
3160             break;
3161           }
3162
3163         if(cmdname)
3164           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
3165       }
3166
3167     if( log_get_errorcount(0) )
3168         g10_exit(2);
3169
3170     if(opt.compress_level==0)
3171       opt.compress_algo=COMPRESS_ALGO_NONE;
3172
3173     /* Check our chosen algorithms against the list of legal
3174        algorithms. */
3175
3176     if(!GNUPG)
3177       {
3178         const char *badalg=NULL;
3179         preftype_t badtype=PREFTYPE_NONE;
3180
3181         if(opt.def_cipher_algo
3182            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
3183           {
3184             badalg=cipher_algo_to_string(opt.def_cipher_algo);
3185             badtype=PREFTYPE_SYM;
3186           }
3187         else if(opt.def_digest_algo
3188                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
3189           {
3190             badalg=digest_algo_to_string(opt.def_digest_algo);
3191             badtype=PREFTYPE_HASH;
3192           }
3193         else if(opt.cert_digest_algo
3194                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
3195           {
3196             badalg=digest_algo_to_string(opt.cert_digest_algo);
3197             badtype=PREFTYPE_HASH;
3198           }
3199         else if(opt.compress_algo!=-1
3200                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
3201           {
3202             badalg=compress_algo_to_string(opt.compress_algo);
3203             badtype=PREFTYPE_ZIP;
3204           }
3205
3206         if(badalg)
3207           {
3208             switch(badtype)
3209               {
3210               case PREFTYPE_SYM:
3211                 log_info(_("you may not use cipher algorithm `%s'"
3212                            " while in %s mode\n"),
3213                          badalg,compliance_option_string());
3214                 break;
3215               case PREFTYPE_HASH:
3216                 log_info(_("you may not use digest algorithm `%s'"
3217                            " while in %s mode\n"),
3218                          badalg,compliance_option_string());
3219                 break;
3220               case PREFTYPE_ZIP:
3221                 log_info(_("you may not use compression algorithm `%s'"
3222                            " while in %s mode\n"),
3223                          badalg,compliance_option_string());
3224                 break;
3225               default:
3226                 BUG();
3227               }
3228
3229             compliance_failure();
3230           }
3231       }
3232
3233     /* set the random seed file */
3234     if( use_random_seed ) {
3235         char *p = make_filename(opt.homedir, "random_seed", NULL );
3236         set_random_seed_file(p);
3237         if (!access (p, F_OK))
3238           register_secured_file (p);
3239         xfree(p);
3240     }
3241
3242     /* If there is no command but the --fingerprint is given, default
3243        to the --list-keys command.  */
3244     if (!cmd && fpr_maybe_cmd)
3245       {
3246         set_cmd (&cmd, aListKeys);
3247       }
3248
3249     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
3250         if( cmd == aKModeC ) {
3251             opt.fingerprint = 1;
3252             cmd = aKMode;
3253         }
3254         opt.list_sigs = 0;
3255         if( opt.verbose > 2 )
3256             opt.check_sigs++;
3257         if( opt.verbose > 1 )
3258             opt.list_sigs++;
3259
3260         opt.verbose = opt.verbose > 1;
3261         g10_opt_verbose = opt.verbose;
3262     }
3263
3264     /* kludge to let -sat generate a clear text signature */
3265     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
3266         cmd = aClearsign;
3267
3268     if( opt.verbose > 1 )
3269         set_packet_list_mode(1);
3270
3271     if (cmd == aGPGConfTest)
3272       g10_exit(0);
3273
3274     /* Add the keyrings, but not for some special commands and not in
3275        case of "-kvv userid keyring".  Also avoid adding the secret
3276        keyring for a couple of commands to avoid unneeded access in
3277        case the secrings are stored on a floppy.
3278
3279        We always need to add the keyrings if we are running under
3280        SELinux, this is so that the rings are added to the list of
3281        secured files. */
3282     if( ALWAYS_ADD_KEYRINGS
3283         || (cmd != aDeArmor && cmd != aEnArmor
3284             && !(cmd == aKMode && argc == 2 )) )
3285       {
3286         if (ALWAYS_ADD_KEYRINGS
3287             || (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
3288                 && cmd != aVerify && cmd != aSym))
3289           {
3290             if (!sec_nrings || default_keyring) /* add default secret rings */
3291               keydb_add_resource ("secring" EXTSEP_S "gpg", 4, 1);
3292             for (sl = sec_nrings; sl; sl = sl->next)
3293               keydb_add_resource ( sl->d, 0, 1 );
3294           }
3295         if( !nrings || default_keyring )  /* add default ring */
3296             keydb_add_resource ("pubring" EXTSEP_S "gpg", 4, 0);
3297         for(sl = nrings; sl; sl = sl->next )
3298             keydb_add_resource ( sl->d, sl->flags, 0 );
3299       }
3300     FREE_STRLIST(nrings);
3301     FREE_STRLIST(sec_nrings);
3302
3303
3304     if( pwfd != -1 )  /* read the passphrase now. */
3305         read_passphrase_from_fd( pwfd );
3306
3307     fname = argc? *argv : NULL;
3308
3309     if(fname && utf8_strings)
3310       opt.flags.utf8_filename=1;
3311
3312     switch( cmd ) {
3313       case aPrimegen:
3314       case aPrintMD:
3315       case aPrintMDs:
3316       case aGenRandom:
3317       case aDeArmor:
3318       case aEnArmor:
3319         break;
3320       case aFixTrustDB:
3321       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
3322       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
3323       default:
3324           /* No need to create the trust model if we are using the
3325          * always trust model.  */
3326         rc = setup_trustdb (opt.trust_model != TM_ALWAYS, trustdb_name);
3327         break;
3328       }
3329     if( rc )
3330         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
3331
3332
3333     switch (cmd)
3334       {
3335       case aStore:
3336       case aSym:
3337       case aSign:
3338       case aSignSym:
3339       case aClearsign:
3340         if (!opt.quiet && any_explicit_recipient)
3341           log_info (_("WARNING: recipients (-r) given "
3342                       "without using public key encryption\n"));
3343         break;
3344       default:
3345         break;
3346       }
3347
3348     switch( cmd )
3349       {
3350       case aStore: /* only store the file */
3351         if( argc > 1 )
3352             wrong_args(_("--store [filename]"));
3353         if( (rc = encode_store(fname)) )
3354             log_error ("storing `%s' failed: %s\n",
3355                        print_fname_stdin(fname),g10_errstr(rc) );
3356         break;
3357       case aSym: /* encrypt the given file only with the symmetric cipher */
3358         if( argc > 1 )
3359             wrong_args(_("--symmetric [filename]"));
3360         if( (rc = encode_symmetric(fname)) )
3361             log_error (_("symmetric encryption of `%s' failed: %s\n"),
3362                         print_fname_stdin(fname),g10_errstr(rc) );
3363         break;
3364
3365       case aEncr: /* encrypt the given file */
3366         if(multifile)
3367           encode_crypt_files(argc, argv, remusr);
3368         else
3369           {
3370             if( argc > 1 )
3371               wrong_args(_("--encrypt [filename]"));
3372             if( (rc = encode_crypt(fname,remusr,0)) )
3373               log_error("%s: encryption failed: %s\n",
3374                         print_fname_stdin(fname), g10_errstr(rc) );
3375           }
3376         break;
3377
3378       case aEncrSym:
3379         /* This works with PGP 8 in the sense that it acts just like a
3380            symmetric message.  It doesn't work at all with 2 or 6.  It
3381            might work with 7, but alas, I don't have a copy to test
3382            with right now. */
3383         if( argc > 1 )
3384           wrong_args(_("--symmetric --encrypt [filename]"));
3385         else if(opt.s2k_mode==0)
3386           log_error(_("you cannot use --symmetric --encrypt"
3387                       " with --s2k-mode 0\n"));
3388         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3389           log_error(_("you cannot use --symmetric --encrypt"
3390                       " while in %s mode\n"),compliance_option_string());
3391         else
3392           {
3393             if( (rc = encode_crypt(fname,remusr,1)) )
3394               log_error("%s: encryption failed: %s\n",
3395                         print_fname_stdin(fname), g10_errstr(rc) );
3396           }
3397         break;
3398
3399       case aSign: /* sign the given file */
3400         sl = NULL;
3401         if( detached_sig ) { /* sign all files */
3402             for( ; argc; argc--, argv++ )
3403                 add_to_strlist( &sl, *argv );
3404         }
3405         else {
3406             if( argc > 1 )
3407                 wrong_args(_("--sign [filename]"));
3408             if( argc ) {
3409                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3410                 strcpy(sl->d, fname);
3411             }
3412         }
3413         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
3414             log_error("signing failed: %s\n", g10_errstr(rc) );
3415         free_strlist(sl);
3416         break;
3417
3418       case aSignEncr: /* sign and encrypt the given file */
3419         if( argc > 1 )
3420             wrong_args(_("--sign --encrypt [filename]"));
3421         if( argc ) {
3422             sl = xmalloc_clear( sizeof *sl + strlen(fname));
3423             strcpy(sl->d, fname);
3424         }
3425         else
3426             sl = NULL;
3427         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
3428             log_error("%s: sign+encrypt failed: %s\n",
3429                       print_fname_stdin(fname), g10_errstr(rc) );
3430         free_strlist(sl);
3431         break;
3432
3433       case aSignEncrSym: /* sign and encrypt the given file */
3434         if( argc > 1 )
3435             wrong_args(_("--symmetric --sign --encrypt [filename]"));
3436         else if(opt.s2k_mode==0)
3437           log_error(_("you cannot use --symmetric --sign --encrypt"
3438                       " with --s2k-mode 0\n"));
3439         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3440           log_error(_("you cannot use --symmetric --sign --encrypt"
3441                       " while in %s mode\n"),compliance_option_string());
3442         else
3443           {
3444             if( argc )
3445               {
3446                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3447                 strcpy(sl->d, fname);
3448               }
3449             else
3450               sl = NULL;
3451             if( (rc = sign_file(sl, detached_sig, locusr, 2, remusr, NULL)) )
3452               log_error("%s: symmetric+sign+encrypt failed: %s\n",
3453                         print_fname_stdin(fname), g10_errstr(rc) );
3454             free_strlist(sl);
3455           }
3456         break;
3457
3458       case aSignSym: /* sign and conventionally encrypt the given file */
3459         if (argc > 1)
3460             wrong_args(_("--sign --symmetric [filename]"));
3461         rc = sign_symencrypt_file (fname, locusr);
3462         if (rc)
3463             log_error("%s: sign+symmetric failed: %s\n",
3464                       print_fname_stdin(fname), g10_errstr(rc) );
3465         break;
3466
3467       case aClearsign: /* make a clearsig */
3468         if( argc > 1 )
3469             wrong_args(_("--clearsign [filename]"));
3470         if( (rc = clearsign_file(fname, locusr, NULL)) )
3471             log_error("%s: clearsign failed: %s\n",
3472                       print_fname_stdin(fname), g10_errstr(rc) );
3473         break;
3474
3475       case aVerify:
3476         if(multifile)
3477           {
3478             if( (rc = verify_files( argc, argv ) ))
3479               log_error("verify files failed: %s\n", g10_errstr(rc) );
3480           }
3481         else
3482           {
3483             if( (rc = verify_signatures( argc, argv ) ))
3484               log_error("verify signatures failed: %s\n", g10_errstr(rc) );
3485           }
3486         break;
3487
3488       case aDecrypt:
3489         if(multifile)
3490           decrypt_messages(argc, argv);
3491         else
3492           {
3493             if( argc > 1 )
3494               wrong_args(_("--decrypt [filename]"));
3495             if( (rc = decrypt_message( fname ) ))
3496               log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
3497           }
3498         break;
3499
3500       case aSignKey:
3501         if( argc != 1 )
3502           wrong_args(_("--sign-key user-id"));
3503         /* fall through */
3504       case aLSignKey:
3505         if( argc != 1 )
3506           wrong_args(_("--lsign-key user-id"));
3507         /* fall through */
3508
3509         sl=NULL;
3510
3511         if(cmd==aSignKey)
3512           append_to_strlist(&sl,"sign");
3513         else if(cmd==aLSignKey)
3514           append_to_strlist(&sl,"lsign");
3515         else
3516           BUG();
3517
3518         append_to_strlist( &sl, "save" );
3519         username = make_username( fname );
3520         keyedit_menu(username, locusr, sl, 0, 0 );
3521         xfree(username);
3522         free_strlist(sl);
3523         break;
3524
3525       case aEditKey: /* Edit a key signature */
3526         if( !argc )
3527             wrong_args(_("--edit-key user-id [commands]"));