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