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