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