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