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