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