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