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