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