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