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