* gpg.c (main): Don't default to import-options convert-sk-to-pk. 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.export_options=EXPORT_ATTRIBUTES;
1697     opt.keyserver_options.import_options=IMPORT_REPAIR_PKS_SUBKEY_BUG;
1698     opt.keyserver_options.export_options=EXPORT_ATTRIBUTES;
1699     opt.keyserver_options.options=
1700       KEYSERVER_INCLUDE_SUBKEYS|KEYSERVER_INCLUDE_REVOKED|KEYSERVER_TRY_DNS_SRV|KEYSERVER_HONOR_KEYSERVER_URL;
1701     opt.verify_options=
1702       VERIFY_SHOW_POLICY_URLS|VERIFY_SHOW_STD_NOTATIONS|VERIFY_SHOW_KEYSERVER_URLS;
1703     opt.trust_model=TM_AUTO;
1704     opt.mangle_dos_filenames=0;
1705     opt.min_cert_level=2;
1706     set_screen_dimensions();
1707     opt.keyid_format=KF_SHORT;
1708     opt.rfc2440_text=1;
1709     opt.def_sig_expire="0";
1710     opt.def_cert_expire="0";
1711     set_homedir ( default_homedir () );
1712
1713 #ifdef ENABLE_CARD_SUPPORT
1714 #if defined(_WIN32) || defined(__CYGWIN__)
1715     opt.pcsc_driver = "winscard.dll";
1716 #elif defined(__APPLE__)
1717     opt.pcsc_driver = "/System/Library/Frameworks/PCSC.framework/PCSC";
1718 #else
1719     opt.pcsc_driver = "libpcsclite.so"; 
1720 #endif
1721 #endif /*ENABLE_CARD_SUPPORT*/
1722
1723     /* check whether we have a config file on the commandline */
1724     orig_argc = argc;
1725     orig_argv = argv;
1726     pargs.argc = &argc;
1727     pargs.argv = &argv;
1728     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
1729     while( arg_parse( &pargs, opts) ) {
1730         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
1731             parse_debug++;
1732         else if( pargs.r_opt == oOptions ) {
1733             /* yes there is one, so we do not try the default one, but
1734              * read the option file when it is encountered at the commandline
1735              */
1736             default_config = 0;
1737         }
1738         else if( pargs.r_opt == oNoOptions )
1739             default_config = 0; /* --no-options */
1740         else if( pargs.r_opt == oHomedir )
1741             set_homedir ( pargs.r.ret_str );
1742         else if( pargs.r_opt == oNoPermissionWarn )
1743             opt.no_perm_warn=1;
1744         else if (pargs.r_opt == oStrict )
1745           {
1746             opt.strict=1;
1747             log_set_strict(1);
1748           }
1749         else if (pargs.r_opt == oNoStrict )
1750           {
1751             opt.strict=0;
1752             log_set_strict(0);
1753           }
1754 #ifdef USE_SHM_COPROCESSING
1755         else if( pargs.r_opt == oRunAsShmCP ) {
1756             /* does not make sense in a options file, we do it here,
1757              * so that we are the able to drop setuid as soon as possible */
1758             opt.shm_coprocess = 1;
1759             requested_shm_size = pargs.r.ret_ulong;
1760         }
1761         else if ( pargs.r_opt == oStatusFD ) {
1762             /* this is needed to ensure that the status-fd filedescriptor is
1763              * initialized when init_shm_coprocessing() is called */
1764             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1765         }
1766 #endif
1767     }
1768
1769 #ifdef HAVE_DOSISH_SYSTEM
1770     if ( strchr (opt.homedir,'\\') ) {
1771         char *d, *buf = xmalloc (strlen (opt.homedir)+1);
1772         const char *s = opt.homedir;
1773         for (d=buf,s=opt.homedir; *s; s++)
1774             *d++ = *s == '\\'? '/': *s;
1775         *d = 0;
1776         set_homedir (buf);
1777     }
1778 #endif
1779 #ifdef USE_SHM_COPROCESSING
1780     if( opt.shm_coprocess ) {
1781         init_shm_coprocessing(requested_shm_size, 1 );
1782     }
1783 #endif
1784     /* initialize the secure memory. */
1785     got_secmem=secmem_init( 32768 );
1786     maybe_setuid = 0;
1787     /* Okay, we are now working under our real uid */
1788
1789 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
1790     /* There should be no way to get to this spot while still carrying
1791        setuid privs.  Just in case, bomb out if we are. */
1792     if(getuid()!=geteuid())
1793       BUG();
1794 #endif
1795
1796     set_native_charset (NULL); /* Try to auto set the character set */
1797
1798     /* Try for a version specific config file first */
1799     if( default_config )
1800       {
1801         char *name=xstrdup("gpg" EXTSEP_S "conf-" SAFE_VERSION);
1802         char *ver=&name[strlen("gpg" EXTSEP_S "conf-")];
1803
1804         do
1805           {
1806             if(configname)
1807               {
1808                 char *tok;
1809
1810                 xfree(configname);
1811                 configname=NULL;
1812
1813                 if((tok=strrchr(ver,SAFE_VERSION_DASH)))
1814                   *tok='\0';
1815                 else if((tok=strrchr(ver,SAFE_VERSION_DOT)))
1816                   *tok='\0';
1817                 else
1818                   break;
1819               }
1820
1821             configname = make_filename(opt.homedir,name,NULL);
1822           }
1823         while(access(configname,R_OK));
1824
1825         xfree(name);
1826
1827         if(!configname)
1828           configname=make_filename(opt.homedir, "gpg" EXTSEP_S "conf", NULL );
1829         if (!access (configname, R_OK))
1830           { /* Print a warning when both config files are present. */
1831             char *p = make_filename(opt.homedir, "options", NULL );
1832             if (!access (p, R_OK))
1833               log_info (_("NOTE: old default options file `%s' ignored\n"), p);
1834             xfree (p);
1835           }
1836         else
1837           { /* Keep on using the old default one. */
1838             xfree (configname);
1839             configname = make_filename(opt.homedir, "options", NULL );
1840           }
1841       }
1842     argc = orig_argc;
1843     argv = orig_argv;
1844     pargs.argc = &argc;
1845     pargs.argv = &argv;
1846     pargs.flags=  1;  /* do not remove the args */
1847
1848     /* By this point we have a homedir, and cannot change it. */
1849     check_permissions(opt.homedir,0);
1850
1851   next_pass:
1852     if( configname ) {
1853       if(check_permissions(configname,1))
1854         {
1855           /* If any options file is unsafe, then disable any external
1856              programs for keyserver calls or photo IDs.  Since the
1857              external program to call is set in the options file, a
1858              unsafe options file can lead to an arbitrary program
1859              being run. */
1860
1861           opt.exec_disable=1;
1862         }
1863
1864         configlineno = 0;
1865         configfp = fopen( configname, "r" );
1866         if (configfp && is_secured_file (fileno (configfp)))
1867           {
1868             fclose (configfp);
1869             configfp = NULL;
1870             errno = EPERM;
1871           }
1872         if( !configfp ) {
1873             if( default_config ) {
1874                 if( parse_debug )
1875                     log_info(_("NOTE: no default option file `%s'\n"),
1876                                                             configname );
1877             }
1878             else {
1879                 log_error(_("option file `%s': %s\n"),
1880                                     configname, strerror(errno) );
1881                 g10_exit(2);
1882             }
1883             xfree(configname); configname = NULL;
1884         }
1885         if( parse_debug && configname )
1886             log_info(_("reading options from `%s'\n"), configname );
1887         default_config = 0;
1888     }
1889
1890     while( optfile_parse( configfp, configname, &configlineno,
1891                                                 &pargs, opts) )
1892       {
1893         switch( pargs.r_opt )
1894           {
1895           case aCheckKeys: 
1896           case aListConfig:
1897           case aGPGConfList:
1898           case aListPackets:
1899           case aImport: 
1900           case aFastImport: 
1901           case aSendKeys: 
1902           case aRecvKeys: 
1903           case aSearchKeys:
1904           case aRefreshKeys:
1905           case aFetchKeys:
1906           case aExport: 
1907             set_cmd (&cmd, pargs.r_opt);
1908             break;
1909           case aListKeys: set_cmd( &cmd, aListKeys); break;
1910           case aListSigs: set_cmd( &cmd, aListSigs); break;
1911           case aExportSecret: set_cmd( &cmd, aExportSecret); break;
1912           case aExportSecretSub: set_cmd( &cmd, aExportSecretSub); break;
1913           case aDeleteSecretKeys:
1914             set_cmd( &cmd, aDeleteSecretKeys);
1915             greeting=1;
1916             break;
1917           case aDeleteSecretAndPublicKeys:
1918             set_cmd( &cmd, aDeleteSecretAndPublicKeys);
1919             greeting=1; 
1920             break;
1921           case aDeleteKeys: set_cmd( &cmd, aDeleteKeys); greeting=1; break;
1922
1923           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
1924           case aSym: set_cmd( &cmd, aSym); break;
1925
1926           case aDecryptFiles: multifile=1; /* fall through */
1927           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
1928
1929           case aEncrFiles: multifile=1; /* fall through */
1930           case aEncr: set_cmd( &cmd, aEncr); break;
1931
1932           case aVerifyFiles: multifile=1; /* fall through */
1933           case aVerify: set_cmd( &cmd, aVerify); break;
1934
1935           case aSign: set_cmd( &cmd, aSign );  break;
1936           case aKeygen: set_cmd( &cmd, aKeygen); greeting=1; break;
1937           case aSignKey: set_cmd( &cmd, aSignKey); break;
1938           case aLSignKey: set_cmd( &cmd, aLSignKey); break;
1939           case aStore: set_cmd( &cmd, aStore); break;
1940           case aEditKey: set_cmd( &cmd, aEditKey); greeting=1; break;
1941           case aClearsign: set_cmd( &cmd, aClearsign); break;
1942           case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
1943           case aDesigRevoke: set_cmd( &cmd, aDesigRevoke); break;
1944           case aPrimegen: set_cmd( &cmd, aPrimegen); break;
1945           case aGenRandom: set_cmd( &cmd, aGenRandom); break;
1946           case aPrintMD: set_cmd( &cmd, aPrintMD); break;
1947           case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
1948           case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
1949           case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
1950           case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
1951           case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
1952           case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
1953           case aDeArmor: set_cmd( &cmd, aDeArmor); break;
1954           case aEnArmor: set_cmd( &cmd, aEnArmor); break;
1955           case aListOwnerTrust:
1956             deprecated_warning(configname,configlineno,
1957                                "--list-ownertrust","--export-ownertrust","");
1958           case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
1959           case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
1960           case aPipeMode:
1961             deprecated_command ("--pipemode");
1962             set_cmd( &cmd, aPipeMode);
1963             break;
1964
1965           case aRebuildKeydbCaches: set_cmd( &cmd, aRebuildKeydbCaches); break;
1966
1967 #ifdef ENABLE_CARD_SUPPORT
1968           case aCardStatus: set_cmd (&cmd, aCardStatus); break;
1969           case aCardEdit: set_cmd (&cmd, aCardEdit); break;
1970           case aChangePIN: set_cmd (&cmd, aChangePIN); break;
1971           case oReaderPort:
1972             card_set_reader_port (pargs.r.ret_str);
1973             break;
1974           case octapiDriver: opt.ctapi_driver = pargs.r.ret_str; break;
1975           case opcscDriver: opt.pcsc_driver = pargs.r.ret_str; break;
1976           case oDisableCCID: opt.disable_ccid = 1; break;
1977 #endif /* ENABLE_CARD_SUPPORT*/
1978
1979           case oArmor: opt.armor = 1; opt.no_armor=0; break;
1980           case oOutput: opt.outfile = pargs.r.ret_str; break;
1981           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
1982           case oQuiet: opt.quiet = 1; break;
1983           case oNoTTY: tty_no_terminal(1); break;
1984           case oDryRun: opt.dry_run = 1; break;
1985           case oInteractive: opt.interactive = 1; break;
1986           case oVerbose:
1987             g10_opt_verbose++;
1988             opt.verbose++;
1989             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
1990             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
1991             break;
1992           case oKOption: set_cmd( &cmd, aKMode ); break;
1993
1994           case oBatch: opt.batch = 1; nogreeting = 1; break;
1995           case oUseAgent:
1996 #ifndef __riscos__
1997             opt.use_agent = 1;
1998 #else /* __riscos__ */
1999             opt.use_agent = 0;
2000             riscos_not_implemented("use-agent");
2001 #endif /* __riscos__ */
2002             break;
2003           case oNoUseAgent: opt.use_agent = 0; break;
2004           case oGpgAgentInfo: opt.gpg_agent_info = pargs.r.ret_str; break;
2005           case oAnswerYes: opt.answer_yes = 1; break;
2006           case oAnswerNo: opt.answer_no = 1; break;
2007           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
2008           case oPrimaryKeyring:
2009             sl=append_to_strlist( &nrings, pargs.r.ret_str);
2010             sl->flags=2;
2011             break;
2012           case oShowKeyring:
2013             deprecated_warning(configname,configlineno,"--show-keyring",
2014                                "--list-options ","show-keyring");
2015             opt.list_options|=LIST_SHOW_KEYRING;
2016             break;
2017           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
2018           case oDebugAll: opt.debug = ~0; break;
2019           case oDebugCCIDDriver: 
2020 #if defined(ENABLE_CARD_SUPPORT) && defined(HAVE_LIBUSB)
2021             ccid_set_debug_level (ccid_set_debug_level (1)+1);
2022 #endif
2023             break;
2024           case oStatusFD:
2025             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
2026             break;
2027           case oStatusFile:
2028             set_status_fd ( open_info_file (pargs.r.ret_str, 1) );
2029             break;
2030           case oAttributeFD:
2031             set_attrib_fd(iobuf_translate_file_handle (pargs.r.ret_int, 1));
2032             break;
2033           case oAttributeFile:
2034             set_attrib_fd ( open_info_file (pargs.r.ret_str, 1) );
2035             break;
2036           case oLoggerFD:
2037             log_set_logfile( NULL,
2038                              iobuf_translate_file_handle (pargs.r.ret_int, 1));
2039             break;
2040           case oLoggerFile:
2041             log_set_logfile( NULL, open_info_file (pargs.r.ret_str, 1) );
2042             break;
2043
2044           case oWithFingerprint:
2045             opt.with_fingerprint = 1;
2046             with_fpr=1; /*fall thru*/
2047           case oFingerprint: opt.fingerprint++; break;
2048           case oSecretKeyring:
2049             append_to_strlist( &sec_nrings, pargs.r.ret_str);
2050             break;
2051           case oOptions:
2052             /* config files may not be nested (silently ignore them) */
2053             if( !configfp ) {
2054                 xfree(configname);
2055                 configname = xstrdup(pargs.r.ret_str);
2056                 goto next_pass;
2057             }
2058             break;
2059           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
2060           case oNoDefKeyring: default_keyring = 0; break;
2061           case oNoGreeting: nogreeting = 1; break;
2062           case oNoVerbose: g10_opt_verbose = 0;
2063                            opt.verbose = 0; opt.list_sigs=0; break;
2064           case oQuickRandom: quick_random_gen(1); break;
2065           case oEmitVersion: opt.no_version=0; break;
2066           case oNoEmitVersion: opt.no_version=1; break;
2067           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
2068           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
2069           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
2070           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
2071           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
2072           case oDefRecipient:
2073                     if( *pargs.r.ret_str )
2074                         opt.def_recipient = make_username(pargs.r.ret_str);
2075                     break;
2076           case oDefRecipientSelf:
2077                     xfree(opt.def_recipient); opt.def_recipient = NULL;
2078                     opt.def_recipient_self = 1;
2079                     break;
2080           case oNoDefRecipient:
2081                     xfree(opt.def_recipient); opt.def_recipient = NULL;
2082                     opt.def_recipient_self = 0;
2083                     break;
2084           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
2085           case oHomedir: break;
2086           case oNoBatch: opt.batch = 0; break;
2087           case oWithKeyData: opt.with_key_data=1; /* fall thru */
2088           case oWithColons: opt.with_colons=':'; break;
2089
2090           case oSkipVerify: opt.skip_verify=1; break;
2091           case oCompressKeys: opt.compress_keys = 1; break;
2092           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
2093             /* There are many programs (like mutt) that call gpg with
2094                --always-trust so keep this option around for a long
2095                time. */
2096           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
2097           case oTrustModel:
2098             parse_trust_model(pargs.r.ret_str);
2099             break;
2100           case oForceOwnertrust:
2101             log_info(_("NOTE: %s is not for normal use!\n"),
2102                      "--force-ownertrust");
2103             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
2104             if(opt.force_ownertrust==-1)
2105               {
2106                 log_error("invalid ownertrust `%s'\n",pargs.r.ret_str);
2107                 opt.force_ownertrust=0;
2108               }
2109             break;
2110           case oLoadExtension:
2111 #ifndef __riscos__
2112 #if defined(USE_DYNAMIC_LINKING) || defined(_WIN32)
2113             if(check_permissions(pargs.r.ret_str,2))
2114               log_info(_("cipher extension `%s' not loaded due to"
2115                          " unsafe permissions\n"),pargs.r.ret_str);
2116             else
2117               register_cipher_extension(orig_argc? *orig_argv:NULL,
2118                                         pargs.r.ret_str);
2119 #endif
2120 #else /* __riscos__ */
2121             riscos_not_implemented("load-extension");
2122 #endif /* __riscos__ */
2123             break;
2124           case oRFC1991:
2125             opt.compliance = CO_RFC1991;
2126             opt.force_v4_certs = 0;
2127             opt.escape_from = 1;
2128             break;
2129           case oOpenPGP:
2130           case oRFC2440:
2131             /* TODO: When 2440bis becomes a RFC, set new values for
2132                oOpenPGP. */
2133             opt.rfc2440_text=1;
2134             opt.compliance = CO_RFC2440;
2135             opt.allow_non_selfsigned_uid = 1;
2136             opt.allow_freeform_uid = 1;
2137             opt.pgp2_workarounds = 0;
2138             opt.escape_from = 0;
2139             opt.force_v3_sigs = 0;
2140             opt.compress_keys = 0;          /* not mandated, but we do it */
2141             opt.compress_sigs = 0;          /* ditto. */
2142             opt.not_dash_escaped = 0;
2143             opt.def_cipher_algo = 0;
2144             opt.def_digest_algo = 0;
2145             opt.cert_digest_algo = 0;
2146             opt.compress_algo = -1;
2147             opt.s2k_mode = 3; /* iterated+salted */
2148             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2149             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2150             break;
2151           case oPGP2:  opt.compliance = CO_PGP2;  break;
2152           case oPGP6:  opt.compliance = CO_PGP6;  break;
2153           case oPGP7:  opt.compliance = CO_PGP7;  break;
2154           case oPGP8:  opt.compliance = CO_PGP8;  break;
2155           case oGnuPG: opt.compliance = CO_GNUPG; break;
2156           case oCompressSigs: opt.compress_sigs = 1; break;
2157           case oRFC2440Text: opt.rfc2440_text=1; break;
2158           case oNoRFC2440Text: opt.rfc2440_text=0; break;
2159           case oRunAsShmCP:
2160 #ifndef __riscos__
2161 # ifndef USE_SHM_COPROCESSING
2162             /* not possible in the option file,
2163              * but we print the warning here anyway */
2164             log_error("shared memory coprocessing is not available\n");
2165 # endif
2166 #else /* __riscos__ */
2167             riscos_not_implemented("run-as-shm-coprocess");
2168 #endif /* __riscos__ */
2169             break;
2170           case oSetFilename: opt.set_filename = pargs.r.ret_str; break;
2171           case oForYourEyesOnly: eyes_only = 1; break;
2172           case oNoForYourEyesOnly: eyes_only = 0; break;
2173           case oSetPolicyURL:
2174             add_policy_url(pargs.r.ret_str,0);
2175             add_policy_url(pargs.r.ret_str,1);
2176             break;
2177           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
2178           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
2179           case oShowPolicyURL:
2180             deprecated_warning(configname,configlineno,"--show-policy-url",
2181                                "--list-options ","show-policy-urls");
2182             deprecated_warning(configname,configlineno,"--show-policy-url",
2183                                "--verify-options ","show-policy-urls");
2184             opt.list_options|=LIST_SHOW_POLICY_URLS;
2185             opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
2186             break;
2187           case oNoShowPolicyURL:
2188             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2189                                "--list-options ","no-show-policy-urls");
2190             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2191                                "--verify-options ","no-show-policy-urls");
2192             opt.list_options&=~LIST_SHOW_POLICY_URLS;
2193             opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
2194             break;
2195           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
2196           case oUseEmbeddedFilename: opt.use_embedded_filename = 1; break;
2197           case oNoUseEmbeddedFilename: opt.use_embedded_filename = 0; break;
2198           case oComment:
2199             if(pargs.r.ret_str[0])
2200               append_to_strlist(&opt.comments,pargs.r.ret_str);
2201             break;
2202           case oDefaultComment:
2203             deprecated_warning(configname,configlineno,
2204                                "--default-comment","--no-comments","");
2205             /* fall through */
2206           case oNoComments:
2207             free_strlist(opt.comments);
2208             opt.comments=NULL;
2209             break;
2210           case oThrowKeyids: opt.throw_keyid = 1; break;
2211           case oNoThrowKeyids: opt.throw_keyid = 0; break;
2212           case oShowPhotos:
2213             deprecated_warning(configname,configlineno,"--show-photos",
2214                                "--list-options ","show-photos");
2215             deprecated_warning(configname,configlineno,"--show-photos",
2216                                "--verify-options ","show-photos");
2217             opt.list_options|=LIST_SHOW_PHOTOS;
2218             opt.verify_options|=VERIFY_SHOW_PHOTOS;
2219             break;
2220           case oNoShowPhotos:
2221             deprecated_warning(configname,configlineno,"--no-show-photos",
2222                                "--list-options ","no-show-photos");
2223             deprecated_warning(configname,configlineno,"--no-show-photos",
2224                                "--verify-options ","no-show-photos");
2225             opt.list_options&=~LIST_SHOW_PHOTOS;
2226             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
2227             break;
2228           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
2229           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
2230           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
2231           case oForceV4Certs: opt.force_v4_certs = 1; break;
2232           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
2233           case oForceMDC: opt.force_mdc = 1; break;
2234           case oNoForceMDC: opt.force_mdc = 0; break;
2235           case oDisableMDC: opt.disable_mdc = 1; break;
2236           case oNoDisableMDC: opt.disable_mdc = 0; break;
2237           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
2238           case oS2KDigest: s2k_digest_string = xstrdup(pargs.r.ret_str); break;
2239           case oS2KCipher: s2k_cipher_string = xstrdup(pargs.r.ret_str); break;
2240           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
2241           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
2242           case oEncryptTo: /* store the recipient in the second list */
2243             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2244             sl->flags = 1;
2245             break;
2246           case oHiddenEncryptTo: /* store the recipient in the second list */
2247             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2248             sl->flags = 1|2;
2249             break;
2250           case oRecipient: /* store the recipient */
2251             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2252             any_explicit_recipient = 1;
2253             break;
2254           case oHiddenRecipient: /* store the recipient with a flag */
2255             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2256             sl->flags = 2;
2257             any_explicit_recipient = 1;
2258             break;
2259           case oTextmodeShort: opt.textmode = 2; break;
2260           case oTextmode: opt.textmode=1;  break;
2261           case oNoTextmode: opt.textmode=0;  break;
2262           case oExpert: opt.expert = 1; break;
2263           case oNoExpert: opt.expert = 0; break;
2264           case oDefSigExpire:
2265             if(*pargs.r.ret_str!='\0')
2266               {
2267                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
2268                   log_error(_("`%s' is not a valid signature expiration\n"),
2269                             pargs.r.ret_str);
2270                 else
2271                   opt.def_sig_expire=pargs.r.ret_str;
2272               }
2273             break;
2274           case oAskSigExpire: opt.ask_sig_expire = 1; break;
2275           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
2276           case oDefCertExpire:
2277             if(*pargs.r.ret_str!='\0')
2278               {
2279                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
2280                   log_error(_("`%s' is not a valid signature expiration\n"),
2281                             pargs.r.ret_str);
2282                 else
2283                   opt.def_cert_expire=pargs.r.ret_str;
2284               }
2285             break;
2286           case oAskCertExpire: opt.ask_cert_expire = 1; break;
2287           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
2288           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
2289           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
2290           case oAskCertLevel: opt.ask_cert_level = 1; break;
2291           case oNoAskCertLevel: opt.ask_cert_level = 0; break;
2292           case oLocalUser: /* store the local users */
2293             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
2294             break;
2295           case oCompress:
2296             /* this is the -z command line option */
2297             opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
2298             break;
2299           case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
2300           case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
2301           case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
2302           case oPasswd:
2303             set_passphrase_from_string(pargs.r.ret_str);
2304             break;
2305           case oPasswdFD:
2306             pwfd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
2307             opt.use_agent = 0;
2308             break;
2309           case oPasswdFile:
2310             pwfd = open_info_file (pargs.r.ret_str, 0);
2311             break;
2312           case oCommandFD:
2313             opt.command_fd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
2314             break;
2315           case oCommandFile:
2316             opt.command_fd = open_info_file (pargs.r.ret_str, 0);
2317             break;
2318           case oCipherAlgo: 
2319             def_cipher_string = xstrdup(pargs.r.ret_str);
2320             break;
2321           case oDigestAlgo:
2322             def_digest_string = xstrdup(pargs.r.ret_str);
2323             break;
2324           case oCompressAlgo:
2325             /* If it is all digits, stick a Z in front of it for
2326                later.  This is for backwards compatibility with
2327                versions that took the compress algorithm number. */
2328             {
2329               char *pt=pargs.r.ret_str;
2330               while(*pt)
2331                 {
2332                   if (!isascii (*pt) || !isdigit (*pt))
2333                     break;
2334
2335                   pt++;
2336                 }
2337
2338               if(*pt=='\0')
2339                 {
2340                   compress_algo_string=xmalloc(strlen(pargs.r.ret_str)+2);
2341                   strcpy(compress_algo_string,"Z");
2342                   strcat(compress_algo_string,pargs.r.ret_str);
2343                 }
2344               else
2345                 compress_algo_string = xstrdup(pargs.r.ret_str);
2346             }
2347             break;
2348           case oCertDigestAlgo: cert_digest_string = xstrdup(pargs.r.ret_str); break;
2349           case oNoSecmemWarn: secmem_set_flags( secmem_get_flags() | 1 ); break;
2350           case oRequireSecmem: require_secmem=1; break;
2351           case oNoRequireSecmem: require_secmem=0; break;
2352           case oNoPermissionWarn: opt.no_perm_warn=1; break;
2353           case oNoMDCWarn: opt.no_mdc_warn=1; break;
2354           case oDisplayCharset:
2355             if( set_native_charset( pargs.r.ret_str ) )
2356                 log_error(_("`%s' is not a valid character set\n"),
2357                           pargs.r.ret_str);
2358             break;
2359           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
2360           case oEscapeFrom: opt.escape_from = 1; break;
2361           case oNoEscapeFrom: opt.escape_from = 0; break;
2362           case oLockOnce: opt.lock_once = 1; break;
2363           case oLockNever: disable_dotlock(); break;
2364           case oLockMultiple:
2365 #ifndef __riscos__
2366             opt.lock_once = 0;
2367 #else /* __riscos__ */
2368             riscos_not_implemented("lock-multiple");
2369 #endif /* __riscos__ */
2370             break;
2371           case oKeyServer:
2372             opt.keyserver=parse_keyserver_uri(pargs.r.ret_str,0,
2373                                               configname,configlineno);
2374             if(!opt.keyserver)
2375               log_error(_("could not parse keyserver URL\n"));
2376             break;
2377           case oKeyServerOptions:
2378             if(!parse_keyserver_options(pargs.r.ret_str))
2379               {
2380                 if(configname)
2381                   log_error(_("%s:%d: invalid keyserver options\n"),
2382                             configname,configlineno);
2383                 else
2384                   log_error(_("invalid keyserver options\n"));
2385               }
2386             break;
2387           case oImportOptions:
2388             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
2389               {
2390                 if(configname)
2391                   log_error(_("%s:%d: invalid import options\n"),
2392                             configname,configlineno);
2393                 else
2394                   log_error(_("invalid import options\n"));
2395               }
2396             break;
2397           case oExportOptions:
2398             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
2399               {
2400                 if(configname)
2401                   log_error(_("%s:%d: invalid export options\n"),
2402                             configname,configlineno);
2403                 else
2404                   log_error(_("invalid export options\n"));
2405               }
2406             break;
2407           case oListOptions:
2408             if(!parse_list_options(pargs.r.ret_str))
2409               {
2410                 if(configname)
2411                   log_error(_("%s:%d: invalid list options\n"),
2412                             configname,configlineno);
2413                 else
2414                   log_error(_("invalid list options\n"));
2415               }
2416             break;
2417           case oVerifyOptions:
2418             {
2419               struct parse_options vopts[]=
2420                 {
2421                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL,
2422                    N_("display photo IDs during signature verification")},
2423                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL,
2424                    N_("show policy URLs during signature verification")},
2425                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL,
2426                    N_("show all notations during signature verification")},
2427                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
2428                    N_("show IETF standard notations during signature verification")},
2429                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
2430                    NULL},
2431                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL,
2432                    N_("show user-supplied notations during signature verification")},
2433                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL,
2434                    N_("show preferred keyserver URLs during signature verification")},
2435                   {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL,
2436                    N_("show user ID validity during signature verification")},
2437                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL,
2438                    N_("show revoked and expired user IDs in signature verification")},
2439                   {NULL,0,NULL,NULL}
2440                 };
2441
2442               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
2443                 {
2444                   if(configname)
2445                     log_error(_("%s:%d: invalid verify options\n"),
2446                               configname,configlineno);
2447                   else
2448                     log_error(_("invalid verify options\n"));
2449                 }
2450             }
2451             break;
2452           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
2453           case oExecPath:
2454             if(set_exec_path(pargs.r.ret_str))
2455               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
2456             else
2457               opt.exec_path_set=1;
2458             break;
2459           case oSetNotation:
2460             add_notation_data( pargs.r.ret_str, 0 );
2461             add_notation_data( pargs.r.ret_str, 1 );
2462             break;
2463           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
2464           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
2465           case oShowNotation:
2466             deprecated_warning(configname,configlineno,"--show-notation",
2467                                "--list-options ","show-notations");
2468             deprecated_warning(configname,configlineno,"--show-notation",
2469                                "--verify-options ","show-notations");
2470             opt.list_options|=LIST_SHOW_NOTATIONS;
2471             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
2472             break;
2473           case oNoShowNotation:
2474             deprecated_warning(configname,configlineno,"--no-show-notation",
2475                                "--list-options ","no-show-notations");
2476             deprecated_warning(configname,configlineno,"--no-show-notation",
2477                                "--verify-options ","no-show-notations");
2478             opt.list_options&=~LIST_SHOW_NOTATIONS;
2479             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
2480             break;
2481           case oUtf8Strings: utf8_strings = 1; break;
2482           case oNoUtf8Strings: utf8_strings = 0; break;
2483           case oDisableCipherAlgo:
2484                 disable_cipher_algo( string_to_cipher_algo(pargs.r.ret_str) );
2485                 break;
2486           case oDisablePubkeyAlgo:
2487                 disable_pubkey_algo( string_to_pubkey_algo(pargs.r.ret_str) );
2488                 break;
2489           case oNoSigCache: opt.no_sig_cache = 1; break;
2490           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
2491           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
2492           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
2493           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
2494           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
2495           case oNoLiteral: opt.no_literal = 1; break;
2496           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
2497           case oHonorHttpProxy:
2498                 add_to_strlist(&opt.keyserver_options.other,"http-proxy");
2499                 deprecated_warning(configname,configlineno,
2500                                    "--honor-http-proxy",
2501                                    "--keyserver-options ","http-proxy");
2502                 break;
2503           case oFastListMode: opt.fast_list_mode = 1; break;
2504           case oFixedListMode: opt.fixed_list_mode = 1; break;
2505           case oListOnly: opt.list_only=1; break;
2506           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
2507           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
2508           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
2509           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
2510           case oNoRandomSeedFile: use_random_seed = 0; break;
2511           case oAutoKeyRetrieve:
2512           case oNoAutoKeyRetrieve:
2513                 if(pargs.r_opt==oAutoKeyRetrieve)
2514                   opt.keyserver_options.options|=KEYSERVER_AUTO_KEY_RETRIEVE;
2515                 else
2516                   opt.keyserver_options.options&=~KEYSERVER_AUTO_KEY_RETRIEVE;
2517
2518                 deprecated_warning(configname,configlineno,
2519                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
2520                                "--no-auto-key-retrieve","--keyserver-options ",
2521                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
2522                                "no-auto-key-retrieve");
2523                 break;
2524           case oShowSessionKey: opt.show_session_key = 1; break;
2525           case oOverrideSessionKey:
2526                 opt.override_session_key = pargs.r.ret_str;
2527                 break;
2528           case oMergeOnly:
2529                 deprecated_warning(configname,configlineno,"--merge-only",
2530                                    "--import-options ","merge-only");
2531                 opt.import_options|=IMPORT_MERGE_ONLY;
2532             break;
2533           case oAllowSecretKeyImport: /* obsolete */ break;
2534           case oTryAllSecrets: opt.try_all_secrets = 1; break;
2535           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
2536           case oEnableSpecialFilenames:
2537             iobuf_enable_special_filenames (1);
2538             break;
2539           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
2540           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
2541           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
2542           case oPreservePermissions: opt.preserve_permissions=1; break;
2543           case oDefaultPreferenceList:
2544             opt.def_preference_list = pargs.r.ret_str;
2545             break;
2546           case oPersonalCipherPreferences:
2547             pers_cipher_list=pargs.r.ret_str;
2548             break;
2549           case oPersonalDigestPreferences:
2550             pers_digest_list=pargs.r.ret_str;
2551             break;
2552           case oPersonalCompressPreferences:
2553             pers_compress_list=pargs.r.ret_str;
2554             break;
2555           case oDisplay: opt.display = pargs.r.ret_str; break;
2556           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
2557           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
2558           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
2559           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
2560           case oGroup: add_group(pargs.r.ret_str); break;
2561           case oUnGroup: rm_group(pargs.r.ret_str); break;
2562           case oNoGroups:
2563             while(opt.grouplist)
2564               {
2565                 struct groupitem *iter=opt.grouplist;
2566                 free_strlist(iter->values);
2567                 opt.grouplist=opt.grouplist->next;
2568                 xfree(iter);
2569               }
2570             break;
2571           case oStrict: opt.strict=1; log_set_strict(1); break;
2572           case oNoStrict: opt.strict=0; log_set_strict(0); break;
2573           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
2574           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
2575           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
2576           case oMultifile: multifile=1; break;
2577           case oKeyidFormat:
2578             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
2579               opt.keyid_format=KF_SHORT;
2580             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
2581               opt.keyid_format=KF_LONG;
2582             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
2583               opt.keyid_format=KF_0xSHORT;
2584             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
2585               opt.keyid_format=KF_0xLONG;
2586             else
2587               log_error("unknown keyid-format `%s'\n",pargs.r.ret_str);
2588             break;
2589
2590           case oExitOnStatusWriteError:
2591             opt.exit_on_status_write_error = 1;
2592             break;
2593
2594           case oLimitCardInsertTries: 
2595             opt.limit_card_insert_tries = pargs.r.ret_int; 
2596             break;
2597
2598           case oRequireBacksigs: opt.require_backsigs=1; break;
2599           case oNoRequireBacksigs: opt.require_backsigs=0; break;
2600
2601           case oNoop: break;
2602
2603           default : pargs.err = configfp? 1:2; break;
2604           }
2605       }
2606
2607
2608     if( configfp ) {
2609         fclose( configfp );
2610         configfp = NULL;
2611         /* Remember the first config file name. */
2612         if (!save_configname)
2613           save_configname = configname;
2614         else
2615           xfree(configname);
2616         configname = NULL;
2617         goto next_pass;
2618     }
2619     xfree( configname ); configname = NULL;
2620     if( log_get_errorcount(0) )
2621         g10_exit(2);
2622
2623     /* The command --gpgconf-list is pretty simple and may be called
2624        directly after the option parsing. */
2625     if (cmd == aGPGConfList)
2626       {
2627         gpgconf_list (save_configname);
2628         g10_exit (0);
2629       }
2630     xfree (save_configname);
2631
2632     if( nogreeting )
2633         greeting = 0;
2634
2635     if( greeting ) {
2636         fprintf(stderr, "%s %s; %s\n",
2637                         strusage(11), strusage(13), strusage(14) );
2638         fprintf(stderr, "%s\n", strusage(15) );
2639     }
2640 #ifdef IS_DEVELOPMENT_VERSION
2641     if( !opt.batch )
2642       {
2643         const char *s;
2644
2645         if((s=strusage(20)))
2646           log_info("%s\n",s);
2647         if((s=strusage(21)))
2648           log_info("%s\n",s);
2649         if((s=strusage(22)))
2650           log_info("%s\n",s);
2651       }
2652 #endif
2653
2654     if (opt.verbose > 2)
2655         log_info ("using character set `%s'\n", get_native_charset ());
2656
2657     if( may_coredump && !opt.quiet )
2658         log_info(_("WARNING: program may create a core file!\n"));
2659
2660     if (eyes_only) {
2661       if (opt.set_filename)
2662           log_info(_("WARNING: %s overrides %s\n"),
2663                    "--for-your-eyes-only","--set-filename");
2664
2665       opt.set_filename="_CONSOLE";
2666     }
2667
2668     if (opt.no_literal) {
2669         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
2670         if (opt.textmode)
2671             log_error(_("%s not allowed with %s!\n"),
2672                        "--textmode", "--no-literal" );
2673         if (opt.set_filename)
2674             log_error(_("%s makes no sense with %s!\n"),
2675                         eyes_only?"--for-your-eyes-only":"--set-filename",
2676                         "--no-literal" );
2677     }
2678
2679 #ifndef ENABLE_AGENT_SUPPORT   
2680     if (opt.use_agent) {
2681       log_info(_("NOTE: %s is not available in this version\n"),
2682                "--use-agent");
2683       opt.use_agent = 0;
2684     }
2685 #endif /*!ENABLE_AGENT_SUPPORT*/
2686
2687     if (opt.set_filesize)
2688         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
2689     if( opt.batch )
2690         tty_batchmode( 1 );
2691
2692     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
2693
2694     if(require_secmem && !got_secmem)
2695       {
2696         log_info(_("will not run with insecure memory due to %s\n"),
2697                  "--require-secmem");
2698         g10_exit(2);
2699       }
2700
2701     set_debug();
2702
2703     /* Do these after the switch(), so they can override settings. */
2704     if(PGP2)
2705       {
2706         int unusable=0;
2707
2708         if(cmd==aSign && !detached_sig)
2709           {
2710             log_info(_("you can only make detached or clear signatures "
2711                        "while in --pgp2 mode\n"));
2712             unusable=1;
2713           }
2714         else if(cmd==aSignEncr || cmd==aSignSym)
2715           {
2716             log_info(_("you can't sign and encrypt at the "
2717                        "same time while in --pgp2 mode\n"));
2718             unusable=1;
2719           }
2720         else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
2721           {
2722             log_info(_("you must use files (and not a pipe) when "
2723                        "working with --pgp2 enabled.\n"));
2724             unusable=1;
2725           }
2726         else if(cmd==aEncr || cmd==aSym)
2727           {
2728             /* Everything else should work without IDEA (except using
2729                a secret key encrypted with IDEA and setting an IDEA
2730                preference, but those have their own error
2731                messages). */
2732
2733             if(check_cipher_algo(CIPHER_ALGO_IDEA))
2734               {
2735                 log_info(_("encrypting a message in --pgp2 mode requires "
2736                            "the IDEA cipher\n"));
2737                 idea_cipher_warn(1);
2738                 unusable=1;
2739               }
2740             else if(cmd==aSym)
2741               {
2742                 /* This only sets IDEA for symmetric encryption
2743                    since it is set via select_algo_from_prefs for
2744                    pk encryption. */
2745                 xfree(def_cipher_string);
2746                 def_cipher_string = xstrdup("idea");
2747               }
2748
2749             /* PGP2 can't handle the output from the textmode
2750                filter, so we disable it for anything that could
2751                create a literal packet (only encryption and
2752                symmetric encryption, since we disable signing
2753                above). */
2754             if(!unusable)
2755               opt.textmode=0;
2756           }
2757
2758         if(unusable)
2759           compliance_failure();
2760         else
2761           {
2762             opt.force_v4_certs = 0;
2763             opt.escape_from = 1;
2764             opt.force_v3_sigs = 1;
2765             opt.pgp2_workarounds = 1;
2766             opt.ask_sig_expire = 0;
2767             opt.ask_cert_expire = 0;
2768             xfree(def_digest_string);
2769             def_digest_string = xstrdup("md5");
2770             xfree(s2k_digest_string);
2771             s2k_digest_string = xstrdup("md5");
2772             opt.compress_algo = COMPRESS_ALGO_ZIP;
2773           }
2774       }
2775     else if(PGP6)
2776       {
2777         opt.escape_from=1;
2778         opt.force_v3_sigs=1;
2779         opt.ask_sig_expire=0;
2780       }
2781     else if(PGP7)
2782       {
2783         opt.escape_from=1;
2784         opt.force_v3_sigs=1;
2785         opt.ask_sig_expire=0;
2786       }
2787     else if(PGP8)
2788       {
2789         opt.escape_from=1;
2790       }
2791
2792     /* must do this after dropping setuid, because string_to...
2793      * may try to load an module */
2794     if( def_cipher_string ) {
2795         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
2796         if(opt.def_cipher_algo==0 &&
2797            (ascii_strcasecmp(def_cipher_string,"idea")==0
2798             || ascii_strcasecmp(def_cipher_string,"s1")==0))
2799           idea_cipher_warn(1);
2800         xfree(def_cipher_string); def_cipher_string = NULL;
2801         if( check_cipher_algo(opt.def_cipher_algo) )
2802             log_error(_("selected cipher algorithm is invalid\n"));
2803     }
2804     if( def_digest_string ) {
2805         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
2806         xfree(def_digest_string); def_digest_string = NULL;
2807         if( check_digest_algo(opt.def_digest_algo) )
2808             log_error(_("selected digest algorithm is invalid\n"));
2809     }
2810     if( compress_algo_string ) {
2811         opt.compress_algo = string_to_compress_algo(compress_algo_string);
2812         xfree(compress_algo_string); compress_algo_string = NULL;
2813         if( check_compress_algo(opt.compress_algo) )
2814             log_error(_("selected compression algorithm is invalid\n"));
2815     }
2816     if( cert_digest_string ) {
2817         opt.cert_digest_algo = string_to_digest_algo(cert_digest_string);
2818         xfree(cert_digest_string); cert_digest_string = NULL;
2819         if( check_digest_algo(opt.cert_digest_algo) )
2820             log_error(_("selected certification digest algorithm is invalid\n"));
2821     }
2822     if( s2k_cipher_string ) {
2823         opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
2824         xfree(s2k_cipher_string); s2k_cipher_string = NULL;
2825         if( check_cipher_algo(opt.s2k_cipher_algo) )
2826             log_error(_("selected cipher algorithm is invalid\n"));
2827     }
2828     if( s2k_digest_string ) {
2829         opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
2830         xfree(s2k_digest_string); s2k_digest_string = NULL;
2831         if( check_digest_algo(opt.s2k_digest_algo) )
2832             log_error(_("selected digest algorithm is invalid\n"));
2833     }
2834     if( opt.completes_needed < 1 )
2835       log_error(_("completes-needed must be greater than 0\n"));
2836     if( opt.marginals_needed < 2 )
2837       log_error(_("marginals-needed must be greater than 1\n"));
2838     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
2839       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
2840     if(opt.def_cert_level<0 || opt.def_cert_level>3)
2841       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
2842     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
2843       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
2844     switch( opt.s2k_mode ) {
2845       case 0:
2846         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
2847         break;
2848       case 1: case 3: break;
2849       default:
2850         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
2851     }
2852
2853     /* This isn't actually needed, but does serve to error out if the
2854        string is invalid. */
2855     if(opt.def_preference_list &&
2856         keygen_set_std_prefs(opt.def_preference_list,0))
2857       log_error(_("invalid default preferences\n"));
2858
2859     /* We provide defaults for the personal digest list.  This is
2860        SHA-1. */
2861     if(!pers_digest_list)
2862       pers_digest_list="h2";
2863
2864     if(pers_cipher_list &&
2865        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
2866       log_error(_("invalid personal cipher preferences\n"));
2867
2868     if(pers_digest_list &&
2869        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
2870       log_error(_("invalid personal digest preferences\n"));
2871
2872     if(pers_compress_list &&
2873        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
2874       log_error(_("invalid personal compress preferences\n"));
2875
2876     /* We don't support all possible commands with multifile yet */
2877     if(multifile)
2878       {
2879         char *cmdname;
2880
2881         switch(cmd)
2882           {
2883           case aSign:
2884             cmdname="--sign";
2885             break;
2886           case aClearsign:
2887             cmdname="--clearsign";
2888             break;
2889           case aDetachedSign:
2890             cmdname="--detach-sign";
2891             break;
2892           case aSym:
2893             cmdname="--symmetric";
2894             break;
2895           case aEncrSym:
2896             cmdname="--symmetric --encrypt";
2897             break;
2898           case aStore:
2899             cmdname="--store";
2900             break;
2901           default:
2902             cmdname=NULL;
2903             break;
2904           }
2905
2906         if(cmdname)
2907           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
2908       }
2909
2910     if( log_get_errorcount(0) )
2911         g10_exit(2);
2912
2913     if(opt.compress_level==0)
2914       opt.compress_algo=COMPRESS_ALGO_NONE;
2915
2916     /* Check our chosen algorithms against the list of legal
2917        algorithms. */
2918
2919     if(!GNUPG)
2920       {
2921         const char *badalg=NULL;
2922         preftype_t badtype=PREFTYPE_NONE;
2923
2924         if(opt.def_cipher_algo
2925            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
2926           {
2927             badalg=cipher_algo_to_string(opt.def_cipher_algo);
2928             badtype=PREFTYPE_SYM;
2929           }
2930         else if(opt.def_digest_algo
2931                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
2932           {
2933             badalg=digest_algo_to_string(opt.def_digest_algo);
2934             badtype=PREFTYPE_HASH;
2935           }
2936         else if(opt.cert_digest_algo
2937                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
2938           {
2939             badalg=digest_algo_to_string(opt.cert_digest_algo);
2940             badtype=PREFTYPE_HASH;
2941           }
2942         else if(opt.compress_algo!=-1
2943                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
2944           {
2945             badalg=compress_algo_to_string(opt.compress_algo);
2946             badtype=PREFTYPE_ZIP;
2947           }
2948
2949         if(badalg)
2950           {
2951             switch(badtype)
2952               {
2953               case PREFTYPE_SYM:
2954                 log_info(_("you may not use cipher algorithm `%s'"
2955                            " while in %s mode\n"),
2956                          badalg,compliance_option_string());
2957                 break;
2958               case PREFTYPE_HASH:
2959                 log_info(_("you may not use digest algorithm `%s'"
2960                            " while in %s mode\n"),
2961                          badalg,compliance_option_string());
2962                 break;
2963               case PREFTYPE_ZIP:
2964                 log_info(_("you may not use compression algorithm `%s'"
2965                            " while in %s mode\n"),
2966                          badalg,compliance_option_string());
2967                 break;
2968               default:
2969                 BUG();
2970               }
2971
2972             compliance_failure();
2973           }
2974       }
2975
2976     /* set the random seed file */
2977     if( use_random_seed ) {
2978         char *p = make_filename(opt.homedir, "random_seed", NULL );
2979         set_random_seed_file(p);
2980         if (!access (p, F_OK))
2981           register_secured_file (p);
2982         xfree(p);
2983     }
2984
2985     if( !cmd && opt.fingerprint && !with_fpr ) {
2986         set_cmd( &cmd, aListKeys);
2987     }
2988
2989     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
2990         if( cmd == aKModeC ) {
2991             opt.fingerprint = 1;
2992             cmd = aKMode;
2993         }
2994         opt.list_sigs = 0;
2995         if( opt.verbose > 2 )
2996             opt.check_sigs++;
2997         if( opt.verbose > 1 )
2998             opt.list_sigs++;
2999
3000         opt.verbose = opt.verbose > 1;
3001         g10_opt_verbose = opt.verbose;
3002     }
3003
3004     /* kludge to let -sat generate a clear text signature */
3005     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
3006         cmd = aClearsign;
3007
3008     if( opt.verbose > 1 )
3009         set_packet_list_mode(1);
3010
3011     /* Add the keyrings, but not for some special commands and not in
3012        case of "-kvv userid keyring".  Also avoid adding the secret
3013        keyring for a couple of commands to avoid unneeded access in
3014        case the secrings are stored on a floppy.
3015        
3016        We always need to add the keyrings if we are running under
3017        SELinux, this is so that the rings are added to the list of
3018        secured files. */
3019     if( ALWAYS_ADD_KEYRINGS 
3020         || (cmd != aDeArmor && cmd != aEnArmor
3021             && !(cmd == aKMode && argc == 2 )) ) 
3022       {
3023         if (ALWAYS_ADD_KEYRINGS
3024             || (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
3025                 && cmd != aVerify && cmd != aSym))
3026           {
3027             if (!sec_nrings || default_keyring) /* add default secret rings */
3028               keydb_add_resource ("secring" EXTSEP_S "gpg", 4, 1);
3029             for (sl = sec_nrings; sl; sl = sl->next)
3030               keydb_add_resource ( sl->d, 0, 1 );
3031           }
3032         if( !nrings || default_keyring )  /* add default ring */
3033             keydb_add_resource ("pubring" EXTSEP_S "gpg", 4, 0);
3034         for(sl = nrings; sl; sl = sl->next )
3035             keydb_add_resource ( sl->d, sl->flags, 0 );
3036       }
3037     FREE_STRLIST(nrings);
3038     FREE_STRLIST(sec_nrings);
3039
3040
3041     if( pwfd != -1 )  /* read the passphrase now. */
3042         read_passphrase_from_fd( pwfd );
3043
3044     fname = argc? *argv : NULL;
3045
3046     switch( cmd ) {
3047       case aPrimegen:
3048       case aPrintMD:
3049       case aPrintMDs:
3050       case aGenRandom:
3051       case aDeArmor:
3052       case aEnArmor:
3053       case aFixTrustDB:
3054         break;
3055       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
3056       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
3057       default: rc = setup_trustdb(1, trustdb_name ); break;
3058     }
3059     if( rc )
3060         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
3061
3062
3063     switch (cmd)
3064       {
3065       case aStore: 
3066       case aSym:  
3067       case aSign: 
3068       case aSignSym: 
3069       case aClearsign: 
3070         if (!opt.quiet && any_explicit_recipient)
3071           log_info (_("WARNING: recipients (-r) given "
3072                       "without using public key encryption\n"));
3073         break;
3074       default:
3075         break;
3076       }
3077
3078     switch( cmd )
3079       {
3080       case aStore: /* only store the file */
3081         if( argc > 1 )
3082             wrong_args(_("--store [filename]"));
3083         if( (rc = encode_store(fname)) )
3084             log_error ("storing `%s' failed: %s\n",
3085                        print_fname_stdin(fname),g10_errstr(rc) );
3086         break;
3087       case aSym: /* encrypt the given file only with the symmetric cipher */
3088         if( argc > 1 )
3089             wrong_args(_("--symmetric [filename]"));
3090         if( (rc = encode_symmetric(fname)) )
3091             log_error (_("symmetric encryption of `%s' failed: %s\n"),
3092                         print_fname_stdin(fname),g10_errstr(rc) );
3093         break;
3094
3095       case aEncr: /* encrypt the given file */
3096         if(multifile)
3097           encode_crypt_files(argc, argv, remusr);
3098         else
3099           {
3100             if( argc > 1 )
3101               wrong_args(_("--encrypt [filename]"));
3102             if( (rc = encode_crypt(fname,remusr,0)) )
3103               log_error("%s: encryption failed: %s\n",
3104                         print_fname_stdin(fname), g10_errstr(rc) );
3105           }
3106         break;
3107
3108       case aEncrSym:
3109         /* This works with PGP 8 in the sense that it acts just like a
3110            symmetric message.  It doesn't work at all with 2 or 6.  It
3111            might work with 7, but alas, I don't have a copy to test
3112            with right now. */
3113         if( argc > 1 )
3114           wrong_args(_("--symmetric --encrypt [filename]"));
3115         else if(opt.s2k_mode==0)
3116           log_error(_("you cannot use --symmetric --encrypt"
3117                       " with --s2k-mode 0\n"));
3118         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3119           log_error(_("you cannot use --symmetric --encrypt"
3120                       " while in %s mode\n"),compliance_option_string());
3121         else
3122           {
3123             if( (rc = encode_crypt(fname,remusr,1)) )
3124               log_error("%s: encryption failed: %s\n",
3125                         print_fname_stdin(fname), g10_errstr(rc) );
3126           }
3127         break;
3128
3129       case aSign: /* sign the given file */
3130         sl = NULL;
3131         if( detached_sig ) { /* sign all files */
3132             for( ; argc; argc--, argv++ )
3133                 add_to_strlist( &sl, *argv );
3134         }
3135         else {
3136             if( argc > 1 )
3137                 wrong_args(_("--sign [filename]"));
3138             if( argc ) {
3139                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3140                 strcpy(sl->d, fname);
3141             }
3142         }
3143         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
3144             log_error("signing failed: %s\n", g10_errstr(rc) );
3145         free_strlist(sl);
3146         break;
3147
3148       case aSignEncr: /* sign and encrypt the given file */
3149         if( argc > 1 )
3150             wrong_args(_("--sign --encrypt [filename]"));
3151         if( argc ) {
3152             sl = xmalloc_clear( sizeof *sl + strlen(fname));
3153             strcpy(sl->d, fname);
3154         }
3155         else
3156             sl = NULL;
3157         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
3158             log_error("%s: sign+encrypt failed: %s\n",
3159                       print_fname_stdin(fname), g10_errstr(rc) );
3160         free_strlist(sl);
3161         break;
3162
3163       case aSignEncrSym: /* sign and encrypt the given file */
3164         if( argc > 1 )
3165             wrong_args(_("--symmetric --sign --encrypt [filename]"));
3166         else if(opt.s2k_mode==0)
3167           log_error(_("you cannot use --symmetric --sign --encrypt"
3168                       " with --s2k-mode 0\n"));
3169         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3170           log_error(_("you cannot use --symmetric --sign --encrypt"
3171                       " while in %s mode\n"),compliance_option_string());
3172         else
3173           {
3174             if( argc )
3175               {
3176                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3177                 strcpy(sl->d, fname);
3178               }
3179             else
3180               sl = NULL;
3181             if( (rc = sign_file(sl, detached_sig, locusr, 2, remusr, NULL)) )
3182               log_error("%s: symmetric+sign+encrypt failed: %s\n",
3183                         print_fname_stdin(fname), g10_errstr(rc) );
3184             free_strlist(sl);
3185           }
3186         break;
3187
3188       case aSignSym: /* sign and conventionally encrypt the given file */
3189         if (argc > 1)
3190             wrong_args(_("--sign --symmetric [filename]"));
3191         rc = sign_symencrypt_file (fname, locusr);
3192         if (rc)
3193             log_error("%s: sign+symmetric failed: %s\n",
3194                       print_fname_stdin(fname), g10_errstr(rc) );
3195         break;
3196
3197       case aClearsign: /* make a clearsig */
3198         if( argc > 1 )
3199             wrong_args(_("--clearsign [filename]"));
3200         if( (rc = clearsign_file(fname, locusr, NULL)) )
3201             log_error("%s: clearsign failed: %s\n",
3202                       print_fname_stdin(fname), g10_errstr(rc) );
3203         break;
3204
3205       case aVerify:
3206         if(multifile)
3207           {
3208             if( (rc = verify_files( argc, argv ) ))
3209               log_error("verify files failed: %s\n", g10_errstr(rc) );
3210           }
3211         else
3212           {
3213             if( (rc = verify_signatures( argc, argv ) ))
3214               log_error("verify signatures failed: %s\n", g10_errstr(rc) );
3215           }
3216         break;
3217
3218       case aDecrypt:
3219         if(multifile)
3220           decrypt_messages(argc, argv);
3221         else
3222           {
3223             if( argc > 1 )
3224               wrong_args(_("--decrypt [filename]"));
3225             if( (rc = decrypt_message( fname ) ))
3226               log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
3227           }
3228         break;
3229             
3230       case aSignKey:
3231         if( argc != 1 )
3232           wrong_args(_("--sign-key user-id"));
3233         /* fall through */
3234       case aLSignKey:
3235         if( argc != 1 )
3236           wrong_args(_("--lsign-key user-id"));
3237         /* fall through */
3238
3239         sl=NULL;
3240
3241         if(cmd==aSignKey)
3242           append_to_strlist(&sl,"sign");
3243         else if(cmd==aLSignKey)
3244           append_to_strlist(&sl,"lsign");
3245         else
3246           BUG();
3247
3248         append_to_strlist( &sl, "save" );
3249         username = make_username( fname );
3250         keyedit_menu(fname, locusr, sl, 0, 0 );
3251         xfree(username);
3252         free_strlist(sl);
3253         break;
3254
3255       case aEditKey: /* Edit a key signature */
3256         if( !argc )
3257             wrong_args(_("--edit-key user-id [commands]"));
3258         username = make_username( fname );
3259         if( argc > 1 ) {
3260             sl = NULL;
3261             for( argc--, argv++ ; argc; argc--, argv++ )
3262                 append_to_strlist( &sl, *argv );
3263             keyedit_menu( username, locusr, sl, 0, 1 );
3264             free_strlist(sl);
3265         }
3266         else
3267             keyedit_menu(username, locusr, NULL, 0, 1 );
3268         xfree(username);
3269         break;
3270
3271       case aDeleteKeys:
3272       case aDeleteSecretKeys:
3273       case aDeleteSecretAndPublicKeys:
3274         sl = NULL;
3275         /* I'm adding these in reverse order as add_to_strlist2
3276            reverses them again, and it's easier to understand in the
3277            proper order :) */
3278         for( ; argc; argc-- )
3279           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
3280         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
3281         free_strlist(sl);
3282         break;
3283
3284       case aCheckKeys:
3285         opt.check_sigs = 1;
3286       case aListSigs:
3287         opt.list_sigs = 1;
3288       case aListKeys:
3289         sl = NULL;
3290         for( ; argc; argc--, argv++ )
3291             add_to_strlist2( &sl, *argv, utf8_strings );
3292         public_key_list( sl );
3293         free_strlist(sl);
3294         break;
3295       case aListSecretKeys:
3296         sl = NULL;
3297         for( ; argc; argc--, argv++ )
3298             add_to_strlist2( &sl, *argv, utf8_strings );
3299         secret_key_list( sl );
3300         free_strlist(sl);
3301         break;
3302
3303       case aKMode: /* list keyring -- NOTE: This will be removed soon */
3304         if( argc < 2 ) { /* -kv [userid] */
3305             sl = NULL;
3306             if (argc && **argv)
3307                 add_to_strlist2( &sl, *argv, utf8_strings );
3308             public_key_list( sl );
3309             free_strlist(sl);
3310         }
3311         else if( argc == 2 ) { /* -kv userid keyring */
3312             if( access( argv[1], R_OK ) ) {
3313                 log_error(_("can't open `%s': %s\n"),
3314                                print_fname_stdin(argv[1]), strerror(errno));
3315             }
3316             else {
3317                 /* add keyring (default keyrings are not registered in this
3318                  * special case */
3319                 keydb_add_resource( argv[1], 0, 0 );
3320                 sl = NULL;
3321                 if (**argv)
3322                     add_to_strlist2( &sl, *argv, utf8_strings );
3323                 public_key_list( sl );
3324                 free_strlist(sl);
3325             }
3326         }
3327         else
3328             wrong_args(_("-k[v][v][v][c] [user-id] [keyring]") );
3329         break;
3330
3331       case aKeygen: /* generate a key */
3332         if( opt.batch ) {
3333             if( argc > 1 )
3334                 wrong_args("--gen-key [parameterfile]");
3335             generate_keypair( argc? *argv : NULL, NULL, NULL );
3336         }
3337         else {
3338             if( argc )
3339                 wrong_args("--gen-key");
3340             generate_keypair(NULL, NULL, NULL);
3341         }
3342         break;
3343
3344       case aFastImport:
3345         opt.import_options |= IMPORT_FAST;
3346       case aImport:
3347         import_keys( argc? argv:NULL, argc, NULL, opt.import_options );
3348         break;
3349
3350       case aExport:
3351       case aSendKeys:
3352       case aRecvKeys:
3353         sl = NULL;
3354         for( ; argc; argc--, argv++ )
3355             add_to_strlist2( &sl, *argv, utf8_strings );
3356         if( cmd == aSendKeys )
3357             rc=keyserver_export( sl );
3358         else if( cmd == aRecvKeys )
3359             rc=keyserver_import( sl );
3360         else
3361             rc=export_pubkeys( sl, opt.export_options );
3362         if(rc)
3363           {
3364             if(cmd==aSendKeys)
3365               log_error(_("keyserver send failed: %s\n"),g10_errstr(rc));
3366             else if(cmd==aRecvKeys)
3367               log_error(_("keyserver receive failed: %s\n"),g10_errstr(rc));
3368             else
3369               log_error(_("key export failed: %s\n"),g10_errstr(rc));
3370           }
3371         free_strlist(sl);
3372         break;
3373
3374      case aSearchKeys:
3375         sl = NULL;
3376         for( ; argc; argc--, argv++ )
3377           append_to_strlist2( &sl, *argv, utf8_strings );
3378         rc=keyserver_search( sl );
3379         if(rc)
3380           log_error(_("keyserver search failed: %s\n"),g10_errstr(rc));
3381         free_strlist(sl);
3382         break;
3383
3384       case aRefreshKeys:
3385         sl = NULL;
3386         for( ; argc; argc--, argv++ )
3387             add_to_strlist2( &sl, *argv, utf8_strings );
3388         rc=keyserver_refresh(sl);
3389         if(rc)
3390           log_error(_("keyserver refresh failed: %s\n"),g10_errstr(rc));
3391         free_strlist(sl);
3392         break;
3393
3394       case aFetchKeys:
3395         sl = NULL;
3396         for( ; argc; argc--, argv++ )
3397             add_to_strlist2( &sl, *argv, utf8_strings );
3398         rc=keyserver_fetch(sl);
3399         if(rc)
3400           log_error("key fetch failed: %s\n",g10_errstr(rc));
3401         free_strlist(sl);
3402         break;
3403
3404       case aExportSecret:
3405         sl = NULL;
3406         for( ; argc; argc--, argv++ )
3407             add_to_strlist2( &sl, *argv, utf8_strings );
3408         export_seckeys( sl );
3409         free_strlist(sl);
3410         break;
3411
3412       case aExportSecretSub:
3413         sl = NULL;
3414         for( ; argc; argc--, argv++ )
3415             add_to_strlist2( &sl, *argv, utf8_strings );
3416         export_secsubkeys( sl );
3417         free_strlist(sl);
3418         break;
3419
3420       case aGenRevoke:
3421         if( argc != 1 )
3422             wrong_args("--gen-revoke user-id");
3423         username =  make_username(*argv);
3424         gen_revoke( username );
3425         xfree( username );
3426         break;
3427
3428       case aDesigRevoke:
3429         if( argc != 1 )
3430             wrong_args("--desig-revoke user-id");
3431         username =  make_username(*argv);
3432         gen_desig_revoke( username, locusr );
3433         xfree( username );
3434         break;
3435
3436       case aDeArmor:
3437         if( argc > 1 )
3438             wrong_args("--dearmor [file]");
3439         rc = dearmor_file( argc? *argv: NULL );
3440         if( rc )
3441             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
3442         break;
3443
3444       case aEnArmor:
3445         if( argc > 1 )
3446             wrong_args("--enarmor [file]");
3447         rc = enarmor_file( argc? *argv: NULL );
3448         if( rc )
3449             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
3450         break;
3451
3452
3453       case aPrimegen:
3454         {   int mode = argc < 2 ? 0 : atoi(*argv);
3455
3456             if( mode == 1 && argc == 2 ) {
3457                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
3458             }
3459             else if( mode == 2 && argc == 3 ) {
3460                 mpi_print( stdout, generate_elg_prime(
3461                                              0, atoi(argv[1]),
3462                                              atoi(argv[2]), NULL,NULL ), 1);
3463             }
3464             else if( mode == 3 && argc == 3 ) {
3465                 MPI *factors;
3466                 mpi_print( stdout, generate_elg_prime(
3467                                              1, atoi(argv[1]),
3468                                              atoi(argv[2]), NULL,&factors ), 1);
3469                 putchar('\n');
3470                 mpi_print( stdout, factors[0], 1 ); /* print q */
3471             }
3472             else if( mode == 4 && argc == 3 ) {
3473                 MPI g = mpi_alloc(1);
3474                 mpi_print( stdout, generate_elg_prime(
3475                                                  0, atoi(argv[1]),
3476                                                  atoi(argv[2]), g, NULL ), 1);
3477                 putchar('\n');
3478                 mpi_print( stdout, g, 1 );
3479                 mpi_free(g);
3480             }
3481             else
3482                 wrong_args("--gen-prime mode bits [qbits] ");
3483             putchar('\n');
3484         }
3485         break;
3486
3487       case aGenRandom:
3488         {
3489             int level = argc ? atoi(*argv):0;
3490             int count = argc > 1 ? atoi(argv[1]): 0;
3491             int endless = !count;
3492
3493             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
3494                 wrong_args("--gen-random 0|1|2 [count]");
3495
3496             while( endless || count ) {
3497                 byte *p;
3498                 /* Wee need a multiple of 3, so that in case of
3499                    armored output we get a correct string.  No
3500                    linefolding is done, as it is best to levae this to
3501                    other tools */
3502                 size_t n = !endless && count < 99? count : 99;
3503
3504                 p = get_random_bits( n*8, level, 0);
3505 #ifdef HAVE_DOSISH_SYSTEM
3506                 setmode ( fileno(stdout), O_BINARY );
3507 #endif
3508                 if (opt.armor) {
3509                     char *tmp = make_radix64_string (p, n);
3510                     fputs (tmp, stdout);
3511                     xfree (tmp);
3512                     if (n%3 == 1)
3513                       putchar ('=');
3514                     if (n%3)
3515                       putchar ('=');
3516                 } else {
3517                     fwrite( p, n, 1, stdout );
3518                 }
3519                 xfree(p);
3520                 if( !endless )
3521                     count -= n;
3522             }
3523             if (opt.armor)
3524                 putchar ('\n');
3525         }
3526         break;
3527
3528       case aPrintMD:
3529         if( argc < 1)
3530             wrong_args("--print-md algo [files]");
3531         {
3532             int all_algos = (**argv=='*' && !(*argv)[1]);
3533             int algo = all_algos? 0 : string_to_digest_algo(*argv);
3534
3535             if( !algo && !all_algos )
3536                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
3537             else {
3538                 argc--; argv++;
3539                 if( !argc )
3540                     print_mds(NULL, algo);
3541                 else {
3542                     for(; argc; argc--, argv++ )
3543                         print_mds(*argv, algo);
3544                 }
3545             }
3546         }
3547         break;
3548
3549       case aPrintMDs: /* old option */
3550         if( !argc )
3551             print_mds(NULL,0);
3552         else {
3553             for(; argc; argc--, argv++ )
3554                 print_mds(*argv,0);
3555         }
3556         break;
3557
3558       case aListTrustDB:
3559         if( !argc )
3560             list_trustdb(NULL);
3561         else {
3562             for( ; argc; argc--, argv++ )
3563                 list_trustdb( *argv );
3564         }
3565         break;
3566
3567       case aUpdateTrustDB:
3568         if( argc )
3569             wrong_args("--update-trustdb");
3570         update_trustdb();
3571         break;
3572
3573       case aCheckTrustDB:
3574         /* Old versions allowed for arguments - ignore them */
3575         check_trustdb();
3576         break;
3577
3578       case aFixTrustDB:
3579         log_error("this command is not yet implemented.\n");
3580         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
3581         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
3582         break;
3583
3584       case aListTrustPath:
3585         if( !argc )
3586             wrong_args("--list-trust-path <user-ids>");
3587         for( ; argc; argc--, argv++ ) {
3588             username = make_username( *argv );
3589             list_trust_path( username );
3590             xfree(username);
3591         }
3592         break;
3593
3594       case aExportOwnerTrust:
3595         if( argc )
3596             wrong_args("--export-ownertrust");
3597         export_ownertrust();
3598         break;
3599
3600       case aImportOwnerTrust:
3601         if( argc > 1 )
3602             wrong_args("--import-ownertrust [file]");
3603         import_ownertrust( argc? *argv:NULL );
3604         break;
3605       
3606       case aPipeMode:
3607         if ( argc )
3608             wrong_args ("--pipemode");
3609         run_in_pipemode ();
3610         break;
3611
3612       case aRebuildKeydbCaches:
3613         if (argc)
3614             wrong_args ("--rebuild-keydb-caches");
3615         keydb_rebuild_caches (1);
3616         break;
3617
3618 #ifdef ENABLE_CARD_SUPPORT
3619       case aCardStatus:
3620         if (argc)
3621             wrong_args ("--card-status");
3622         card_status (stdout, NULL, 0);
3623         break;
3624
3625       case aCardEdit:
3626         if (argc) {
3627             sl = NULL;
3628             for (argc--, argv++ ; argc; argc--, argv++)
3629                 append_to_strlist (&sl, *argv);
3630             card_edit (sl);
3631             free_strlist (sl);
3632         }
3633         else
3634             card_edit (NULL);
3635         break;
3636
3637       case aChangePIN:
3638         if (!argc)
3639             change_pin (0,1);
3640         else if (argc == 1)
3641             change_pin (atoi (*argv),1);
3642         else
3643         wrong_args ("--change-pin [no]");
3644         break;
3645 #endif /* ENABLE_CARD_SUPPORT*/
3646
3647       case aListConfig:
3648         {
3649           char *str=collapse_args(argc,argv);
3650           list_config(str);
3651           xfree(str);
3652         }
3653         break;
3654
3655       case aListPackets:
3656         opt.list_packets=2;
3657       default:
3658         if( argc > 1 )
3659             wrong_args(_("[filename]"));
3660         /* Issue some output for the unix newbie */
3661         if( !fname && !opt.outfile && isatty( fileno(stdin) )
3662                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
3663             log_info(_("Go ahead and type your message ...\n"));
3664
3665         a = iobuf_open(fname);
3666         if (a && is_secured_file (iobuf_get_fd (a)))
3667           {
3668             iobuf_close (a);
3669             a = NULL;
3670             errno = EPERM;
3671           }
3672         if( !a )
3673             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
3674         else {
3675
3676             if( !opt.no_armor ) {
3677                 if( use_armor_filter( a ) ) {
3678                     memset( &afx, 0, sizeof afx);
3679                     iobuf_push_filter( a, armor_filter, &afx );
3680                 }
3681             }
3682             if( cmd == aListPackets ) {
3683                 set_packet_list_mode(1);
3684                 opt.list_packets=1;
3685             }
3686             rc = proc_packets(NULL, a );
3687             if( rc )
3688                 log_error("processing message failed: %s\n", g10_errstr(rc) );
3689             iobuf_close(a);
3690         }
3691         break;
3692       }
3693
3694     /* cleanup */
3695     FREE_STRLIST(remusr);
3696     FREE_STRLIST(locusr);
3697     g10_exit(0);
3698     return 8; /*NEVER REACHED*/
3699 }
3700
3701
3702 void
3703 g10_exit( int rc )
3704 {
3705 #ifdef ENABLE_CARD_SUPPORT
3706     card_close ();
3707 #endif
3708     update_random_seed_file();
3709     if( opt.debug & DBG_MEMSTAT_VALUE ) {
3710         m_print_stats("on exit");
3711         random_dump_stats();
3712     }
3713     if( opt.debug )
3714         secmem_dump_stats();
3715     secmem_term();
3716     rc = rc? rc : log_get_errorcount(0)? 2 :
3717                         g10_errors_seen? 1 : 0;
3718     exit(rc );
3719 }
3720
3721
3722 /* Pretty-print hex hashes.  This assumes at least an 80-character
3723    display, but there are a few other similar assumptions in the
3724    display code. */
3725 static void
3726 print_hex( MD_HANDLE md, int algo, const char *fname )
3727 {
3728   int i,n,count,indent=0;
3729   const byte *p;
3730
3731   if(fname)
3732     indent=printf("%s: ",fname);
3733
3734   if(indent>40)
3735     {
3736       printf("\n");
3737       indent=0;
3738     }
3739
3740   if(algo==DIGEST_ALGO_RMD160)
3741     indent+=printf("RMD160 = ");
3742   else if(algo>0)
3743     indent+=printf("%6s = ",digest_algo_to_string(algo));
3744   else
3745     algo=abs(algo);
3746
3747   count=indent;
3748
3749   p = md_read( md, algo );
3750   n = md_digest_length(algo);
3751
3752   count+=printf("%02X",*p++);
3753
3754   for(i=1;i<n;i++,p++)
3755     {
3756       if(n==16)
3757         {
3758           if(count+2>79)
3759             {
3760               printf("\n%*s",indent," ");
3761               count=indent;
3762             }
3763           else
3764             count+=printf(" ");
3765
3766           if(!(i%8))
3767             count+=printf(" ");
3768         }
3769       else if (n==20)
3770         {
3771           if(!(i%2))
3772             {
3773               if(count+4>79)
3774                 {
3775                   printf("\n%*s",indent," ");
3776                   count=indent;
3777                 }
3778               else
3779                 count+=printf(" ");
3780             }
3781
3782           if(!(i%10))
3783             count+=printf(" ");
3784         }
3785       else
3786         {
3787           if(!(i%4))
3788             {
3789               if(count+8>79)
3790                 {
3791                   printf("\n%*s",indent," ");
3792                   count=indent;
3793                 }
3794               else
3795                 count+=printf(" ");
3796             }
3797         }
3798
3799       count+=printf("%02X",*p);
3800     }
3801
3802   printf("\n");
3803 }
3804
3805 static void
3806 print_hashline( MD_HANDLE md, int algo, const char *fname )
3807 {
3808     int i, n;
3809     const byte *p;
3810     
3811     if ( fname ) {
3812         for (p = fname; *p; p++ ) {
3813             if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
3814                 printf("%%%02X", *p );
3815             else 
3816                 putchar( *p );
3817         }
3818     }
3819     putchar(':');
3820     printf("%d:", algo );
3821     p = md_read( md, algo );
3822     n = md_digest_length(algo);
3823     for(i=0; i < n ; i++, p++ ) 
3824         printf("%02X", *p );
3825     putchar(':');
3826     putchar('\n');
3827 }
3828
3829 static void
3830 print_mds( const char *fname, int algo )
3831 {
3832     FILE *fp;
3833     char buf[1024];
3834     size_t n;
3835     MD_HANDLE md;
3836
3837     if( !fname ) {
3838         fp = stdin;
3839 #ifdef HAVE_DOSISH_SYSTEM
3840         setmode ( fileno(fp) , O_BINARY );
3841 #endif
3842     }
3843     else {
3844         fp = fopen( fname, "rb" );
3845         if (fp && is_secured_file (fileno (fp)))
3846           {
3847             fclose (fp);
3848             fp = NULL;
3849             errno = EPERM;
3850           }
3851     }
3852     if( !fp ) {
3853         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
3854         return;
3855     }
3856
3857     md = md_open( 0, 0 );
3858     if( algo )
3859         md_enable( md, algo );
3860     else {
3861         md_enable( md, DIGEST_ALGO_MD5 );
3862         md_enable( md, DIGEST_ALGO_SHA1 );
3863         md_enable( md, DIGEST_ALGO_RMD160 );
3864 #ifdef USE_SHA256
3865         md_enable( md, DIGEST_ALGO_SHA256 );
3866 #endif
3867 #ifdef USE_SHA512
3868         md_enable( md, DIGEST_ALGO_SHA384 );
3869         md_enable( md, DIGEST_ALGO_SHA512 );
3870 #endif
3871     }
3872
3873     while( (n=fread( buf, 1, DIM(buf), fp )) )
3874         md_write( md, buf, n );
3875     if( ferror(fp) )
3876         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
3877     else {
3878         md_final(md);
3879         if ( opt.with_colons ) {
3880             if ( algo ) 
3881                 print_hashline( md, algo, fname );
3882             else {
3883                 print_hashline( md, DIGEST_ALGO_MD5, fname );
3884                 print_hashline( md, DIGEST_ALGO_SHA1, fname );
3885                 print_hashline( md, DIGEST_ALGO_RMD160, fname );
3886 #ifdef USE_SHA256
3887                 print_hashline( md, DIGEST_ALGO_SHA256, fname );
3888 #endif
3889 #ifdef USE_SHA512
3890                 print_hashline( md, DIGEST_ALGO_SHA384, fname );
3891                 print_hashline( md, DIGEST_ALGO_SHA512, fname );
3892 #endif
3893             }
3894         }
3895         else {
3896             if( algo )
3897                print_hex(md,-algo,fname);
3898             else {
3899                 print_hex( md, DIGEST_ALGO_MD5, fname );
3900                 print_hex( md, DIGEST_ALGO_SHA1, fname );
3901                 print_hex( md, DIGEST_ALGO_RMD160, fname );
3902 #ifdef USE_SHA256
3903                 print_hex( md, DIGEST_ALGO_SHA256, fname );
3904 #endif
3905 #ifdef USE_SHA512
3906                 print_hex( md, DIGEST_ALGO_SHA384, fname );
3907                 print_hex( md, DIGEST_ALGO_SHA512, fname );
3908 #endif
3909             }
3910         }
3911     }
3912     md_close(md);
3913
3914     if( fp != stdin )
3915         fclose(fp);
3916 }
3917
3918
3919 /****************
3920  * Check the supplied name,value string and add it to the notation
3921  * data to be used for signatures.  which==0 for sig notations, and 1
3922  * for cert notations.
3923 */
3924 static void
3925 add_notation_data( const char *string, int which )
3926 {
3927     const char *s;
3928     STRLIST sl,*notation_data;
3929     int critical=0;
3930     int highbit=0;
3931     int saw_at=0;
3932
3933     if(which)
3934       notation_data=&opt.cert_notation_data;
3935     else
3936       notation_data=&opt.sig_notation_data;
3937
3938     if( *string == '!' ) {
3939         critical = 1;
3940         string++;
3941     }
3942
3943     /* If and when the IETF assigns some official name tags, we'll
3944        have to add them here. */
3945
3946     for( s=string ; *s != '='; s++ )
3947       {
3948         if( *s=='@')
3949           saw_at++;
3950
3951         if( !*s || !isascii (*s) || (!isgraph(*s) && !isspace(*s)) )
3952           {
3953             log_error(_("a notation name must have only printable characters "
3954                         "or spaces, and end with an '='\n") );
3955             return;
3956           }
3957       }
3958
3959     if(!saw_at && !opt.expert)
3960       {
3961         log_error(_("a user notation name must contain the '@' character\n"));
3962         return;
3963       }
3964     if (saw_at > 1)
3965       {
3966         log_error(_("a notation name must not contain more than "
3967                     "one '@' character\n"));
3968         return;
3969       }
3970
3971     /* we only support printable text - therefore we enforce the use
3972      * of only printable characters (an empty value is valid) */
3973     for( s++; *s ; s++ ) {
3974         if ( isascii (*s) )
3975           highbit = 1;
3976         else if (iscntrl(*s)) {
3977             log_error(_("a notation value must not use"
3978                         " any control characters\n") );
3979             return;
3980         }
3981     }
3982
3983     if( highbit )   /* must use UTF8 encoding */
3984         sl = add_to_strlist2( notation_data, string, utf8_strings );
3985     else
3986         sl = add_to_strlist( notation_data, string );
3987
3988     if( critical )
3989         sl->flags |= 1;
3990 }
3991
3992 static void
3993 add_policy_url( const char *string, int which )
3994 {
3995   unsigned int i,critical=0;
3996   STRLIST sl;
3997
3998   if(*string=='!')
3999     {
4000       string++;
4001       critical=1;
4002     }
4003
4004   for(i=0;i<strlen(string);i++)
4005     if( !isascii (string[i]) || iscntrl(string[i]))
4006       break;
4007
4008   if(i==0 || i<strlen(string))
4009     {
4010       if(which)
4011         log_error(_("the given certification policy URL is invalid\n"));
4012       else
4013         log_error(_("the given signature policy URL is invalid\n"));
4014     }
4015
4016   if(which)
4017     sl=add_to_strlist( &opt.cert_policy_url, string );
4018   else
4019     sl=add_to_strlist( &opt.sig_policy_url, string );
4020
4021   if(critical)
4022     sl->flags |= 1;    
4023 }
4024
4025 static void
4026 add_keyserver_url( const char *string, int which )
4027 {
4028   unsigned int i,critical=0;
4029   STRLIST sl;
4030
4031   if(*string=='!')
4032     {
4033       string++;
4034       critical=1;
4035     }
4036
4037   for(i=0;i<strlen(string);i++)
4038     if( !isascii (string[i]) || iscntrl(string[i]))
4039       break;
4040
4041   if(i==0 || i<strlen(string))
4042     {
4043       if(which)
4044         BUG();
4045       else
4046         log_error(_("the given preferred keyserver URL is invalid\n"));
4047     }
4048
4049   if(which)
4050     BUG();
4051   else
4052     sl=add_to_strlist( &opt.sig_keyserver_url, string );
4053
4054   if(critical)
4055     sl->flags |= 1;    
4056 }