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