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