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