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