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