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