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