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