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