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