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