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