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