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