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