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