Note: I have not fully tested the new key creation due to a pc/sc
[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   /* this is wrong since the show-sig-subpackets could have been set
1469      from a previous incarnation of list-options */
1470
1471   if(parse_options(str,&opt.list_options,lopts,1))
1472     {
1473       if(opt.list_options&LIST_SHOW_SIG_SUBPACKETS)
1474         {
1475           /* Unset so users can pass multiple lists in. */
1476           opt.list_options&=~LIST_SHOW_SIG_SUBPACKETS;
1477           if(!parse_subpacket_list(subpackets))
1478             return 0;
1479         }
1480       else if(subpackets==NULL && opt.show_subpackets)
1481         {
1482           /* User did 'no-show-subpackets' */
1483           m_free(opt.show_subpackets);
1484           opt.show_subpackets=NULL;
1485         }
1486
1487       return 1;
1488     }
1489   else
1490     return 0;
1491 }
1492
1493
1494 /* Collapses argc/argv into a single string that must be freed */
1495 static char *
1496 collapse_args(int argc,char *argv[])
1497 {
1498   char *str=NULL;
1499   int i,first=1,len=0;
1500
1501   for(i=0;i<argc;i++)
1502     {
1503       len+=strlen(argv[i])+2;
1504       str=m_realloc(str,len);
1505       if(first)
1506         {
1507           str[0]='\0';
1508           first=0;
1509         }
1510       else
1511         strcat(str," ");
1512
1513       strcat(str,argv[i]);
1514     }
1515
1516   return str;
1517 }
1518
1519
1520 int
1521 main( int argc, char **argv )
1522 {
1523     ARGPARSE_ARGS pargs;
1524     IOBUF a;
1525     int rc=0;
1526     int orig_argc;
1527     char **orig_argv;
1528     const char *fname;
1529     char *username;
1530     int may_coredump;
1531     STRLIST sl, remusr= NULL, locusr=NULL;
1532     STRLIST nrings=NULL, sec_nrings=NULL;
1533     armor_filter_context_t afx;
1534     int detached_sig = 0;
1535     FILE *configfp = NULL;
1536     char *configname = NULL;
1537     char *save_configname = NULL;
1538     unsigned configlineno;
1539     int parse_debug = 0;
1540     int default_config = 1;
1541     int default_keyring = 1;
1542     int greeting = 0;
1543     int nogreeting = 0;
1544     int use_random_seed = 1;
1545     enum cmd_and_opt_values cmd = 0;
1546     const char *trustdb_name = NULL;
1547     char *def_cipher_string = NULL;
1548     char *def_digest_string = NULL;
1549     char *compress_algo_string = NULL;
1550     char *cert_digest_string = NULL;
1551     char *s2k_cipher_string = NULL;
1552     char *s2k_digest_string = NULL;
1553     char *pers_cipher_list = NULL;
1554     char *pers_digest_list = NULL;
1555     char *pers_compress_list = NULL;
1556     int eyes_only=0;
1557     int multifile=0;
1558     int pwfd = -1;
1559     int with_fpr = 0; /* make an option out of --fingerprint */
1560     int any_explicit_recipient = 0;
1561 #ifdef USE_SHM_COPROCESSING
1562     ulong requested_shm_size=0;
1563 #endif
1564
1565 #ifdef __riscos__
1566     opt.lock_once = 1;
1567 #endif /* __riscos__ */
1568
1569     trap_unaligned();
1570     secmem_set_flags( secmem_get_flags() | 2 ); /* suspend warnings */
1571     /* Please note that we may running SUID(ROOT), so be very CAREFUL
1572      * when adding any stuff between here and the call to
1573      * secmem_init()  somewhere after the option parsing
1574      */
1575     log_set_name("gpg");
1576     secure_random_alloc(); /* put random number into secure memory */
1577     may_coredump = disable_core_dumps();
1578     init_signals();
1579     create_dotlock(NULL); /* register locking cleanup */
1580     i18n_init();
1581     opt.command_fd = -1; /* no command fd */
1582     opt.compress_level = -1; /* defaults to standard compress level */
1583     opt.bz2_compress_level = -1; /* defaults to standard compress level */
1584     /* note: if you change these lines, look at oOpenPGP */
1585     opt.def_cipher_algo = 0;
1586     opt.def_digest_algo = 0;
1587     opt.cert_digest_algo = 0;
1588     opt.compress_algo = -1; /* defaults to DEFAULT_COMPRESS_ALGO */
1589     opt.s2k_mode = 3; /* iterated+salted */
1590     opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
1591 #ifdef USE_CAST5
1592     opt.s2k_cipher_algo = CIPHER_ALGO_CAST5;
1593 #else
1594     opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
1595 #endif
1596     opt.completes_needed = 1;
1597     opt.marginals_needed = 3;
1598     opt.max_cert_depth = 5;
1599     opt.pgp2_workarounds = 1;
1600     opt.force_v3_sigs = 1;
1601     opt.escape_from = 1;
1602     opt.import_options=IMPORT_SK2PK;
1603     opt.export_options=EXPORT_INCLUDE_ATTRIBUTES;
1604     opt.keyserver_options.import_options=IMPORT_REPAIR_PKS_SUBKEY_BUG;
1605     opt.keyserver_options.export_options=EXPORT_INCLUDE_ATTRIBUTES;
1606     opt.keyserver_options.options=
1607       KEYSERVER_INCLUDE_SUBKEYS|KEYSERVER_INCLUDE_REVOKED|KEYSERVER_TRY_DNS_SRV|KEYSERVER_HONOR_KEYSERVER_URL;
1608     opt.verify_options=
1609       VERIFY_SHOW_POLICY_URLS|VERIFY_SHOW_STD_NOTATIONS|VERIFY_SHOW_KEYSERVER_URLS;
1610     opt.trust_model=TM_AUTO;
1611     opt.mangle_dos_filenames=0;
1612     opt.min_cert_level=2;
1613     set_screen_dimensions();
1614     opt.keyid_format=KF_SHORT;
1615 #if defined (_WIN32)
1616     set_homedir ( read_w32_registry_string( NULL,
1617                                     "Software\\GNU\\GnuPG", "HomeDir" ));
1618 #else
1619     set_homedir ( getenv("GNUPGHOME") );
1620 #endif
1621     if( !*opt.homedir )
1622         set_homedir ( GNUPG_HOMEDIR );
1623
1624 #ifdef ENABLE_CARD_SUPPORT
1625 # ifdef _WIN32
1626     opt.pcsc_driver = "winscard.dll"; 
1627 #else
1628     opt.pcsc_driver = "libpcsclite.so"; 
1629 #endif
1630 #endif /*ENABLE_CARD_SUPPORT*/
1631
1632     /* check whether we have a config file on the commandline */
1633     orig_argc = argc;
1634     orig_argv = argv;
1635     pargs.argc = &argc;
1636     pargs.argv = &argv;
1637     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
1638     while( arg_parse( &pargs, opts) ) {
1639         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
1640             parse_debug++;
1641         else if( pargs.r_opt == oOptions ) {
1642             /* yes there is one, so we do not try the default one, but
1643              * read the option file when it is encountered at the commandline
1644              */
1645             default_config = 0;
1646         }
1647         else if( pargs.r_opt == oNoOptions )
1648             default_config = 0; /* --no-options */
1649         else if( pargs.r_opt == oHomedir )
1650             set_homedir ( pargs.r.ret_str );
1651         else if( pargs.r_opt == oNoPermissionWarn )
1652             opt.no_perm_warn=1;
1653         else if (pargs.r_opt == oStrict )
1654           {
1655             opt.strict=1;
1656             log_set_strict(1);
1657           }
1658         else if (pargs.r_opt == oNoStrict )
1659           {
1660             opt.strict=0;
1661             log_set_strict(0);
1662           }
1663 #ifdef USE_SHM_COPROCESSING
1664         else if( pargs.r_opt == oRunAsShmCP ) {
1665             /* does not make sense in a options file, we do it here,
1666              * so that we are the able to drop setuid as soon as possible */
1667             opt.shm_coprocess = 1;
1668             requested_shm_size = pargs.r.ret_ulong;
1669         }
1670         else if ( pargs.r_opt == oStatusFD ) {
1671             /* this is needed to ensure that the status-fd filedescriptor is
1672              * initialized when init_shm_coprocessing() is called */
1673             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1674         }
1675 #endif
1676     }
1677
1678 #ifdef HAVE_DOSISH_SYSTEM
1679     if ( strchr (opt.homedir,'\\') ) {
1680         char *d, *buf = m_alloc (strlen (opt.homedir)+1);
1681         const char *s = opt.homedir;
1682         for (d=buf,s=opt.homedir; *s; s++)
1683             *d++ = *s == '\\'? '/': *s;
1684         *d = 0;
1685         set_homedir (buf);
1686     }
1687 #endif
1688 #ifdef USE_SHM_COPROCESSING
1689     if( opt.shm_coprocess ) {
1690         init_shm_coprocessing(requested_shm_size, 1 );
1691     }
1692 #endif
1693     /* initialize the secure memory. */
1694     secmem_init( 32768 );
1695     maybe_setuid = 0;
1696     /* Okay, we are now working under our real uid */
1697
1698     set_native_charset (NULL); /* Try to auto set the character set */
1699
1700     /* Try for a version specific config file first */
1701     if( default_config )
1702       {
1703         char *name=m_strdup("gpg" EXTSEP_S "conf-" SAFE_VERSION);
1704         char *ver=&name[strlen("gpg" EXTSEP_S "conf-")];
1705
1706         do
1707           {
1708             if(configname)
1709               {
1710                 char *tok;
1711
1712                 m_free(configname);
1713                 configname=NULL;
1714
1715                 if((tok=strrchr(ver,SAFE_VERSION_DASH)))
1716                   *tok='\0';
1717                 else if((tok=strrchr(ver,SAFE_VERSION_DOT)))
1718                   *tok='\0';
1719                 else
1720                   break;
1721               }
1722
1723             configname = make_filename(opt.homedir,name,NULL);
1724           }
1725         while(access(configname,R_OK));
1726
1727         m_free(name);
1728
1729         if(!configname)
1730           configname=make_filename(opt.homedir, "gpg" EXTSEP_S "conf", NULL );
1731         if (!access (configname, R_OK))
1732           { /* Print a warning when both config files are present. */
1733             char *p = make_filename(opt.homedir, "options", NULL );
1734             if (!access (p, R_OK))
1735               log_info (_("NOTE: old default options file `%s' ignored\n"), p);
1736             m_free (p);
1737           }
1738         else
1739           { /* Keep on using the old default one. */
1740             m_free (configname);
1741             configname = make_filename(opt.homedir, "options", NULL );
1742           }
1743       }
1744     argc = orig_argc;
1745     argv = orig_argv;
1746     pargs.argc = &argc;
1747     pargs.argv = &argv;
1748     pargs.flags=  1;  /* do not remove the args */
1749
1750     /* By this point we have a homedir, and cannot change it. */
1751     check_permissions(opt.homedir,0);
1752
1753   next_pass:
1754     if( configname ) {
1755       if(check_permissions(configname,1))
1756         {
1757           /* If any options file is unsafe, then disable any external
1758              programs for keyserver calls or photo IDs.  Since the
1759              external program to call is set in the options file, a
1760              unsafe options file can lead to an arbitrary program
1761              being run. */
1762
1763           opt.exec_disable=1;
1764         }
1765
1766         configlineno = 0;
1767         configfp = fopen( configname, "r" );
1768         if( !configfp ) {
1769             if( default_config ) {
1770                 if( parse_debug )
1771                     log_info(_("NOTE: no default option file `%s'\n"),
1772                                                             configname );
1773             }
1774             else {
1775                 log_error(_("option file `%s': %s\n"),
1776                                     configname, strerror(errno) );
1777                 g10_exit(2);
1778             }
1779             m_free(configname); configname = NULL;
1780         }
1781         if( parse_debug && configname )
1782             log_info(_("reading options from `%s'\n"), configname );
1783         default_config = 0;
1784     }
1785
1786     while( optfile_parse( configfp, configname, &configlineno,
1787                                                 &pargs, opts) )
1788       {
1789         switch( pargs.r_opt )
1790           {
1791           case aCheckKeys: 
1792           case aListConfig:
1793           case aGPGConfList:
1794           case aListPackets:
1795           case aImport: 
1796           case aFastImport: 
1797           case aSendKeys: 
1798           case aRecvKeys: 
1799           case aSearchKeys:
1800           case aRefreshKeys:
1801           case aExport: 
1802             set_cmd (&cmd, pargs.r_opt);
1803             break;
1804           case aListKeys: set_cmd( &cmd, aListKeys); break;
1805           case aListSigs: set_cmd( &cmd, aListSigs); break;
1806           case aExportSecret: set_cmd( &cmd, aExportSecret); break;
1807           case aExportSecretSub: set_cmd( &cmd, aExportSecretSub); break;
1808           case aDeleteSecretKeys:
1809             set_cmd( &cmd, aDeleteSecretKeys);
1810             greeting=1;
1811             break;
1812           case aDeleteSecretAndPublicKeys:
1813             set_cmd( &cmd, aDeleteSecretAndPublicKeys);
1814             greeting=1; 
1815             break;
1816           case aDeleteKeys: set_cmd( &cmd, aDeleteKeys); greeting=1; break;
1817
1818           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
1819           case aSym: set_cmd( &cmd, aSym); break;
1820
1821           case aDecryptFiles: multifile=1; /* fall through */
1822           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
1823
1824           case aEncrFiles: multifile=1; /* fall through */
1825           case aEncr: set_cmd( &cmd, aEncr); break;
1826
1827           case aVerifyFiles: multifile=1; /* fall through */
1828           case aVerify: set_cmd( &cmd, aVerify); break;
1829
1830           case aSign: set_cmd( &cmd, aSign );  break;
1831           case aKeygen: set_cmd( &cmd, aKeygen); greeting=1; break;
1832           case aSignKey: set_cmd( &cmd, aSignKey); break;
1833           case aLSignKey: set_cmd( &cmd, aLSignKey); break;
1834           case aNRSignKey: set_cmd( &cmd, aNRSignKey); break;
1835           case aNRLSignKey: set_cmd( &cmd, aNRLSignKey); break;
1836           case aStore: set_cmd( &cmd, aStore); break;
1837           case aEditKey: set_cmd( &cmd, aEditKey); greeting=1; break;
1838           case aClearsign: set_cmd( &cmd, aClearsign); break;
1839           case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
1840           case aDesigRevoke: set_cmd( &cmd, aDesigRevoke); break;
1841           case aPrimegen: set_cmd( &cmd, aPrimegen); break;
1842           case aGenRandom: set_cmd( &cmd, aGenRandom); break;
1843           case aPrintMD: set_cmd( &cmd, aPrintMD); break;
1844           case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
1845           case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
1846           case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
1847           case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
1848           case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
1849           case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
1850           case aDeArmor: set_cmd( &cmd, aDeArmor); break;
1851           case aEnArmor: set_cmd( &cmd, aEnArmor); break;
1852           case aListOwnerTrust:
1853             deprecated_warning(configname,configlineno,
1854                                "--list-ownertrust","--export-ownertrust","");
1855           case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
1856           case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
1857           case aPipeMode: set_cmd( &cmd, aPipeMode); break;
1858           case aRebuildKeydbCaches: set_cmd( &cmd, aRebuildKeydbCaches); break;
1859
1860 #ifdef ENABLE_CARD_SUPPORT
1861           case aCardStatus: set_cmd (&cmd, aCardStatus); break;
1862           case aCardEdit: set_cmd (&cmd, aCardEdit); break;
1863           case aChangePIN: set_cmd (&cmd, aChangePIN); break;
1864           case oReaderPort:
1865             card_set_reader_port (pargs.r.ret_str);
1866             break;
1867           case octapiDriver: opt.ctapi_driver = pargs.r.ret_str; break;
1868           case opcscDriver: opt.pcsc_driver = pargs.r.ret_str; break;
1869           case oDisableCCID: opt.disable_ccid = 1; break;
1870           case oAllowAdmin: opt.allow_admin = 1; break;
1871           case oDenyAdmin: opt.allow_admin = 0; break;
1872 #endif /* ENABLE_CARD_SUPPORT*/
1873
1874           case oArmor: opt.armor = 1; opt.no_armor=0; break;
1875           case oOutput: opt.outfile = pargs.r.ret_str; break;
1876           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
1877           case oQuiet: opt.quiet = 1; break;
1878           case oNoTTY: tty_no_terminal(1); break;
1879           case oDryRun: opt.dry_run = 1; break;
1880           case oInteractive: opt.interactive = 1; break;
1881           case oVerbose:
1882             g10_opt_verbose++;
1883             opt.verbose++;
1884             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
1885             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
1886             break;
1887           case oKOption: set_cmd( &cmd, aKMode ); break;
1888
1889           case oBatch: opt.batch = 1; nogreeting = 1; break;
1890           case oUseAgent:
1891 #ifndef __riscos__
1892             opt.use_agent = 1;
1893 #else /* __riscos__ */
1894             opt.use_agent = 0;
1895             riscos_not_implemented("use-agent");
1896 #endif /* __riscos__ */
1897             break;
1898           case oNoUseAgent: opt.use_agent = 0; break;
1899           case oGpgAgentInfo: opt.gpg_agent_info = pargs.r.ret_str; break;
1900           case oAnswerYes: opt.answer_yes = 1; break;
1901           case oAnswerNo: opt.answer_no = 1; break;
1902           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
1903           case oPrimaryKeyring:
1904             sl=append_to_strlist( &nrings, pargs.r.ret_str);
1905             sl->flags=2;
1906             break;
1907           case oShowKeyring:
1908             deprecated_warning(configname,configlineno,"--show-keyring",
1909                                "--list-options ","show-keyring");
1910             opt.list_options|=LIST_SHOW_KEYRING;
1911             break;
1912           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
1913           case oDebugAll: opt.debug = ~0; break;
1914           case oDebugCCIDDriver: 
1915 #if defined(ENABLE_CARD_SUPPORT) && defined(HAVE_LIBUSB)
1916             ccid_set_debug_level (1);
1917 #endif
1918             break;
1919           case oStatusFD:
1920             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1921             break;
1922 #ifdef __riscos__
1923           case oStatusFile:
1924             set_status_fd( iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1925             break;
1926 #endif /* __riscos__ */
1927           case oAttributeFD:
1928             set_attrib_fd(iobuf_translate_file_handle (pargs.r.ret_int, 1));
1929             break;
1930 #ifdef __riscos__
1931           case oAttributeFile:
1932             set_attrib_fd(iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1933             break;
1934 #endif /* __riscos__ */
1935           case oLoggerFD:
1936             log_set_logfile( NULL,
1937                              iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1938             break;
1939 #ifdef __riscos__
1940           case oLoggerFile:
1941             log_set_logfile( NULL,
1942                              iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1943             break;
1944 #endif /* __riscos__ */
1945           case oWithFingerprint:
1946             opt.with_fingerprint = 1;
1947             with_fpr=1; /*fall thru*/
1948           case oFingerprint: opt.fingerprint++; break;
1949           case oSecretKeyring: append_to_strlist( &sec_nrings, pargs.r.ret_str); break;
1950           case oOptions:
1951             /* config files may not be nested (silently ignore them) */
1952             if( !configfp ) {
1953                 m_free(configname);
1954                 configname = m_strdup(pargs.r.ret_str);
1955                 goto next_pass;
1956             }
1957             break;
1958           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
1959           case oNoDefKeyring: default_keyring = 0; break;
1960           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
1961           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
1962           case oNoGreeting: nogreeting = 1; break;
1963           case oNoVerbose: g10_opt_verbose = 0;
1964                            opt.verbose = 0; opt.list_sigs=0; break;
1965           case oQuickRandom: quick_random_gen(1); break;
1966           case oSKComments: opt.sk_comments=1; break;
1967           case oNoSKComments: opt.sk_comments=0; break;
1968           case oEmitVersion: opt.no_version=0; break;
1969           case oNoEmitVersion: opt.no_version=1; break;
1970           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
1971           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
1972           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
1973           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
1974           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
1975           case oDefRecipient:
1976                     if( *pargs.r.ret_str )
1977                         opt.def_recipient = make_username(pargs.r.ret_str);
1978                     break;
1979           case oDefRecipientSelf:
1980                     m_free(opt.def_recipient); opt.def_recipient = NULL;
1981                     opt.def_recipient_self = 1;
1982                     break;
1983           case oNoDefRecipient:
1984                     m_free(opt.def_recipient); opt.def_recipient = NULL;
1985                     opt.def_recipient_self = 0;
1986                     break;
1987           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
1988           case oHomedir: break;
1989           case oNoBatch: opt.batch = 0; break;
1990           case oWithKeyData: opt.with_key_data=1; /* fall thru */
1991           case oWithColons: opt.with_colons=':'; break;
1992
1993           case oSkipVerify: opt.skip_verify=1; break;
1994           case oCompressKeys: opt.compress_keys = 1; break;
1995           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
1996             /* There are many programs (like mutt) that call gpg with
1997                --always-trust so keep this option around for a long
1998                time. */
1999           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
2000           case oTrustModel:
2001             if(ascii_strcasecmp(pargs.r.ret_str,"pgp")==0)
2002               opt.trust_model=TM_PGP;
2003             else if(ascii_strcasecmp(pargs.r.ret_str,"classic")==0)
2004               opt.trust_model=TM_CLASSIC;
2005             else if(ascii_strcasecmp(pargs.r.ret_str,"always")==0)
2006               opt.trust_model=TM_ALWAYS;
2007             else if(ascii_strcasecmp(pargs.r.ret_str,"auto")==0)
2008               opt.trust_model=TM_AUTO;
2009             else
2010               log_error("unknown trust model \"%s\"\n",pargs.r.ret_str);
2011             break;
2012           case oForceOwnertrust:
2013             log_info(_("NOTE: %s is not for normal use!\n"),
2014                      "--force-ownertrust");
2015             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
2016             if(opt.force_ownertrust==-1)
2017               {
2018                 log_error("invalid ownertrust \"%s\"\n",pargs.r.ret_str);
2019                 opt.force_ownertrust=0;
2020               }
2021             break;
2022           case oLoadExtension:
2023 #ifndef __riscos__
2024 #if defined(USE_DYNAMIC_LINKING) || defined(_WIN32)
2025             if(check_permissions(pargs.r.ret_str,2))
2026               log_info(_("cipher extension `%s' not loaded due to"
2027                          " unsafe permissions\n"),pargs.r.ret_str);
2028             else
2029               register_cipher_extension(orig_argc? *orig_argv:NULL,
2030                                         pargs.r.ret_str);
2031 #endif
2032 #else /* __riscos__ */
2033             riscos_not_implemented("load-extension");
2034 #endif /* __riscos__ */
2035             break;
2036           case oRFC1991:
2037             opt.compliance = CO_RFC1991;
2038             opt.force_v4_certs = 0;
2039             opt.escape_from = 1;
2040             break;
2041           case oRFC2440:
2042           case oOpenPGP:
2043             /* TODO: When 2440bis becomes a RFC, these may need
2044                changing. */
2045             opt.compliance = CO_RFC2440;
2046             opt.allow_non_selfsigned_uid = 1;
2047             opt.allow_freeform_uid = 1;
2048             opt.pgp2_workarounds = 0;
2049             opt.escape_from = 0;
2050             opt.force_v3_sigs = 0;
2051             opt.compress_keys = 0;          /* not mandated  but we do it */
2052             opt.compress_sigs = 0;          /* ditto. */
2053             opt.not_dash_escaped = 0;
2054             opt.def_cipher_algo = 0;
2055             opt.def_digest_algo = 0;
2056             opt.cert_digest_algo = 0;
2057             opt.compress_algo = -1;
2058             opt.s2k_mode = 3; /* iterated+salted */
2059             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2060             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2061             break;
2062           case oPGP2:  opt.compliance = CO_PGP2;  break;
2063           case oPGP6:  opt.compliance = CO_PGP6;  break;
2064           case oPGP7:  opt.compliance = CO_PGP7;  break;
2065           case oPGP8:  opt.compliance = CO_PGP8;  break;
2066           case oGnuPG: opt.compliance = CO_GNUPG; break;
2067           case oCompressSigs: opt.compress_sigs = 1; break;
2068           case oRunAsShmCP:
2069 #ifndef __riscos__
2070 # ifndef USE_SHM_COPROCESSING
2071             /* not possible in the option file,
2072              * but we print the warning here anyway */
2073             log_error("shared memory coprocessing is not available\n");
2074 # endif
2075 #else /* __riscos__ */
2076             riscos_not_implemented("run-as-shm-coprocess");
2077 #endif /* __riscos__ */
2078             break;
2079           case oSetFilename: opt.set_filename = pargs.r.ret_str; break;
2080           case oForYourEyesOnly: eyes_only = 1; break;
2081           case oNoForYourEyesOnly: eyes_only = 0; break;
2082           case oSetPolicyURL:
2083             add_policy_url(pargs.r.ret_str,0);
2084             add_policy_url(pargs.r.ret_str,1);
2085             break;
2086           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
2087           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
2088           case oShowPolicyURL:
2089             deprecated_warning(configname,configlineno,"--show-policy-url",
2090                                "--list-options ","show-policy-urls");
2091             deprecated_warning(configname,configlineno,"--show-policy-url",
2092                                "--verify-options ","show-policy-urls");
2093             opt.list_options|=LIST_SHOW_POLICY_URLS;
2094             opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
2095             break;
2096           case oNoShowPolicyURL:
2097             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2098                                "--list-options ","no-show-policy-urls");
2099             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2100                                "--verify-options ","no-show-policy-urls");
2101             opt.list_options&=~LIST_SHOW_POLICY_URLS;
2102             opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
2103             break;
2104           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
2105           case oUseEmbeddedFilename: opt.use_embedded_filename = 1; break;
2106           case oNoUseEmbeddedFilename: opt.use_embedded_filename = 0; break;
2107           case oComment:
2108             if(pargs.r.ret_str[0])
2109               append_to_strlist(&opt.comments,pargs.r.ret_str);
2110             break;
2111           case oDefaultComment:
2112             deprecated_warning(configname,configlineno,
2113                                "--default-comment","--no-comments","");
2114             /* fall through */
2115           case oNoComments:
2116             free_strlist(opt.comments);
2117             opt.comments=NULL;
2118             break;
2119           case oThrowKeyids: opt.throw_keyid = 1; break;
2120           case oNoThrowKeyids: opt.throw_keyid = 0; break;
2121           case oShowPhotos:
2122             deprecated_warning(configname,configlineno,"--show-photos",
2123                                "--list-options ","show-photos");
2124             deprecated_warning(configname,configlineno,"--show-photos",
2125                                "--verify-options ","show-photos");
2126             opt.list_options|=LIST_SHOW_PHOTOS;
2127             opt.verify_options|=VERIFY_SHOW_PHOTOS;
2128             break;
2129           case oNoShowPhotos:
2130             deprecated_warning(configname,configlineno,"--no-show-photos",
2131                                "--list-options ","no-show-photos");
2132             deprecated_warning(configname,configlineno,"--no-show-photos",
2133                                "--verify-options ","no-show-photos");
2134             opt.list_options&=~LIST_SHOW_PHOTOS;
2135             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
2136             break;
2137           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
2138           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
2139           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
2140           case oForceV4Certs: opt.force_v4_certs = 1; break;
2141           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
2142           case oForceMDC: opt.force_mdc = 1; break;
2143           case oNoForceMDC: opt.force_mdc = 0; break;
2144           case oDisableMDC: opt.disable_mdc = 1; break;
2145           case oNoDisableMDC: opt.disable_mdc = 0; break;
2146           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
2147           case oS2KDigest: s2k_digest_string = m_strdup(pargs.r.ret_str); break;
2148           case oS2KCipher: s2k_cipher_string = m_strdup(pargs.r.ret_str); break;
2149           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
2150           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
2151           case oEncryptTo: /* store the recipient in the second list */
2152             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2153             sl->flags = 1;
2154             break;
2155           case oHiddenEncryptTo: /* store the recipient in the second list */
2156             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2157             sl->flags = 1|2;
2158             break;
2159           case oRecipient: /* store the recipient */
2160             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2161             any_explicit_recipient = 1;
2162             break;
2163           case oHiddenRecipient: /* store the recipient with a flag */
2164             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2165             sl->flags = 2;
2166             any_explicit_recipient = 1;
2167             break;
2168           case oTextmodeShort: opt.textmode = 2; break;
2169           case oTextmode: opt.textmode=1;  break;
2170           case oNoTextmode: opt.textmode=0;  break;
2171           case oExpert: opt.expert = 1; break;
2172           case oNoExpert: opt.expert = 0; break;
2173           case oAskSigExpire: opt.ask_sig_expire = 1; break;
2174           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
2175           case oAskCertExpire: opt.ask_cert_expire = 1; break;
2176           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
2177           case oAskCertLevel: opt.ask_cert_level = 1; break;
2178           case oNoAskCertLevel: opt.ask_cert_level = 0; break;
2179           case oUser: /* store the local users */
2180             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
2181             break;
2182           case oCompress:
2183             /* this is the -z command line option */
2184             opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
2185             break;
2186           case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
2187           case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
2188           case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
2189           case oPasswdFD:
2190             pwfd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
2191             opt.use_agent = 0;
2192             break;
2193 #ifdef __riscos__
2194           case oPasswdFile:
2195             pwfd = iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 0), 0);
2196             break;
2197 #endif /* __riscos__ */
2198           case oCommandFD:
2199             opt.command_fd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
2200             break;
2201 #ifdef __riscos__
2202           case oCommandFile:
2203             opt.command_fd = iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 0), 0);
2204             break;
2205 #endif /* __riscos__ */
2206           case oCipherAlgo: def_cipher_string = m_strdup(pargs.r.ret_str); break;
2207           case oDigestAlgo: def_digest_string = m_strdup(pargs.r.ret_str); break;
2208           case oCompressAlgo:
2209             /* If it is all digits, stick a Z in front of it for
2210                later.  This is for backwards compatibility with
2211                versions that took the compress algorithm number. */
2212             {
2213               char *pt=pargs.r.ret_str;
2214               while(*pt)
2215                 {
2216                   if(!isdigit(*pt))
2217                     break;
2218
2219                   pt++;
2220                 }
2221
2222               if(*pt=='\0')
2223                 {
2224                   compress_algo_string=m_alloc(strlen(pargs.r.ret_str)+2);
2225                   strcpy(compress_algo_string,"Z");
2226                   strcat(compress_algo_string,pargs.r.ret_str);
2227                 }
2228               else
2229                 compress_algo_string = m_strdup(pargs.r.ret_str);
2230             }
2231             break;
2232           case oCertDigestAlgo: cert_digest_string = m_strdup(pargs.r.ret_str); break;
2233           case oNoSecmemWarn: secmem_set_flags( secmem_get_flags() | 1 ); break;
2234           case oNoPermissionWarn: opt.no_perm_warn=1; break;
2235           case oNoMDCWarn: opt.no_mdc_warn=1; break;
2236           case oDisplayCharset:
2237             if( set_native_charset( pargs.r.ret_str ) )
2238                 log_error(_("`%s' is not a valid character set\n"),
2239                           pargs.r.ret_str);
2240             break;
2241           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
2242           case oEscapeFrom: opt.escape_from = 1; break;
2243           case oNoEscapeFrom: opt.escape_from = 0; break;
2244           case oLockOnce: opt.lock_once = 1; break;
2245           case oLockNever: disable_dotlock(); break;
2246           case oLockMultiple:
2247 #ifndef __riscos__
2248             opt.lock_once = 0;
2249 #else /* __riscos__ */
2250             riscos_not_implemented("lock-multiple");
2251 #endif /* __riscos__ */
2252             break;
2253           case oKeyServer:
2254             opt.keyserver=parse_keyserver_uri(pargs.r.ret_str,0,
2255                                               configname,configlineno);
2256             if(!opt.keyserver)
2257               log_error(_("could not parse keyserver URL\n"));
2258             break;
2259           case oKeyServerOptions:
2260             if(!parse_keyserver_options(pargs.r.ret_str))
2261               {
2262                 if(configname)
2263                   log_error(_("%s:%d: invalid keyserver options\n"),
2264                             configname,configlineno);
2265                 else
2266                   log_error(_("invalid keyserver options\n"));
2267               }
2268             break;
2269           case oImportOptions:
2270             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
2271               {
2272                 if(configname)
2273                   log_error(_("%s:%d: invalid import options\n"),
2274                             configname,configlineno);
2275                 else
2276                   log_error(_("invalid import options\n"));
2277               }
2278             break;
2279           case oExportOptions:
2280             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
2281               {
2282                 if(configname)
2283                   log_error(_("%s:%d: invalid export options\n"),
2284                             configname,configlineno);
2285                 else
2286                   log_error(_("invalid export options\n"));
2287               }
2288             break;
2289           case oListOptions:
2290             if(!parse_list_options(pargs.r.ret_str))
2291               {
2292                 if(configname)
2293                   log_error(_("%s:%d: invalid list options\n"),
2294                             configname,configlineno);
2295                 else
2296                   log_error(_("invalid list options\n"));
2297               }
2298             break;
2299           case oVerifyOptions:
2300             {
2301               struct parse_options vopts[]=
2302                 {
2303                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL},
2304                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL},
2305                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL},
2306                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL},
2307                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL},
2308                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL},
2309                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL},
2310                   {"show-validity",VERIFY_SHOW_VALIDITY,NULL},
2311                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL},
2312                   {NULL,0,NULL}
2313                 };
2314
2315               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
2316                 {
2317                   if(configname)
2318                     log_error(_("%s:%d: invalid verify options\n"),
2319                               configname,configlineno);
2320                   else
2321                     log_error(_("invalid verify options\n"));
2322                 }
2323             }
2324             break;
2325           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
2326           case oExecPath:
2327             if(set_exec_path(pargs.r.ret_str,0))
2328               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
2329             else
2330               opt.exec_path_set=1;
2331             break;
2332           case oSetNotation:
2333             add_notation_data( pargs.r.ret_str, 0 );
2334             add_notation_data( pargs.r.ret_str, 1 );
2335             break;
2336           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
2337           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
2338           case oShowNotation:
2339             deprecated_warning(configname,configlineno,"--show-notation",
2340                                "--list-options ","show-notations");
2341             deprecated_warning(configname,configlineno,"--show-notation",
2342                                "--verify-options ","show-notations");
2343             opt.list_options|=LIST_SHOW_NOTATIONS;
2344             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
2345             break;
2346           case oNoShowNotation:
2347             deprecated_warning(configname,configlineno,"--no-show-notation",
2348                                "--list-options ","no-show-notations");
2349             deprecated_warning(configname,configlineno,"--no-show-notation",
2350                                "--verify-options ","no-show-notations");
2351             opt.list_options&=~LIST_SHOW_NOTATIONS;
2352             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
2353             break;
2354           case oUtf8Strings: utf8_strings = 1; break;
2355           case oNoUtf8Strings: utf8_strings = 0; break;
2356           case oDisableCipherAlgo:
2357                 disable_cipher_algo( string_to_cipher_algo(pargs.r.ret_str) );
2358                 break;
2359           case oDisablePubkeyAlgo:
2360                 disable_pubkey_algo( string_to_pubkey_algo(pargs.r.ret_str) );
2361                 break;
2362           case oNoSigCache: opt.no_sig_cache = 1; break;
2363           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
2364           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
2365           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
2366           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
2367           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
2368           case oNoLiteral: opt.no_literal = 1; break;
2369           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
2370           case oHonorHttpProxy:
2371                 add_to_strlist(&opt.keyserver_options.other,"http-proxy");
2372                 deprecated_warning(configname,configlineno,
2373                                    "--honor-http-proxy",
2374                                    "--keyserver-options ","http-proxy");
2375                 break;
2376           case oFastListMode: opt.fast_list_mode = 1; break;
2377           case oFixedListMode: opt.fixed_list_mode = 1; break;
2378           case oListOnly: opt.list_only=1; break;
2379           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
2380           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
2381           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
2382           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
2383           case oNoRandomSeedFile: use_random_seed = 0; break;
2384           case oAutoKeyRetrieve:
2385           case oNoAutoKeyRetrieve:
2386                 if(pargs.r_opt==oAutoKeyRetrieve)
2387                   opt.keyserver_options.options|=KEYSERVER_AUTO_KEY_RETRIEVE;
2388                 else
2389                   opt.keyserver_options.options&=~KEYSERVER_AUTO_KEY_RETRIEVE;
2390
2391                 deprecated_warning(configname,configlineno,
2392                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
2393                                "--no-auto-key-retrieve","--keyserver-options ",
2394                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
2395                                "no-auto-key-retrieve");
2396                 break;
2397           case oShowSessionKey: opt.show_session_key = 1; break;
2398           case oOverrideSessionKey:
2399                 opt.override_session_key = pargs.r.ret_str;
2400                 break;
2401           case oMergeOnly:
2402                 deprecated_warning(configname,configlineno,"--merge-only",
2403                                    "--import-options ","merge-only");
2404                 opt.import_options|=IMPORT_MERGE_ONLY;
2405             break;
2406           case oAllowSecretKeyImport: /* obsolete */ break;
2407           case oTryAllSecrets: opt.try_all_secrets = 1; break;
2408           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
2409           case oEnableSpecialFilenames:
2410             iobuf_enable_special_filenames (1);
2411             break;
2412           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
2413           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
2414           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
2415           case oPreservePermissions: opt.preserve_permissions=1; break;
2416           case oDefaultPreferenceList:
2417             opt.def_preference_list = pargs.r.ret_str;
2418             break;
2419           case oPersonalCipherPreferences:
2420             pers_cipher_list=pargs.r.ret_str;
2421             break;
2422           case oPersonalDigestPreferences:
2423             pers_digest_list=pargs.r.ret_str;
2424             break;
2425           case oPersonalCompressPreferences:
2426             pers_compress_list=pargs.r.ret_str;
2427             break;
2428           case oDisplay: opt.display = pargs.r.ret_str; break;
2429           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
2430           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
2431           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
2432           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
2433           case oGroup: add_group(pargs.r.ret_str); break;
2434           case oUnGroup: rm_group(pargs.r.ret_str); break;
2435           case oNoGroups:
2436             while(opt.grouplist)
2437               {
2438                 struct groupitem *iter=opt.grouplist;
2439                 free_strlist(iter->values);
2440                 opt.grouplist=opt.grouplist->next;
2441                 m_free(iter);
2442               }
2443             break;
2444           case oStrict: opt.strict=1; log_set_strict(1); break;
2445           case oNoStrict: opt.strict=0; log_set_strict(0); break;
2446           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
2447           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
2448           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
2449           case oMultifile: multifile=1; break;
2450           case oKeyidFormat:
2451             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
2452               opt.keyid_format=KF_SHORT;
2453             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
2454               opt.keyid_format=KF_LONG;
2455             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
2456               opt.keyid_format=KF_0xSHORT;
2457             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
2458               opt.keyid_format=KF_0xLONG;
2459             else
2460               log_error("unknown keyid-format \"%s\"\n",pargs.r.ret_str);
2461             break;
2462
2463           default : pargs.err = configfp? 1:2; break;
2464           }
2465       }
2466
2467
2468     if( configfp ) {
2469         fclose( configfp );
2470         configfp = NULL;
2471         /* Remember the first config file name. */
2472         if (!save_configname)
2473           save_configname = configname;
2474         else
2475           m_free(configname);
2476         configname = NULL;
2477         goto next_pass;
2478     }
2479     m_free( configname ); configname = NULL;
2480     if( log_get_errorcount(0) )
2481         g10_exit(2);
2482
2483     /* The command --gpgconf-list is pretty simple and may be called
2484        directly after the option parsing. */
2485     if (cmd == aGPGConfList)
2486       {
2487         gpgconf_list (save_configname);
2488         g10_exit (0);
2489       }
2490     m_free (save_configname);
2491
2492     if( nogreeting )
2493         greeting = 0;
2494
2495     if( greeting ) {
2496         fprintf(stderr, "%s %s; %s\n",
2497                         strusage(11), strusage(13), strusage(14) );
2498         fprintf(stderr, "%s\n", strusage(15) );
2499     }
2500 #ifdef IS_DEVELOPMENT_VERSION
2501     if( !opt.batch )
2502       {
2503         const char *s;
2504
2505         if((s=strusage(20)))
2506           log_info("%s\n",s);
2507         if((s=strusage(21)))
2508           log_info("%s\n",s);
2509         if((s=strusage(22)))
2510           log_info("%s\n",s);
2511       }
2512 #endif
2513
2514     if (opt.verbose > 2)
2515         log_info ("using character set `%s'\n", get_native_charset ());
2516
2517     if( may_coredump && !opt.quiet )
2518         log_info(_("WARNING: program may create a core file!\n"));
2519
2520     if (eyes_only) {
2521       if (opt.set_filename)
2522           log_info(_("WARNING: %s overrides %s\n"),
2523                    "--for-your-eyes-only","--set-filename");
2524
2525       opt.set_filename="_CONSOLE";
2526     }
2527
2528     if (opt.no_literal) {
2529         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
2530         if (opt.textmode)
2531             log_error(_("%s not allowed with %s!\n"),
2532                        "--textmode", "--no-literal" );
2533         if (opt.set_filename)
2534             log_error(_("%s makes no sense with %s!\n"),
2535                         eyes_only?"--for-your-eyes-only":"--set-filename",
2536                         "--no-literal" );
2537     }
2538
2539     if (opt.set_filesize)
2540         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
2541     if( opt.batch )
2542         tty_batchmode( 1 );
2543
2544     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
2545
2546     set_debug();
2547
2548     /* Do these after the switch(), so they can override settings. */
2549     if(PGP2)
2550       {
2551         int unusable=0;
2552
2553         if(cmd==aSign && !detached_sig)
2554           {
2555             log_info(_("you can only make detached or clear signatures "
2556                        "while in --pgp2 mode\n"));
2557             unusable=1;
2558           }
2559         else if(cmd==aSignEncr || cmd==aSignSym)
2560           {
2561             log_info(_("you can't sign and encrypt at the "
2562                        "same time while in --pgp2 mode\n"));
2563             unusable=1;
2564           }
2565         else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
2566           {
2567             log_info(_("you must use files (and not a pipe) when "
2568                        "working with --pgp2 enabled.\n"));
2569             unusable=1;
2570           }
2571         else if(cmd==aEncr || cmd==aSym)
2572           {
2573             /* Everything else should work without IDEA (except using
2574                a secret key encrypted with IDEA and setting an IDEA
2575                preference, but those have their own error
2576                messages). */
2577
2578             if(check_cipher_algo(CIPHER_ALGO_IDEA))
2579               {
2580                 log_info(_("encrypting a message in --pgp2 mode requires "
2581                            "the IDEA cipher\n"));
2582                 idea_cipher_warn(1);
2583                 unusable=1;
2584               }
2585             else if(cmd==aSym)
2586               {
2587                 /* This only sets IDEA for symmetric encryption
2588                    since it is set via select_algo_from_prefs for
2589                    pk encryption. */
2590                 m_free(def_cipher_string);
2591                 def_cipher_string = m_strdup("idea");
2592               }
2593
2594             /* PGP2 can't handle the output from the textmode
2595                filter, so we disable it for anything that could
2596                create a literal packet (only encryption and
2597                symmetric encryption, since we disable signing
2598                above). */
2599             if(!unusable)
2600               opt.textmode=0;
2601           }
2602
2603         if(unusable)
2604           compliance_failure();
2605         else
2606           {
2607             opt.force_v4_certs = 0;
2608             opt.sk_comments = 0;
2609             opt.escape_from = 1;
2610             opt.force_v3_sigs = 1;
2611             opt.pgp2_workarounds = 1;
2612             opt.ask_sig_expire = 0;
2613             opt.ask_cert_expire = 0;
2614             m_free(def_digest_string);
2615             def_digest_string = m_strdup("md5");
2616             opt.compress_algo = COMPRESS_ALGO_ZIP;
2617           }
2618       }
2619     else if(PGP6)
2620       {
2621         opt.sk_comments=0;
2622         opt.escape_from=1;
2623         opt.force_v3_sigs=1;
2624         opt.ask_sig_expire=0;
2625       }
2626     else if(PGP7)
2627       {
2628         opt.sk_comments=0;
2629         opt.escape_from=1;
2630         opt.force_v3_sigs=1;
2631         opt.ask_sig_expire=0;
2632       }
2633     else if(PGP8)
2634       {
2635         opt.escape_from=1;
2636       }
2637
2638     /* must do this after dropping setuid, because string_to...
2639      * may try to load an module */
2640     if( def_cipher_string ) {
2641         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
2642         if(opt.def_cipher_algo==0 &&
2643            (ascii_strcasecmp(def_cipher_string,"idea")==0
2644             || ascii_strcasecmp(def_cipher_string,"s1")==0))
2645           idea_cipher_warn(1);
2646         m_free(def_cipher_string); def_cipher_string = NULL;
2647         if( check_cipher_algo(opt.def_cipher_algo) )
2648             log_error(_("selected cipher algorithm is invalid\n"));
2649     }
2650     if( def_digest_string ) {
2651         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
2652         m_free(def_digest_string); def_digest_string = NULL;
2653         if( check_digest_algo(opt.def_digest_algo) )
2654             log_error(_("selected digest algorithm is invalid\n"));
2655     }
2656     if( compress_algo_string ) {
2657         opt.compress_algo = string_to_compress_algo(compress_algo_string);
2658         m_free(compress_algo_string); compress_algo_string = NULL;
2659         if( check_compress_algo(opt.compress_algo) )
2660             log_error(_("selected compression algorithm is invalid\n"));
2661     }
2662     if( cert_digest_string ) {
2663         opt.cert_digest_algo = string_to_digest_algo(cert_digest_string);
2664         m_free(cert_digest_string); cert_digest_string = NULL;
2665         if( check_digest_algo(opt.cert_digest_algo) )
2666             log_error(_("selected certification digest algorithm is invalid\n"));
2667     }
2668     if( s2k_cipher_string ) {
2669         opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
2670         m_free(s2k_cipher_string); s2k_cipher_string = NULL;
2671         if( check_cipher_algo(opt.s2k_cipher_algo) )
2672             log_error(_("selected cipher algorithm is invalid\n"));
2673     }
2674     if( s2k_digest_string ) {
2675         opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
2676         m_free(s2k_digest_string); s2k_digest_string = NULL;
2677         if( check_digest_algo(opt.s2k_digest_algo) )
2678             log_error(_("selected digest algorithm is invalid\n"));
2679     }
2680     if( opt.completes_needed < 1 )
2681       log_error(_("completes-needed must be greater than 0\n"));
2682     if( opt.marginals_needed < 2 )
2683       log_error(_("marginals-needed must be greater than 1\n"));
2684     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
2685       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
2686     if(opt.def_cert_level<0 || opt.def_cert_level>3)
2687       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
2688     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
2689       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
2690     switch( opt.s2k_mode ) {
2691       case 0:
2692         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
2693         break;
2694       case 1: case 3: break;
2695       default:
2696         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
2697     }
2698
2699     /* This isn't actually needed, but does serve to error out if the
2700        string is invalid. */
2701     if(opt.def_preference_list &&
2702         keygen_set_std_prefs(opt.def_preference_list,0))
2703       log_error(_("invalid default preferences\n"));
2704
2705     /* We provide defaults for the personal digest list.  This is
2706        SHA-1. */
2707     if(!pers_digest_list)
2708       pers_digest_list="h2";
2709
2710     if(pers_cipher_list &&
2711        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
2712       log_error(_("invalid personal cipher preferences\n"));
2713
2714     if(pers_digest_list &&
2715        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
2716       log_error(_("invalid personal digest preferences\n"));
2717
2718     if(pers_compress_list &&
2719        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
2720       log_error(_("invalid personal compress preferences\n"));
2721
2722     /* We don't support all possible commands with multifile yet */
2723     if(multifile)
2724       {
2725         char *cmdname;
2726
2727         switch(cmd)
2728           {
2729           case aSign:
2730             cmdname="--sign";
2731             break;
2732           case aClearsign:
2733             cmdname="--clearsign";
2734             break;
2735           case aDetachedSign:
2736             cmdname="--detach-sign";
2737             break;
2738           case aSym:
2739             cmdname="--symmetric";
2740             break;
2741           case aEncrSym:
2742             cmdname="--symmetric --encrypt";
2743             break;
2744           case aStore:
2745             cmdname="--store";
2746             break;
2747           default:
2748             cmdname=NULL;
2749             break;
2750           }
2751
2752         if(cmdname)
2753           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
2754       }
2755
2756     if( log_get_errorcount(0) )
2757         g10_exit(2);
2758
2759     if(opt.compress_level==0)
2760       opt.compress_algo=COMPRESS_ALGO_NONE;
2761
2762     /* Check our chosen algorithms against the list of legal
2763        algorithms. */
2764
2765     if(!GNUPG)
2766       {
2767         const char *badalg=NULL;
2768         preftype_t badtype=PREFTYPE_NONE;
2769
2770         if(opt.def_cipher_algo
2771            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
2772           {
2773             badalg=cipher_algo_to_string(opt.def_cipher_algo);
2774             badtype=PREFTYPE_SYM;
2775           }
2776         else if(opt.def_digest_algo
2777                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
2778           {
2779             badalg=digest_algo_to_string(opt.def_digest_algo);
2780             badtype=PREFTYPE_HASH;
2781           }
2782         else if(opt.cert_digest_algo
2783                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
2784           {
2785             badalg=digest_algo_to_string(opt.cert_digest_algo);
2786             badtype=PREFTYPE_HASH;
2787           }
2788         else if(opt.compress_algo!=-1
2789                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
2790           {
2791             badalg=compress_algo_to_string(opt.compress_algo);
2792             badtype=PREFTYPE_ZIP;
2793           }
2794
2795         if(badalg)
2796           {
2797             switch(badtype)
2798               {
2799               case PREFTYPE_SYM:
2800                 log_info(_("you may not use cipher algorithm `%s'"
2801                            " while in %s mode\n"),
2802                          badalg,compliance_option_string());
2803                 break;
2804               case PREFTYPE_HASH:
2805                 log_info(_("you may not use digest algorithm `%s'"
2806                            " while in %s mode\n"),
2807                          badalg,compliance_option_string());
2808                 break;
2809               case PREFTYPE_ZIP:
2810                 log_info(_("you may not use compression algorithm `%s'"
2811                            " while in %s mode\n"),
2812                          badalg,compliance_option_string());
2813                 break;
2814               default:
2815                 BUG();
2816               }
2817
2818             compliance_failure();
2819           }
2820       }
2821
2822     /* set the random seed file */
2823     if( use_random_seed ) {
2824         char *p = make_filename(opt.homedir, "random_seed", NULL );
2825         set_random_seed_file(p);
2826         m_free(p);
2827     }
2828
2829     if( !cmd && opt.fingerprint && !with_fpr ) {
2830         set_cmd( &cmd, aListKeys);
2831     }
2832
2833     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
2834         if( cmd == aKModeC ) {
2835             opt.fingerprint = 1;
2836             cmd = aKMode;
2837         }
2838         opt.list_sigs = 0;
2839         if( opt.verbose > 2 )
2840             opt.check_sigs++;
2841         if( opt.verbose > 1 )
2842             opt.list_sigs++;
2843
2844         opt.verbose = opt.verbose > 1;
2845         g10_opt_verbose = opt.verbose;
2846     }
2847
2848     /* kludge to let -sat generate a clear text signature */
2849     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
2850         cmd = aClearsign;
2851
2852     if( opt.verbose > 1 )
2853         set_packet_list_mode(1);
2854
2855     /* Add the keyrings, but not for some special commands and not in
2856        case of "-kvv userid keyring".  Also avoid adding the secret
2857        keyring for a couple of commands to avoid unneeded access in
2858        case the secrings are stored on a floppy */
2859     if( cmd != aDeArmor && cmd != aEnArmor
2860         && !(cmd == aKMode && argc == 2 ) ) 
2861       {
2862         if (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
2863             && cmd != aVerify && cmd != aSym)
2864           {
2865             if (!sec_nrings || default_keyring) /* add default secret rings */
2866               keydb_add_resource ("secring" EXTSEP_S "gpg", 0, 1);
2867             for (sl = sec_nrings; sl; sl = sl->next)
2868               keydb_add_resource ( sl->d, 0, 1 );
2869           }
2870         if( !nrings || default_keyring )  /* add default ring */
2871             keydb_add_resource ("pubring" EXTSEP_S "gpg", 0, 0);
2872         for(sl = nrings; sl; sl = sl->next )
2873             keydb_add_resource ( sl->d, sl->flags, 0 );
2874       }
2875     FREE_STRLIST(nrings);
2876     FREE_STRLIST(sec_nrings);
2877
2878
2879     if( pwfd != -1 )  /* read the passphrase now. */
2880         read_passphrase_from_fd( pwfd );
2881
2882     fname = argc? *argv : NULL;
2883
2884     switch( cmd ) {
2885       case aPrimegen:
2886       case aPrintMD:
2887       case aPrintMDs:
2888       case aGenRandom:
2889       case aDeArmor:
2890       case aEnArmor:
2891       case aFixTrustDB:
2892         break;
2893       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
2894       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
2895       default: rc = setup_trustdb(1, trustdb_name ); break;
2896     }
2897     if( rc )
2898         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
2899
2900
2901     switch (cmd)
2902       {
2903       case aStore: 
2904       case aSym:  
2905       case aSign: 
2906       case aSignSym: 
2907       case aClearsign: 
2908         if (!opt.quiet && any_explicit_recipient)
2909           log_info (_("WARNING: recipients (-r) given "
2910                       "without using public key encryption\n"));
2911         break;
2912       default:
2913         break;
2914       }
2915
2916     switch( cmd )
2917       {
2918       case aStore: /* only store the file */
2919         if( argc > 1 )
2920             wrong_args(_("--store [filename]"));
2921         if( (rc = encode_store(fname)) )
2922             log_error_f( print_fname_stdin(fname),
2923                         "store failed: %s\n", g10_errstr(rc) );
2924         break;
2925       case aSym: /* encrypt the given file only with the symmetric cipher */
2926         if( argc > 1 )
2927             wrong_args(_("--symmetric [filename]"));
2928         if( (rc = encode_symmetric(fname)) )
2929             log_error_f(print_fname_stdin(fname),
2930                         "symmetric encryption failed: %s\n",g10_errstr(rc) );
2931         break;
2932
2933       case aEncr: /* encrypt the given file */
2934         if(multifile)
2935           encode_crypt_files(argc, argv, remusr);
2936         else
2937           {
2938             if( argc > 1 )
2939               wrong_args(_("--encrypt [filename]"));
2940             if( (rc = encode_crypt(fname,remusr,0)) )
2941               log_error("%s: encryption failed: %s\n",
2942                         print_fname_stdin(fname), g10_errstr(rc) );
2943           }
2944         break;
2945
2946       case aEncrSym:
2947         /* This works with PGP 8 in the sense that it acts just like a
2948            symmetric message.  It doesn't work at all with 2 or 6.  It
2949            might work with 7, but alas, I don't have a copy to test
2950            with right now. */
2951         if( argc > 1 )
2952           wrong_args(_("--symmetric --encrypt [filename]"));
2953         else if(opt.s2k_mode==0)
2954           log_error(_("you cannot use --symmetric --encrypt"
2955                       " with --s2k-mode 0\n"));
2956         else if(PGP2 || PGP6 || PGP7 || RFC1991)
2957           log_error(_("you cannot use --symmetric --encrypt"
2958                       " while in %s mode\n"),compliance_option_string());
2959         else
2960           {
2961             if( (rc = encode_crypt(fname,remusr,1)) )
2962               log_error("%s: encryption failed: %s\n",
2963                         print_fname_stdin(fname), g10_errstr(rc) );
2964           }
2965         break;
2966
2967       case aSign: /* sign the given file */
2968         sl = NULL;
2969         if( detached_sig ) { /* sign all files */
2970             for( ; argc; argc--, argv++ )
2971                 add_to_strlist( &sl, *argv );
2972         }
2973         else {
2974             if( argc > 1 )
2975                 wrong_args(_("--sign [filename]"));
2976             if( argc ) {
2977                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
2978                 strcpy(sl->d, fname);
2979             }
2980         }
2981         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
2982             log_error("signing failed: %s\n", g10_errstr(rc) );
2983         free_strlist(sl);
2984         break;
2985
2986       case aSignEncr: /* sign and encrypt the given file */
2987         if( argc > 1 )
2988             wrong_args(_("--sign --encrypt [filename]"));
2989         if( argc ) {
2990             sl = m_alloc_clear( sizeof *sl + strlen(fname));
2991             strcpy(sl->d, fname);
2992         }
2993         else
2994             sl = NULL;
2995         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
2996             log_error("%s: sign+encrypt failed: %s\n",
2997                       print_fname_stdin(fname), g10_errstr(rc) );
2998         free_strlist(sl);
2999         break;
3000
3001       case aSignEncrSym: /* sign and encrypt the given file */
3002         if( argc > 1 )
3003             wrong_args(_("--symmetric --sign --encrypt [filename]"));
3004         else if(opt.s2k_mode==0)
3005           log_error(_("you cannot use --symmetric --sign --encrypt"
3006                       " with --s2k-mode 0\n"));
3007         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3008           log_error(_("you cannot use --symmetric --sign --encrypt"
3009                       " while in %s mode\n"),compliance_option_string());
3010         else
3011           {
3012             if( argc )
3013               {
3014                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
3015                 strcpy(sl->d, fname);
3016               }
3017             else
3018               sl = NULL;
3019             if( (rc = sign_file(sl, detached_sig, locusr, 2, remusr, NULL)) )
3020               log_error("%s: symmetric+sign+encrypt failed: %s\n",
3021                         print_fname_stdin(fname), g10_errstr(rc) );
3022             free_strlist(sl);
3023           }
3024         break;
3025
3026       case aSignSym: /* sign and conventionally encrypt the given file */
3027         if (argc > 1)
3028             wrong_args(_("--sign --symmetric [filename]"));
3029         rc = sign_symencrypt_file (fname, locusr);
3030         if (rc)
3031             log_error("%s: sign+symmetric failed: %s\n",
3032                       print_fname_stdin(fname), g10_errstr(rc) );
3033         break;
3034
3035       case aClearsign: /* make a clearsig */
3036         if( argc > 1 )
3037             wrong_args(_("--clearsign [filename]"));
3038         if( (rc = clearsign_file(fname, locusr, NULL)) )
3039             log_error("%s: clearsign failed: %s\n",
3040                       print_fname_stdin(fname), g10_errstr(rc) );
3041         break;
3042
3043       case aVerify:
3044         if(multifile)
3045           {
3046             if( (rc = verify_files( argc, argv ) ))
3047               log_error("verify files failed: %s\n", g10_errstr(rc) );
3048           }
3049         else
3050           {
3051             if( (rc = verify_signatures( argc, argv ) ))
3052               log_error("verify signatures failed: %s\n", g10_errstr(rc) );
3053           }
3054         break;
3055
3056       case aDecrypt:
3057         if(multifile)
3058           decrypt_messages(argc, argv);
3059         else
3060           {
3061             if( argc > 1 )
3062               wrong_args(_("--decrypt [filename]"));
3063             if( (rc = decrypt_message( fname ) ))
3064               log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
3065           }
3066         break;
3067             
3068       case aSignKey:
3069         if( argc != 1 )
3070           wrong_args(_("--sign-key user-id"));
3071         /* fall through */
3072       case aLSignKey:
3073         if( argc != 1 )
3074           wrong_args(_("--lsign-key user-id"));
3075         /* fall through */
3076       case aNRSignKey:
3077         if( argc != 1 )
3078           wrong_args(_("--nrsign-key user-id"));
3079         /* fall through */
3080       case aNRLSignKey:
3081         if( argc != 1 )
3082           wrong_args(_("--nrlsign-key user-id"));
3083
3084         sl=NULL;
3085
3086         if(cmd==aSignKey)
3087           append_to_strlist(&sl,"sign");
3088         else if(cmd==aLSignKey)
3089           append_to_strlist(&sl,"lsign");
3090         else if(cmd==aNRSignKey)
3091           append_to_strlist(&sl,"nrsign");
3092         else if(cmd==aNRLSignKey)
3093           append_to_strlist(&sl,"nrlsign");
3094         else
3095           BUG();
3096
3097         append_to_strlist( &sl, "save" );
3098         username = make_username( fname );
3099         keyedit_menu(fname, locusr, sl, 0, 0 );
3100         m_free(username);
3101         free_strlist(sl);
3102         break;
3103
3104       case aEditKey: /* Edit a key signature */
3105         if( !argc )
3106             wrong_args(_("--edit-key user-id [commands]"));
3107         username = make_username( fname );
3108         if( argc > 1 ) {
3109             sl = NULL;
3110             for( argc--, argv++ ; argc; argc--, argv++ )
3111                 append_to_strlist( &sl, *argv );
3112             keyedit_menu( username, locusr, sl, 0, 1 );
3113             free_strlist(sl);
3114         }
3115         else
3116             keyedit_menu(username, locusr, NULL, 0, 1 );
3117         m_free(username);
3118         break;
3119
3120       case aDeleteKeys:
3121       case aDeleteSecretKeys:
3122       case aDeleteSecretAndPublicKeys:
3123         sl = NULL;
3124         /* I'm adding these in reverse order as add_to_strlist2
3125            reverses them again, and it's easier to understand in the
3126            proper order :) */
3127         for( ; argc; argc-- )
3128           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
3129         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
3130         free_strlist(sl);
3131         break;
3132
3133       case aCheckKeys:
3134         opt.check_sigs = 1;
3135       case aListSigs:
3136         opt.list_sigs = 1;
3137       case aListKeys:
3138         sl = NULL;
3139         for( ; argc; argc--, argv++ )
3140             add_to_strlist2( &sl, *argv, utf8_strings );
3141         public_key_list( sl );
3142         free_strlist(sl);
3143         break;
3144       case aListSecretKeys:
3145         sl = NULL;
3146         for( ; argc; argc--, argv++ )
3147             add_to_strlist2( &sl, *argv, utf8_strings );
3148         secret_key_list( sl );
3149         free_strlist(sl);
3150         break;
3151
3152       case aKMode: /* list keyring -- NOTE: This will be removed soon */
3153         if( argc < 2 ) { /* -kv [userid] */
3154             sl = NULL;
3155             if (argc && **argv)
3156                 add_to_strlist2( &sl, *argv, utf8_strings );
3157             public_key_list( sl );
3158             free_strlist(sl);
3159         }
3160         else if( argc == 2 ) { /* -kv userid keyring */
3161             if( access( argv[1], R_OK ) ) {
3162                 log_error(_("can't open `%s': %s\n"),
3163                                print_fname_stdin(argv[1]), strerror(errno));
3164             }
3165             else {
3166                 /* add keyring (default keyrings are not registered in this
3167                  * special case */
3168                 keydb_add_resource( argv[1], 0, 0 );
3169                 sl = NULL;
3170                 if (**argv)
3171                     add_to_strlist2( &sl, *argv, utf8_strings );
3172                 public_key_list( sl );
3173                 free_strlist(sl);
3174             }
3175         }
3176         else
3177             wrong_args(_("-k[v][v][v][c] [user-id] [keyring]") );
3178         break;
3179
3180       case aKeygen: /* generate a key */
3181         if( opt.batch ) {
3182             if( argc > 1 )
3183                 wrong_args("--gen-key [parameterfile]");
3184             generate_keypair( argc? *argv : NULL, NULL, NULL );
3185         }
3186         else {
3187             if( argc )
3188                 wrong_args("--gen-key");
3189             generate_keypair(NULL, NULL, NULL);
3190         }
3191         break;
3192
3193       case aFastImport:
3194         opt.import_options |= IMPORT_FAST_IMPORT;
3195       case aImport:
3196         import_keys( argc? argv:NULL, argc, NULL, opt.import_options );
3197         break;
3198
3199       case aExport:
3200       case aSendKeys:
3201       case aRecvKeys:
3202         sl = NULL;
3203         for( ; argc; argc--, argv++ )
3204             add_to_strlist2( &sl, *argv, utf8_strings );
3205         if( cmd == aSendKeys )
3206             rc=keyserver_export( sl );
3207         else if( cmd == aRecvKeys )
3208             rc=keyserver_import( sl );
3209         else
3210             rc=export_pubkeys( sl, opt.export_options );
3211         if(rc)
3212           {
3213             if(cmd==aSendKeys)
3214               log_error(_("keyserver send failed: %s\n"),g10_errstr(rc));
3215             else if(cmd==aRecvKeys)
3216               log_error(_("keyserver receive failed: %s\n"),g10_errstr(rc));
3217             else
3218               log_error(_("key export failed: %s\n"),g10_errstr(rc));
3219           }
3220         free_strlist(sl);
3221         break;
3222
3223      case aSearchKeys:
3224         sl = NULL;
3225         for( ; argc; argc--, argv++ )
3226           append_to_strlist2( &sl, *argv, utf8_strings );
3227         rc=keyserver_search( sl );
3228         if(rc)
3229           log_error(_("keyserver search failed: %s\n"),g10_errstr(rc));
3230         free_strlist(sl);
3231         break;
3232
3233       case aRefreshKeys:
3234         sl = NULL;
3235         for( ; argc; argc--, argv++ )
3236             add_to_strlist2( &sl, *argv, utf8_strings );
3237         rc=keyserver_refresh(sl);
3238         if(rc)
3239           log_error(_("keyserver refresh failed: %s\n"),g10_errstr(rc));
3240         free_strlist(sl);
3241         break;
3242
3243       case aExportSecret:
3244         sl = NULL;
3245         for( ; argc; argc--, argv++ )
3246             add_to_strlist2( &sl, *argv, utf8_strings );
3247         export_seckeys( sl );
3248         free_strlist(sl);
3249         break;
3250
3251       case aExportSecretSub:
3252         sl = NULL;
3253         for( ; argc; argc--, argv++ )
3254             add_to_strlist2( &sl, *argv, utf8_strings );
3255         export_secsubkeys( sl );
3256         free_strlist(sl);
3257         break;
3258
3259       case aGenRevoke:
3260         if( argc != 1 )
3261             wrong_args("--gen-revoke user-id");
3262         username =  make_username(*argv);
3263         gen_revoke( username );
3264         m_free( username );
3265         break;
3266
3267       case aDesigRevoke:
3268         if( argc != 1 )
3269             wrong_args("--desig-revoke user-id");
3270         username =  make_username(*argv);
3271         gen_desig_revoke( username );
3272         m_free( username );
3273         break;
3274
3275       case aDeArmor:
3276         if( argc > 1 )
3277             wrong_args("--dearmor [file]");
3278         rc = dearmor_file( argc? *argv: NULL );
3279         if( rc )
3280             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
3281         break;
3282
3283       case aEnArmor:
3284         if( argc > 1 )
3285             wrong_args("--enarmor [file]");
3286         rc = enarmor_file( argc? *argv: NULL );
3287         if( rc )
3288             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
3289         break;
3290
3291
3292       case aPrimegen:
3293         {   int mode = argc < 2 ? 0 : atoi(*argv);
3294
3295             if( mode == 1 && argc == 2 ) {
3296                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
3297             }
3298             else if( mode == 2 && argc == 3 ) {
3299                 mpi_print( stdout, generate_elg_prime(
3300                                              0, atoi(argv[1]),
3301                                              atoi(argv[2]), NULL,NULL ), 1);
3302             }
3303             else if( mode == 3 && argc == 3 ) {
3304                 MPI *factors;
3305                 mpi_print( stdout, generate_elg_prime(
3306                                              1, atoi(argv[1]),
3307                                              atoi(argv[2]), NULL,&factors ), 1);
3308                 putchar('\n');
3309                 mpi_print( stdout, factors[0], 1 ); /* print q */
3310             }
3311             else if( mode == 4 && argc == 3 ) {
3312                 MPI g = mpi_alloc(1);
3313                 mpi_print( stdout, generate_elg_prime(
3314                                                  0, atoi(argv[1]),
3315                                                  atoi(argv[2]), g, NULL ), 1);
3316                 putchar('\n');
3317                 mpi_print( stdout, g, 1 );
3318                 mpi_free(g);
3319             }
3320             else
3321                 wrong_args("--gen-prime mode bits [qbits] ");
3322             putchar('\n');
3323         }
3324         break;
3325
3326       case aGenRandom:
3327         {
3328             int level = argc ? atoi(*argv):0;
3329             int count = argc > 1 ? atoi(argv[1]): 0;
3330             int endless = !count;
3331
3332             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
3333                 wrong_args("--gen-random 0|1|2 [count]");
3334
3335             while( endless || count ) {
3336                 byte *p;
3337                 /* Wee need a multiple of 3, so that in case of
3338                    armored output we get a correct string.  No
3339                    linefolding is done, as it is best to levae this to
3340                    other tools */
3341                 size_t n = !endless && count < 99? count : 99;
3342
3343                 p = get_random_bits( n*8, level, 0);
3344 #ifdef HAVE_DOSISH_SYSTEM
3345                 setmode ( fileno(stdout), O_BINARY );
3346 #endif
3347                 if (opt.armor) {
3348                     char *tmp = make_radix64_string (p, n);
3349                     fputs (tmp, stdout);
3350                     m_free (tmp);
3351                     if (n%3 == 1)
3352                       putchar ('=');
3353                     if (n%3)
3354                       putchar ('=');
3355                 } else {
3356                     fwrite( p, n, 1, stdout );
3357                 }
3358                 m_free(p);
3359                 if( !endless )
3360                     count -= n;
3361             }
3362             if (opt.armor)
3363                 putchar ('\n');
3364         }
3365         break;
3366
3367       case aPrintMD:
3368         if( argc < 1)
3369             wrong_args("--print-md algo [files]");
3370         {
3371             int all_algos = (**argv=='*' && !(*argv)[1]);
3372             int algo = all_algos? 0 : string_to_digest_algo(*argv);
3373
3374             if( !algo && !all_algos )
3375                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
3376             else {
3377                 argc--; argv++;
3378                 if( !argc )
3379                     print_mds(NULL, algo);
3380                 else {
3381                     for(; argc; argc--, argv++ )
3382                         print_mds(*argv, algo);
3383                 }
3384             }
3385         }
3386         break;
3387
3388       case aPrintMDs: /* old option */
3389         if( !argc )
3390             print_mds(NULL,0);
3391         else {
3392             for(; argc; argc--, argv++ )
3393                 print_mds(*argv,0);
3394         }
3395         break;
3396
3397       case aListTrustDB:
3398         if( !argc )
3399             list_trustdb(NULL);
3400         else {
3401             for( ; argc; argc--, argv++ )
3402                 list_trustdb( *argv );
3403         }
3404         break;
3405
3406       case aUpdateTrustDB:
3407         if( argc )
3408             wrong_args("--update-trustdb");
3409         update_trustdb();
3410         break;
3411
3412       case aCheckTrustDB:
3413         /* Old versions allowed for arguments - ignore them */
3414         check_trustdb();
3415         break;
3416
3417       case aFixTrustDB:
3418         log_error("this command is not yet implemented.\n");
3419         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
3420         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
3421         break;
3422
3423       case aListTrustPath:
3424         if( !argc )
3425             wrong_args("--list-trust-path <user-ids>");
3426         for( ; argc; argc--, argv++ ) {
3427             username = make_username( *argv );
3428             list_trust_path( username );
3429             m_free(username);
3430         }
3431         break;
3432
3433       case aExportOwnerTrust:
3434         if( argc )
3435             wrong_args("--export-ownertrust");
3436         export_ownertrust();
3437         break;
3438
3439       case aImportOwnerTrust:
3440         if( argc > 1 )
3441             wrong_args("--import-ownertrust [file]");
3442         import_ownertrust( argc? *argv:NULL );
3443         break;
3444       
3445       case aPipeMode:
3446         if ( argc )
3447             wrong_args ("--pipemode");
3448         run_in_pipemode ();
3449         break;
3450
3451       case aRebuildKeydbCaches:
3452         if (argc)
3453             wrong_args ("--rebuild-keydb-caches");
3454         keydb_rebuild_caches (1);
3455         break;
3456
3457 #ifdef ENABLE_CARD_SUPPORT
3458       case aCardStatus:
3459         if (argc)
3460             wrong_args ("--card-status");
3461         card_status (stdout, NULL, 0);
3462         break;
3463
3464       case aCardEdit:
3465         if (argc) {
3466             sl = NULL;
3467             for (argc--, argv++ ; argc; argc--, argv++)
3468                 append_to_strlist (&sl, *argv);
3469             card_edit (sl);
3470             free_strlist (sl);
3471         }
3472         else
3473             card_edit (NULL);
3474         break;
3475
3476       case aChangePIN:
3477         if (!argc)
3478             change_pin (0);
3479         else if (argc == 1)
3480             change_pin ( atoi (*argv));
3481         else
3482         wrong_args ("--change-pin [no]");
3483         break;
3484 #endif /* ENABLE_CARD_SUPPORT*/
3485
3486       case aListConfig:
3487         {
3488           char *str=collapse_args(argc,argv);
3489           list_config(str);
3490           m_free(str);
3491         }
3492         break;
3493
3494       case aListPackets:
3495         opt.list_packets=2;
3496       default:
3497         if( argc > 1 )
3498             wrong_args(_("[filename]"));
3499         /* Issue some output for the unix newbie */
3500         if( !fname && !opt.outfile && isatty( fileno(stdin) )