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